from __future__ import annotations

from dataclasses import dataclass
from typing import Any, Iterable, Mapping

from .setpieces import TeamSetPiecePlan
from .officiating import OfficiatingRules
from .environment import MatchEnvironmentState
from .medical import MedicalRules, TeamMedicalContext
from .clock import ClockRules


STATE_SCHEMA_VERSION = 8


class EngineStateError(ValueError):
    """Raised when an engine state/result payload violates the pure contract."""


def _require_non_empty_string(value: Any, *, field_name: str) -> str:
    if not isinstance(value, str) or not value.strip():
        raise EngineStateError(f"{field_name} must be a non-empty string.")
    return value


def _require_int(value: Any, *, field_name: str, minimum: int | None = None) -> int:
    if isinstance(value, bool) or not isinstance(value, int):
        raise EngineStateError(f"{field_name} must be an integer.")
    if minimum is not None and value < minimum:
        raise EngineStateError(f"{field_name} must be >= {minimum}.")
    return value


@dataclass(frozen=True, slots=True)
class PlayerState:
    player_id: str
    natural_position: str
    lineup_slot: str
    role: str
    is_captain: bool
    ratings: tuple[tuple[str, int], ...]
    fatigue_index: int = 0
    tactical_role: str = "AUTO"
    position_familiarity: int = 100
    position_familiarities: tuple[tuple[str, int], ...] = ()

    def __post_init__(self):
        _require_non_empty_string(self.player_id, field_name="player_id")
        _require_non_empty_string(
            self.natural_position, field_name="natural_position"
        )
        _require_non_empty_string(self.role, field_name="role")
        if not isinstance(self.lineup_slot, str):
            raise EngineStateError("lineup_slot must be a string.")
        if not isinstance(self.is_captain, bool):
            raise EngineStateError("is_captain must be boolean.")

        _require_int(self.fatigue_index, field_name="fatigue_index", minimum=0)
        if self.fatigue_index > 100:
            raise EngineStateError("fatigue_index must be <= 100.")
        _require_non_empty_string(self.tactical_role, field_name="tactical_role")
        _require_int(self.position_familiarity, field_name="position_familiarity", minimum=0)
        if self.position_familiarity > 100:
            raise EngineStateError("position_familiarity must be <= 100.")
        familiar_positions = set()
        for position, value in self.position_familiarities:
            _require_non_empty_string(position, field_name="familiarity position")
            _require_int(value, field_name=f"familiarity {position}", minimum=0)
            if value > 100:
                raise EngineStateError(f"familiarity {position} must be <= 100.")
            if position in familiar_positions:
                raise EngineStateError(f"Duplicate position familiarity {position}.")
            familiar_positions.add(position)

        seen = set()
        for name, value in self.ratings:
            _require_non_empty_string(name, field_name="rating name")
            _require_int(value, field_name=f"rating {name}", minimum=1)
            if value > 100:
                raise EngineStateError(f"rating {name} must be <= 100.")
            if name in seen:
                raise EngineStateError(f"Duplicate rating {name}.")
            seen.add(name)

    def to_payload(self) -> dict[str, Any]:
        return {
            "player_id": self.player_id,
            "natural_position": self.natural_position,
            "lineup_slot": self.lineup_slot,
            "role": self.role,
            "is_captain": self.is_captain,
            "ratings": {name: value for name, value in self.ratings},
            "fatigue_index": self.fatigue_index,
            "tactical_role": self.tactical_role,
            "position_familiarity": self.position_familiarity,
            "position_familiarities": {name: value for name, value in self.position_familiarities},
        }

    @classmethod
    def from_payload(cls, payload: Mapping[str, Any]) -> "PlayerState":
        ratings = payload.get("ratings")
        if not isinstance(ratings, Mapping):
            raise EngineStateError("ratings must be a mapping.")
        familiarities = payload.get("position_familiarities") or {}
        if not isinstance(familiarities, Mapping):
            raise EngineStateError("position_familiarities must be a mapping.")
        return cls(
            player_id=payload.get("player_id"),
            natural_position=payload.get("natural_position"),
            lineup_slot=payload.get("lineup_slot", ""),
            role=payload.get("role"),
            is_captain=payload.get("is_captain"),
            ratings=tuple(sorted((str(k), v) for k, v in ratings.items())),
            fatigue_index=payload.get("fatigue_index", 0),
            tactical_role=payload.get("tactical_role", "AUTO"),
            position_familiarity=payload.get("position_familiarity", 100),
            position_familiarities=tuple(sorted((str(k), int(v)) for k, v in familiarities.items())),
        )


