"""Internal API: templates, drafts, locks, preview, publish, versions (TZ I6-I23)."""

from __future__ import annotations

from typing import Any, Literal

from django.http import HttpRequest, HttpResponse
from ninja import Body, Field, Header, Router, Schema, Status

from snapfile.auth_sso.auth import EditorJwtAuth, require
from snapfile.auth_sso.sessions import EditorPrincipal
from snapfile.core import ids
from snapfile.core.errors import ApiError
from snapfile.core.pagination import paginate
from snapfile.jobs.preview import run_preview
from snapfile.jobs.service import job_dict
from snapfile.projects.variables import build_json_schema, example_data, known_paths
from snapfile.render.signing import signed_url

from . import service
from .jsonpatch import PatchError, apply_patch
from .models import Template, TemplateVersion
from .scene import unknown_variables, validate_scene
from .thumbnails import thumbnail_png
from .usage import document_usage

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


class TemplateCreate(Schema):
    key: str = Field(..., max_length=64)
    name: str = Field(..., max_length=255)
    description: str | None = None
    tags: list[str] | None = None
    format: Literal["A3", "A4", "A5", "Letter", "Legal"] = "A4"
    orientation: Literal["portrait", "landscape"] = "portrait"
    document: dict[str, Any] | None = Field(None, description="Import an existing scene graph")
    from_template_id: str | None = Field(None, description="Create as a copy of another template")
    sample_data: dict[str, Any] | None = None


class TemplatePatch(Schema):
    name: str | None = None
    key: str | None = None
    description: str | None = None
    language: str | None = Field(None, max_length=16, description='Language code; "" clears it')
    archived: bool | None = Field(None, description="Archive (switch off for the API) or bring back; admin only")
    group_key: str | None = Field(None, max_length=64, description='API group key, e.g. "aga-proposal"; "" clears it')
    is_default: bool | None = Field(None, description="Default template of its language within the group")
    allowed_users: list[dict[str, Any]] | None = Field(
        None, description='[{"id": external user id, "name": snapshot}]; empty = everyone in the project'
    )
    default_format: str | None = None
    tags: list[str] | None = None
    output_defaults: dict[str, Any] | None = None
    sample_data: dict[str, Any] | None = None
    test_data_sets: list[dict[str, Any]] | None = Field(
        None, description='Named test data sets [{"id", "name", "data"}]; the set with id "sample" is sample_data'
    )
    variables_override: list[dict[str, Any]] | None = None


class SampleDataIn(Schema):
    sample_data: dict[str, Any]


class DraftPut(Schema):
    base_revision: int | None = None
    baseVersion: int | None = None
    document: dict[str, Any]
    client_ts: str | None = None


class DraftPatch(Schema):
    base_revision: int | None = None
    baseVersion: int | None = None
    ops: list[dict[str, Any]]


class DuplicateIn(Schema):
    key: str | None = None
    name: str | None = None
    language: str | None = Field(None, max_length=16)
    as_variant: bool = False


class PreviewIn(Schema):
    data: dict[str, Any] | None = None
    format: Literal["pdf", "png", "jpg"] = "png"
    pages: str | list[int] | None = None
    dpi: int = Field(110, ge=36, le=300)
    highlightMissing: bool = False
    version: int | None = Field(None, description="Render a published version instead of the draft")


class PublishIn(Schema):
    base_revision: int | None = None
    comment: str | None = Field(None, max_length=2000)
    check_render: bool = True
    acknowledge_warnings: list[str] = Field(default_factory=list)


class LockIn(Schema):
    takeover: bool = False


def _principal(request: HttpRequest) -> EditorPrincipal:
    return request.auth  # type: ignore[attr-defined]


def _tpl(request: HttpRequest, template_id: str) -> Template:
    return service.get_template(request.project, template_id, _principal(request))  # type: ignore[attr-defined]


def _revision(base: int | None, alt: int | None, if_match: str | None) -> int:
    for value in (base, alt):
        if value is not None:
            return int(value)
    if if_match:
        try:
            return int(if_match.strip('W/"'))
        except ValueError:
            pass
    raise ApiError(422, "VALIDATION_FAILED", "base_revision (or If-Match) is required", [{"pointer": "/base_revision"}])


