"""Public API v1 for client services (TZ 2.8.5)."""

from __future__ import annotations

import time
from typing import Any
from urllib.parse import quote

from django.conf import settings
from django.http import HttpRequest, HttpResponse, HttpResponseRedirect, JsonResponse
from ninja import Header, Router, Status

from snapfile.core import ids
from snapfile.core.crypto import base62, canonical_json, encrypt_secret, sha256_hex
from snapfile.core.errors import ApiError
from snapfile.core.pagination import paginate
from snapfile.doctemplates.models import Template, TemplateVersion
from snapfile.doctemplates.service import resolve_api_template
from snapfile.jobs.models import RenderFile, RenderJob, WebhookDelivery
from snapfile.jobs.service import (
    cancel_job,
    create_render_job,
    delete_job,
    job_dict,
    resolve_version,
    validate_payload,
)
from snapfile.projects.variables import example_data
from snapfile.render.signing import signed_url

from .auth import ApiKeyAuth, client_ip, require_scope
from .schemas import (
    EditSessionEnvelope,
    EditSessionIn,
    ErrorOut,
    JobEnvelope,
    JobList,
    PreviewIn,
    RenderIn,
    RevokeUserIn,
    ValidateIn,
    WebhookConfigIn,
)

router = Router(auth=ApiKeyAuth(), tags=["public"])
IDEM_RE_CHARS = set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-:.")


def _project(request: HttpRequest) -> Any:
    return request.project  # type: ignore[attr-defined]


def _job(request: HttpRequest, job_id: str) -> RenderJob:
    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", "project")
        .filter(project=_project(request), pk=uid)
        .first()
    )
    if job is None:
        raise ApiError(404, "JOB_NOT_FOUND", "Job not found")
    return job


def _version_info(t: Template) -> dict[str, Any] | None:
    v = t.current_version
    return {"number": v.number, "published_at": v.published_at.isoformat()} if v else None


# --------------------------------------------------------------------------------------------- project / templates


@router.get("project", summary="A1. Project info, limits, output settings")
def get_project(request: HttpRequest) -> dict[str, Any]:
    require_scope(request, "read")
    p = _project(request)
    s = p.effective_settings
    return {
        "project": {
            "id": ids.encode("prj", p.id),
            "slug": p.slug,
            "name": p.name,
            "client_name": p.client_name,
            "limits": {
                k: s[k]
                for k in ("max_pages", "max_payload_kb", "sync_max_cost", "rate_limit_per_min", "file_ttl_hours")
            },
            "settings": {k: s[k] for k in ("locale", "timezone", "currency", "default_output", "kerning")},
            "webhook_url": p.webhook_url,
        }
    }


@router.get("templates", summary="A2. List templates")
def list_templates(
    request: HttpRequest, tag: str | None = None, q: str | None = None, published: bool | None = None
) -> dict[str, Any]:
    require_scope(request, "templates:read")
    qs = Template.objects.select_related("current_version").filter(
        project=_project(request), deleted_at__isnull=True, archived_at__isnull=True
    )
    if q:
        qs = qs.filter(name__icontains=q) | qs.filter(key__icontains=q)
    if published is not None:
        qs = qs.filter(current_version__isnull=not published)
    items = []
    for t in qs.order_by("key"):
        if tag and tag not in (t.tags or []):
            continue
        items.append(
            {
                "id": ids.encode("tpl", t.id),
                "key": t.key,
                "name": t.name,
                "language": t.language,
                "group_key": t.group_key,
                "is_default": t.is_default,
                "variant_of": ids.encode("tpl", t.variant_of_id) if t.variant_of_id else None,
                "tags": t.tags or [],
                "current_version": _version_info(t),
            }
        )
    return {"data": items, "next_cursor": None}


@router.get("templates/{key}", summary="A3. Template card")
def get_template(request: HttpRequest, key: str, lang: str | None = None) -> dict[str, Any]:
    require_scope(request, "templates:read")
    t = resolve_api_template(_project(request), key, lang)
    versions = (
        TemplateVersion.objects.filter(template=t)
        .order_by("-number")
        .values("number", "status", "published_at", "comment")[:50]
    )
    doc = t.current_version.document if t.current_version else t.draft_document
    return {
        "template": {
            "id": ids.encode("tpl", t.id),
            "key": t.key,
            "name": t.name,
            "description": t.description,
            "language": t.language,
            "variant_of": ids.encode("tpl", t.variant_of_id) if t.variant_of_id else None,
            "tags": t.tags or [],
            "current_version": _version_info(t),
            "output_defaults": t.output_defaults,
            "sheets": [
                {
                    "id": s.get("id"),
                    "name": s.get("name"),
                    "format": s.get("format"),
                    "orientation": s.get("orientation"),
                    "size": s.get("size"),
                }
                for s in doc.get("sheets", [])
            ],
            "versions": [{**v, "published_at": v["published_at"].isoformat()} for v in versions],
        }
    }


