"""Lineup/starter validation for lineup-dependent props."""

import logging
from datetime import datetime, timezone
from typing import List, Dict, Any, Optional, Tuple

from .enums import LineupStatus, ValidationState
from .config import get_policy
from .normalization import normalize_player_name
from .models import ConflictDetail

log = logging.getLogger("pub-integrity")

# Prop types that require confirmed starter/lineup status
LINEUP_DEPENDENT_PROPS = {
    # MLB
    "hits", "runs", "rbis", "total_bases", "strikeouts_batter",
    # NHL
    "saves", "goals_against", "shots_on_goal",
    # Soccer
    "shots", "shots_on_target", "tackles",
    # Generic
    "points", "rebounds", "assists", "blocks", "steals",
    "passing_yards", "rushing_yards", "receiving_yards",
}

# Props that specifically require goalie / pitcher confirmation
GOALIE_PITCHER_PROPS = {
    "saves", "goals_against", "wins", "strikeouts_pitcher",
    "earned_runs", "hits_allowed", "innings_pitched",
}


def is_lineup_dependent(prop_type: str, league: str) -> bool:
    """Check if a prop type requires lineup confirmation in this league."""
    prop_lower = prop_type.lower().strip()

    if league == "mlb":
        # In MLB, virtually all batter props are lineup-dependent
        return True

    if league == "nhl" and prop_lower in GOALIE_PITCHER_PROPS:
        return True

    return prop_lower in LINEUP_DEPENDENT_PROPS


def validate_lineup_status(
    player_name: str,
    prop_type: str,
    league: str,
    game_start: Optional[datetime],
    lineup_data: List[Dict[str, Any]],
) -> Tuple[LineupStatus, Optional[ConflictDetail]]:
    """
    Validate that a player is confirmed in the lineup if the prop requires it.

    Returns (lineup_status, conflict_or_none).
    """
    policy = get_policy(league)
    norm = normalize_player_name(player_name)
    prop_lower = prop_type.lower().strip()

    # Find lineup entry
    player_lineup = None
    for entry in lineup_data:
        if normalize_player_name(entry.get("player_name", "")) == norm:
            player_lineup = entry
            break

    if player_lineup is None:
        lineup_status = LineupStatus.UNKNOWN
    else:
        raw = player_lineup.get("lineup_status", "UNKNOWN")
        try:
            lineup_status = LineupStatus(raw) if isinstance(raw, str) else raw
        except ValueError:
            lineup_status = LineupStatus.UNKNOWN

    # Check if this prop requires lineup confirmation
    if not is_lineup_dependent(prop_lower, league):
        return lineup_status, None

    # Check if we're inside the lineup-lock window
    now = datetime.now(timezone.utc)
    inside_lock_window = False
    if game_start:
        minutes_to_game = (game_start - now).total_seconds() / 60
        inside_lock_window = minutes_to_game <= policy.lineup_lock_before_game_min

    # If lineup is confirmed and player is starter, all good
    if lineup_status.is_confirmed_starter:
        return lineup_status, None

    # If we're inside lock window and lineup is unconfirmed, suppress
    if inside_lock_window and not lineup_status.is_confirmed_starter:
        if lineup_status == LineupStatus.BENCH or lineup_status == LineupStatus.CONFIRMED_OUT_OF_LINEUP:
            conflict = ConflictDetail(
                conflict_type="NOT_IN_STARTING_LINEUP",
                player_name=player_name,
                player_id=norm,
                field="lineup_status",
                official_value=lineup_status.value,
                severity="high",
                source="lineup_validation",
                detail=f"Player {player_name} is {lineup_status.value} — "
                       f"prop '{prop_type}' requires confirmed starter",
            )
            return lineup_status, conflict

        if lineup_status == LineupStatus.UNKNOWN and not policy.allow_pre_lineup_props:
            conflict = ConflictDetail(
                conflict_type="LINEUP_UNKNOWN_IN_LOCK_WINDOW",
                player_name=player_name,
                player_id=norm,
                field="lineup_status",
                official_value="UNKNOWN",
                severity="high",
                source="lineup_validation",
                detail=f"Lineup unknown for {player_name} inside lock window — "
                       f"league policy requires confirmation for '{prop_type}'",
            )
            return lineup_status, conflict

    # Goalie/pitcher specific check
    if prop_lower in GOALIE_PITCHER_PROPS:
        if league == "nhl" and lineup_status not in (LineupStatus.STARTING_GOALIE, LineupStatus.PROJECTED_GOALIE):
            if inside_lock_window:
                conflict = ConflictDetail(
                    conflict_type="GOALIE_NOT_CONFIRMED",
                    player_name=player_name,
                    player_id=norm,
                    field="goalie_status",
                    official_value=lineup_status.value,
                    severity="high",
                    source="lineup_validation",
                    detail=f"Goalie prop for {player_name} but status is {lineup_status.value}",
                )
                return lineup_status, conflict

    # Outside lock window with unknown lineup — provisional
    return lineup_status, None