@router.get("templates", summary="I6. List templates")
def list_templates(request: HttpRequest, limit: int = 100, cursor: str | None = None, q: str | None = None) -> Any:
    qs = Template.objects.select_related("current_version").filter(
        project=request.project,  # type: ignore[attr-defined]
        deleted_at__isnull=True,
    )
    p = _principal(request)
    if p.templates:
        qs = qs.filter(key__in=p.templates)
    if q:
        qs = qs.filter(name__icontains=q)
    rows, nxt = paginate(qs, limit, cursor)
    rows = [t for t in rows if service.user_allowed(t, p.user_id, p.role)]
    return {"data": [service.template_dict(t) for t in rows], "next_cursor": nxt}


@router.post("templates", response={201: dict}, summary="I7. Create a template (blank, copy or import)")
def create_template(request: HttpRequest, body: TemplateCreate) -> Any:
    principal = require(request, "edit")
    project = request.project  # type: ignore[attr-defined]
    if body.from_template_id:
        src = service.get_template(project, body.from_template_id, principal)
        t = service.duplicate(src, principal.actor, body.key, body.name, request)
    else:
        t = service.create_template(
            project,
            principal.actor,
            key=body.key,
            name=body.name,
            description=body.description,
            tags=body.tags,
            document=body.document,
            fmt=body.format,
            orientation=body.orientation,
            sample_data=body.sample_data,
            request=request,
        )
    return Status(201, {"template": service.template_dict(t, draft=True)})


@router.get("templates/{template_id}", summary="I8. Template with draft")
def get_template(request: HttpRequest, template_id: str) -> Any:
    return {"template": service.template_dict(_tpl(request, template_id), draft=True)}


@router.patch("templates/{template_id}", summary="I9. Update metadata / sample data")
def patch_template(request: HttpRequest, template_id: str, body: TemplatePatch) -> Any:
    principal = require(request, "edit")
    fields = body.dict(exclude_unset=True)
    if "allowed_users" in fields or "archived" in fields or "group_key" in fields or "is_default" in fields:
        require(request, "admin")
    t = service.update_meta(_tpl(request, template_id), principal.actor, fields, request)
    return {"template": service.template_dict(t, draft=True)}


@router.delete(
    "templates/{template_id}",
    response={204: None},
    summary="I10. Delete (admin): soft by default; permanent=true removes an archived template with its generations",
)
def delete_template(request: HttpRequest, template_id: str, permanent: bool = False) -> Any:
    principal = require(request, "admin")
    if permanent:
        service.purge(_tpl(request, template_id), principal.actor, request)
    else:
        service.soft_delete(_tpl(request, template_id), principal.actor, request)
    return Status(204, None)


@router.post("templates/{template_id}/duplicate", response={201: dict}, summary="I11. Duplicate")
def duplicate(request: HttpRequest, template_id: str, body: DuplicateIn) -> Any:
    principal = require(request, "edit")
    t = service.duplicate(
        _tpl(request, template_id), principal.actor, body.key, body.name, request, body.language, body.as_variant
    )
    return Status(201, {"template": service.template_dict(t, draft=True)})


@router.put("templates/{template_id}/draft", summary="I12. Autosave (full document, optimistic lock)")
def put_draft(
    request: HttpRequest, template_id: str, body: DraftPut, if_match: str | None = Header(None, alias="If-Match")
) -> Any:
    principal = require(request, "edit")
    base = _revision(body.base_revision, body.baseVersion, if_match)
    result = service.save_draft(_tpl(request, template_id), principal, body.document, base, request)
    return {**result, "version": result["revision"]}


@router.patch("templates/{template_id}/draft", summary="I13. Autosave (RFC 6902 JSON Patch)")
def patch_draft(
    request: HttpRequest, template_id: str, body: DraftPatch, if_match: str | None = Header(None, alias="If-Match")
) -> Any:
    principal = require(request, "edit")
    base = _revision(body.base_revision, body.baseVersion, if_match)
    t = _tpl(request, template_id)
    if t.draft_revision != base:
        raise ApiError(
            409,
            "REVISION_CONFLICT",
            "Draft was changed elsewhere",
            [{"current_revision": t.draft_revision, "updated_by": t.updated_by}],
        )
    try:
        doc = apply_patch(t.draft_document, body.ops)
    except PatchError as exc:
        raise ApiError(422, "VALIDATION_FAILED", f"JSON Patch failed: {exc}") from exc
    result = service.save_draft(t, principal, doc, base, request)
    return {**result, "version": result["revision"]}


