"""Render jobs: creation (sync/async, idempotency, validation) and execution with lease (TZ 2.1.4 В, 2.8.5)."""

from __future__ import annotations

import json
import logging
import threading
import time
from datetime import timedelta
from functools import lru_cache
from typing import Any

from django.conf import settings
from django.db import IntegrityError, OperationalError, close_old_connections, connection, transaction
from django.utils import timezone
from jsonschema import Draft202012Validator

from snapfile.core import ids
from snapfile.core.crypto import canonical_json, sha256_hex
from snapfile.core.dbconn import revive_connection
from snapfile.core.errors import ApiError
from snapfile.core.storage import store
from snapfile.doctemplates.models import Template, TemplateVersion
from snapfile.integration.models import ApiKey
from snapfile.projects.models import Project
from snapfile.projects.variables import derived_defs
from snapfile.render.plans import draft_plan, version_plan
from snapfile.render.service import render_for_project, safe_filename, store_outputs
from snapfile.render.signing import signed_url
from snapfile_render import ENGINE_VERSION
from snapfile_render.errors import RenderCanceled, RenderError

from .models import RenderFile, RenderJob
from .queue import JobQueue, make_owner
from .webhooks import enqueue_event

log = logging.getLogger("snapfile.render")
queue = JobQueue(RenderJob)

PERMANENT_PREFIXES = (
    "PAYLOAD_",
    "SCENE_",
    "TEMPLATE_",
    "PAGINATION_",
    "FONT_",
    "PDFA_",
    "RASTER_",
    "DOCUMENT_",
    "REPEATER_",
)
RESOURCE_CODES = ("RENDER_TIMEOUT", "RESOURCE_LIMIT")


class LeaseLost(Exception):
    pass


# --------------------------------------------------------------------------------------------- validation


@lru_cache(maxsize=64)
def _validator(version_id: str, schema_json: str) -> Draft202012Validator:
    return Draft202012Validator(json.loads(schema_json))


def _pointer(path: Any) -> str:
    return "/" + "/".join(str(p) for p in path)


def validate_payload(
    version: TemplateVersion | None, json_schema: dict[str, Any] | None, data: Any, mode: str = "strict"
) -> list[dict[str, Any]]:
    """Return warnings (lenient) or raise 422 PAYLOAD_INVALID with up to 100 JSON-pointer errors."""
    if not isinstance(data, dict):
        raise ApiError(422, "PAYLOAD_INVALID", "data must be a JSON object")
    if not json_schema:
        return []
    key = str(version.id) if version else sha256_hex(canonical_json(json_schema))
    validator = _validator(key, json.dumps(json_schema, sort_keys=True))
    errors = []
    for err in validator.iter_errors(data):
        item = {"pointer": _pointer(err.absolute_path), "rule": err.validator, "message": err.message[:300]}
        if err.validator == "required":
            missing = err.message.split("'")[1] if "'" in err.message else ""
            item["pointer"] = _pointer([*err.absolute_path, missing])
        errors.append(item)
        if len(errors) >= 100:
            break
    if errors and mode == "strict":
        raise ApiError(422, "PAYLOAD_INVALID", "Input data does not match the template schema", errors)
    return [{"code": "PAYLOAD_LENIENT", **e} for e in errors]


# --------------------------------------------------------------------------------------------- serialisation


def file_dict(f: RenderFile, absolute: bool = True) -> dict[str, Any]:
    return {
        "id": ids.encode("fil", f.id),
        "kind": f.kind,
        "filename": f.filename,
        "mime": f.mime,
        "size_bytes": f.size_bytes,
        "sha256": f.sha256,
        "page": (f.sheet_index + 1) if f.sheet_index is not None else None,
        "width_px": f.width_px,
        "height_px": f.height_px,
        "url": signed_url(f.id, f.expires_at, absolute=absolute) if f.deleted_at is None else None,
        "expires_at": f.expires_at.isoformat(),
    }


