"""Prediction API endpoints"""
from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import Session
from typing import Optional
from datetime import datetime
from app.core.db.database import get_db
from app.core.db.repositories.prediction_repository import PredictionRepository
from app.core.db.repositories.model_repository import ModelRepository
from pydantic import BaseModel

router = APIRouter()

class PredictionResponse(BaseModel):
    id: int
    match_id: int
    home_team_name: str
    away_team_name: str
    match_date: datetime
    prob_home_win: float
    prob_draw: float
    prob_away_win: float
    confidence: Optional[float]
    model_version: str
    class Config:
        from_attributes = True

@router.get("/predictions/upcoming")
async def get_upcoming_predictions(
    league: Optional[str] = Query(None, description="League ID"),
    model_version: Optional[str] = Query("latest", description="Model version"),
    limit: int = Query(100, ge=1, le=1000),
    db: Session = Depends(get_db)
):
    league_id = None
    if league and league.strip():
        try:
            league_id = int(league)
        except (ValueError, TypeError):
            league_id = None
    
    prediction_repo = PredictionRepository(db)
    model_repo = ModelRepository(db)
    
    if model_version == "latest":
        model = model_repo.get_latest()
    else:
        model = model_repo.get_by_version(model_version)
    
    if not model:
        return []
    
    predictions = prediction_repo.get_upcoming(
        league_id=league_id,
        model_id=model.id,
        limit=limit
    )
    
    result = []
    for pred in predictions:
        match = pred.match
        result.append(PredictionResponse(
            id=pred.id,
            match_id=pred.match_id,
            home_team_name=match.home_team.name,
            away_team_name=match.away_team.name,
            match_date=match.match_date,
            prob_home_win=pred.prob_home_win,
            prob_draw=pred.prob_draw,
            prob_away_win=pred.prob_away_win,
            confidence=pred.confidence,
            model_version=model.version,
            analysis_text=getattr(pred, 'analysis_text', None),
            analysis_generated_at=getattr(pred, 'analysis_generated_at', None)
        ))
    
    return result