"""Pure-Python policy for matchday deadlines and operational state.

No Django/ORM imports are allowed here.  The policy is deterministic and
versioned so historical operations can be replayed after balancing changes.
"""
from __future__ import annotations

from dataclasses import dataclass
from datetime import datetime, timedelta


POLICY_KEY = "ftg.matchday.operations.v1"
POLICY_VERSION = "1.0.0"
SCHEMA_VERSION = 1

DEFAULT_LINEUP_DEADLINE_MINUTES = 60
DEFAULT_CHECKIN_OPEN_MINUTES = 120
DEFAULT_CHECKIN_DEADLINE_MINUTES = 15
DEFAULT_MAX_DELAY_MINUTES = 15


@dataclass(frozen=True)
class MatchdayTimeline:
    lineup_deadline_at: datetime
    checkin_opens_at: datetime
    checkin_deadline_at: datetime
    kickoff_at: datetime
    grace_deadline_at: datetime


class MatchdayOperationsPolicyV1:
    policy_key = POLICY_KEY
    policy_version = POLICY_VERSION
    schema_version = SCHEMA_VERSION

    @classmethod
    def build_timeline(
        cls,
        *,
        kickoff_at: datetime,
        lineup_deadline_minutes: int = DEFAULT_LINEUP_DEADLINE_MINUTES,
        checkin_open_minutes: int = DEFAULT_CHECKIN_OPEN_MINUTES,
        checkin_deadline_minutes: int = DEFAULT_CHECKIN_DEADLINE_MINUTES,
        max_delay_minutes: int = DEFAULT_MAX_DELAY_MINUTES,
    ) -> MatchdayTimeline:
        if kickoff_at.tzinfo is None or kickoff_at.utcoffset() is None:
            raise ValueError("kickoff_at must be timezone-aware")
        cls.validate_parameters(
            lineup_deadline_minutes=lineup_deadline_minutes,
            checkin_open_minutes=checkin_open_minutes,
            checkin_deadline_minutes=checkin_deadline_minutes,
            max_delay_minutes=max_delay_minutes,
        )
        return MatchdayTimeline(
            lineup_deadline_at=kickoff_at - timedelta(minutes=lineup_deadline_minutes),
            checkin_opens_at=kickoff_at - timedelta(minutes=checkin_open_minutes),
            checkin_deadline_at=kickoff_at - timedelta(minutes=checkin_deadline_minutes),
            kickoff_at=kickoff_at,
            grace_deadline_at=kickoff_at + timedelta(minutes=max_delay_minutes),
        )

    @staticmethod
    def validate_parameters(
        *,
        lineup_deadline_minutes: int,
        checkin_open_minutes: int,
        checkin_deadline_minutes: int,
        max_delay_minutes: int,
    ) -> None:
        values = {
            "lineup_deadline_minutes": lineup_deadline_minutes,
            "checkin_open_minutes": checkin_open_minutes,
            "checkin_deadline_minutes": checkin_deadline_minutes,
            "max_delay_minutes": max_delay_minutes,
        }
        if any(not isinstance(value, int) for value in values.values()):
            raise TypeError("matchday timing parameters must be integers")
        if not 15 <= lineup_deadline_minutes <= 360:
            raise ValueError("lineup_deadline_minutes must be between 15 and 360")
        if not 30 <= checkin_open_minutes <= 360:
            raise ValueError("checkin_open_minutes must be between 30 and 360")
        if not 0 <= checkin_deadline_minutes <= 120:
            raise ValueError("checkin_deadline_minutes must be between 0 and 120")
        if not 0 <= max_delay_minutes <= 120:
            raise ValueError("max_delay_minutes must be between 0 and 120")
        if checkin_open_minutes <= checkin_deadline_minutes:
            raise ValueError("check-in open time must precede the check-in deadline")
        if lineup_deadline_minutes < checkin_deadline_minutes:
            raise ValueError("lineup deadline must not be later than the check-in deadline")

    @staticmethod
    def attendance_status(*, checked_in_at: datetime, checkin_deadline_at: datetime) -> str:
        if checked_in_at.tzinfo is None or checked_in_at.utcoffset() is None:
            raise ValueError("checked_in_at must be timezone-aware")
        return "PRESENT" if checked_in_at <= checkin_deadline_at else "LATE"

    @staticmethod
    def temporal_state(*, now: datetime, timeline: MatchdayTimeline, both_ready: bool) -> str:
        if now.tzinfo is None or now.utcoffset() is None:
            raise ValueError("now must be timezone-aware")
        if both_ready and now < timeline.kickoff_at:
            return "READY"
        if now < timeline.lineup_deadline_at:
            return "OPEN"
        if now < timeline.kickoff_at:
            return "DEADLINE_PASSED"
        if both_ready and now <= timeline.grace_deadline_at:
            return "READY"
        if now <= timeline.grace_deadline_at:
            return "DELAYED"
        return "NO_SHOW_REVIEW"
