"""
Pydantic v2 Schemas for RTSport API
Source of truth: contract.md §1
"""
from datetime import datetime
from typing import Optional, List, Dict, Any
from pydantic import BaseModel, Field, ConfigDict, field_validator
import json


# ============== ENUMS ==============
class CurrentStatus(str):
    """Athlete clearance status - cached property"""
    CLEARED = "cleared"
    RESTRICTED = "restricted"
    OUT = "out"


class Severity(str):
    """Clinical diagnosis - static"""
    MILD = "mild"
    MODERATE = "moderate"
    SEVERE = "severe"


class AttentionLevel(str):
    """Operational priority - updated daily by AT"""
    URGENT = "urgent"
    WARNING = "warning"
    STABLE = "stable"


class CaseStatus(str):
    """Case lifecycle status"""
    ACTIVE = "active"
    RESOLVED = "resolved"


class MilestoneStatus(str):
    """Milestone completion status"""
    PENDING = "pending"
    ACHIEVED = "achieved"
    SKIPPED = "skipped"


class EventType(str):
    """Event classification"""
    NOTE = "note"
    STATUS_CHANGE = "status_change"
    RESTRICTION_ADDED = "restriction_added"
    CLEARANCE_GRANTED = "clearance_granted"


class VisibilityRole(str):
    """FERPA visibility roles"""
    AT = "at"
    COACH = "coach"
    PARENT = "parent"


# ============== SCHOOL SCHEMA ==============
class SchoolConfig(BaseModel):
    """School-specific configuration"""
    model_config = ConfigDict(extra="allow")
    
    primary_color: Optional[str] = None
    logo_url: Optional[str] = None
    sport_names: Optional[Dict[str, str]] = None


class SchoolSchema(BaseModel):
    """
    The Tenant - multi-tenant boundary
    Every operational model must include school_id for data isolation
    """
    model_config = ConfigDict(populate_by_name=True, from_attributes=True)
    
    id: str = Field(..., description="Unique school identifier (e.g., schl_001)")
    name: str = Field(..., description="School display name")
    domain: str = Field(..., description="Email domain for auto-provisioning")
    config: Optional[SchoolConfig] = Field(default=None, description="School branding/config")


class SchoolCreate(BaseModel):
    """Create new school"""
    name: str
    domain: str
    config: Optional[SchoolConfig] = None


class SchoolUpdate(BaseModel):
    """Update existing school"""
    name: Optional[str] = None
    domain: Optional[str] = None
    config: Optional[SchoolConfig] = None


# ============== ATHLETE SCHEMA ==============
class AthleteSchema(BaseModel):
    """
    The central node - roster queries pull this fast without clinical payload
    current_status is a cached property - updated via DB trigger or transaction hook
    """
    model_config = ConfigDict(populate_by_name=True, from_attributes=True)
    
    id: str = Field(..., description="Unique athlete identifier (e.g., ath_102938)")
    school_id: str = Field(..., description="Tenant isolation key")
    first_name: str
    last_name: str
    grade: int = Field(..., ge=9, le=12, description="High school grade level")
    sports: List[str] = Field(default_factory=list, description="Sports participated in")
    team: Optional[str] = Field(default=None, description="Team assignment (e.g., Varsity)")
    parent_ids: List[str] = Field(default_factory=list, description="Linked parent user IDs")
    current_status: str = Field(default="cleared", description="Cached: cleared|restricted|out")
    active_case_ids: List[str] = Field(default_factory=list, description="Currently active case IDs")

    @field_validator('sports', 'parent_ids', 'active_case_ids', mode='before')
    @classmethod
    def parse_json_list(cls, v):
        """Parse JSON string fields from SQLite (ARRAY columns stored as strings)."""
        if isinstance(v, str):
            try:
                return json.loads(v)
            except (json.JSONDecodeError, ValueError):
                return []
        if isinstance(v, list):
            return v
        return []


class AthleteCreate(BaseModel):
    """Create new athlete"""
    school_id: str
    first_name: str
    last_name: str
    grade: int = Field(..., ge=9, le=12)
    sports: List[str] = Field(default_factory=list)
    team: Optional[str] = None
    parent_ids: List[str] = Field(default_factory=list)


class AthleteUpdate(BaseModel):
    """Update existing athlete"""
    first_name: Optional[str] = None
    last_name: Optional[str] = None
    grade: Optional[int] = Field(default=None, ge=9, le=12)
    sports: Optional[List[str]] = None
    team: Optional[str] = None
    parent_ids: Optional[List[str]] = None


# ============== CASE SCHEMA ==============
class CaseSchema(BaseModel):
    """
    A single injury lifecycle
    - severity: clinical diagnosis (static)
    - attention_level: operational priority (updated daily by AT)
    - Resolved via clearance_granted event; reopenable within 30 days
    """
    model_config = ConfigDict(populate_by_name=True, from_attributes=True)
    
    id: str = Field(..., description="Unique case identifier (e.g., cas_554433)")
    school_id: str = Field(..., description="Tenant isolation key")
    athlete_id: str = Field(..., description="Reference to parent athlete")
    title: str = Field(..., description="Human-readable injury description")
    severity: str = Field(..., description="Clinical: mild|moderate|severe")
    attention_level: str = Field(default="stable", description="Operational: urgent|warning|stable")
    status: str = Field(default="active", description="Lifecycle: active|resolved")
    opened_at: datetime = Field(..., description="Case creation timestamp")
    # Case reopening support (30-day window)
    reopened_from_case_id: Optional[str] = Field(default=None, description="Original case ID if reopened within 30 days")
    reopened_at: Optional[datetime] = Field(default=None, description="When case was reopened")
    resolved_at: Optional[datetime] = Field(default=None, description="Resolution timestamp")
    primary_at_id: str = Field(..., description="ID of primary athletic trainer")


