"""Pure set-piece policy primitives shared by snapshot, validation and engines."""
from __future__ import annotations

from dataclasses import dataclass
from typing import Any, Mapping

CORNER_ROUTINES = frozenset({"MIXED", "NEAR_POST", "FAR_POST", "CROWD_KEEPER", "SHORT"})
FREE_KICK_ROUTINES = frozenset({"MIXED", "DIRECT", "CROSS", "SHORT"})


@dataclass(frozen=True, slots=True)
class TeamSetPiecePlan:
    penalty_taker_id: str | None = None
    direct_free_kick_taker_id: str | None = None
    left_corner_taker_id: str | None = None
    right_corner_taker_id: str | None = None
    aerial_target_player_id: str | None = None
    penalty_order: tuple[str, ...] = ()
    corner_routine: str = "MIXED"
    free_kick_routine: str = "MIXED"

    def __post_init__(self):
        for name in (
            "penalty_taker_id", "direct_free_kick_taker_id", "left_corner_taker_id",
            "right_corner_taker_id", "aerial_target_player_id",
        ):
            value = getattr(self, name)
            if value is not None and (not isinstance(value, str) or not value.strip()):
                raise ValueError(f"{name} must be null or a non-empty player id.")
        if self.corner_routine not in CORNER_ROUTINES:
            raise ValueError("Unsupported corner routine.")
        if self.free_kick_routine not in FREE_KICK_ROUTINES:
            raise ValueError("Unsupported free-kick routine.")
        if len(self.penalty_order) > 11 or len(set(self.penalty_order)) != len(self.penalty_order):
            raise ValueError("Penalty order must contain at most 11 unique player ids.")
        if any(not isinstance(pid, str) or not pid.strip() for pid in self.penalty_order):
            raise ValueError("Penalty order player ids must be non-empty strings.")

    def to_payload(self) -> dict[str, Any]:
        return {
            "penalty_taker_id": self.penalty_taker_id,
            "direct_free_kick_taker_id": self.direct_free_kick_taker_id,
            "left_corner_taker_id": self.left_corner_taker_id,
            "right_corner_taker_id": self.right_corner_taker_id,
            "aerial_target_player_id": self.aerial_target_player_id,
            "penalty_order": list(self.penalty_order),
            "corner_routine": self.corner_routine,
            "free_kick_routine": self.free_kick_routine,
        }

    @classmethod
    def from_payload(cls, payload: Mapping[str, Any] | None) -> "TeamSetPiecePlan":
        payload = payload or {}
        order = payload.get("penalty_order") or ()
        if isinstance(order, (str, bytes)):
            raise ValueError("penalty_order must be a sequence.")
        return cls(
            penalty_taker_id=payload.get("penalty_taker_id"),
            direct_free_kick_taker_id=payload.get("direct_free_kick_taker_id"),
            left_corner_taker_id=payload.get("left_corner_taker_id"),
            right_corner_taker_id=payload.get("right_corner_taker_id"),
            aerial_target_player_id=payload.get("aerial_target_player_id"),
            penalty_order=tuple(str(value) for value in order),
            corner_routine=payload.get("corner_routine", "MIXED"),
            free_kick_routine=payload.get("free_kick_routine", "MIXED"),
        )
