"""Asynchronous conversion. This is the path for large documents."""

from __future__ import annotations

import logging

from fastapi import APIRouter, Response, status
from fastapi.responses import FileResponse

from ..deps import get_container
from ..errors import ConversionError, JobNotFoundError
from ..models import ConvertRequest, JobAccepted, JobState

logger = logging.getLogger(__name__)

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


def _result_url(job_id: str) -> str:
    root = get_container().settings.root_path.rstrip("/")
    return f"{root}/jobs/{job_id}/result"


CREATE_DESCRIPTION = """
Zaradi konverzi do fronty a hned vrati 202 s identifikatorem jobu. Telo je
stejne jako u POST /convert.

Postup sledujte pres GET /jobs/{job_id}, hotove PDF stahnete z
GET /jobs/{job_id}/result. Volitelny `callback_url` dostane po dokonceni POST
se stejnym telem, jake vraci GET /jobs/{job_id}.

**Uchovavani souboru.** Hotove PDF zustava na disku sluzby, aby slo stahnout.
Meziprodukty renderu se po dokonceni smazou, zustava jen vysledek. Dostupny je
`JOB_RESULT_TTL_SECONDS` (vychozi 1 hodina) od dokonceni jobu, presny cas je
v poli `expires_at`. Pak se soubor i zaznam jobu smazou a dalsi dotaz vraci 404.
Stahovat lze opakovane. Neuspesny job se maze hned. Uloziste je docasny adresar
procesu, restart sluzby vysledky ztrati.
"""


@router.post(
    "",
    response_model=JobAccepted,
    status_code=status.HTTP_202_ACCEPTED,
    summary="Zaradi konverzi do fronty",
    description=CREATE_DESCRIPTION,
)
async def create_job(request: ConvertRequest) -> JobAccepted:
    job = get_container().jobs.submit(request)
    return JobAccepted(
        job_id=job.id,
        status=job.state.status,
        created_at=job.state.created_at,
        result_url=_result_url(job.id),
    )


STATE_DESCRIPTION = """
Stav jobu, postup renderu a vysledek kontrol.

Stavy: `queued`, `running`, `done`, `failed`, `cancelled`, `expired`.

`progress.pass_number` rozlisuje prvni a druhy pruchod. Druhy nastava jen
u dokumentu s generovanym obsahem, takze ukazatel postupu probehne dvakrat.

`expires_at` je cas, do ktereho je vysledek ke stazeni. `missing_assets` je
seznam assetu, ktere se nepodarilo nacist, `warnings` obsahuje veci, na ktere
sluzba upozornuje, aniz by kvuli nim konverze selhala.
"""


@router.get(
    "/{job_id}",
    response_model=JobState,
    summary="Stav jobu",
    description=STATE_DESCRIPTION,
)
async def job_state(job_id: str) -> JobState:
    job = get_container().jobs.get(job_id)
    state = job.state.model_copy()
    if state.status == "done":
        state.result_url = _result_url(job_id)
    return state


@router.get(
    "/{job_id}/result",
    summary="Stahne hotove PDF",
    description=(
        "Stahne vysledek jobu. Soubor se streamuje, nenacita se cely do pameti. "
        "Stahovat lze opakovane, dokud vysledek nevyprsi. Doba dostupnosti je "
        "JOB_RESULT_TTL_SECONDS od dokonceni jobu, presny cas je v poli expires_at "
        "u GET /jobs/{job_id}."
    ),
    response_class=Response,
    responses={
        200: {"content": {"application/pdf": {}}, "description": "Hotove PDF."},
        404: {"description": "Job neexistuje nebo uz expiroval."},
        409: {"description": "Job jeste nedobehl nebo skoncil chybou."},
    },
)
async def job_result(job_id: str):
    container = get_container()
    job = container.jobs.get(job_id)

    if job.state.status != "done":
        error = ConversionError(
            f"Vysledek neni k dispozici, job je ve stavu {job.state.status}.",
            {"status": job.state.status},
        )
        error.error_code = "result_not_ready"
        error.status_code = 409
        raise error

    path = container.storage.result_path(job_id)
    if not path.exists():
        raise JobNotFoundError("Soubor s vysledkem uz neexistuje, job pravdepodobne expiroval.")

    filename = job.request.filename or "dokument.pdf"
    return FileResponse(
        path,
        media_type="application/pdf",
        filename=filename,
        headers={
            "X-Page-Count": str(job.state.page_count or 0),
            "X-Engine-Used": job.state.engine_used or "",
        },
    )


@router.delete(
    "/{job_id}",
    response_model=JobState,
    summary="Zrusi job nebo smaze jeho vysledek",
    description=(
        "Zrusi bezici job nebo smaze hotovy vysledek hned, bez cekani na expiraci. "
        "Soubor se z uloziste odstrani okamzite, zaznam jobu zustava jeste po dobu "
        "TTL, aby bylo videt, co se s nim stalo."
    ),
)
async def delete_job(job_id: str) -> JobState:
    return get_container().jobs.cancel(job_id).state