"""Image retouch router: process images, get results, price comparison."""

import uuid

from fastapi import (
    APIRouter,
    BackgroundTasks,
    Depends,
    File,
    Form,
    HTTPException,
    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.retouch import RetouchStatus
from app.schemas.retouch import (
    PriceCompareRequest,
    PriceCompareResponse,
    RetouchProcessResponse,
    RetouchResultResponse,
)
from app.services import retouch_service, price_compare_service
from app.services.vehicle_service import get_vehicle_by_id
from app.tasks.retouch_processing import run_retouch_processing

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


@router.post(
    "/process",
    response_model=RetouchProcessResponse,
    status_code=status.HTTP_202_ACCEPTED,
)
async def process_image(
    background_tasks: BackgroundTasks,
    file: UploadFile = File(..., description="Image file to retouch"),
    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 retouching via Flux.1-Pro.

    Returns 202 with retouch_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 retouch_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.",
                }
            },
        )

    file_bytes = await file.read()

    if not retouch_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
    vehicle_info = 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",
                    }
                },
            )

        # Fetch vehicle info for better retouch prompt
        vehicle = await get_vehicle_by_id(db, parsed_vehicle_id)
        if vehicle:
            vehicle_info = {
                "make": vehicle.make,
                "model": vehicle.model,
                "year": vehicle.year,
                "color": vehicle.color,
            }

    try:
        result = await retouch_service.upload_retouch_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_retouch_processing, result.id, vehicle_info)

    return RetouchProcessResponse(
        message="Retouch processing queued",
        retouch_id=result.id,
        status=result.status.value
        if isinstance(result.status, RetouchStatus)
        else str(result.status),
    )


@router.get(
    "/results/{result_id}",
    response_model=RetouchResultResponse,
    status_code=status.HTTP_200_OK,
)
async def get_retouch_result(
    result_id: uuid.UUID,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """Get a single retouch result by ID.

    Returns status, original and retouched file paths.
    If processing is still ongoing, status will be 'processing'.
    If processing failed, status will be 'failed' with error_message.
    """
    result = await retouch_service.get_result(db, result_id)
    if result is None:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail={
                "error": {
                    "code": "RETOUCH_NOT_FOUND",
                    "message": "Retouch result not found",
                }
            },
        )
    return RetouchResultResponse.model_validate(result)


@router.post(
    "/price-compare",
    response_model=PriceCompareResponse,
    status_code=status.HTTP_200_OK,
)
async def price_compare(
    body: PriceCompareRequest,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """Compare prices for a vehicle by searching comparable listings.

    Returns comparable listings and average price.
    If no comparable listings found, returns empty list with null average.
    """
    try:
        result = await price_compare_service.compare_prices(db, body.vehicle_id)
    except ValueError as exc:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail={"error": {"code": "VEHICLE_NOT_FOUND", "message": str(exc)}},
        )
    return result