from decimal import Decimal
from django.db.models import Q
from django.shortcuts import get_object_or_404
from rest_framework import permissions, serializers
from rest_framework.response import Response
from rest_framework.views import APIView
from api_core.application import mutation
from clubs.models import Club
from economy.exceptions import EconomyError
from federations.access import is_federation_platform_admin
from federations.models import FederationAdminAssignment
from .exceptions import LineupError
from .friendly_models import FriendlyGame
from . import friendlies


def managed_clubs(user):
    return Club.objects.filter(Q(ownership_record__owner=user) |
        Q(ownership_record__isnull=True, coach_career__user=user) | Q(coach_career__user=user)).distinct()


def visible_games(user):
    qs = FriendlyGame.objects.select_related("home_club", "away_club", "federation")
    if is_federation_platform_admin(user):
        return qs
    ids = managed_clubs(user).values_list("pk", flat=True)
    feds = FederationAdminAssignment.objects.filter(user=user, role="GOVERNOR", is_active=True,
                                                    federation__status="ACTIVE").values_list("federation_id", flat=True)
    return qs.filter(Q(home_club_id__in=ids) | Q(away_club_id__in=ids) | Q(federation_id__in=feds))


def snapshot(game, detailed=False):
    data = {name: str(getattr(game, name)) for name in ("id", "home_club_id", "away_club_id", "federation_id", "offered_by_club_id", "stake")}
    data.update(status=game.status, version=game.version, home_club_name=game.home_club.name,
        away_club_name=game.away_club.name, federation_name=game.federation.name,
        scheduled_at=game.scheduled_at.isoformat(), home_score=game.home_score, away_score=game.away_score,
        result_hash=game.result_hash, state_hash=game.state_hash, decision_note=game.decision_note)
    if detailed:
        data["audit"] = [{"action": a.action, "actor_id": str(a.actor_id) if a.actor_id else None,
                          "evidence": a.evidence, "evidence_hash": a.evidence_hash,
                          "created_at": a.created_at.isoformat()} for a in game.audit.all()]
        data["result"] = game.result_payload
        if game.status in {"REVIEW", "SETTLED", "VOID"} and game.result_hash:
            data["simulation_input"] = {"seed": str(game.seed), "engine_key": game.engine_key,
                "engine_version": game.engine_version, "state": game.state_payload}
    return data


class StrictInput(serializers.Serializer):
    def validate(self, attrs):
        if set(self.initial_data) - set(self.fields):
            raise serializers.ValidationError("Unknown request fields.")
        return attrs


class ProposalInput(StrictInput):
    home_club_id = serializers.UUIDField()
    away_club_id = serializers.UUIDField()
    stake = serializers.DecimalField(max_digits=24, decimal_places=8, min_value=Decimal("0"))
    scheduled_at = serializers.DateTimeField()


class ActionInput(StrictInput):
    action = serializers.ChoiceField(choices=["counter", "accept", "decline", "withdraw", "approve", "settle", "void"])
    version = serializers.IntegerField(min_value=1)
    club_id = serializers.UUIDField(required=False)
    stake = serializers.DecimalField(max_digits=24, decimal_places=8, min_value=Decimal("0"), required=False)
    scheduled_at = serializers.DateTimeField(required=False)
    note = serializers.CharField(max_length=4000, required=False, default="")
    result_hash = serializers.CharField(max_length=64, required=False, default="")


class FriendliesView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request):
        qs = visible_games(request.user).order_by("-created_at")
        if request.query_params.get("federation_id"):
            try:
                federation_id = serializers.UUIDField().run_validation(request.query_params["federation_id"])
            except serializers.ValidationError:
                return Response({"detail": "Invalid federation ID."}, status=400)
            qs = qs.filter(federation_id=federation_id)
        return Response({"results": [snapshot(g) for g in qs[:100]]})

    def post(self, request):
        data = ProposalInput(data=request.data)
        data.is_valid(raise_exception=True)
        return mutation(request=request, scope="friendlies.propose",
            operation=lambda: friendlies.propose(user=request.user, **data.validated_data),
            serialize=snapshot, success_status=201, domain_errors=(friendlies.FriendlyError, EconomyError, LineupError))


class FriendlyOptionsView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request):
        from .friendly_supervision import context, eligible_supervisors
        supervision = context()
        region_ids = set(supervision[0])
        own = list(managed_clubs(request.user).filter(status="ACTIVE")
                   .select_related('coach_career__user', 'ownership_record__owner', 'regional_federation'))
        mine = [{"id": str(c.pk), "name": c.name, "ready": c.regional_federation_id in region_ids,
                 "unavailable_reason": "" if c.regional_federation_id in region_ids else
                 "اتصال باشگاه به فدراسیون منطقه‌ای فعال تکمیل نشده است؛ ثبت منطقه‌ای باید اصلاح شود."}
                for c in own]
        opponents = []
        candidates = (Club.objects.filter(status='ACTIVE', regional_federation_id__in=region_ids)
                      .exclude(pk__in=[c.pk for c in own])
                      .select_related('coach_career__user', 'ownership_record__owner', 'regional_federation')
                      .order_by('name', 'pk'))
        for opponent in candidates.iterator():
            home_ids = []
            for home in own:
                if home.regional_federation_id not in region_ids:
                    continue
                try:
                    friendlies._independent([home, opponent])
                    if not eligible_supervisors([home, opponent], data=supervision):
                        continue
                except friendlies.FriendlyError:
                    continue
                home_ids.append(str(home.pk))
            if home_ids:
                opponents.append({'id': str(opponent.pk), 'name': opponent.name,
                                  'eligible_home_club_ids': home_ids})
            if len(opponents) >= 500:
                break
        return Response({'my_clubs': mine, 'opponents': opponents,
                         'supervision_available':bool(supervision[1]),
                         'supervision_note': '' if supervision[1] else 'برای نظارت، رئیس مستقل یکی از فدراسیون‌های منطقه‌ای باید توسط رئیس مادر تعیین شود.'})


class FriendlyDetailView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def get(self, request, game_id):
        return Response(snapshot(get_object_or_404(visible_games(request.user), pk=game_id), detailed=True))


class FriendlyActionView(APIView):
    permission_classes = [permissions.IsAuthenticated]
    def post(self, request, game_id):
        get_object_or_404(visible_games(request.user), pk=game_id)
        serializer = ActionInput(data=request.data)
        serializer.is_valid(raise_exception=True)
        data = serializer.validated_data
        action = data["action"]
        if action == "counter" and not all(k in data for k in ("stake", "scheduled_at")):
            return Response({"detail": "Counteroffer requires amount and kickoff."}, status=400)
        if action == "approve":
            operation = lambda: friendlies.approve(user=request.user, game_id=game_id, version=data["version"], note=data["note"])
        elif action in {"settle", "void"}:
            operation = lambda: friendlies.decide(user=request.user, game_id=game_id, version=data["version"], action=action, note=data["note"], result_hash=data["result_hash"])
        else:
            operation = lambda: friendlies.negotiate(user=request.user, game_id=game_id, version=data["version"], action=action,
                club_id=data.get("club_id"), stake=data.get("stake"), scheduled_at=data.get("scheduled_at"))
        return mutation(request=request, scope=f"friendlies.{game_id}.{action}", operation=operation,
            serialize=snapshot, domain_errors=(friendlies.FriendlyError, EconomyError, LineupError))