@dataclass(frozen=True, slots=True)
class TeamState:
    club_id: str
    formation: str
    starters: tuple[PlayerState, ...]
    substitutes: tuple[PlayerState, ...]
    set_piece_plan: TeamSetPiecePlan = TeamSetPiecePlan()
    formation_training: tuple[tuple[str, float], ...] = ()

    def __post_init__(self):
        training_ids = set()
        for player_id, points in self.formation_training:
            _require_non_empty_string(player_id, field_name="formation training player")
            if player_id in training_ids or isinstance(points, bool) or not isinstance(points, (int, float)) or not 0 <= points <= 100:
                raise EngineStateError("Formation training requires unique players and points 0..100.")
            training_ids.add(player_id)
        _require_non_empty_string(self.club_id, field_name="club_id")
        _require_non_empty_string(self.formation, field_name="formation")
        if len(self.starters) != 11:
            raise EngineStateError("A TeamState must contain exactly 11 starters.")

        player_ids = [p.player_id for p in (*self.starters, *self.substitutes)]
        if len(player_ids) != len(set(player_ids)):
            raise EngineStateError("A TeamState cannot contain duplicate players.")
        if not training_ids <= set(player_ids):
            raise EngineStateError("Formation training must refer to selected squad players.")

        captain_count = sum(1 for player in self.starters if player.is_captain)
        if captain_count != 1:
            raise EngineStateError("A TeamState must contain exactly one captain.")
        if any(player.is_captain for player in self.substitutes):
            raise EngineStateError("A substitute cannot be captain in TeamState.")

    def to_payload(self) -> dict[str, Any]:
        return {
            "club_id": self.club_id,
            "formation": self.formation,
            "starters": [player.to_payload() for player in self.starters],
            "substitutes": [player.to_payload() for player in self.substitutes],
            "set_piece_plan": self.set_piece_plan.to_payload(),
            **({"formation_training": dict(self.formation_training)} if self.formation_training else {}),
        }

    @classmethod
    def from_payload(cls, payload: Mapping[str, Any]) -> "TeamState":
        learning = payload.get("formation_training") or {}
        if not isinstance(learning, Mapping):
            raise EngineStateError("formation_training must be a mapping.")
        starters = payload.get("starters")
        substitutes = payload.get("substitutes")
        if not isinstance(starters, Iterable) or isinstance(starters, (str, bytes)):
            raise EngineStateError("starters must be a sequence.")
        if not isinstance(substitutes, Iterable) or isinstance(
            substitutes, (str, bytes)
        ):
            raise EngineStateError("substitutes must be a sequence.")
        return cls(
            club_id=payload.get("club_id"),
            formation=payload.get("formation"),
            starters=tuple(PlayerState.from_payload(item) for item in starters),
            substitutes=tuple(
                PlayerState.from_payload(item) for item in substitutes
            ),
            set_piece_plan=TeamSetPiecePlan.from_payload(payload.get("set_piece_plan")),
            formation_training=tuple(sorted(learning.items())),
        )