@router.get("templates/{key}/schema", summary="A4. Variable schema (JSON Schema or variable list)")
def get_schema(
    request: HttpRequest, key: str, format: str = "jsonschema", version: str = "current", lang: str | None = None
) -> Any:
    require_scope(request, "templates:read")
    t = resolve_api_template(_project(request), key, lang)
    v = resolve_version(t, version)
    if format == "list":
        return {"variables": v.schema_snapshot, "version": v.number}
    return v.json_schema


@router.get("templates/{key}/sample", summary="A5. Sample data")
def get_sample(request: HttpRequest, key: str, lang: str | None = None) -> Any:
    require_scope(request, "templates:read")
    t = resolve_api_template(_project(request), key, lang)
    if isinstance(t.sample_data, dict):
        return t.sample_data
    v = t.current_version
    return example_data(v.schema_snapshot if v else [])


# --------------------------------------------------------------------------------------------- render


def _fingerprint(request: HttpRequest, body: dict[str, Any]) -> str:
    return sha256_hex(f"{request.method}\n{request.path}\n{canonical_json(body)}")


def _pdf_response(job: RenderJob) -> HttpResponse:
    f = job.files.filter(kind="pdf").first()
    if f is None:
        raise ApiError(500, "RENDER_FAILED", "PDF file is missing")
    from snapfile.core.storage import store

    resp = HttpResponse(store().read(f.path), content_type="application/pdf")
    resp["Content-Disposition"] = f"attachment; filename=\"{f.filename}\"; filename*=UTF-8''{quote(f.filename)}"
    resp["X-Snapfile-Job-Id"] = ids.encode("job", job.id) or ""
    resp["X-Snapfile-Pages"] = str(job.pages or 0)
    resp["X-Snapfile-Warnings"] = str(len(job.warnings or []))
    return resp


@router.post(
    "templates/{key}/render",
    summary="A6. Render a document (sync / async)",
    response={200: JobEnvelope, 202: JobEnvelope, 409: ErrorOut, 422: ErrorOut, 504: ErrorOut},
)
def render(
    request: HttpRequest, key: str, body: RenderIn, idempotency_key: str | None = Header(None, alias="Idempotency-Key")
) -> Any:
    api_key = require_scope(request, "render")
    project = _project(request)
    if idempotency_key is not None and (
        not 1 <= len(idempotency_key) <= 128 or not set(idempotency_key) <= IDEM_RE_CHARS
    ):
        raise ApiError(400, "BAD_REQUEST", "Invalid Idempotency-Key")
    if body.webhook_url:
        hosts = project.setting("allowed_webhook_hosts") or []
        from urllib.parse import urlsplit

        if hosts and urlsplit(body.webhook_url).hostname not in hosts:
            raise ApiError(422, "VALIDATION_FAILED", "webhook_url host is not allowed", [{"pointer": "/webhook_url"}])
    t = resolve_api_template(project, key, body.lang or body.data.get("lang"))
    version = resolve_version(t, body.version)
    raw = body.dict()
    job, replayed = create_render_job(
        project=project,
        template=t,
        version=version,
        data=body.data,
        output=raw["output"],
        mode=body.mode,
        validation=body.validation,
        external_ref=body.external_ref,
        webhook_url=body.webhook_url,
        deterministic=body.deterministic,
        api_key=api_key,
        idempotency_key=idempotency_key,
        fingerprint=_fingerprint(request, raw),
    )
    job = RenderJob.objects.select_related("template", "template_version", "project").get(pk=job.pk)
    if job.status == "failed":
        status = 504 if job.error_code == "RENDER_TIMEOUT" else 422
        if job.error_code in ("RENDER_FAILED", "STORAGE_ERROR", "DB_ERROR"):
            status = 500
        raise ApiError(
            status,
            job.error_code or "RENDER_FAILED",
            job.error_message or "Render failed",
            [w for w in (job.warnings or []) if isinstance(w, dict)][:50],
        )
    accept = request.headers.get("Accept", "")
    if job.status == "succeeded" and "application/pdf" in accept and (job.output or {}).get("format") == "pdf":
        resp = _pdf_response(job)
    else:
        status = 200 if job.status in ("succeeded", "canceled") else 202
        resp = JsonResponse({"job": job_dict(job)}, status=status)
        if status == 202:
            resp["Location"] = f"/api/v1/jobs/{ids.encode('job', job.id)}"
    if replayed:
        resp["Idempotent-Replayed"] = "true"
    return resp


