"""Manager-only hypothetical matchup analysis; never reads an opponent's draft."""

from django.core.exceptions import ValidationError as DjangoValidationError
from rest_framework import permissions, serializers
from rest_framework.response import Response
from rest_framework.views import APIView

from clubs.access import can_manage_club
from clubs.models import Club, ClubSquadMembership
from injuries.resolver import FatigueResolver
from players.models import PLAYER_RATING_FIELDS, Player

from .constants import FORMATION_SLOTS
from .engine.roles import (
    SLOT_TARGET_POSITION,
    familiarity_from_map,
    resolve_tactical_role,
)
from .engine.shape_matchup import evaluate_pair
from .engine.state import PlayerState
from .exceptions import LineupError
from .tactical_catalog import catalog, validate_plan


def scenario(value, *, prefix, club=None):
    if (
        not isinstance(value, dict)
        or not isinstance(value.get("formation"), str)
        or value.get("formation") not in FORMATION_SLOTS
    ):
        raise serializers.ValidationError("Unknown formation.")
    code = value["formation"]
    plan = validate_plan(value.get("tactical_plan") or {})
    rows = value.get("starters") or [
        {"slot": slot} for slot in FORMATION_SLOTS[code] if code != "CUSTOM"
    ]
    if (
        not isinstance(rows, list)
        or len(rows) != 11
        or not all(isinstance(row, dict) for row in rows)
    ):
        raise serializers.ValidationError(
            "Analysis requires eleven starting positions."
        )
    slots = [row.get("slot") for row in rows]
    if (
        any(not isinstance(slot, str) for slot in slots)
        or len(set(slots)) != 11
        or "GK" not in slots
        or not set(slots) <= set(FORMATION_SLOTS[code])
    ):
        raise serializers.ValidationError("Use eleven unique valid slots including GK.")
    ids = [str(row["player_id"]) for row in rows if row.get("player_id")]
    players = {}
    if ids and club:
        if len(ids) != 11 or len(set(ids)) != 11:
            raise serializers.ValidationError(
                "Provide eleven distinct club players or use a structural scenario."
            )
        try:
            current = {
                str(pk)
                for pk in ClubSquadMembership.objects.filter(
                    club=club, player_id__in=ids
                ).values_list("player_id", flat=True)
            }
            players = {
                str(p.pk): p
                for p in Player.objects.filter(pk__in=current).prefetch_related(
                    "position_familiarities"
                )
            }
        except (ValueError, TypeError, DjangoValidationError) as exc:
            raise serializers.ValidationError("Invalid player identity.") from exc
        if len(players) != 11:
            raise serializers.ValidationError(
                "Analysis may use only your club's current players."
            )
    elif ids:
        raise serializers.ValidationError(
            "Opponent player identities are not accepted; use a hypothetical quality."
        )
    quality = value.get("quality", 50)
    if (
        isinstance(quality, bool)
        or not isinstance(quality, int)
        or not 1 <= quality <= 100
    ):
        raise serializers.ValidationError("Hypothetical quality must be 1..100.")
    captain_id = value.get("captain_id")
    if captain_id is not None and (not ids or str(captain_id) not in ids):
        raise serializers.ValidationError("Captain must be among the eleven selected players.")
    result = []
    for i, row in enumerate(rows):
        slot = row["slot"]
        try:
            role = resolve_tactical_role(row.get("tactical_role", "AUTO"), slot)
        except ValueError as exc:
            raise serializers.ValidationError(str(exc)) from exc
        player = players.get(str(row.get("player_id")))
        if player and ((slot == "GK") != (player.position == "GK")):
            raise serializers.ValidationError(
                "Goalkeeper and outfield positions cannot be exchanged."
            )
        ratings = {
            name: int(getattr(player, name)) if player else quality
            for name in PLAYER_RATING_FIELDS
        }
        familiarities = (
            {r.position: r.familiarity for r in player.position_familiarities.all()}
            if player
            else {}
        )
        result.append(
            PlayerState(
                player_id=str(player.pk) if player else f"{prefix}-{i}",
                natural_position=player.position
                if player
                else SLOT_TARGET_POSITION[slot],
                lineup_slot=slot,
                role="STARTER",
                is_captain=(str(player.pk) == str(captain_id)) if captain_id is not None else i == 0,
                ratings=tuple(sorted(ratings.items())),
                tactical_role=role,
                position_familiarity=familiarity_from_map(
                    player.position, familiarities, slot
                )
                if player
                else 100,
                fatigue_index=round(
                    float(FatigueResolver.for_player(player=player).fatigue_index)
                )
                if player
                else 0,
            )
        )
    return result, plan, bool(players)


class TacticalCatalogView(APIView):
    permission_classes = (permissions.IsAuthenticated,)

    def get(self, request):
        return Response(catalog())


class TacticalAnalysisView(APIView):
    permission_classes = (permissions.IsAuthenticated,)

    def post(self, request, club_id):
        if not isinstance(request.data, dict):
            raise serializers.ValidationError("Analysis input must be an object.")
        club = Club.objects.filter(pk=club_id).first()
        if club is None:
            return Response({"detail": "Club not found."}, status=404)
        if not can_manage_club(request.user, club):
            return Response(
                {"detail": "Club management permission required."}, status=403
            )
        try:
            own, first, actual = scenario(
                request.data.get("own"), prefix="own", club=club
            )
            other, second, _ = scenario(
                request.data.get("opponent"), prefix="hypothetical"
            )
            minute = request.data.get("minute", 0)
            if (
                isinstance(minute, bool)
                or not isinstance(minute, int)
                or not 0 <= minute <= 120
            ):
                raise serializers.ValidationError("Minute must be 0..120.")

            def evaluate(opponents):
                return evaluate_pair(
                    own,
                    opponents,
                    first["attacking_strategy"],
                    first["defensive_strategy"],
                    second["attacking_strategy"],
                    second["defensive_strategy"],
                    minute,
                )

            analysis = evaluate(other)
            matrix = []
            if request.data.get("compare_all", False) is True:
                for code in FORMATION_SLOTS:
                    if code == "CUSTOM":
                        continue
                    opponents, _, _ = scenario(
                        {**request.data["opponent"], "formation": code, "starters": []},
                        prefix="hypothetical",
                    )
                    row = evaluate(opponents)
                    matrix.append(
                        {
                            "formation": code,
                            "own_factor": row["home"]["chance_factor"],
                            "opponent_factor": row["away"]["chance_factor"],
                            "edges": row["home"]["edges"],
                        }
                    )
            return Response(
                {
                    "analysis": analysis,
                    "matrix": matrix,
                    "own_basis": "CURRENT_PLAYER_ATTRIBUTES"
                    if actual
                    else "HYPOTHETICAL_EQUAL_QUALITY",
                    "opponent_basis": "USER_CONFIGURED_HYPOTHETICAL",
                    "notice": "این شاخص‌ها احتمال برد نیستند؛ چینش و تاکتیک حریف فرضی است و ترکیب خصوصی او خوانده نمی‌شود.",
                }
            )
        except LineupError as exc:
            return Response({"detail": str(exc)}, status=400)