@router.post("templates/{template_id}/lock", summary="I14. Take/extend the soft lock (TTL 90 s)")
def lock(request: HttpRequest, template_id: str, body: LockIn | None = None) -> Any:
    principal = require(request, "edit")
    return service.take_lock(_tpl(request, template_id), principal, takeover=bool(body and body.takeover))


@router.post("templates/{template_id}/lock/heartbeat", summary="Lock heartbeat (every 30 s)")
def lock_heartbeat(request: HttpRequest, template_id: str) -> Any:
    principal = require(request, "edit")
    return service.take_lock(_tpl(request, template_id), principal)


@router.post("templates/{template_id}/lock/takeover", summary="Take over the lock (admin)")
def lock_takeover(request: HttpRequest, template_id: str) -> Any:
    principal = require(request, "admin")
    return service.take_lock(_tpl(request, template_id), principal, takeover=True)


@router.delete("templates/{template_id}/lock", response={204: None}, summary="I15. Release the lock")
def unlock(request: HttpRequest, template_id: str) -> Any:
    principal = require(request, "edit")
    service.release_lock(_tpl(request, template_id), principal)
    return Status(204, None)


@router.post("templates/{template_id}/validate", summary="I16. Validate the draft")
def validate(request: HttpRequest, template_id: str) -> Any:
    t = _tpl(request, template_id)
    errors, warnings, plan = validate_scene(t.draft_document)
    if plan is not None:
        tree = service.effective_variables(t)
        unknown = unknown_variables(plan, known_paths(tree))
        warnings += [{"code": "SCENE_UNKNOWN_VARIABLE", "path": p} for p in unknown]
        dep_errors, _ = service._check_dependencies(t.project, plan)
        errors += dep_errors
    return {
        "valid": not errors,
        "errors": errors,
        "warnings": warnings,
        "revision": t.draft_revision,
        "changes": service.draft_changes(t, plan.get("variables") if plan is not None else None),
    }


@router.get("templates/{template_id}/schema", summary="Effective variables (project + template) and JSON Schema")
def schema(request: HttpRequest, template_id: str) -> Any:
    t = _tpl(request, template_id)
    tree = service.effective_variables(t)
    return {"variables": tree, "json_schema": build_json_schema(tree), "example": example_data(tree)}


@router.get("templates/{template_id}/sample-data", summary="Sample (test) data of the template")
def get_sample(request: HttpRequest, template_id: str) -> Any:
    t = _tpl(request, template_id)
    return {
        "sample_data": t.sample_data
        if isinstance(t.sample_data, dict)
        else example_data(service.effective_variables(t)),
        "stored": isinstance(t.sample_data, dict),
    }


@router.put("templates/{template_id}/sample-data", summary="Replace sample (test) data")
def put_sample(request: HttpRequest, template_id: str, body: SampleDataIn = Body(...)) -> Any:
    principal = require(request, "edit")
    t = service.update_meta(_tpl(request, template_id), principal.actor, {"sample_data": body.sample_data}, request)
    return {"sample_data": t.sample_data}


@router.get(
    "templates/{template_id}/thumbnail",
    summary="PNG thumbnail of the first sheet of the draft (rendered lazily, cached by draft hash)",
)
def thumbnail(request: HttpRequest, template_id: str, h: str | None = None) -> HttpResponse:
    png = thumbnail_png(_tpl(request, template_id))
    if png is None:
        raise ApiError(404, "NOT_FOUND", "Thumbnail is not available")
    resp = HttpResponse(png, content_type="image/png")
    resp["Cache-Control"] = "private, max-age=86400" if h else "private, no-cache"
    return resp


@router.get("variables/usage", summary="I29. Where variables are used (templates and node counts)")
def variables_usage(request: HttpRequest) -> Any:
    qs = Template.objects.filter(project=request.project, deleted_at__isnull=True).only(  # type: ignore[attr-defined]
        "id", "key", "name", "draft_document"
    )
    p = _principal(request)
    if p.templates:
        qs = qs.filter(key__in=p.templates)
    by_path: dict[str, list[dict[str, Any]]] = {}
    for t in qs.order_by("name"):
        for path, nodes in sorted(document_usage(t.draft_document).items()):
            by_path.setdefault(path, []).append(
                {"id": ids.encode("tpl", t.id), "key": t.key, "name": t.name, "nodes": nodes}
            )
    return {"data": [{"path": k, "templates": v} for k, v in sorted(by_path.items())]}