@router.post("templates/{key}/validate", summary="A7. Validate data without rendering")
def validate(request: HttpRequest, key: str, body: ValidateIn) -> dict[str, Any]:
    require_scope(request, "render")
    t = resolve_api_template(_project(request), key, body.lang or body.data.get("lang"))
    v = resolve_version(t, body.version)
    try:
        warnings = validate_payload(v, v.json_schema, body.data, body.validation)
    except ApiError as exc:
        if exc.code != "PAYLOAD_INVALID":
            raise
        return {"valid": False, "errors": exc.details, "warnings": []}
    return {"valid": True, "errors": [], "warnings": warnings}


@router.post("templates/{key}/preview", summary="A8. Quick preview (PNG of the first pages, not stored long)")
def preview(request: HttpRequest, key: str, body: PreviewIn) -> Any:
    api_key = require_scope(request, "render")
    project = _project(request)
    t = resolve_api_template(project, key, body.lang or body.data.get("lang"))
    v = resolve_version(t, body.version)
    from snapfile.jobs.preview import run_preview

    job = run_preview(
        project=project,
        template=t,
        version=v,
        data=body.data,
        output={"format": body.format, "dpi": min(body.dpi, 150), "pages": body.pages, "split": "per_sheet"},
        api_key=api_key,
        initiator=None,
    )
    files = list(job.files.all())
    accept = request.headers.get("Accept", "")
    if len(files) == 1 and ("image/" in accept or "application/pdf" in accept):
        from snapfile.core.storage import store

        return HttpResponse(store().read(files[0].path), content_type=files[0].mime)
    return {"job": job_dict(job)}


# --------------------------------------------------------------------------------------------- jobs


@router.get("jobs/{job_id}", response={200: JobEnvelope}, summary="A10. Job status (long poll: ?wait=10)")
def get_job(request: HttpRequest, job_id: str, wait: int = 0) -> Any:
    require_scope(request, "render")
    job = _job(request, job_id)
    deadline = time.monotonic() + max(0, min(wait, 10))
    while job.status in ("queued", "running") and time.monotonic() < deadline:
        time.sleep(0.5)
        job.refresh_from_db()
    return {"job": job_dict(job)}


@router.get("jobs", response=JobList, summary="A11. List jobs")
def list_jobs(
    request: HttpRequest,
    status: str | None = None,
    template: str | None = None,
    external_ref: str | None = None,
    limit: int = 50,
    cursor: str | None = None,
) -> Any:
    require_scope(request, "render")
    qs = RenderJob.objects.select_related("template", "template_version").filter(project=_project(request))
    if status:
        qs = qs.filter(status=status)
    if template:
        qs = qs.filter(template__key=template)
    if external_ref:
        qs = qs.filter(external_ref=external_ref)
    rows, nxt = paginate(qs.prefetch_related("files"), limit, cursor)
    return {"data": [job_dict(j) for j in rows], "next_cursor": nxt}


@router.post("jobs/{job_id}/cancel", response={200: JobEnvelope}, summary="A12. Cancel a job")
def cancel(request: HttpRequest, job_id: str) -> Any:
    require_scope(request, "render")
    return {"job": job_dict(cancel_job(_job(request, job_id)))}


@router.delete("jobs/{job_id}", response={204: None}, summary="A13. Delete a job and its files")
def delete(request: HttpRequest, job_id: str) -> Any:
    require_scope(request, "render")
    delete_job(_job(request, job_id))
    return Status(204, None)


@router.get("jobs/{job_id}/files/{file_id}", summary="A14. Download a file (302 to a signed URL)")
def job_file(request: HttpRequest, job_id: str, file_id: str) -> HttpResponse:
    require_scope(request, "render")
    job = _job(request, job_id)
    try:
        fid = ids.decode("fil", file_id)
    except ids.InvalidId as exc:
        raise ApiError(404, "NOT_FOUND", "File not found") from exc
    f = RenderFile.objects.filter(render_job=job, pk=fid).first()
    if f is None:
        raise ApiError(404, "NOT_FOUND", "File not found")
    if f.deleted_at is not None:
        raise ApiError(410, "GONE", "File expired")
    return HttpResponseRedirect(signed_url(f.id, f.expires_at))


# --------------------------------------------------------------------------------------------- edit sessions


