"""Pure authoritative report contract for Match Engine v3 causal football."""
from __future__ import annotations

from dataclasses import dataclass
from typing import Any, Mapping

from ..state import ATTACKING_STRATEGIES, DEFENSIVE_STRATEGIES, TACTICAL_TRIGGER_TYPES, EngineStateError
from .v2 import MatchReportV2, PlayerMatchStatisticsV2, ReportEventV2, TeamMatchStatisticsV2
from .v22 import TacticalDecisionV22

REPORT_SCHEMA_VERSION = 7
REPORT_BUILDER_KEY = "ftg.match.report.v3.causal"
REPORT_BUILDER_VERSION = "3.12.0"


@dataclass(frozen=True, slots=True)
class MatchReportV3:
    events: tuple[ReportEventV2, ...]
    team_statistics: tuple[TeamMatchStatisticsV2, ...]
    player_statistics: tuple[PlayerMatchStatisticsV2, ...]
    tactical_decisions: tuple[TacticalDecisionV22, ...]
    advanced_analytics: Mapping[str, Any]
    schema_version: int = REPORT_SCHEMA_VERSION

    def __post_init__(self):
        if self.schema_version != REPORT_SCHEMA_VERSION:
            raise EngineStateError("Unsupported Match Report v3 schema.")
        # Reuse the mature v2 event/stat validation contract.
        MatchReportV2(
            events=self.events,
            team_statistics=self.team_statistics,
            player_statistics=self.player_statistics,
        )
        sequences = [row.sequence for row in self.tactical_decisions]
        if sequences != list(range(1, len(sequences) + 1)):
            raise EngineStateError("Causal tactical decision sequences must be contiguous from 1.")
        phase_order = {"REGULATION": 0, "EXTRA_TIME": 1}
        if list(self.tactical_decisions) != sorted(
            self.tactical_decisions,
            key=lambda row: (phase_order[row.phase], row.minute, row.sequence),
        ):
            raise EngineStateError("Causal tactical decisions are not chronologically ordered.")
        if not isinstance(self.advanced_analytics, Mapping):
            raise EngineStateError("advanced_analytics must be a mapping.")
        required = {"schema_version", "policy_key", "policy_version", "team_statistics", "player_statistics", "shots", "man_of_the_match", "segment_statistics"}
        analytics_schema_version = int(self.advanced_analytics.get("schema_version", 0))
        if analytics_schema_version >= 4:
            required |= {"referee_events", "officiating_summary"}
        if analytics_schema_version >= 5:
            required |= {"environment", "environment_effects"}
        if analytics_schema_version >= 6:
            required |= {"medical_events", "medical_summary", "medical_context"}
        if analytics_schema_version >= 7:
            required |= {"defensive_events", "defensive_summary"}
        if analytics_schema_version >= 8:
            required |= {"possession_events", "possession_summary", "pass_events", "passing_network", "transition_summary"}
        if analytics_schema_version >= 9:
            required |= {"pressing_events", "pressing_summary"}
        if analytics_schema_version >= 10:
            required |= {"off_ball_events", "off_ball_summary"}
        if analytics_schema_version >= 11:
            required |= {"goalkeeper_distribution_events", "goalkeeper_distribution_summary"}
        if analytics_schema_version >= 12:
            required |= {"match_clock", "clock_events"}
        if analytics_schema_version >= 13:
            required |= {"bench_ai_decisions", "bench_ai_summary"}
        missing = required - set(self.advanced_analytics)
        if missing:
            raise EngineStateError("Causal advanced analytics is missing: " + ", ".join(sorted(missing)))
        if len(self.advanced_analytics.get("team_statistics") or []) != 2:
            raise EngineStateError("Causal advanced analytics must contain exactly two team rows.")

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