"""Router for Anomali detection endpoints."""

from fastapi import APIRouter, Depends, HTTPException, Query, status
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.database import get_db
from app.dependencies import get_current_user
from app.models.user import User
from app.schemas.anomali import AnomaliCreate, AnomaliResolve, AnomaliUpdate
from app.services import anomali_service

router = APIRouter(
    prefix="/spbus/{spbu_id}/anomali",
    tags=["anomali"],
)


@router.get("", response_model=dict)
async def list_anomali(
    spbu_id: int,
    tipe: str | None = Query(default=None),
    status_filter: str | None = Query(default=None, alias="status"),
    skip: int = Query(default=0, ge=0),
    limit: int = Query(default=50, ge=1, le=200),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> dict:
    rows, total = await anomali_service.list_anomali(
        db, spbu_id, tipe=tipe, status=status_filter, skip=skip, limit=limit
    )
    return {
        "data": [r.model_dump() for r in rows],
        "meta": {"total": total, "page": skip // limit + 1, "per_page": limit},
    }


@router.get("/count", response_model=dict)
async def count_active(
    spbu_id: int,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> dict:
    count = await anomali_service.count_active(db, spbu_id)
    return {"data": {"count": count}}


@router.get("/{anomali_id}", response_model=dict)
async def get_anomali(
    spbu_id: int,
    anomali_id: int,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> dict:
    try:
        result = await anomali_service.get_anomali(db, spbu_id, anomali_id)
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(e))
    return {"data": result.model_dump()}


@router.post("", response_model=dict, status_code=status.HTTP_201_CREATED)
async def create_anomali(
    spbu_id: int,
    data: AnomaliCreate,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> dict:
    try:
        result = await anomali_service.create_anomali(db, spbu_id, data)
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
    return {"data": result.model_dump(), "message": "Anomali berhasil dicatat"}


@router.patch("/{anomali_id}", response_model=dict)
async def update_anomali(
    spbu_id: int,
    anomali_id: int,
    data: AnomaliUpdate,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> dict:
    try:
        result = await anomali_service.update_anomali(db, spbu_id, anomali_id, data)
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
    return {"data": result.model_dump(), "message": "Anomali berhasil diupdate"}


@router.patch("/{anomali_id}/resolve", response_model=dict)
async def resolve_anomali(
    spbu_id: int,
    anomali_id: int,
    data: AnomaliResolve,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> dict:
    try:
        result = await anomali_service.resolve_anomali(
            db, spbu_id, anomali_id, data, resolved_by_id=current_user.id
        )
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
    return {"data": result.model_dump(), "message": "Anomali berhasil diresolve"}