from fastapi import APIRouter, HTTPException, Request, status

from auth import CurrentUser
from schemas import (
    CreateSessionRequest,
    CreateSessionResponse,
    SendMessageRequest,
    SendMessageResponse,
    SessionHistoryResponse,
    UserUsageResponse,
)
from service import ChatProviderError, ChatService
from storage import SessionNotFoundError, SessionStorageError


router = APIRouter()


def get_chat_service(request: Request) -> ChatService:
    return request.app.state.chat_service


@router.post(
    "/sessions",
    response_model=CreateSessionResponse,
    status_code=status.HTTP_201_CREATED,
    tags=["sessions"],
)
async def create_session(
    request: Request,
    _user: CurrentUser,
    body: CreateSessionRequest | None = None,
) -> CreateSessionResponse:
    try:
        return await get_chat_service(request).create_session(
            _user.user_id,
            body.system_prompt if body is not None else None,
        )
    except SessionStorageError as exc:
        raise HTTPException(status_code=500, detail=str(exc)) from exc


@router.post(
    "/sessions/{session_id}/messages",
    response_model=SendMessageResponse,
    tags=["sessions"],
)
async def send_message(
    session_id: str,
    body: SendMessageRequest,
    request: Request,
    user: CurrentUser,
) -> SendMessageResponse:
    try:
        response = await get_chat_service(request).generate_response(
            session_id, body.content, user.user_id
        )
        return response
    except SessionNotFoundError as exc:
        raise HTTPException(status_code=404, detail="session not found") from exc
    except ChatProviderError as exc:
        raise HTTPException(status_code=502, detail=str(exc)) from exc
    except SessionStorageError as exc:
        raise HTTPException(status_code=500, detail=str(exc)) from exc


@router.get(
    "/sessions/{session_id}/messages",
    response_model=SessionHistoryResponse,
    tags=["sessions"],
)
async def get_session_history(
    session_id: str,
    request: Request,
    _user: CurrentUser,
) -> SessionHistoryResponse:
    try:
        return await get_chat_service(request).get_session_history(
            session_id, _user.user_id
        )
    except SessionNotFoundError as exc:
        raise HTTPException(status_code=404, detail="session not found") from exc
    except SessionStorageError as exc:
        raise HTTPException(status_code=500, detail=str(exc)) from exc


@router.get("/usage", response_model=UserUsageResponse, tags=["usage"])
async def get_current_user_usage(
    request: Request,
    user: CurrentUser,
) -> UserUsageResponse:
    return await get_chat_service(request).get_user_usage(user.user_id)