"""Application services for pre-match tactical plans and kickoff intelligence snapshots."""
from __future__ import annotations

from decimal import Decimal

from django.db import transaction

from staff.constants import ANALYST, ASSIGNMENT_ACTIVE, ASSISTANT_COACH, HEAD_COACH
from staff.models import ClubStaffAssignment

from .constants import (
    AttackingStrategy,
    DefensiveStrategy,
    LineupStatus,
    TacticalAdaptationMode,
    TacticalTriggerType,
)
from .engine.serialization import payload_sha256
from .engine.state import TacticalInstructionState, TeamTacticalContext
from .exceptions import TacticalInstructionError, TacticalPlanNotEditableError, TacticalSnapshotError
from .models import MatchLineup, MatchTacticalContextSnapshot, MatchTacticalInstruction, MatchTacticalPlan


def _editable_lineup(lineup_id):
    try:
        lineup = MatchLineup.objects.select_for_update(of=("self",)).select_related("match", "club").get(pk=lineup_id)
    except MatchLineup.DoesNotExist as exc:
        from .exceptions import LineupNotFoundError
        raise LineupNotFoundError("Lineup does not exist.") from exc
    if lineup.status != LineupStatus.DRAFT:
        raise TacticalPlanNotEditableError("Tactical plan is editable only while the lineup is DRAFT.")
    if hasattr(lineup.match, "simulation_snapshot"):
        raise TacticalPlanNotEditableError("Kickoff snapshot already exists; tactical plan is frozen.")
    return lineup


class MatchTacticalPlanService:
    @staticmethod
    @transaction.atomic
    def configure(*, lineup_id, attacking_strategy, defensive_strategy, adaptation_mode):
        lineup = _editable_lineup(lineup_id)
        if attacking_strategy not in AttackingStrategy.values:
            raise TacticalInstructionError("Unsupported attacking strategy.")
        if defensive_strategy not in DefensiveStrategy.values:
            raise TacticalInstructionError("Unsupported defensive strategy.")
        if adaptation_mode not in TacticalAdaptationMode.values:
            raise TacticalInstructionError("Unsupported tactical adaptation mode.")
        plan, _ = MatchTacticalPlan.objects.select_for_update().get_or_create(
            lineup=lineup,
            defaults={
                "attacking_strategy": attacking_strategy,
                "defensive_strategy": defensive_strategy,
                "adaptation_mode": adaptation_mode,
            },
        )
        changed = []
        for field, value in (
            ("attacking_strategy", attacking_strategy),
            ("defensive_strategy", defensive_strategy),
            ("adaptation_mode", adaptation_mode),
        ):
            if getattr(plan, field) != value:
                setattr(plan, field, value)
                changed.append(field)
        if changed:
            plan.save(update_fields=[*changed, "updated_at"])
        return plan

    @staticmethod
    @transaction.atomic
    def add_instruction(*, lineup_id, priority, trigger_type, minute_from, attacking_strategy, defensive_strategy):
        lineup = _editable_lineup(lineup_id)
        if trigger_type not in TacticalTriggerType.values:
            raise TacticalInstructionError("Unsupported tactical trigger type.")
        if attacking_strategy not in AttackingStrategy.values or defensive_strategy not in DefensiveStrategy.values:
            raise TacticalInstructionError("Unsupported tactical strategy in instruction.")
        if isinstance(priority, bool) or not isinstance(priority, int) or not 1 <= priority <= 100:
            raise TacticalInstructionError("Instruction priority must be 1..100.")
        if isinstance(minute_from, bool) or not isinstance(minute_from, int) or not 1 <= minute_from <= 120:
            raise TacticalInstructionError("Instruction minute_from must be 1..120.")
        plan, _ = MatchTacticalPlan.objects.select_for_update().get_or_create(lineup=lineup)
        if MatchTacticalInstruction.objects.filter(plan=plan, priority=priority).exists():
            raise TacticalInstructionError("Instruction priority already exists in this plan.")
        return MatchTacticalInstruction.objects.create(
            plan=plan,
            priority=priority,
            trigger_type=trigger_type,
            minute_from=minute_from,
            attacking_strategy=attacking_strategy,
            defensive_strategy=defensive_strategy,
        )

    @staticmethod
    @transaction.atomic
    def clear_instructions(*, lineup_id):
        lineup = _editable_lineup(lineup_id)
        try:
            plan = MatchTacticalPlan.objects.select_for_update().get(lineup=lineup)
        except MatchTacticalPlan.DoesNotExist:
            return 0
        deleted, _ = MatchTacticalInstruction.objects.filter(plan=plan).delete()
        return deleted