def job_dict(job: RenderJob, *, absolute: bool = True) -> dict[str, Any]:
    jid = ids.encode("job", job.id)
    files = [file_dict(f, absolute) for f in job.files.all()] if job.status in ("succeeded", "expired") else []
    out: dict[str, Any] = {
        "id": jid,
        "status": job.status,
        "mode": job.mode,
        "kind": job.kind,
        "attempts": job.attempts,
        "template": {"key": job.template.key, "version": job.template_version.number if job.template_version else None},
        "pages": job.pages,
        "files": files,
        "warnings": job.warnings or [],
        "timings": job.timings or {},
        "external_ref": job.external_ref,
        "status_url": f"/api/v1/jobs/{jid}",
        "created_at": job.created_at.isoformat(),
        "queued_at": job.queued_at.isoformat() if job.queued_at else None,
        "started_at": job.started_at.isoformat() if job.started_at else None,
        "finished_at": job.finished_at.isoformat() if job.finished_at else None,
        "error": None,
    }
    if job.status == "failed" or (job.error_code and job.status == "queued"):
        out["error"] = {"code": job.error_code, "message": job.error_message or ""}
    return out


# --------------------------------------------------------------------------------------------- creation


def estimate_cost(document: dict[str, Any], data: dict[str, Any], output: dict[str, Any]) -> int:
    sheets = len(document.get("sheets") or [])
    payload_kb = len(json.dumps(data, default=str)) / 1024
    cost = sheets + int(payload_kb / 25)
    if output.get("format") in ("png", "jpg"):
        dpi = int(output.get("dpi") or 150)
        megapixels = sheets * (8.27 * dpi / 1) * (11.7 * dpi) / 1_000_000
        cost += int(megapixels * 2)
    return max(1, cost)


def resolve_version(template: Template, version: Any) -> TemplateVersion:
    if version in (None, "", "current"):
        if template.current_version_id is None:
            raise ApiError(422, "TEMPLATE_NOT_PUBLISHED", "Template has no published version")
        return TemplateVersion.objects.get(pk=template.current_version_id)
    try:
        number = int(version)
    except (TypeError, ValueError) as exc:
        raise ApiError(400, "BAD_REQUEST", "version must be 'current' or an integer") from exc
    v = TemplateVersion.objects.filter(template=template, number=number).first()
    if v is None:
        raise ApiError(404, "NOT_FOUND", f"Version {number} not found")
    return v


def create_render_job(
    *,
    project: Project,
    template: Template,
    version: TemplateVersion,
    data: dict[str, Any],
    output: dict[str, Any],
    mode: str = "auto",
    validation: str = "strict",
    external_ref: str | None = None,
    webhook_url: str | None = None,
    deterministic: bool = False,
    api_key: ApiKey | None = None,
    idempotency_key: str | None = None,
    fingerprint: str | None = None,
    kind: str = "render",
) -> tuple[RenderJob, bool]:
    """Returns (job, replayed). Sync jobs are executed before returning."""
    lenient_warnings = validate_payload(version, version.json_schema, data, validation)
    payload_text = canonical_json(data)
    max_kb = int(project.setting("max_payload_kb") or 5120)
    if len(payload_text.encode()) > max_kb * 1024:
        raise ApiError(413, "PAYLOAD_TOO_LARGE", f"Payload exceeds {max_kb} KB")
    cost = estimate_cost(version.document, data, output)
    sync_limit = int(project.setting("sync_max_cost") or settings.RENDER_SYNC_MAX_COST)
    run_sync = settings.SNAPFILE_QUEUE_MODE == "sync" or mode == "sync" or (mode == "auto" and cost <= sync_limit)
    now = timezone.now()
    ttl_hours = int(output.get("ttl_hours") or project.setting("file_ttl_hours") or settings.FILE_TTL_HOURS)
    if api_key is not None and api_key.env == "test":
        ttl_hours = 1
    owner = make_owner()
    idem_hash = sha256_hex(idempotency_key) if idempotency_key else None
    job = RenderJob(
        project=project,
        template=template,
        template_version=version,
        api_key=api_key,
        kind=kind,
        mode="sync" if run_sync else "async",
        queue="render-high" if cost <= sync_limit else "render",
        priority=1 if run_sync else 5,
        status="running" if run_sync else "queued",
        attempts=1 if run_sync else 0,
        max_attempts=settings.SNAPFILE_JOB_MAX_ATTEMPTS,
        lease_owner=owner if run_sync else None,
        lease_until=now + timedelta(seconds=settings.RENDER_TIMEOUT_SYNC + 30) if run_sync else None,
        started_at=now if run_sync else None,
        output={**output, "ttl_hours": ttl_hours, "deterministic": deterministic},
        payload=data,
        payload_hash=sha256_hex(payload_text),
        idempotency_key_hash=idem_hash,
        request_fingerprint=fingerprint,
        external_ref=external_ref,
        webhook_url=webhook_url,
        cost_estimate=cost,
        warnings=lenient_warnings or None,
        engine_version=ENGINE_VERSION,
        queued_at=now,
    )
    try:
        with transaction.atomic():
            job.save(force_insert=True)
    except IntegrityError:
        if not idem_hash:
            raise
        existing = RenderJob.objects.filter(project=project, idempotency_key_hash=idem_hash).first()
        if existing is None:
            raise
        if existing.request_fingerprint and fingerprint and existing.request_fingerprint != fingerprint:
            raise ApiError(409, "IDEMPOTENCY_CONFLICT", "Idempotency-Key was used with a different request") from None
        if existing.mode == "sync" and existing.status == "running":
            deadline = time.monotonic() + 10
            while existing.status == "running" and time.monotonic() < deadline:
                time.sleep(0.25)
                existing.refresh_from_db()
            if existing.status == "running":
                raise ApiError(
                    409, "IDEMPOTENCY_IN_PROGRESS", "Request with this key is in progress", headers={"Retry-After": "2"}
                ) from None
        return existing, True
    if run_sync:
        execute_job(job, owner, timeout_s=settings.RENDER_TIMEOUT_SYNC)
        job.refresh_from_db()
    return job, False


