from django.db import models
from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes.fields import GenericForeignKey
from django.conf import settings
from typing import Any, Dict, Optional
from django.db.models import QuerySet


class DiffMixin:
    """Mixin to add diffing capabilities to models"""

    def get_prev_record(self) -> Optional[Any]:
        """Get the previous record for this instance"""
        try:
            return (
                type(self)
                .objects.filter(
                    pgh_created_at__lt=self.pgh_created_at,
                    pgh_obj_id=self.pgh_obj_id,
                )
                .order_by("-pgh_created_at")
                .first()
            )
        except (AttributeError, TypeError):
            return None

    def diff_against_previous(self) -> Dict:
        """Compare this record against the previous one"""
        prev_record = self.get_prev_record()
        if not prev_record:
            return {}

        skip_fields = {
            "pgh_id",
            "pgh_created_at",
            "pgh_label",
            "pgh_obj_id",
            "pgh_context_id",
            "_state",
            "created_at",
            "updated_at",
        }

        changes = {}
        for field, value in self.__dict__.items():
            # Skip internal fields and those we don't want to track
            if field.startswith("_") or field in skip_fields or field.endswith("_id"):
                continue

            try:
                old_value = getattr(prev_record, field)
                new_value = value
                if old_value != new_value:
                    changes[field] = {
                        "old": (str(old_value) if old_value is not None else "None"),
                        "new": (str(new_value) if new_value is not None else "None"),
                    }
            except AttributeError:
                continue

        return changes


class TrackedModel(models.Model):
    """Abstract base class for models that need history tracking"""

    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        abstract = True

    def get_history(self) -> QuerySet:
        """Get all history records for this instance in chronological order"""
        event_model = self.events.model  # pghistory provides this automatically
        if event_model:
            return event_model.objects.filter(pgh_obj_id=self.pk).order_by(
                "-pgh_created_at"
            )
        return self.__class__.objects.none()


class HistoricalSlug(models.Model):
    """Track historical slugs for models"""

    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveIntegerField()
    content_object = GenericForeignKey("content_type", "object_id")
    slug = models.SlugField(max_length=255)
    created_at = models.DateTimeField(auto_now_add=True)
    user = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        null=True,
        blank=True,
        on_delete=models.SET_NULL,
        related_name="historical_slugs",
    )

    class Meta:
        unique_together = ("content_type", "slug")
        indexes = [
            models.Index(fields=["content_type", "object_id"]),
            models.Index(fields=["slug"]),
        ]

    def __str__(self) -> str:
        return f"{self.content_type} - {self.object_id} - {self.slug}"