from uuid import UUID
from datetime import datetime, timezone

from fastapi import APIRouter, Depends, Query, HTTPException
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import selectinload

from app.core.database import get_db
from app.models.assessment import FraudAssessment, ConfidenceLevel
from app.repositories.assessment_repo import AssessmentRepository
from app.schemas.assessment import (
    AssessmentOut,
    AssessmentListOut,
    ReviewSubmit,
    InquirySuggestionOut,
)
from app.services.assessment_service import generate_inquiry_suggestions

router = APIRouter()


@router.get("/cases/{case_id}/assessments", response_model=AssessmentListOut)
async def list_assessments(
    case_id: UUID,
    confidence_level: ConfidenceLevel | None = None,
    db: AsyncSession = Depends(get_db),
):
    repo = AssessmentRepository(db)
    items, total = await repo.list_by_case(case_id, confidence_level=confidence_level)
    return AssessmentListOut(items=items, total=total)


@router.post("/assessments/{assessment_id}/review", response_model=AssessmentOut)
async def review_assessment(
    assessment_id: UUID,
    body: ReviewSubmit,
    db: AsyncSession = Depends(get_db),
):
    repo = AssessmentRepository(db)
    assessment = await repo.get(assessment_id)
    if not assessment:
        raise HTTPException(404, "认定记录不存在")

    assessment = await repo.update(assessment, {
        "review_status": body.review_status,
        "review_note": body.review_note,
        "reviewed_by": body.reviewed_by,
        "reviewed_at": datetime.now(timezone.utc),
    })

    # eager-load the transaction relationship to avoid lazy-load in async context
    result = await db.execute(
        select(FraudAssessment)
        .options(selectinload(FraudAssessment.transaction))
        .where(FraudAssessment.id == assessment_id)
    )
    assessment = result.scalar_one()
    return assessment


@router.get("/cases/{case_id}/inquiry-suggestions", response_model=InquirySuggestionOut)
async def get_inquiry_suggestions(case_id: UUID, db: AsyncSession = Depends(get_db)):
    suggestions = await generate_inquiry_suggestions(case_id, db)
    return InquirySuggestionOut(suggestions=suggestions)