class MatchTacticalContextService:
    """Freeze plan + current staff capability into immutable kickoff evidence."""

    @classmethod
    def snapshot_pair(cls, *, match, lineups):
        if len(lineups) != 2 or any(lineup.status != LineupStatus.LOCKED for lineup in lineups):
            raise TacticalSnapshotError("Exactly two LOCKED lineups are required for tactical snapshotting.")
        prepared = {str(lineup.club_id): cls._prepare(lineup) for lineup in lineups}
        result = {}
        for lineup in lineups:
            own = prepared[str(lineup.club_id)]
            opponent = next(value for cid, value in prepared.items() if cid != str(lineup.club_id))
            payload = dict(own["payload"])
            payload["opponent_observation"] = {
                "formation": opponent["lineup"].formation,
                "attacking_strategy": opponent["context"].attacking_strategy,
                "defensive_strategy": opponent["context"].defensive_strategy,
                "observation_confidence": own["context"].analysis_quality,
            }
            snapshot = MatchTacticalContextSnapshot.objects.create(
                match=match,
                club=lineup.club,
                lineup=lineup,
                plan=own["plan"],
                head_coach_assignment=own["assignments"].get(HEAD_COACH),
                assistant_coach_assignment=own["assignments"].get(ASSISTANT_COACH),
                analyst_assignment=own["assignments"].get(ANALYST),
                attacking_strategy=own["context"].attacking_strategy,
                defensive_strategy=own["context"].defensive_strategy,
                adaptation_mode=own["context"].adaptation_mode,
                coaching_quality=Decimal(str(round(own["context"].coaching_quality, 3))),
                analysis_quality=own["context"].analysis_quality,
                context_payload=payload,
                context_hash=payload_sha256(payload),
            )
            result[str(lineup.club_id)] = (snapshot, own["context"])
        return result

    @classmethod
    def _prepare(cls, lineup):
        try:
            plan = MatchTacticalPlan.objects.prefetch_related("instructions").get(lineup=lineup)
        except MatchTacticalPlan.DoesNotExist:
            plan = None
        instructions = () if plan is None else tuple(
            TacticalInstructionState(
                priority=row.priority,
                trigger_type=row.trigger_type,
                minute_from=row.minute_from,
                attacking_strategy=row.attacking_strategy,
                defensive_strategy=row.defensive_strategy,
            )
            for row in plan.instructions.all().order_by("priority", "id")
        )
        assignments = {
            row.role: row
            for row in ClubStaffAssignment.objects.select_related("staff_member__capability")
            .filter(club=lineup.club, status=ASSIGNMENT_ACTIVE, role__in=[HEAD_COACH, ASSISTANT_COACH, ANALYST])
            .order_by("role", "staff_member__capability__tactical", "staff_member__capability__level", "id")
        }

        from staff.match_effects import current_effect
        eligible = {row["assignment_id"] for row in current_effect(lineup.club_id)["staff"]}
        assignments = {role: row for role, row in assignments.items() if (not row.employment_plan_id and role != HEAD_COACH) or str(row.pk) in eligible}

        def capability(role, field, default):
            assignment = assignments.get(role)
            if assignment is None:
                return default
            return int(getattr(assignment.staff_member.capability, field))

        head_tactical = capability(HEAD_COACH, "tactical", 50)
        head_leadership = capability(HEAD_COACH, "leadership", 50)
        assistant_tactical = capability(ASSISTANT_COACH, "tactical", 50)
        analyst_tactical = capability(ANALYST, "tactical", 0)
        analyst_level = capability(ANALYST, "level", 0)
        analysis_quality = min(100, round(
            analyst_tactical * 0.65 + analyst_level * 6.0 + head_tactical * 0.15
        ))
        context = TeamTacticalContext(
            attacking_strategy=plan.attacking_strategy if plan else AttackingStrategy.BALANCED,
            defensive_strategy=plan.defensive_strategy if plan else DefensiveStrategy.BALANCED,
            adaptation_mode=plan.adaptation_mode if plan else TacticalAdaptationMode.BALANCED,
            instructions=instructions,
            head_coach_tactical=head_tactical,
            head_coach_leadership=head_leadership,
            assistant_coach_tactical=assistant_tactical,
            analyst_tactical=analyst_tactical,
            analyst_level=analyst_level,
            analysis_quality=analysis_quality,
        )
        staff_payload = {}
        for role, assignment in assignments.items():
            profile = assignment.staff_member.capability
            staff_payload[role] = {
                "assignment_id": str(assignment.pk),
                "staff_member_id": str(assignment.staff_member_id),
                "capability_revision": profile.revision,
                "level": profile.level,
                "leadership": profile.leadership,
                "tactical": profile.tactical,
            }
        payload = {
            "schema_version": 1,
            "match_id": str(lineup.match_id),
            "club_id": str(lineup.club_id),
            "lineup_id": str(lineup.pk),
            "formation": lineup.formation,
            "plan_id": str(plan.pk) if plan else None,
            "tactical_context": context.to_payload(),
            "staff": staff_payload,
        }
        return {
            "lineup": lineup,
            "plan": plan,
            "context": context,
            "assignments": assignments,
            "payload": payload,
        }
