"""Pure-Python contracts for authoritative match reports.

These structures deliberately contain only facts the current simulation can
truthfully support. Cards, assists, substitutions, shots and possession are not
represented until an engine/report version models them authoritatively.
"""

from __future__ import annotations

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

from ..state import EngineStateError

REPORT_SCHEMA_VERSION = 1
GOAL_EVENT = "GOAL"


def _non_empty(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: int = 0, maximum: int | None = None) -> int:
    if isinstance(value, bool) or not isinstance(value, int):
        raise EngineStateError(f"{field} must be an integer.")
    if value < minimum:
        raise EngineStateError(f"{field} must be >= {minimum}.")
    if maximum is not None and value > maximum:
        raise EngineStateError(f"{field} must be <= {maximum}.")
    return value


@dataclass(frozen=True, slots=True)
class ReportEvent:
    sequence: int
    minute: int
    event_type: str
    club_id: str
    player_id: str

    def __post_init__(self):
        _integer(self.sequence, "event sequence", minimum=1)
        _integer(self.minute, "event minute", minimum=1, maximum=90)
        if self.event_type != GOAL_EVENT:
            raise EngineStateError(f"Unsupported report event type: {self.event_type!r}.")
        _non_empty(self.club_id, "event club_id")
        _non_empty(self.player_id, "event player_id")

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

    @classmethod
    def from_payload(cls, payload: Mapping[str, Any]) -> "ReportEvent":
        if not isinstance(payload, Mapping):
            raise EngineStateError("Report event payload must be a mapping.")
        return cls(
            sequence=payload.get("sequence"),
            minute=payload.get("minute"),
            event_type=payload.get("event_type"),
            club_id=payload.get("club_id"),
            player_id=payload.get("player_id"),
        )


@dataclass(frozen=True, slots=True)
class TeamMatchStatistics:
    club_id: str
    goals_for: int
    goals_against: int
    clean_sheet: bool

    def __post_init__(self):
        _non_empty(self.club_id, "team statistics club_id")
        _integer(self.goals_for, "goals_for", minimum=0)
        _integer(self.goals_against, "goals_against", minimum=0)
        if not isinstance(self.clean_sheet, bool):
            raise EngineStateError("clean_sheet must be boolean.")
        if self.clean_sheet != (self.goals_against == 0):
            raise EngineStateError("clean_sheet must agree with goals_against.")

    def to_payload(self) -> dict[str, Any]:
        return {
            "club_id": self.club_id,
            "goals_for": self.goals_for,
            "goals_against": self.goals_against,
            "clean_sheet": self.clean_sheet,
        }

    @classmethod
    def from_payload(cls, payload: Mapping[str, Any]) -> "TeamMatchStatistics":
        if not isinstance(payload, Mapping):
            raise EngineStateError("Team statistics payload must be a mapping.")
        return cls(
            club_id=payload.get("club_id"),
            goals_for=payload.get("goals_for"),
            goals_against=payload.get("goals_against"),
            clean_sheet=payload.get("clean_sheet"),
        )


@dataclass(frozen=True, slots=True)
class PlayerMatchStatistics:
    player_id: str
    club_id: str
    started: bool
    minutes_played: int
    goals: int
    clean_sheet: bool

    def __post_init__(self):
        _non_empty(self.player_id, "player statistics player_id")
        _non_empty(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", minimum=0, maximum=120)
        _integer(self.goals, "player goals", minimum=0)
        if not isinstance(self.clean_sheet, bool):
            raise EngineStateError("clean_sheet must be boolean.")
        if self.started and self.minutes_played <= 0:
            raise EngineStateError("A starter must have positive minutes_played.")

    def to_payload(self) -> dict[str, Any]:
        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,
        }

    @classmethod
    def from_payload(cls, payload: Mapping[str, Any]) -> "PlayerMatchStatistics":
        if not isinstance(payload, Mapping):
            raise EngineStateError("Player statistics payload must be a mapping.")
        return cls(
            player_id=payload.get("player_id"),
            club_id=payload.get("club_id"),
            started=payload.get("started"),
            minutes_played=payload.get("minutes_played"),
            goals=payload.get("goals"),
            clean_sheet=payload.get("clean_sheet"),
        )


@dataclass(frozen=True, slots=True)
class MatchReport:
    events: tuple[ReportEvent, ...]
    team_statistics: tuple[TeamMatchStatistics, ...]
    player_statistics: tuple[PlayerMatchStatistics, ...]
    schema_version: int = REPORT_SCHEMA_VERSION

    def __post_init__(self):
        _integer(self.schema_version, "report schema_version", minimum=1)

        sequences = [event.sequence for event in self.events]
        if sequences != list(range(1, len(self.events) + 1)):
            raise EngineStateError("Report event sequences must be contiguous from 1.")
        if list(self.events) != sorted(self.events, key=lambda e: (e.minute, e.sequence)):
            raise EngineStateError("Report events must be ordered by minute/sequence.")

        team_ids = [item.club_id for item in self.team_statistics]
        if len(team_ids) != 2 or len(set(team_ids)) != 2:
            raise EngineStateError("A match report must contain exactly two team statistics rows.")

        player_ids = [item.player_id for item in self.player_statistics]
        if len(player_ids) != len(set(player_ids)):
            raise EngineStateError("Player statistics cannot contain duplicate players.")

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

    @classmethod
    def from_payload(cls, payload: Mapping[str, Any]) -> "MatchReport":
        if not isinstance(payload, Mapping):
            raise EngineStateError("MatchReport payload must be a mapping.")
        events = payload.get("events")
        team_stats = payload.get("team_statistics")
        player_stats = payload.get("player_statistics")
        for value, field in (
            (events, "events"),
            (team_stats, "team_statistics"),
            (player_stats, "player_statistics"),
        ):
            if not isinstance(value, Iterable) or isinstance(value, (str, bytes, Mapping)):
                raise EngineStateError(f"{field} must be a sequence.")
        return cls(
            schema_version=payload.get("schema_version"),
            events=tuple(ReportEvent.from_payload(item) for item in events),
            team_statistics=tuple(TeamMatchStatistics.from_payload(item) for item in team_stats),
            player_statistics=tuple(PlayerMatchStatistics.from_payload(item) for item in player_stats),
        )
