"""Document CRUD and validation API."""

from __future__ import annotations

from fastapi import APIRouter, Depends, HTTPException, Query
from fastapi.responses import FileResponse
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from app.api.serializers import document_out
from app.db import get_session
from app.models import Document
from app.schemas import DocStatus, DocumentOut, DocumentUpdate
from app.services.cleanup import cleanup_orphan_documents
from app.services.paths import resolve_stored_path
from app.services.validation import (
    apply_duplicate_flags,
    apply_post_extract_checks,
    average_from_detail,
    mark_fields_confirmed,
)

router = APIRouter(prefix="/api/documents", tags=["documents"])


@router.get("", response_model=list[DocumentOut])
async def list_documents(
    status: str | None = None,
    doc_type: str | None = None,
    limit: int = Query(100, ge=1, le=500),
    session: AsyncSession = Depends(get_session),
) -> list[DocumentOut]:
    """List processed documents (files that still exist)."""
    stmt = select(Document).order_by(Document.created_at.desc())
    if status:
        stmt = stmt.where(Document.status == status)
    if doc_type:
        stmt = stmt.where(Document.doc_type == doc_type)
    stmt = stmt.limit(limit * 5)
    result = await session.execute(stmt)
    docs = []
    for d in result.scalars().all():
        if len(docs) >= limit:
            break
        try:
            if resolve_stored_path(d.file_path).is_file():
                docs.append(document_out(d))
        except FileNotFoundError:
            continue
    return docs


@router.post("/cleanup")
async def cleanup_documents(
    session: AsyncSession = Depends(get_session),
) -> dict[str, int]:
    """Remove orphan DB rows whose files were deleted."""
    return await cleanup_orphan_documents(session)


@router.get("/{doc_id}", response_model=DocumentOut)
async def get_document(
    doc_id: str,
    session: AsyncSession = Depends(get_session),
) -> DocumentOut:
    """Fetch one document."""
    doc = await session.get(Document, doc_id)
    if not doc:
        raise HTTPException(404, "Document not found")
    return document_out(doc)


@router.get("/{doc_id}/file")
async def get_document_file(
    doc_id: str,
    session: AsyncSession = Depends(get_session),
) -> FileResponse:
    """Serve original uploaded file for validation UI."""
    doc = await session.get(Document, doc_id)
    if not doc:
        raise HTTPException(404, "Document not found")
    try:
        path = resolve_stored_path(doc.file_path)
    except FileNotFoundError as exc:
        raise HTTPException(
            404,
            "Original file is no longer available",
        ) from exc
    if not path.is_file():
        raise HTTPException(
            404,
            "Original file is no longer available",
        )
    return FileResponse(
        path,
        filename=doc.filename,
        media_type=doc.mime_type or "application/octet-stream",
        content_disposition_type="inline",
    )


@router.patch("/{doc_id}", response_model=DocumentOut)
async def update_document(
    doc_id: str,
    body: DocumentUpdate,
    session: AsyncSession = Depends(get_session),
) -> DocumentOut:
    """Apply manual corrections and re-run checks."""
    doc = await session.get(Document, doc_id)
    if not doc:
        raise HTTPException(404, "Document not found")

    if body.doc_type:
        doc.doc_type = body.doc_type
    doc.extracted = body.extracted

    issues, is_dup, dup_of = await apply_post_extract_checks(
        session,
        document_id=doc.id,
        doc_type=doc.doc_type,
        data=body.extracted,
    )
    apply_duplicate_flags(
        doc,
        is_duplicate=is_dup,
        duplicate_of=dup_of,
    )

    conf = mark_fields_confirmed(body.extracted, doc.confidence)
    doc.confidence = conf
    doc.avg_confidence = average_from_detail(conf) or 1.0
    doc.issues = issues
    doc.status = DocStatus.VALIDATED.value
    await session.commit()
    await session.refresh(doc)
    return document_out(doc)