"""
API Router for Race endpoints
"""
from fastapi import APIRouter, Depends, HTTPException
from sqlmodel import Session, select
from typing import List, Optional
from datetime import date
from pydantic import BaseModel

from app.db.database import get_session
from app.models.racing import Race, Runner

router = APIRouter()


class RaceResponse(BaseModel):
    """Race response schema"""
    race_id: str
    race_date: date
    venue: str
    race_number: int
    race_name: Optional[str]
    distance: Optional[int]
    track: Optional[str]


class RunnerResponse(BaseModel):
    """Runner response schema"""
    runner_id: str
    horse_number: Optional[int]
    horse_name: str
    jockey_name: str = ""
    trainer_name: str = ""
    barrier: Optional[int]
    weight_carried: Optional[float]


class RaceWithRunners(BaseModel):
    """Race with runners"""
    race_id: str
    race_date: date
    venue: str
    race_number: int
    race_name: Optional[str]
    distance: Optional[int]
    track: Optional[str]
    runners: List[RunnerResponse] = []


@router.get("/", response_model=List[RaceResponse])
async def list_races(
    race_date: Optional[date] = None,
    venue: Optional[str] = None,
    session: Session = Depends(get_session)
):
    """List races with optional filters"""
    query = select(Race)
    
    if race_date:
        query = query.where(Race.race_date == race_date)
    
    if venue:
        query = query.where(Race.venue == venue)
    
    query = query.order_by(Race.race_date.desc(), Race.race_number)
    
    races = session.exec(query).all()
    return races


@router.get("/{race_id}", response_model=RaceWithRunners)
async def get_race(
    race_id: str,
    session: Session = Depends(get_session)
):
    """Get race by ID with runners"""
    race = session.get(Race, race_id)
    
    if not race:
        raise HTTPException(status_code=404, detail="Race not found")
    
    # Get runners
    runners_query = select(Runner).where(Runner.race_id == race_id)
    runners = session.exec(runners_query).all()
    
    # Build response
    return RaceWithRunners(
        race_id=race.race_id,
        race_date=race.race_date,
        venue=race.venue,
        race_number=race.race_number,
        race_name=race.race_name,
        distance=race.distance,
        track=race.track,
        runners=[
            RunnerResponse(
                runner_id=str(r.runner_id),
                horse_number=r.horse_number,
                horse_name="",  # Would need join to get horse name
                jockey_name="",
                trainer_name="",
                barrier=r.barrier,
                weight_carried=r.weight_carried
            )
            for r in runners
        ]
    )


@router.get("/upcoming/today")
async def get_todays_races(
    session: Session = Depends(get_session)
):
    """Get today's races"""
    today = date.today()
    query = select(Race).where(Race.race_date == today)
    query = query.order_by(Race.race_number)
    
    races = session.exec(query).all()
    
    return {
        "date": today,
        "count": len(races),
        "races": races
    }