"""Pure authoritative Match Report v2 contracts.

v2 models the facts needed by the live-match domain: goals, substitutions,
cards, in-match injuries, extra time and penalty shootouts.  It intentionally
remains pure Python so historical reports can be replayed without Django.
"""
from __future__ import annotations

from dataclasses import dataclass
from typing import Any, Iterable, Mapping

from ..state import EngineStateError

REPORT_SCHEMA_VERSION = 2
REPORT_BUILDER_KEY = "ftg.match.report.v2"
REPORT_BUILDER_VERSION = "2.0.0"

EVENT_GOAL = "GOAL"
EVENT_YELLOW = "YELLOW_CARD"
EVENT_SECOND_YELLOW = "SECOND_YELLOW"
EVENT_RED = "RED_CARD"
EVENT_SUBSTITUTION = "SUBSTITUTION"
EVENT_INJURY = "INJURY"
EVENT_PENALTY_SCORED = "PENALTY_SCORED"
EVENT_PENALTY_MISSED = "PENALTY_MISSED"

SUPPORTED_EVENTS = {
    EVENT_GOAL,
    EVENT_YELLOW,
    EVENT_SECOND_YELLOW,
    EVENT_RED,
    EVENT_SUBSTITUTION,
    EVENT_INJURY,
    EVENT_PENALTY_SCORED,
    EVENT_PENALTY_MISSED,
}

PHASE_REGULATION = "REGULATION"
PHASE_EXTRA_TIME = "EXTRA_TIME"
PHASE_SHOOTOUT = "SHOOTOUT"
SUPPORTED_PHASES = {PHASE_REGULATION, PHASE_EXTRA_TIME, PHASE_SHOOTOUT}


def _string(value: Any, field: str) -> str:
    if not isinstance(value, str) or not value.strip():
        raise EngineStateError(f"{field} must be a non-empty string.")
    return value


def _integer(value: Any, field: str, minimum=0, maximum=None) -> int:
    if isinstance(value, bool) or not isinstance(value, int):
        raise EngineStateError(f"{field} must be an integer.")
    if value < minimum or (maximum is not None and value > maximum):
        raise EngineStateError(f"{field} is outside the supported range.")
    return value


@dataclass(frozen=True, slots=True)
class ReportEventV2:
    sequence: int
    minute: int
    phase: str
    event_type: str
    club_id: str
    player_id: str
    secondary_player_id: str | None = None
    detail: tuple[tuple[str, Any], ...] = ()

    def __post_init__(self):
        _integer(self.sequence, "event sequence", 1)
        _integer(self.minute, "event minute", 1, 120)
        if self.phase not in SUPPORTED_PHASES:
            raise EngineStateError("Unsupported match event phase.")
        if self.event_type not in SUPPORTED_EVENTS:
            raise EngineStateError("Unsupported Match Report v2 event type.")
        _string(self.club_id, "event club_id")
        _string(self.player_id, "event player_id")
        if self.event_type == EVENT_SUBSTITUTION:
            _string(self.secondary_player_id, "substitution secondary_player_id")
            if self.secondary_player_id == self.player_id:
                raise EngineStateError("A substitution must exchange two different players.")
        elif self.secondary_player_id is not None:
            raise EngineStateError("secondary_player_id is only valid for substitutions.")
        if self.phase == PHASE_SHOOTOUT and self.event_type not in {
            EVENT_PENALTY_SCORED, EVENT_PENALTY_MISSED
        }:
            raise EngineStateError("Only penalty events may use the SHOOTOUT phase.")
        if self.event_type in {EVENT_PENALTY_SCORED, EVENT_PENALTY_MISSED} and self.phase != PHASE_SHOOTOUT:
            raise EngineStateError("Penalty shootout events must use SHOOTOUT phase.")

    @property
    def detail_payload(self) -> dict[str, Any]:
        return {str(k): v for k, v in self.detail}

    def to_payload(self) -> dict[str, Any]:
        return {
            "sequence": self.sequence,
            "minute": self.minute,
            "phase": self.phase,
            "event_type": self.event_type,
            "club_id": self.club_id,
            "player_id": self.player_id,
            "secondary_player_id": self.secondary_player_id,
            "detail": self.detail_payload,
        }


