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

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

router = APIRouter()


class PredictionResponse(BaseModel):
    """Prediction response"""
    runner_id: str
    horse_number: int = 0
    horse_name: str = ""
    win_probability: float
    place_probability: float
    win_rank: int = 0
    place_rank: int = 0
    confidence: float = 0.0
    explanation: List[dict] = []


class RacePredictions(BaseModel):
    """All predictions for a race"""
    race_id: str
    race_date: date
    venue: str
    race_number: int
    predictions: List[PredictionResponse]


@router.get("/race/{race_id}", response_model=RacePredictions)
async def get_race_predictions(
    race_id: str,
    session: Session = Depends(get_session)
):
    """Get all predictions for a race"""
    race = session.get(Race, race_id)
    if not race:
        raise HTTPException(status_code=404, detail="Race not found")
    
    # Get predictions
    query = select(Prediction).where(Prediction.race_id == race_id)
    query = query.order_by(Prediction.win_probability.desc())
    
    predictions = session.exec(query).all()
    
    if not predictions:
        raise HTTPException(status_code=404, detail="No predictions available")
    
    pred_responses = []
    for pred in predictions:
        pred_responses.append(PredictionResponse(
            runner_id=str(pred.runner_id),
            horse_number=0,
            horse_name="",
            win_probability=pred.win_probability,
            place_probability=pred.place_probability,
            win_rank=pred.win_rank or 0,
            place_rank=pred.place_rank or 0,
            confidence=pred.confidence_score or 0.0,
            explanation=[]
        ))
    
    return RacePredictions(
        race_id=race_id,
        race_date=race.race_date,
        venue=race.venue,
        race_number=race.race_number,
        predictions=pred_responses
    )


@router.post("/generate/{race_id}")
async def generate_predictions(
    race_id: str,
    session: Session = Depends(get_session)
):
    """Generate predictions for a race"""
    race = session.get(Race, race_id)
    if not race:
        raise HTTPException(status_code=404, detail="Race not found")
    
    # Get runners
    query = select(Runner).where(Runner.race_id == race_id)
    runners = session.exec(query).all()
    
    if not runners:
        raise HTTPException(status_code=404, detail="No runners found")
    
    return {
        "message": "Prediction generation triggered",
        "race_id": race_id,
        "runners_count": len(runners),
        "status": "pending"
    }