"""OCR router: upload, get results, list results, apply to vehicle."""

import uuid

from fastapi import (
    APIRouter,
    BackgroundTasks,
    Depends,
    File,
    Form,
    HTTPException,
    Query,
    UploadFile,
    status,
)
from sqlalchemy.ext.asyncio import AsyncSession

from app.config import settings
from app.database import get_db
from app.dependencies import get_current_user
from app.models.user import User
from app.models.ocr_result import OCRStatus
from app.schemas.ocr import (
    OCRApplyResponse,
    OCRResultListResponse,
    OCRResultResponse,
    OCRUploadResponse,
)
from app.services import ocr_service
from app.tasks.ocr_processing import run_ocr_processing

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


@router.post(
    "/upload",
    response_model=OCRUploadResponse,
    status_code=status.HTTP_202_ACCEPTED,
)
async def upload_scan(
    background_tasks: BackgroundTasks,
    file: UploadFile = File(..., description="Image file to OCR"),
    vehicle_id: str | None = Form(None, description="Optional vehicle ID to link"),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """Upload an image file for OCR processing.

    Returns 202 with ocr_result_id. Processing happens asynchronously.
    """
    if not file or not file.filename:
        raise HTTPException(
            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
            detail={"error": {"code": "NO_FILE", "message": "No file provided"}},
        )

    mime_type = file.content_type or ""
    if not ocr_service.validate_mime_type(mime_type):
        raise HTTPException(
            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
            detail={
                "error": {
                    "code": "INVALID_MIME_TYPE",
                    "message": f"Invalid MIME type: {mime_type}. Only image/* types are allowed.",
                }
            },
        )

    # Read file content
    file_bytes = await file.read()

    if not ocr_service.validate_file_size(len(file_bytes)):
        raise HTTPException(
            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
            detail={
                "error": {
                    "code": "FILE_TOO_LARGE",
                    "message": f"File size exceeds limit of {settings.MAX_FILE_SIZE_MB} MB",
                }
            },
        )

    # Parse optional vehicle_id
    parsed_vehicle_id: uuid.UUID | None = None
    if vehicle_id:
        try:
            parsed_vehicle_id = uuid.UUID(vehicle_id)
        except (ValueError, TypeError):
            raise HTTPException(
                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                detail={
                    "error": {
                        "code": "INVALID_VEHICLE_ID",
                        "message": "Invalid vehicle UUID",
                    }
                },
            )

    try:
        ocr_result = await ocr_service.upload_file(
            db=db,
            file_bytes=file_bytes,
            file_name=file.filename or "upload.png",
            mime_type=mime_type,
            vehicle_id=parsed_vehicle_id,
        )
    except ValueError as exc:
        raise HTTPException(
            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
            detail={"error": {"code": "UPLOAD_FAILED", "message": str(exc)}},
        )

    # Queue background processing
    background_tasks.add_task(run_ocr_processing, ocr_result.id)

    return OCRUploadResponse(
        message="OCR processing queued",
        ocr_result_id=ocr_result.id,
        status=ocr_result.status.value
        if isinstance(ocr_result.status, OCRStatus)
        else str(ocr_result.status),
    )


@router.get(
    "/results/{result_id}",
    response_model=OCRResultResponse,
    status_code=status.HTTP_200_OK,
)
async def get_ocr_result(
    result_id: uuid.UUID,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """Get a single OCR result by ID."""
    ocr_result = await ocr_service.get_result(db, result_id)
    if ocr_result is None:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail={
                "error": {"code": "OCR_NOT_FOUND", "message": "OCR result not found"}
            },
        )
    return OCRResultResponse.model_validate(ocr_result)


@router.get(
    "/results",
    response_model=OCRResultListResponse,
    status_code=status.HTTP_200_OK,
)
async def list_ocr_results(
    db: AsyncSession = Depends(get_db),
    vehicle_id: uuid.UUID | None = Query(None, description="Filter by vehicle ID"),
    page: int = Query(1, ge=1, description="Page number"),
    page_size: int = Query(20, ge=1, le=100, description="Items per page"),
    current_user: User = Depends(get_current_user),
):
    """List OCR results, optionally filtered by vehicle_id."""
    items, total = await ocr_service.list_results(
        db=db,
        vehicle_id=vehicle_id,
        page=page,
        page_size=page_size,
    )
    return OCRResultListResponse(
        items=[OCRResultResponse.model_validate(item) for item in items],
        total=total,
        page=page,
        page_size=page_size,
    )


@router.post(
    "/results/{result_id}/apply",
    response_model=OCRApplyResponse,
    status_code=status.HTTP_200_OK,
)
async def apply_ocr_to_vehicle(
    result_id: uuid.UUID,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """Apply OCR structured data to the linked vehicle."""
    try:
        ocr_result, vehicle, updated_fields = await ocr_service.apply_to_vehicle(
            db, result_id
        )
    except ValueError as exc:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail={"error": {"code": "APPLY_FAILED", "message": str(exc)}},
        )

    return OCRApplyResponse(
        message="OCR data applied to vehicle",
        ocr_result_id=ocr_result.id,
        vehicle_id=vehicle.id,
        updated_fields=updated_fields,
    )