@dataclass(frozen=True, slots=True)
class MatchRules:
    requires_winner: bool = False
    allows_extra_time: bool = False
    allows_penalties: bool = False
    max_substitutions: int = 5
    max_substitution_windows: int = 3
    officiating: OfficiatingRules = OfficiatingRules()
    medical: MedicalRules = MedicalRules()
    clock: ClockRules = ClockRules()

    def __post_init__(self):
        for name, value in (
            ("requires_winner", self.requires_winner),
            ("allows_extra_time", self.allows_extra_time),
            ("allows_penalties", self.allows_penalties),
        ):
            if not isinstance(value, bool):
                raise EngineStateError(f"{name} must be boolean.")
        _require_int(self.max_substitutions, field_name="max_substitutions", minimum=0)
        _require_int(self.max_substitution_windows, field_name="max_substitution_windows", minimum=0)
        if self.max_substitutions > 6 or self.max_substitution_windows > 4:
            raise EngineStateError("Match substitution rules exceed supported v2 limits.")
        if self.requires_winner and not (self.allows_extra_time or self.allows_penalties):
            raise EngineStateError("Winner-required match needs a draw-resolution rule.")
        if not isinstance(self.officiating, OfficiatingRules):
            raise EngineStateError("officiating must be OfficiatingRules.")
        if not isinstance(self.medical, MedicalRules):
            raise EngineStateError("medical must be MedicalRules.")
        if not isinstance(self.clock, ClockRules):
            raise EngineStateError("clock must be ClockRules.")

    def to_payload(self) -> dict[str, Any]:
        return {
            "requires_winner": self.requires_winner,
            "allows_extra_time": self.allows_extra_time,
            "allows_penalties": self.allows_penalties,
            "max_substitutions": self.max_substitutions,
            "max_substitution_windows": self.max_substitution_windows,
            "officiating": self.officiating.to_payload(),
            "medical": self.medical.to_payload(),
            "clock": self.clock.to_payload(),
        }

    @classmethod
    def from_payload(cls, payload: Mapping[str, Any] | None) -> "MatchRules":
        payload = payload or {}
        return cls(
            requires_winner=payload.get("requires_winner", False),
            allows_extra_time=payload.get("allows_extra_time", False),
            allows_penalties=payload.get("allows_penalties", False),
            max_substitutions=payload.get("max_substitutions", 5),
            max_substitution_windows=payload.get("max_substitution_windows", 3),
            officiating=OfficiatingRules.from_payload(payload.get("officiating")),
            medical=MedicalRules.from_payload(payload.get("medical")),
            clock=ClockRules.from_payload(payload.get("clock")),
        )


ATTACKING_STRATEGIES = frozenset({
    "BALANCED", "POSSESSION", "DIRECT", "COUNTER_ATTACK", "WIDE_PLAY", "HIGH_TEMPO",
})
DEFENSIVE_STRATEGIES = frozenset({
    "BALANCED", "HIGH_PRESS", "MID_BLOCK", "LOW_BLOCK", "MAN_MARKING", "ZONAL_COMPACT",
})
TACTICAL_ADAPTATION_MODES = frozenset({"STATIC", "BALANCED", "RESPONSIVE"})
TACTICAL_TRIGGER_TYPES = frozenset({
    "MINUTE", "TRAILING", "LEADING", "DRAWING", "SELF_RED_CARD", "OPPONENT_RED_CARD",
})


@dataclass(frozen=True, slots=True)
class TacticalInstructionState:
    priority: int
    trigger_type: str
    minute_from: int
    attacking_strategy: str
    defensive_strategy: str

    def __post_init__(self):
        _require_int(self.priority, field_name="tactical instruction priority", minimum=1)
        _require_int(self.minute_from, field_name="tactical instruction minute_from", minimum=1)
        if self.priority > 100 or self.minute_from > 120:
            raise EngineStateError("Tactical instruction values exceed supported limits.")
        if self.trigger_type not in TACTICAL_TRIGGER_TYPES:
            raise EngineStateError("Unsupported tactical trigger type.")
        if self.attacking_strategy not in ATTACKING_STRATEGIES:
            raise EngineStateError("Unsupported attacking strategy.")
        if self.defensive_strategy not in DEFENSIVE_STRATEGIES:
            raise EngineStateError("Unsupported defensive strategy.")

    def to_payload(self) -> dict[str, Any]:
        return {
            "priority": self.priority,
            "trigger_type": self.trigger_type,
            "minute_from": self.minute_from,
            "attacking_strategy": self.attacking_strategy,
            "defensive_strategy": self.defensive_strategy,
        }

    @classmethod
    def from_payload(cls, payload: Mapping[str, Any]) -> "TacticalInstructionState":
        return cls(
            priority=payload.get("priority"),
            trigger_type=payload.get("trigger_type"),
            minute_from=payload.get("minute_from"),
            attacking_strategy=payload.get("attacking_strategy"),
            defensive_strategy=payload.get("defensive_strategy"),
        )