@dataclass(frozen=True, slots=True)
class TeamMatchStatisticsV2:
    club_id: str
    goals_for: int
    goals_against: int
    clean_sheet: bool
    yellow_cards: int
    red_cards: int
    substitutions: int

    def __post_init__(self):
        _string(self.club_id, "team club_id")
        for field, value in (
            ("goals_for", self.goals_for), ("goals_against", self.goals_against),
            ("yellow_cards", self.yellow_cards), ("red_cards", self.red_cards),
            ("substitutions", self.substitutions),
        ):
            _integer(value, field, 0)
        if not isinstance(self.clean_sheet, bool) or self.clean_sheet != (self.goals_against == 0):
            raise EngineStateError("Team clean_sheet is inconsistent.")

    def to_payload(self):
        return {
            "club_id": self.club_id,
            "goals_for": self.goals_for,
            "goals_against": self.goals_against,
            "clean_sheet": self.clean_sheet,
            "yellow_cards": self.yellow_cards,
            "red_cards": self.red_cards,
            "substitutions": self.substitutions,
        }


@dataclass(frozen=True, slots=True)
class PlayerMatchStatisticsV2:
    player_id: str
    club_id: str
    started: bool
    minutes_played: int
    goals: int
    clean_sheet: bool
    yellow_cards: int = 0
    red_cards: int = 0
    substituted_in: bool = False
    substituted_out: bool = False
    injured: bool = False

    def __post_init__(self):
        _string(self.player_id, "player statistics player_id")
        _string(self.club_id, "player statistics club_id")
        if not isinstance(self.started, bool):
            raise EngineStateError("started must be boolean.")
        _integer(self.minutes_played, "minutes_played", 0, 120)
        _integer(self.goals, "goals", 0)
        _integer(self.yellow_cards, "yellow_cards", 0, 2)
        _integer(self.red_cards, "red_cards", 0, 1)
        for name, value in (
            ("clean_sheet", self.clean_sheet), ("substituted_in", self.substituted_in),
            ("substituted_out", self.substituted_out), ("injured", self.injured),
        ):
            if not isinstance(value, bool):
                raise EngineStateError(f"{name} must be boolean.")
        if self.started and self.substituted_in:
            raise EngineStateError("A starter cannot be marked substituted_in.")
        if self.started and self.minutes_played <= 0:
            raise EngineStateError("A starter must have positive minutes played.")

    def to_payload(self):
        return {
            "player_id": self.player_id,
            "club_id": self.club_id,
            "started": self.started,
            "minutes_played": self.minutes_played,
            "goals": self.goals,
            "clean_sheet": self.clean_sheet,
            "yellow_cards": self.yellow_cards,
            "red_cards": self.red_cards,
            "substituted_in": self.substituted_in,
            "substituted_out": self.substituted_out,
            "injured": self.injured,
        }


@dataclass(frozen=True, slots=True)
class MatchReportV2:
    events: tuple[ReportEventV2, ...]
    team_statistics: tuple[TeamMatchStatisticsV2, ...]
    player_statistics: tuple[PlayerMatchStatisticsV2, ...]
    schema_version: int = REPORT_SCHEMA_VERSION

    def __post_init__(self):
        if self.schema_version != REPORT_SCHEMA_VERSION:
            raise EngineStateError("Unsupported Match Report v2 schema.")
        sequences = [e.sequence for e in self.events]
        if sequences != list(range(1, len(self.events) + 1)):
            raise EngineStateError("Report event sequences must be contiguous from 1.")
        phase_order = {PHASE_REGULATION: 0, PHASE_EXTRA_TIME: 1, PHASE_SHOOTOUT: 2}
        if list(self.events) != sorted(
            self.events, key=lambda e: (phase_order[e.phase], e.minute, e.sequence)
        ):
            raise EngineStateError("Report events are not chronologically ordered.")
        if len({row.club_id for row in self.team_statistics}) != 2:
            raise EngineStateError("A report must contain two team rows.")
        player_ids = [row.player_id for row in self.player_statistics]
        if len(player_ids) != len(set(player_ids)):
            raise EngineStateError("Player statistic rows must be unique.")

    def to_payload(self) -> dict[str, Any]:
        return {
            "schema_version": self.schema_version,
            "events": [e.to_payload() for e in self.events],
            "team_statistics": [r.to_payload() for r in self.team_statistics],
            "player_statistics": [r.to_payload() for r in self.player_statistics],
        }
