rename-mvp/app/api/session.py

from fastapi import APIRouter, HTTPException, Query
from pydantic import BaseModel, Field

from app.services.session_service import SessionService

router = APIRouter()


class SelectedEpisodesAddRequest(BaseModel):
    items: list[dict] = Field(default_factory=list)


class SelectedEpisodesReorderRequest(BaseModel):
    from_index: int = Field(ge=0)
    to_index: int = Field(ge=0)


class SelectedFilesAddRequest(BaseModel):
    items: list[dict] = Field(default_factory=list)


class SelectedFilesReorderRequest(BaseModel):
    from_index: int = Field(ge=0)
    to_index: int = Field(ge=0)


class SessionSettingsRequest(BaseModel):
    set_file_date_to_first_aired_date: bool | None = None
    default_media_root_path: str | None = None
    remember_max_series: int | None = Field(default=None, ge=1, le=100)


class RememberedSeriesUpsertRequest(BaseModel):
    item: dict = Field(default_factory=dict)


def _normalize_session_id(session_id: str) -> str:
    normalized = session_id.strip()
    if not normalized:
        raise HTTPException(status_code=400, detail="session_id must not be empty")
    return normalized


@router.get("/selected-episodes")
def get_selected_episodes(session_id: str = Query("default", min_length=1)):
    service = SessionService()
    normalized_session_id = _normalize_session_id(session_id)
    items = service.list_selected_episodes(normalized_session_id)
    return {"session_id": normalized_session_id, "items": items}


@router.post("/selected-episodes")
def add_selected_episodes(
    payload: SelectedEpisodesAddRequest,
    session_id: str = Query("default", min_length=1),
):
    service = SessionService()
    normalized_session_id = _normalize_session_id(session_id)
    items = service.add_selected_episodes(normalized_session_id, payload.items)
    return {"session_id": normalized_session_id, "items": items}


@router.delete("/selected-episodes")
def clear_selected_episodes(session_id: str = Query("default", min_length=1)):
    service = SessionService()
    normalized_session_id = _normalize_session_id(session_id)
    service.clear_selected_episodes(normalized_session_id)
    return {"session_id": normalized_session_id, "items": []}


@router.delete("/selected-episodes/{selection_id}")
def remove_selected_episode(selection_id: int, session_id: str = Query("default", min_length=1)):
    service = SessionService()
    normalized_session_id = _normalize_session_id(session_id)
    items = service.remove_selected_episode(normalized_session_id, selection_id)
    return {"session_id": normalized_session_id, "items": items}


@router.post("/selected-episodes/reorder")
def reorder_selected_episodes(
    payload: SelectedEpisodesReorderRequest,
    session_id: str = Query("default", min_length=1),
):
    service = SessionService()
    normalized_session_id = _normalize_session_id(session_id)
    try:
        items = service.reorder_selected_episodes(
            normalized_session_id,
            payload.from_index,
            payload.to_index,
        )
    except ValueError as exc:
        raise HTTPException(status_code=400, detail=str(exc))

    return {"session_id": normalized_session_id, "items": items}


@router.get("/selected-files")
def get_selected_files(session_id: str = Query("default", min_length=1)):
    service = SessionService()
    normalized_session_id = _normalize_session_id(session_id)
    items = service.list_selected_files(normalized_session_id)
    return {"session_id": normalized_session_id, "items": items}


@router.post("/selected-files")
def add_selected_files(
    payload: SelectedFilesAddRequest,
    session_id: str = Query("default", min_length=1),
):
    service = SessionService()
    normalized_session_id = _normalize_session_id(session_id)
    items = service.add_selected_files(normalized_session_id, payload.items)
    return {"session_id": normalized_session_id, "items": items}


@router.delete("/selected-files")
def clear_selected_files(session_id: str = Query("default", min_length=1)):
    service = SessionService()
    normalized_session_id = _normalize_session_id(session_id)
    service.clear_selected_files(normalized_session_id)
    return {"session_id": normalized_session_id, "items": []}


@router.delete("/selected-files/{selection_id}")
def remove_selected_file(selection_id: int, session_id: str = Query("default", min_length=1)):
    service = SessionService()
    normalized_session_id = _normalize_session_id(session_id)
    items = service.remove_selected_file(normalized_session_id, selection_id)
    return {"session_id": normalized_session_id, "items": items}


@router.post("/selected-files/reorder")
def reorder_selected_files(
    payload: SelectedFilesReorderRequest,
    session_id: str = Query("default", min_length=1),
):
    service = SessionService()
    normalized_session_id = _normalize_session_id(session_id)
    try:
        items = service.reorder_selected_files(
            normalized_session_id,
            payload.from_index,
            payload.to_index,
        )
    except ValueError as exc:
        raise HTTPException(status_code=400, detail=str(exc))

    return {"session_id": normalized_session_id, "items": items}


@router.get("/settings")
def get_session_settings():
    service = SessionService()
    return {"settings": service.get_settings()}


@router.put("/settings")
def put_session_settings(payload: SessionSettingsRequest):
    service = SessionService()
    try:
        settings = service.update_settings(payload.model_dump(exclude_unset=True))
    except ValueError as exc:
        raise HTTPException(status_code=400, detail=str(exc))
    return {"settings": settings}


@router.get("/remembered-series")
def get_remembered_series():
    service = SessionService()
    items = service.list_remembered_series()
    return {"items": items}


@router.post("/remembered-series")
def post_remembered_series(payload: RememberedSeriesUpsertRequest):
    service = SessionService()
    try:
        items = service.remember_series(payload.item)
    except ValueError as exc:
        raise HTTPException(status_code=400, detail=str(exc))
    return {"items": items}


@router.delete("/remembered-series")
def delete_remembered_series():
    service = SessionService()
    service.clear_remembered_series()
    return {"items": []}


@router.get("/mapping-preview")
def get_mapping_preview(session_id: str = Query("default", min_length=1)):
    service = SessionService()
    normalized_session_id = _normalize_session_id(session_id)
    try:
        return service.build_mapping_preview(normalized_session_id)
    except ValueError as exc:
        raise HTTPException(status_code=400, detail=str(exc))


@router.get("/filename-preview")
def get_filename_preview(session_id: str = Query("default", min_length=1)):
    service = SessionService()
    normalized_session_id = _normalize_session_id(session_id)
    try:
        return service.build_filename_preview(normalized_session_id)
    except ValueError as exc:
        raise HTTPException(status_code=400, detail=str(exc))


@router.post("/rename-execute")
def rename_execute(
    session_id: str = Query("default", min_length=1),
    confirm: bool = Query(False),
):
    service = SessionService()
    normalized_session_id = _normalize_session_id(session_id)
    try:
        return service.execute_rename(normalized_session_id, confirm=confirm)
    except ValueError as exc:
        raise HTTPException(status_code=400, detail=str(exc))


@router.get("/rename-log")
def get_rename_log(
    session_id: str = Query("default", min_length=1),
    limit: int = Query(20, ge=1, le=200),
):
    service = SessionService()
    normalized_session_id = _normalize_session_id(session_id)
    items = service.list_rename_runs(normalized_session_id, limit=limit)
    return {
        "session_id": normalized_session_id,
        "items": items,
    }


@router.get("/rename-log/{run_id}")
def get_rename_log_run(run_id: int):
    service = SessionService()
    run = service.get_rename_run(run_id)
    if run is None:
        raise HTTPException(status_code=404, detail="rename run not found")
    return run