"""Availability validation using official injury/status data."""

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

from .enums import AvailabilityStatus, ValidationState
from .normalization import normalize_player_name
from .models import ConflictDetail

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


def validate_player_availability(
    player_name: str,
    availability_reports: List[Dict[str, Any]],
    blocking_statuses: List[str],
) -> Tuple[AvailabilityStatus, Optional[ConflictDetail]]:
    """
    Check if player is available based on official injury/status data.

    Returns (status, conflict_or_none).
    """
    norm = normalize_player_name(player_name)

    # Find matching report
    for report in availability_reports:
        if report.get("normalized_name") == norm:
            status = report["availability_status"]

            if isinstance(status, str):
                try:
                    status = AvailabilityStatus(status)
                except ValueError:
                    status = AvailabilityStatus.UNKNOWN

            if status.is_blocking:
                conflict = ConflictDetail(
                    conflict_type="PLAYER_UNAVAILABLE",
                    player_name=player_name,
                    player_id=norm,
                    field="availability",
                    official_value=status.value,
                    severity="high",
                    source=report.get("source", "official"),
                    detail=f"Player {player_name} status: {status.value} "
                           f"(detail: {report.get('detailed_status', 'N/A')})",
                )
                return status, conflict

            return status, None

    # No report found — player is presumed available
    return AvailabilityStatus.AVAILABLE, None


def build_availability_lookup(
    reports: List[Dict[str, Any]],
) -> Dict[str, Dict[str, Any]]:
    """Build normalized-name → report lookup for fast access."""
    lookup: Dict[str, Dict[str, Any]] = {}
    for r in reports:
        norm = r.get("normalized_name", "")
        if norm:
            # Keep the most severe status per player
            existing = lookup.get(norm)
            if existing:
                existing_status = existing.get("availability_status", AvailabilityStatus.UNKNOWN)
                new_status = r.get("availability_status", AvailabilityStatus.UNKNOWN)
                if isinstance(existing_status, AvailabilityStatus) and isinstance(new_status, AvailabilityStatus):
                    if new_status.is_blocking and not existing_status.is_blocking:
                        lookup[norm] = r
            else:
                lookup[norm] = r
    return lookup