@router.post("templates/{template_id}/preview", summary="I17. Render the draft with test data (PDF or PNG)")
def preview(request: HttpRequest, template_id: str, body: PreviewIn) -> Any:
    principal = _principal(request)
    t = _tpl(request, template_id)
    version = None
    if body.version is not None:
        version = TemplateVersion.objects.filter(template=t, number=body.version).first()
        if version is None:
            raise ApiError(404, "NOT_FOUND", "Version not found")
    data = (
        body.data
        if body.data is not None
        else (t.sample_data if isinstance(t.sample_data, dict) else example_data(service.effective_variables(t)))
    )
    pages = body.pages
    if isinstance(pages, list):
        pages = ",".join(str(p) for p in pages)
    job = run_preview(
        project=t.project,
        template=t,
        version=version,
        data=data,
        output={"format": body.format, "dpi": body.dpi, "pages": pages, "split": "per_sheet"},
        api_key=None,
        initiator=principal.snapshot(),
        highlight_missing=body.highlightMissing,
    )
    out = job_dict(job, absolute=False)
    if job.status != "succeeded":
        raise ApiError(
            422,
            out["error"]["code"] if out["error"] else "RENDER_FAILED",
            out["error"]["message"] if out["error"] else "Preview failed",
            job.warnings or [],
        )
    # The editor shows previews in <iframe>/<img>: ``url`` is the inline variant, ``download_url`` the attachment.
    inline = {
        ids.encode("fil", f.id): signed_url(f.id, f.expires_at, "inline", absolute=False) for f in job.files.all()
    }
    files = [{**f, "download_url": f["url"], "url": inline.get(f["id"], f["url"])} for f in out["files"]]
    return {
        "url": files[0]["url"] if files else None,
        "download_url": files[0]["download_url"] if files else None,
        "pages": job.pages,
        "durationMs": out["timings"].get("total_ms"),
        "files": files,
        "warnings": out["warnings"],
        "job": out,
    }


@router.post("templates/{template_id}/publish", response={201: dict}, summary="I18. Publish the draft")
def publish(request: HttpRequest, template_id: str, body: PublishIn) -> Any:
    principal = require(request, "edit")
    t = _tpl(request, template_id)
    v = service.publish(
        t,
        principal,
        base_revision=body.base_revision,
        comment=body.comment,
        check=body.check_render,
        acknowledge=body.acknowledge_warnings,
        request=request,
    )
    return Status(
        201,
        {
            "version": {
                **service.version_dict(v),
                "check_render": getattr(v, "check_render", None),
                "warnings": getattr(v, "publish_warnings", []),
            }
        },
    )


@router.get("templates/{template_id}/versions", summary="I19. Versions")
def versions(request: HttpRequest, template_id: str) -> Any:
    t = _tpl(request, template_id)
    rows = TemplateVersion.objects.filter(template=t).order_by("-number")
    current = t.current_version_id
    return {"data": [{**service.version_dict(v), "current": v.id == current} for v in rows]}


@router.get("templates/{template_id}/versions/{number}", summary="I20. Version document")
def version(request: HttpRequest, template_id: str, number: int) -> Any:
    t = _tpl(request, template_id)
    v = TemplateVersion.objects.filter(template=t, number=number).first()
    if v is None:
        raise ApiError(404, "NOT_FOUND", "Version not found")
    return {"version": service.version_dict(v, document=True)}


@router.post("templates/{template_id}/versions/{number}/activate", summary="I21. Make a version current (admin)")
def activate(request: HttpRequest, template_id: str, number: int) -> Any:
    principal = require(request, "admin")
    v = service.activate_version(_tpl(request, template_id), number, principal, request)
    return {"version": service.version_dict(v)}


@router.post("templates/{template_id}/versions/{number}/restore", summary="I22. Copy a version into the draft")
def restore(request: HttpRequest, template_id: str, number: int) -> Any:
    principal = require(request, "edit")
    return service.restore_version(_tpl(request, template_id), number, principal, request)