@dataclass(frozen=True, slots=True)
class TeamTacticalContext:
    attacking_strategy: str = "BALANCED"
    defensive_strategy: str = "BALANCED"
    adaptation_mode: str = "BALANCED"
    instructions: tuple[TacticalInstructionState, ...] = ()
    head_coach_tactical: int = 50
    head_coach_leadership: int = 50
    assistant_coach_tactical: int = 50
    analyst_tactical: int = 0
    analyst_level: int = 0
    analysis_quality: int = 0

    def __post_init__(self):
        if self.attacking_strategy not in ATTACKING_STRATEGIES:
            raise EngineStateError("Unsupported attacking strategy.")
        if self.defensive_strategy not in DEFENSIVE_STRATEGIES:
            raise EngineStateError("Unsupported defensive strategy.")
        if self.adaptation_mode not in TACTICAL_ADAPTATION_MODES:
            raise EngineStateError("Unsupported tactical adaptation mode.")
        for name, value, minimum in (
            ("head_coach_tactical", self.head_coach_tactical, 0),
            ("head_coach_leadership", self.head_coach_leadership, 0),
            ("assistant_coach_tactical", self.assistant_coach_tactical, 0),
            ("analyst_tactical", self.analyst_tactical, 0),
            ("analysis_quality", self.analysis_quality, 0),
        ):
            _require_int(value, field_name=name, minimum=minimum)
            if value > 100:
                raise EngineStateError(f"{name} must be <= 100.")
        _require_int(self.analyst_level, field_name="analyst_level", minimum=0)
        if self.analyst_level > 5:
            raise EngineStateError("analyst_level must be <= 5.")
        priorities = [item.priority for item in self.instructions]
        if len(priorities) != len(set(priorities)):
            raise EngineStateError("Tactical instruction priorities must be unique.")

    @property
    def coaching_quality(self) -> float:
        return (
            self.head_coach_tactical * 0.60
            + self.assistant_coach_tactical * 0.25
            + self.head_coach_leadership * 0.15
        )

    def to_payload(self) -> dict[str, Any]:
        return {
            "attacking_strategy": self.attacking_strategy,
            "defensive_strategy": self.defensive_strategy,
            "adaptation_mode": self.adaptation_mode,
            "instructions": [item.to_payload() for item in self.instructions],
            "head_coach_tactical": self.head_coach_tactical,
            "head_coach_leadership": self.head_coach_leadership,
            "assistant_coach_tactical": self.assistant_coach_tactical,
            "analyst_tactical": self.analyst_tactical,
            "analyst_level": self.analyst_level,
            "analysis_quality": self.analysis_quality,
        }

    @classmethod
    def from_payload(cls, payload: Mapping[str, Any] | None) -> "TeamTacticalContext":
        payload = payload or {}
        instructions = payload.get("instructions") or ()
        return cls(
            attacking_strategy=payload.get("attacking_strategy", "BALANCED"),
            defensive_strategy=payload.get("defensive_strategy", "BALANCED"),
            adaptation_mode=payload.get("adaptation_mode", "BALANCED"),
            instructions=tuple(TacticalInstructionState.from_payload(item) for item in instructions),
            head_coach_tactical=payload.get("head_coach_tactical", 50),
            head_coach_leadership=payload.get("head_coach_leadership", 50),
            assistant_coach_tactical=payload.get("assistant_coach_tactical", 50),
            analyst_tactical=payload.get("analyst_tactical", 0),
            analyst_level=payload.get("analyst_level", 0),
            analysis_quality=payload.get("analysis_quality", 0),
        )


