"""Friendlies are isolated from league Fixture/Match and official standings."""
import uuid
from django.conf import settings
from django.db import models
from django.db.models import Q, F


class ProtectedFriendlyQuerySet(models.QuerySet):
    def update(self, **kwargs):
        raise ValueError("Use governed friendly services.")
    def delete(self):
        raise ValueError("Friendly evidence cannot be deleted.")


class FriendlyGame(models.Model):
    objects = ProtectedFriendlyQuerySet.as_manager()
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    home_club = models.ForeignKey("clubs.Club", on_delete=models.PROTECT, related_name="home_friendlies")
    away_club = models.ForeignKey("clubs.Club", on_delete=models.PROTECT, related_name="away_friendlies")
    federation = models.ForeignKey("federations.Federation", on_delete=models.PROTECT, related_name="friendlies")
    offered_by_club = models.ForeignKey("clubs.Club", on_delete=models.PROTECT, related_name="friendly_offers")
    proposed_by = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.PROTECT, related_name="proposed_friendlies")
    accepted_by = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, on_delete=models.PROTECT, related_name="accepted_friendlies")
    status = models.CharField(max_length=16, default="PROPOSED")
    version = models.PositiveIntegerField(default=1)
    stake = models.DecimalField(max_digits=24, decimal_places=8, default=0)
    scheduled_at = models.DateTimeField()
    home_reservation = models.OneToOneField("economy.LedgerEntry", null=True, on_delete=models.PROTECT, related_name="friendly_home_reserve")
    away_reservation = models.OneToOneField("economy.LedgerEntry", null=True, on_delete=models.PROTECT, related_name="friendly_away_reserve")
    approved_by = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, on_delete=models.PROTECT, related_name="approved_friendlies")
    decided_by = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, on_delete=models.PROTECT, related_name="decided_friendlies")
    # Generated once, private before play. No client-controlled seed or score.
    seed = models.PositiveBigIntegerField(null=True)
    engine_key = models.CharField(max_length=64, blank=True)
    engine_version = models.CharField(max_length=32, blank=True)
    state_payload = models.JSONField(default=dict)
    state_hash = models.CharField(max_length=64, blank=True)
    result_payload = models.JSONField(default=dict)
    result_hash = models.CharField(max_length=64, blank=True)
    home_score = models.PositiveSmallIntegerField(null=True)
    away_score = models.PositiveSmallIntegerField(null=True)
    started_at = models.DateTimeField(null=True)
    completed_at = models.DateTimeField(null=True)
    decision_note = models.TextField(blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        indexes = [models.Index(fields=["status", "scheduled_at"], name="friendly_due_idx")]
        constraints = [
            models.CheckConstraint(condition=~Q(home_club=F("away_club")), name="friendly_distinct_clubs"),
            models.CheckConstraint(condition=Q(stake__gte=0), name="friendly_nonnegative_stake"),
            models.CheckConstraint(condition=Q(version__gte=1), name="friendly_version_positive"),
            models.CheckConstraint(condition=Q(status__in=["PROPOSED", "FUNDED", "APPROVED", "RUNNING", "REVIEW", "SETTLED", "VOID", "DECLINED"]), name="friendly_valid_status"),
            models.CheckConstraint(condition=(Q(offered_by_club=F("home_club")) | Q(offered_by_club=F("away_club"))), name="friendly_offering_participant"),
            models.CheckConstraint(condition=(Q(status__in=["PROPOSED", "DECLINED", "VOID"]) | Q(accepted_by__isnull=False)), name="friendly_acceptance_shape"),
            models.CheckConstraint(condition=(~Q(status__in=["REVIEW", "SETTLED"]) | Q(completed_at__isnull=False, home_score__isnull=False, away_score__isnull=False)), name="friendly_result_shape"),
            models.CheckConstraint(condition=(~Q(status__in=["FUNDED", "APPROVED", "RUNNING", "REVIEW", "SETTLED"], stake__gt=0) | Q(home_reservation__isnull=False, away_reservation__isnull=False)), name="friendly_funding_shape"),
        ]

    def save(self, *args, **kwargs):
        if not self._state.adding:
            old = type(self).objects.get(pk=self.pk)
            if old.status in {"SETTLED", "VOID", "DECLINED"}:
                raise ValueError("Resolved friendly is immutable.")
            allowed = {"PROPOSED": {"PROPOSED", "FUNDED", "APPROVED", "DECLINED", "VOID"},
                       "FUNDED": {"FUNDED", "APPROVED", "VOID"}, "APPROVED": {"APPROVED", "RUNNING", "VOID"},
                       "RUNNING": {"RUNNING", "REVIEW", "VOID"}, "REVIEW": {"REVIEW", "SETTLED", "VOID"}}
            if self.status not in allowed.get(old.status, set()):
                raise ValueError("Invalid friendly lifecycle transition.")
            names = ["home_club_id", "away_club_id", "federation_id"]
            if old.status != "PROPOSED":
                names += ["stake", "version", "scheduled_at", "proposed_by_id", "offered_by_club_id", "accepted_by_id", "home_reservation_id", "away_reservation_id"]
            if old.state_hash:
                names += ["seed", "state_hash", "state_payload", "engine_key", "engine_version", "started_at"]
            if old.result_hash:
                names += ["result_hash", "result_payload", "home_score", "away_score", "completed_at"]
            if any(getattr(old, name) != getattr(self, name) for name in names):
                raise ValueError("Friendly terms, participants and sealed evidence are immutable.")
        return super().save(*args, **kwargs)

    def delete(self, *args, **kwargs):
        raise ValueError("Friendly records cannot be deleted.")


class FriendlyAudit(models.Model):
    objects = ProtectedFriendlyQuerySet.as_manager()
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    game = models.ForeignKey(FriendlyGame, on_delete=models.PROTECT, related_name="audit")
    actor = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, on_delete=models.PROTECT)
    action = models.CharField(max_length=32)
    evidence = models.JSONField(default=dict)
    evidence_hash = models.CharField(max_length=64)
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ["created_at", "id"]

    def save(self, *args, **kwargs):
        if not self._state.adding:
            raise ValueError("Friendly audit is immutable.")
        return super().save(*args, **kwargs)

    def delete(self, *args, **kwargs):
        raise ValueError("Friendly audit is immutable.")
