"""Internal API: generation history of the project (TZ I42)."""

from __future__ import annotations

from datetime import datetime, time, timedelta
from typing import Any

from django.http import HttpRequest
from django.utils import timezone
from ninja import Router

from snapfile.auth_sso.auth import EditorJwtAuth
from snapfile.core import ids
from snapfile.core.errors import ApiError
from snapfile.core.pagination import paginate

from .models import RenderJob
from .service import job_dict

router = Router(auth=EditorJwtAuth(), tags=["internal: jobs"])


def _history_dict(job: RenderJob, show_payload: bool) -> dict[str, Any]:
    """Public job shape plus the fields of the generation history screen (03_frontend 3.4.6 e)."""
    out = job_dict(job, absolute=False)
    files = out["files"]
    timings = job.timings or {}
    out["template"] = {
        **out["template"],
        "id": ids.encode("tpl", job.template_id),
        "name": job.template.name,
    }
    out["format"] = (job.output or {}).get("format", "pdf")
    out["duration_ms"] = timings.get("total_ms")
    out["size_bytes"] = sum(f.get("size_bytes") or 0 for f in files) if files else None
    out["source"] = job.api_key.name if job.api_key_id and job.api_key else ("editor" if job.initiator else None)
    out["preview"] = job.kind == "preview"
    if show_payload:
        out["payload"] = job.payload
    return out


@router.get("jobs", summary="I42. Generation history (render + preview)")
def list_jobs(
    request: HttpRequest,
    kind: str | None = None,
    status: str | None = None,
    template: str | None = None,
    limit: int = 50,
    cursor: str | None = None,
) -> Any:
    qs = (
        RenderJob.objects.select_related("template", "template_version", "api_key")
        .prefetch_related("files")
        .filter(project=request.project)
    )  # type: ignore[attr-defined]
    if kind:
        qs = qs.filter(kind=kind)
    if status:
        qs = qs.filter(status=status)
    if template:
        qs = qs.filter(template__key=template)
    rows, nxt = paginate(qs, limit, cursor)
    # viewer does not see request payloads (03_frontend 3.4.6 e)
    show_payload = request.auth.role != "viewer"  # type: ignore[attr-defined]
    return {"data": [_history_dict(j, show_payload) for j in rows], "next_cursor": nxt}


def _p95(values: list[int]) -> int:
    if not values:
        return 0
    values = sorted(values)
    return values[min(len(values) - 1, int(len(values) * 0.95))]


@router.get("jobs/stats", summary="Generation statistics per day (count, failures, p95 duration)")
def jobs_stats(request: HttpRequest, days: int = 7, kind: str | None = "render") -> Any:
    days = max(1, min(int(days), 90))
    tz = timezone.get_current_timezone()
    today = timezone.localdate()
    start = today - timedelta(days=days - 1)
    since = timezone.make_aware(datetime.combine(start, time.min), tz)
    qs = RenderJob.objects.filter(project=request.project, created_at__gte=since)  # type: ignore[attr-defined]
    if kind:
        qs = qs.filter(kind=kind)
    buckets: dict[str, dict[str, Any]] = {
        (start + timedelta(days=i)).isoformat(): {"count": 0, "failed": 0, "pages": 0, "durations": []}
        for i in range(days)
    }
    for created, status, pages, timings in qs.values_list("created_at", "status", "pages", "timings").iterator():
        b = buckets.get(timezone.localtime(created, tz).date().isoformat())
        if b is None:
            continue
        b["count"] += 1
        b["failed"] += status == "failed"
        b["pages"] += pages or 0
        total = (timings or {}).get("total_ms")
        if isinstance(total, int | float):
            b["durations"].append(int(total))
    out = [
        {"date": d, "count": b["count"], "failed": b["failed"], "pages": b["pages"], "p95_ms": _p95(b["durations"])}
        for d, b in buckets.items()
    ]
    all_durations = [x for b in buckets.values() for x in b["durations"]]
    return {
        "days": out,
        "total": {
            "count": sum(x["count"] for x in out),
            "failed": sum(x["failed"] for x in out),
            "pages": sum(x["pages"] for x in out),
            "p95_ms": _p95(all_durations),
        },
    }


@router.get("preview-jobs/{job_id}", summary="Preview job status (editor polling)")
def preview_job(request: HttpRequest, job_id: str) -> Any:
    try:
        uid = ids.decode("job", job_id)
    except ids.InvalidId as exc:
        raise ApiError(404, "JOB_NOT_FOUND", "Job not found") from exc
    job = (
        RenderJob.objects.select_related("template", "template_version").filter(project=request.project, pk=uid).first()
    )  # type: ignore[attr-defined]
    if job is None:
        raise ApiError(404, "JOB_NOT_FOUND", "Job not found")
    return {"job": job_dict(job, absolute=False)}