class CaseCreate(BaseModel):
    """Create new case"""
    school_id: str
    athlete_id: str
    title: str
    severity: str = Field(..., pattern=r"^(mild|moderate|severe)$")
    attention_level: str = Field(default="stable", pattern=r"^(urgent|warning|stable)$")
    primary_at_id: str


class CaseUpdate(BaseModel):
    """Update existing case"""
    title: Optional[str] = None
    attention_level: Optional[str] = Field(default=None, pattern=r"^(urgent|warning|stable)$")
    status: Optional[str] = Field(default=None, pattern=r"^(active|resolved)$")
    resolved_at: Optional[datetime] = None
    reopened_from_case_id: Optional[str] = None
    reopened_at: Optional[datetime] = None
    primary_at_id: Optional[str] = None


# ============== MILESTONE SCHEMA ==============
class MilestoneSchema(BaseModel):
    """
    Forward-looking targets - Phase Bar UI
    Separate from Events (which are backward-looking records)
    """
    model_config = ConfigDict(populate_by_name=True, from_attributes=True)
    
    id: str = Field(..., description="Unique milestone identifier (e.g., mil_001)")
    school_id: str = Field(..., description="Tenant isolation key")
    case_id: str = Field(..., description="Reference to parent case")
    title: str = Field(..., description="Milestone description")
    target_date: datetime = Field(..., description="Target completion date")
    status: str = Field(default="pending", description="pending|achieved|skipped")
    achieved_at: Optional[datetime] = Field(default=None, description="Actual completion timestamp")


class MilestoneCreate(BaseModel):
    """Create new milestone"""
    school_id: str
    case_id: str
    title: str
    target_date: datetime


class MilestoneUpdate(BaseModel):
    """Update existing milestone"""
    title: Optional[str] = None
    target_date: Optional[datetime] = None
    status: Optional[str] = Field(default=None, pattern=r"^(pending|achieved|skipped)$")
    achieved_at: Optional[datetime] = None


# ============== EVENT SCHEMA ==============
class EventContent(BaseModel):
    """Event content payload"""
    model_config = ConfigDict(extra="allow")
    
    text: str = Field(..., description="Main event content")
    clinical_notes: Optional[str] = Field(default=None, description="AT-only clinical details")


class EventSchema(BaseModel):
    """
    The workhorse - every sideline entry, clinical note, or clearance is an Event
    
    FERPA RULE: visibility defaults to ["at"] unless explicitly expanded
    clinical_notes is stripped from responses for non-AT roles
    
    clearance_granted event atomically updates parent Case status to "resolved"
    """
    model_config = ConfigDict(populate_by_name=True, from_attributes=True)
    
    id: str = Field(..., description="Unique event identifier (e.g., evt_776655)")
    school_id: str = Field(..., description="Tenant isolation key")
    case_id: str = Field(..., description="Reference to parent case")
    author_id: str = Field(..., description="ID of event creator")
    event_type: str = Field(..., description="note|status_change|restriction_added|clearance_granted")
    visibility: List[str] = Field(default_factory=lambda: ["at"], description="Roles that can view")
    content: EventContent = Field(..., description="Event content payload")
    timestamp: datetime = Field(..., description="Event timestamp")


class EventCreate(BaseModel):
    """Create new event"""
    school_id: str
    case_id: str
    author_id: str
    event_type: str = Field(..., pattern=r"^(note|status_change|restriction_added|clearance_granted)$")
    visibility: List[str] = Field(default_factory=lambda: ["at"])
    content: EventContent


class EventUpdate(BaseModel):
    """Update existing event"""
    visibility: Optional[List[str]] = None
    content: Optional[EventContent] = None


# ============== SIDELINE ENTRY SCHEMA ==============
class SidelineEntryRequest(BaseModel):
    """
    3-tap rapid entry form - primary data entry path for ATs on the sideline
    
    Backend action:
    - Creates new Case if no active case exists for athlete + body_part
    - Creates initial Event
    - Updates athlete.current_status via trigger/hook
    """
    school_id: str = Field(..., description="Tenant isolation key")
    athlete_id: str = Field(..., description="Injured athlete")
    body_part: str = Field(..., description="Injury location (e.g., 'Ankle - Right')")
    severity: str = Field(..., pattern=r"^(mild|moderate|severe)$")
    attention_level: str = Field(default="stable", pattern=r"^(urgent|warning|stable)$")
    removed_from_play: bool = Field(default=False, description="Whether athlete was removed from play")
    notes: Optional[str] = Field(default=None, description="Optional clinical notes")


class SidelineEntryResponse(BaseModel):
    """Response from sideline entry"""
    case_id: str = Field(..., description="Created or existing case ID")
    event_id: str = Field(..., description="Created event ID")
    athlete_status: str = Field(..., description="Updated athlete current_status")
    is_new_case: bool = Field(..., description="Whether a new case was created")


# ============== ROSTER QUERY SCHEMAS ==============
class RosterQueryParams(BaseModel):
    """Query parameters for roster endpoint"""
    school_id: str
    sport: Optional[str] = None
    team: Optional[str] = None


class RosterResponse(BaseModel):
    """Paginated roster response"""
    athletes: List[AthleteSchema]
    total: int
    school_id: str