# --------------------------------------------------------------------------------------------- execution


class _Heartbeat(threading.Thread):
    def __init__(self, job_id: Any, owner: str, interval: float = 15.0) -> None:
        super().__init__(daemon=True, name=f"lease-{job_id}")
        self.job_id = job_id
        self.owner = owner
        self.interval = interval
        self.stop_event = threading.Event()
        self.lost = False
        self.canceled = False

    def run(self) -> None:
        try:
            while not self.stop_event.wait(self.interval):
                alive, cancel = queue.heartbeat(self.job_id, self.owner)
                if not alive:
                    self.lost = True
                    return
                if cancel:
                    self.canceled = True
        except Exception:  # pragma: no cover - DB outage: the reaper takes over
            log.exception("heartbeat failed")
        finally:
            connection.close()


def _plan_for(job: RenderJob) -> dict[str, Any]:
    if job.template_version_id:
        return version_plan(job.template_version)[0]
    return draft_plan(job.template)[0]


def _cleanup_old_attempts(job: RenderJob, base: str, attempt: int) -> None:
    root = base.rsplit("/", 1)[0]
    for n in range(1, attempt):
        store().delete_tree(f"{root}/a{n}")


def execute_job(job: RenderJob, owner: str, *, timeout_s: float | None = None, heartbeat: bool = False) -> str:
    """Render one claimed job. Returns the final status (or 'lost')."""
    hb = _Heartbeat(job.pk, owner) if heartbeat else None
    if hb:
        hb.start()

    def check() -> None:
        if hb and hb.lost:
            raise LeaseLost()
        if hb and hb.canceled:
            raise RenderCanceled()

    started = time.perf_counter()
    created = job.created_at
    base = f"renders/{created:%Y/%m/%d}/{job.id}/a{job.attempts}"
    try:
        plan = _plan_for(job)
        output = job.output or {}
        result = render_for_project(
            job.project,
            plan,
            job.payload or {},
            output,
            deterministic=bool(output.get("deterministic")),
            timeout_s=timeout_s or settings.RENDER_TIMEOUT_ASYNC,
            check=check,
            missing_placeholder=bool(output.get("highlight_missing")),
            derived=derived_defs(job.template_version.schema_snapshot) if job.template_version_id else None,
            doc_vars={
                "jobId": ids.encode("job", job.id),
                "templateKey": job.template.key,
                "version": job.template_version.number if job.template_version else None,
            },
            watermark="TEST" if job.api_key_id and job.api_key and job.api_key.env == "test" else None,
        )
        check()
        revive_connection()  # the render may have outlived the server's idle timeout (wait_timeout)
        filename = safe_filename(output.get("filename"), job.template.key)
        t0 = time.perf_counter()
        stored = store_outputs(base, result, output, filename)
        store_ms = int((time.perf_counter() - t0) * 1000)
        now = timezone.now()
        expires = now + timedelta(hours=int(output.get("ttl_hours") or settings.FILE_TTL_HOURS))
        timings = {**result.timings, "store_ms": store_ms, "total_ms": int((time.perf_counter() - started) * 1000)}
        warnings = (job.warnings or []) + result.warnings
        keep_payload = bool(job.project.setting("store_payload"))
        with transaction.atomic():
            fields: dict[str, Any] = dict(
                status="succeeded",
                pages=result.page_count,
                warnings=warnings[:200],
                timings=timings,
                finished_at=now,
                expires_at=expires,
                error_code=None,
                error_message=None,
            )
            if not keep_payload:
                fields["payload"] = None
            if not queue.finish(job.pk, owner, **fields):
                raise LeaseLost()
            RenderFile.objects.bulk_create(
                [
                    RenderFile(
                        render_job=job,
                        project_id=job.project_id,
                        kind=s.kind,
                        sheet_index=s.sheet_index,
                        filename=s.filename,
                        path=s.path,
                        mime=s.mime,
                        size_bytes=s.size_bytes,
                        sha256=s.sha256,
                        width_px=s.width_px,
                        height_px=s.height_px,
                        expires_at=expires,
                    )
                    for s in stored
                ]
            )
            if job.kind == "render":
                job.refresh_from_db()
                enqueue_event(job.project, "render.succeeded", {"job": job_dict(job)}, job.webhook_url)
        _cleanup_old_attempts(job, base, job.attempts)
        log.info(
            "render finished",
            extra={
                "event": "render.done",
                "job_id": str(job.id),
                "pages": result.page_count,
                "duration_ms": timings["total_ms"],
                "project": job.project.slug,
            },
        )
        return "succeeded"
    except LeaseLost:
        store().delete_tree(base)
        log.warning("lease lost", extra={"event": "queue.lease_lost", "job_id": str(job.id)})
        return "lost"
    except RenderCanceled:
        store().delete_tree(base)
        queue.finish(job.pk, owner, status="canceled", finished_at=timezone.now(), error_code="CANCELED")
        return "canceled"
    except RenderError as exc:
        store().delete_tree(base)
        status = queue.retry_or_fail(job, owner, exc.code, exc.message, retryable=False)
        if exc.details:
            RenderJob.objects.filter(pk=job.pk).update(warnings=(job.warnings or []) + exc.details[:50])
        _notify_failure(job, status)
        return status
    except (OperationalError, OSError) as exc:
        store().delete_tree(base)
        if isinstance(exc, OperationalError):
            close_old_connections()  # drop a broken connection before reporting the failure
        code = "STORAGE_ERROR" if isinstance(exc, OSError) else "DB_ERROR"
        status = queue.retry_or_fail(job, owner, code, str(exc), retryable=True)
        _notify_failure(job, status)
        return status
    except Exception as exc:
        store().delete_tree(base)
        log.exception("render crashed", extra={"event": "render.crash", "job_id": str(job.id)})
        status = queue.retry_or_fail(job, owner, "RENDER_FAILED", f"{type(exc).__name__}: {exc}", retryable=False)
        _notify_failure(job, status)
        return status
    finally:
        if hb:
            hb.stop_event.set()