@router.post("edit-sessions", response={201: EditSessionEnvelope}, summary="A16. Issue a one-time editor link")
def create_edit_session(request: HttpRequest, body: EditSessionIn) -> Any:
    api_key = require_scope(request, "editor:issue")
    from snapfile.auth_sso.sessions import issue_session

    session, token = issue_session(
        _project(request),
        api_key=api_key,
        user=body.user.dict(),
        role=body.role,
        permissions=body.permissions,
        templates=body.templates,
        open_target=body.open,
        locale=body.locale,
        return_url=body.return_url,
        client_session_ref=body.client_session_ref,
        ttl_minutes=body.ttl_minutes,
        ip=client_ip(request),
    )
    base = settings.SNAPFILE_BASE_URL
    return Status(
        201,
        {
            "session": {
                "id": ids.encode("ses", session.id),
                "url": f"{base}/editor/handoff?t={token}",
                "sso_url": f"{base}/editor/sso?token={token}",
                "handoff_expires_at": session.handoff_expires_at.isoformat(),
                "expires_at": session.expires_at.isoformat(),
            }
        },
    )


@router.post("edit-sessions/revoke-user", summary="A18. Revoke all sessions of a user")
def revoke_user_sessions(request: HttpRequest, body: RevokeUserIn) -> dict[str, Any]:
    require_scope(request, "editor:issue")
    from snapfile.auth_sso.sessions import revoke_user

    return {"revoked": revoke_user(_project(request), body.external_user_id)}


@router.delete("edit-sessions/{session_id}", response={204: None}, summary="A17. Revoke an editor session")
def revoke_session(request: HttpRequest, session_id: str) -> Any:
    require_scope(request, "editor:issue")
    from snapfile.auth_sso.models import EditSession
    from snapfile.auth_sso.sessions import revoke

    try:
        uid = ids.decode("ses", session_id)
    except ids.InvalidId as exc:
        raise ApiError(404, "NOT_FOUND", "Session not found") from exc
    s = EditSession.objects.filter(project=_project(request), pk=uid).first()
    if s is None:
        raise ApiError(404, "NOT_FOUND", "Session not found")
    revoke(s)
    return Status(204, None)


# --------------------------------------------------------------------------------------------- webhooks


def _delivery_dict(d: WebhookDelivery) -> dict[str, Any]:
    return {
        "id": ids.encode("dlv", d.id),
        "event": d.event,
        "event_id": d.event_id,
        "url": d.url,
        "status": d.status,
        "attempts": d.attempts,
        "response_code": d.response_code,
        "response_snippet": d.response_snippet,
        "next_attempt_at": d.available_at.isoformat(),
        "delivered_at": d.delivered_at.isoformat() if d.delivered_at else None,
        "created_at": d.created_at.isoformat(),
    }


@router.get("webhooks/deliveries", summary="A19. Webhook delivery log")
def deliveries(request: HttpRequest, limit: int = 50, cursor: str | None = None) -> dict[str, Any]:
    require_scope(request, "webhooks")
    rows, nxt = paginate(WebhookDelivery.objects.filter(project=_project(request)), limit, cursor)
    return {"data": [_delivery_dict(d) for d in rows], "next_cursor": nxt}


@router.post("webhooks/deliveries/{delivery_id}/redeliver", summary="A20. Redeliver a webhook")
def redeliver(request: HttpRequest, delivery_id: str) -> dict[str, Any]:
    require_scope(request, "webhooks")
    from django.utils import timezone

    try:
        uid = ids.decode("dlv", delivery_id)
    except ids.InvalidId as exc:
        raise ApiError(404, "NOT_FOUND", "Delivery not found") from exc
    d = WebhookDelivery.objects.filter(project=_project(request), pk=uid).first()
    if d is None:
        raise ApiError(404, "NOT_FOUND", "Delivery not found")
    WebhookDelivery.objects.filter(pk=d.pk).update(
        status="queued", available_at=timezone.now(), attempts=0, lease_owner=None, lease_until=None
    )
    d.refresh_from_db()
    return {"delivery": _delivery_dict(d)}


@router.put("webhooks/config", summary="A21. Webhook URL and secret")
def webhook_config(request: HttpRequest, body: WebhookConfigIn) -> dict[str, Any]:
    require_scope(request, "webhooks")
    p = _project(request)
    p.webhook_url = body.url
    secret = None
    if body.rotate_secret or (body.url and not p.webhook_secret_enc):
        secret = "whsec_" + base62(24)
        p.webhook_secret_enc = encrypt_secret(secret)
    p.save(update_fields=["webhook_url", "webhook_secret_enc", "updated_at"])
    return {"webhook_url": p.webhook_url, "secret": secret}
