"""Library resource routes."""

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

from app.api.schemas.library import (
    ArchiveLibraryResourceResponse,
    CreateLibraryResourceRequest,
    LibraryResourceListResponse,
    LibraryResourceRead,
    PresignUploadRequest,
    PresignUploadResponse,
    UpdateLibraryResourceRequest,
)
from app.application.services.library_service import LibraryService
from app.domain.enums import LibraryResourceType
from app.infra.db.session import get_db_session

router = APIRouter(prefix="/library", tags=["library"])
library_service = LibraryService()


@router.post("/uploads/presign", response_model=PresignUploadResponse)
async def create_library_upload_presign(payload: PresignUploadRequest) -> PresignUploadResponse:
    """Create direct-upload metadata for a library file."""

    return library_service.create_upload_presign(
        resource_type=payload.resource_type,
        file_name=payload.file_name,
        content_type=payload.content_type,
    )


@router.post("/resources", response_model=LibraryResourceRead, status_code=status.HTTP_201_CREATED)
async def create_library_resource(
    payload: CreateLibraryResourceRequest,
    session: AsyncSession = Depends(get_db_session),
) -> LibraryResourceRead:
    """Create a library resource with already-uploaded file metadata."""

    return await library_service.create_resource(session, payload)


@router.get("/resources", response_model=LibraryResourceListResponse)
async def list_library_resources(
    resource_type: LibraryResourceType | None = Query(default=None),
    query: str | None = Query(default=None, min_length=1),
    gender: str | None = Query(default=None),
    age_group: str | None = Query(default=None),
    environment: str | None = Query(default=None),
    category: str | None = Query(default=None),
    page: int = Query(default=1, ge=1),
    limit: int = Query(default=20, ge=1, le=100),
    session: AsyncSession = Depends(get_db_session),
) -> LibraryResourceListResponse:
    """List library resources with basic filtering."""

    return await library_service.list_resources(
        session,
        resource_type=resource_type,
        query=query,
        gender=gender,
        age_group=age_group,
        environment=environment,
        category=category,
        page=page,
        limit=limit,
    )


@router.patch("/resources/{resource_id}", response_model=LibraryResourceRead)
async def update_library_resource(
    resource_id: int,
    payload: UpdateLibraryResourceRequest,
    session: AsyncSession = Depends(get_db_session),
) -> LibraryResourceRead:
    """Update editable metadata on a library resource."""

    return await library_service.update_resource(session, resource_id, payload)


@router.delete("/resources/{resource_id}", response_model=ArchiveLibraryResourceResponse)
async def archive_library_resource(
    resource_id: int,
    session: AsyncSession = Depends(get_db_session),
) -> ArchiveLibraryResourceResponse:
    """Archive a library resource instead of hard deleting it."""

    return await library_service.archive_resource(session, resource_id)