@dataclass(frozen=True, slots=True)
class MatchState:
    match_id: str
    fixture_id: str
    competition_id: str
    season_id: str
    home: TeamState
    away: TeamState
    rules: MatchRules = MatchRules()
    home_tactics: TeamTacticalContext = TeamTacticalContext()
    away_tactics: TeamTacticalContext = TeamTacticalContext()
    environment: MatchEnvironmentState = MatchEnvironmentState()
    home_medical: TeamMedicalContext = TeamMedicalContext()
    away_medical: TeamMedicalContext = TeamMedicalContext()
    schema_version: int = STATE_SCHEMA_VERSION

    def __post_init__(self):
        _require_non_empty_string(self.match_id, field_name="match_id")
        _require_non_empty_string(self.fixture_id, field_name="fixture_id")
        _require_non_empty_string(self.competition_id, field_name="competition_id")
        _require_non_empty_string(self.season_id, field_name="season_id")
        _require_int(self.schema_version, field_name="schema_version", minimum=1)
        if not isinstance(self.environment, MatchEnvironmentState):
            raise EngineStateError("environment must be MatchEnvironmentState.")
        if not isinstance(self.home_medical, TeamMedicalContext) or not isinstance(self.away_medical, TeamMedicalContext):
            raise EngineStateError("home_medical and away_medical must be TeamMedicalContext.")
        if self.home.club_id == self.away.club_id:
            raise EngineStateError("Home and away teams must be different.")
        home_player_ids = {
            player.player_id
            for player in (*self.home.starters, *self.home.substitutes)
        }
        away_player_ids = {
            player.player_id
            for player in (*self.away.starters, *self.away.substitutes)
        }
        if home_player_ids & away_player_ids:
            raise EngineStateError(
                "The same player cannot appear for both teams in MatchState."
            )

    def to_payload(self) -> dict[str, Any]:
        return {
            "schema_version": self.schema_version,
            "match_id": self.match_id,
            "fixture_id": self.fixture_id,
            "competition_id": self.competition_id,
            "season_id": self.season_id,
            "home": self.home.to_payload(),
            "away": self.away.to_payload(),
            "rules": self.rules.to_payload(),
            "home_tactics": self.home_tactics.to_payload(),
            "away_tactics": self.away_tactics.to_payload(),
            "environment": self.environment.to_payload(),
            "home_medical": self.home_medical.to_payload(),
            "away_medical": self.away_medical.to_payload(),
        }

    @classmethod
    def from_payload(cls, payload: Mapping[str, Any]) -> "MatchState":
        if not isinstance(payload, Mapping):
            raise EngineStateError("MatchState payload must be a mapping.")
        return cls(
            schema_version=payload.get("schema_version"),
            match_id=payload.get("match_id"),
            fixture_id=payload.get("fixture_id"),
            competition_id=payload.get("competition_id"),
            season_id=payload.get("season_id"),
            home=TeamState.from_payload(payload.get("home") or {}),
            away=TeamState.from_payload(payload.get("away") or {}),
            rules=MatchRules.from_payload(payload.get("rules")),
            home_tactics=TeamTacticalContext.from_payload(payload.get("home_tactics")),
            away_tactics=TeamTacticalContext.from_payload(payload.get("away_tactics")),
            environment=MatchEnvironmentState.from_payload(payload.get("environment")),
            home_medical=TeamMedicalContext.from_payload(payload.get("home_medical")),
            away_medical=TeamMedicalContext.from_payload(payload.get("away_medical")),
        )


@dataclass(frozen=True, slots=True)
class SimulationResult:
    """Authoritative score output from a concrete match engine.

    Detailed events/statistics remain deliberately outside the score schema.
    They are represented by a separately-versioned MatchReport so expanding
    timeline/statistics contracts never rewrites historical engine-result
    payloads or replay hashes.
    """

    home_score: int
    away_score: int

    def __post_init__(self):
        _require_int(self.home_score, field_name="home_score", minimum=0)
        _require_int(self.away_score, field_name="away_score", minimum=0)

    def to_payload(self) -> dict[str, int]:
        return {
            "home_score": self.home_score,
            "away_score": self.away_score,
        }

    @classmethod
    def from_payload(cls, payload: Mapping[str, Any]) -> "SimulationResult":
        if not isinstance(payload, Mapping):
            raise EngineStateError("SimulationResult payload must be a mapping.")
        return cls(
            home_score=payload.get("home_score"),
            away_score=payload.get("away_score"),
        )
