"""Pure medical protocol contracts for authoritative in-match health decisions.

These values are frozen into the kickoff snapshot.  The match engine can then
make deterministic treatment / return-to-play decisions without consulting the
ORM or mutable club configuration during replay.
"""
from __future__ import annotations

from dataclasses import dataclass
from typing import Any, Mapping


class MedicalStateError(ValueError):
    pass


def _int(value: Any, name: str, low: int, high: int) -> int:
    if isinstance(value, bool) or not isinstance(value, int) or not low <= value <= high:
        raise MedicalStateError(f"{name} must be an integer in [{low}, {high}].")
    return value


@dataclass(frozen=True, slots=True)
class MedicalRules:
    """Competition-level safety protocol frozen at kickoff.

    A confirmed concussion can never return in the same match.  The optional
    concussion substitution is an additional replacement allowance used only
    when the competition explicitly enables it.
    """

    medical_stoppages_enabled: bool = True
    concussion_protocol_enabled: bool = True
    mandatory_concussion_removal: bool = True
    concussion_substitution_enabled: bool = False
    max_concussion_substitutions: int = 1
    max_assessment_seconds: int = 300

    def __post_init__(self):
        for name in (
            "medical_stoppages_enabled",
            "concussion_protocol_enabled",
            "mandatory_concussion_removal",
            "concussion_substitution_enabled",
        ):
            if not isinstance(getattr(self, name), bool):
                raise MedicalStateError(f"{name} must be boolean.")
        _int(self.max_concussion_substitutions, "max_concussion_substitutions", 0, 2)
        _int(self.max_assessment_seconds, "max_assessment_seconds", 60, 600)
        if self.mandatory_concussion_removal and not self.concussion_protocol_enabled:
            raise MedicalStateError(
                "mandatory_concussion_removal requires concussion_protocol_enabled."
            )
        if self.concussion_substitution_enabled and self.max_concussion_substitutions < 1:
            raise MedicalStateError(
                "Enabled concussion substitutions require at least one allowance."
            )

    def to_payload(self) -> dict[str, Any]:
        return {
            "medical_stoppages_enabled": self.medical_stoppages_enabled,
            "concussion_protocol_enabled": self.concussion_protocol_enabled,
            "mandatory_concussion_removal": self.mandatory_concussion_removal,
            "concussion_substitution_enabled": self.concussion_substitution_enabled,
            "max_concussion_substitutions": self.max_concussion_substitutions,
            "max_assessment_seconds": self.max_assessment_seconds,
        }

    @classmethod
    def from_payload(cls, payload: Mapping[str, Any] | None) -> "MedicalRules":
        payload = payload or {}
        return cls(
            medical_stoppages_enabled=payload.get("medical_stoppages_enabled", True),
            concussion_protocol_enabled=payload.get("concussion_protocol_enabled", True),
            mandatory_concussion_removal=payload.get("mandatory_concussion_removal", True),
            concussion_substitution_enabled=payload.get("concussion_substitution_enabled", False),
            max_concussion_substitutions=payload.get("max_concussion_substitutions", 1),
            max_assessment_seconds=payload.get("max_assessment_seconds", 300),
        )


@dataclass(frozen=True, slots=True)
class TeamMedicalContext:
    """Frozen club medical-department capability used only for borderline cases.

    Capability may improve recognition, treatment and conservative decisions,
    but it never permits a confirmed concussion to return to play.
    """

    assessment_quality: int = 60
    treatment_quality: int = 60
    concussion_recognition: int = 70
    welfare_bias: int = 75
    source: str = "DEFAULT"

    def __post_init__(self):
        _int(self.assessment_quality, "assessment_quality", 1, 100)
        _int(self.treatment_quality, "treatment_quality", 1, 100)
        _int(self.concussion_recognition, "concussion_recognition", 1, 100)
        _int(self.welfare_bias, "welfare_bias", 1, 100)
        if not isinstance(self.source, str) or not self.source.strip():
            raise MedicalStateError("source must be non-empty.")

    def to_payload(self) -> dict[str, Any]:
        return {
            "assessment_quality": self.assessment_quality,
            "treatment_quality": self.treatment_quality,
            "concussion_recognition": self.concussion_recognition,
            "welfare_bias": self.welfare_bias,
            "source": self.source,
        }

    @classmethod
    def from_payload(cls, payload: Mapping[str, Any] | None) -> "TeamMedicalContext":
        payload = payload or {}
        return cls(
            assessment_quality=payload.get("assessment_quality", 60),
            treatment_quality=payload.get("treatment_quality", 60),
            concussion_recognition=payload.get("concussion_recognition", 70),
            welfare_bias=payload.get("welfare_bias", 75),
            source=payload.get("source", "DEFAULT"),
        )
