from uuid import uuid4

from fastapi import APIRouter, Depends, HTTPException, Request, Response
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.security import get_current_user
from app.db.session import get_db
from app.models.user import User
from app.schemas.ai import (
    AIProviderStatusResponse,
    BGPBriefRequest,
    BGPBriefRecordResponse,
    BGPBriefRecordSummary,
    SituationalAnalysisRequest,
    SituationalAnalysisResponse,
)
from app.services.ai_client import AIProviderClient, get_ai_provider_client
from app.services.bgp_ai_brief import build_bgp_brief_request
from app.services.bgp_ai_brief_store import (
    get_bgp_brief_record,
    get_latest_bgp_brief_record,
    list_bgp_brief_records,
    save_bgp_brief_record,
)

router = APIRouter()


@router.get("/provider/status", response_model=AIProviderStatusResponse)
async def get_ai_provider_status(
    request: Request,
    response: Response,
    current_user: User = Depends(get_current_user),
    provider_client: AIProviderClient = Depends(get_ai_provider_client),
):
    request_id = request.headers.get("X-Request-ID") or str(uuid4())
    response.headers["X-Request-ID"] = request_id
    return await provider_client.get_status(request_id=request_id)


@router.post("/situational-awareness/analyze", response_model=SituationalAnalysisResponse)
async def analyze_situational_awareness(
    payload: SituationalAnalysisRequest,
    request: Request,
    response: Response,
    current_user: User = Depends(get_current_user),
    provider_client: AIProviderClient = Depends(get_ai_provider_client),
):
    request_id = request.headers.get("X-Request-ID") or str(uuid4())
    response.headers["X-Request-ID"] = request_id
    return await provider_client.analyze(payload, request_id=request_id)


@router.get("/bgp/briefs", response_model=list[BGPBriefRecordSummary])
async def list_saved_bgp_briefs(
    current_user: User = Depends(get_current_user),
):
    return list_bgp_brief_records()


@router.get("/bgp/briefs/latest", response_model=BGPBriefRecordResponse | None)
async def get_latest_saved_bgp_brief(
    current_user: User = Depends(get_current_user),
):
    return get_latest_bgp_brief_record()


@router.get("/bgp/briefs/{brief_id}", response_model=BGPBriefRecordResponse)
async def get_saved_bgp_brief(
    brief_id: str,
    current_user: User = Depends(get_current_user),
):
    record = get_bgp_brief_record(brief_id)
    if record is None:
        raise HTTPException(status_code=404, detail="BGP brief not found")
    return record


@router.post("/bgp/brief", response_model=BGPBriefRecordResponse)
async def analyze_bgp_brief(
    payload: BGPBriefRequest,
    request: Request,
    response: Response,
    current_user: User = Depends(get_current_user),
    provider_client: AIProviderClient = Depends(get_ai_provider_client),
    db: AsyncSession = Depends(get_db),
):
    request_id = request.headers.get("X-Request-ID") or str(uuid4())
    response.headers["X-Request-ID"] = request_id

    brief_request = await build_bgp_brief_request(
        db,
        incident_limit=payload.incident_limit,
        anomaly_limit=payload.anomaly_limit,
        collector_limit=payload.collector_limit,
    )
    brief_request.preferred_model = payload.preferred_model
    brief_request.thinking = payload.thinking

    analysis = await provider_client.analyze(brief_request, request_id=request_id)
    return save_bgp_brief_record(analysis, request_id=request_id)