from fastapi import APIRouter, HTTPException, Depends
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
from typing import List

from app.models.base import get_db
from app.models.game_session import GameSession
from app.models.game_event import GameEvent

router = APIRouter()


@router.get("/{session_id}")
async def get_replay(
    session_id: int,
    db: AsyncSession = Depends(get_db)
):
    """
    Get replay data for a game session.
    Returns all events in chronological order.
    """
    # Get session
    result = await db.execute(
        select(GameSession).where(GameSession.id == session_id)
    )
    session = result.scalar_one_or_none()

    if not session:
        raise HTTPException(status_code=404, detail="Session not found")

    # Get all events
    events_result = await db.execute(
        select(GameEvent)
        .where(GameEvent.session_id == session_id)
        .order_by(GameEvent.timestamp)
    )
    events = events_result.scalars().all()

    return {
        "session": {
            "id": session.id,
            "room_code": session.room_code,
            "team_a_score": session.team_a_score,
            "team_b_score": session.team_b_score,
            "status": session.status,
            "created_at": session.created_at,
            "finished_at": session.finished_at
        },
        "events": [
            {
                "id": e.id,
                "event_type": e.event_type,
                "player_name": e.player_name,
                "team": e.team,
                "question_id": e.question_id,
                "answer_given": e.answer_given,
                "was_correct": e.was_correct,
                "was_steal": e.was_steal,
                "points_earned": e.points_earned,
                "timestamp": e.timestamp
            }
            for e in events
        ]
    }


@router.get("/code/{room_code}")
async def get_replay_by_code(
    room_code: str,
    db: AsyncSession = Depends(get_db)
):
    """
    Get replay data by room code.
    """
    result = await db.execute(
        select(GameSession).where(GameSession.room_code == room_code)
    )
    session = result.scalar_one_or_none()

    if not session:
        raise HTTPException(status_code=404, detail="Session not found")

    return await get_replay(session.id, db)


@router.get("/")
async def list_replays(
    limit: int = 20,
    offset: int = 0,
    db: AsyncSession = Depends(get_db)
):
    """
    List recent finished game sessions.
    """
    result = await db.execute(
        select(GameSession)
        .where(GameSession.status == "finished")
        .order_by(GameSession.finished_at.desc())
        .offset(offset)
        .limit(limit)
    )
    sessions = result.scalars().all()

    return [
        {
            "id": s.id,
            "room_code": s.room_code,
            "team_a_score": s.team_a_score,
            "team_b_score": s.team_b_score,
            "finished_at": s.finished_at
        }
        for s in sessions
    ]