def _notify_failure(job: RenderJob, status: str) -> None:
    if status == "failed" and job.kind == "render":
        job.refresh_from_db()
        with transaction.atomic():
            enqueue_event(job.project, "render.failed", {"job": job_dict(job)}, job.webhook_url)


def cancel_job(job: RenderJob) -> RenderJob:
    if RenderJob.objects.filter(pk=job.pk, status="queued").update(status="canceled", finished_at=timezone.now()):
        job.refresh_from_db()
        return job
    RenderJob.objects.filter(pk=job.pk, status="running").update(cancel_requested=True)
    job.refresh_from_db()
    return job


def delete_job(job: RenderJob) -> None:
    for f in job.files.all():
        store().delete(f.path)
    store().delete_tree(f"renders/{job.created_at:%Y/%m/%d}/{job.id}")
    job.delete()


def run_one(queues: list[str], owner: str) -> str | None:
    job = queue.claim(owner, queues)
    if job is None:
        return None
    return execute_job(job, owner, heartbeat=True)


def reap_render_jobs() -> tuple[int, int]:
    requeued, failed = queue.reap()
    for pk in failed:
        job = RenderJob.objects.filter(pk=pk).select_related("project", "template").first()
        if job and job.kind == "render":
            with transaction.atomic():
                enqueue_event(job.project, "render.failed", {"job": job_dict(job)}, job.webhook_url)
    return len(requeued), len(failed)
