"""Running the engine for a project and storing outputs (TZ 2.6.2 stage 6, 2.10)."""

from __future__ import annotations

import hashlib
import io
import re
import unicodedata
import zipfile
from collections.abc import Callable
from dataclasses import dataclass
from typing import Any

from django.conf import settings

from snapfile.assets.fonts import font_library
from snapfile.core.storage import store
from snapfile.projects.models import Project
from snapfile_render.renderer import RenderOptions, RenderResult, render

from .adapters import ProjectAssetResolver

SAFE_NAME_RE = re.compile(r"[^A-Za-z0-9._\-]+")


def safe_filename(name: str | None, default: str = "document") -> str:
    if not name:
        return default
    ascii_name = unicodedata.normalize("NFKD", name).encode("ascii", "ignore").decode()
    clean = SAFE_NAME_RE.sub("_", ascii_name).strip("._") or default
    return clean[:120]


def render_for_project(
    project: Project,
    plan: dict[str, Any],
    data: dict[str, Any] | None,
    output: dict[str, Any],
    *,
    deterministic: bool = False,
    missing_placeholder: bool = False,
    timeout_s: float | None = None,
    check: Callable[[], None] | None = None,
    doc_vars: dict[str, Any] | None = None,
    watermark: str | None = None,
    derived: list[tuple[str, str]] | None = None,
) -> RenderResult:
    if derived is None:
        from snapfile.projects.variables import derived_defs, get_tree

        derived = derived_defs(get_tree(project))
    data = data or {}
    lang = data.get("lang")
    fonts = font_library(project)
    assets = ProjectAssetResolver(project)
    max_pages = min(int(project.setting("max_pages") or 200), settings.RENDER_MAX_PAGES)
    options = RenderOptions(
        format=output.get("format", "pdf"),
        dpi=int(output.get("dpi") or 150),
        quality=int(output.get("quality") or 85),
        pages=output.get("pages"),
        background=output.get("background") or "#FFFFFF",
        deterministic=deterministic,
        locale=output.get("locale")
        or (lang if isinstance(lang, str) and lang else None)
        or plan.get("locale")
        or project.setting("locale")
        or "ru",
        derived=derived,
        kerning=bool(project.setting("kerning")),
        missing_placeholder=missing_placeholder,
        max_pages=max_pages,
        timeout_s=timeout_s,
        check=check,
        doc_vars=doc_vars or {},
        watermark=watermark,
    )
    return render(plan, data, options, fonts, assets)


@dataclass
class StoredFile:
    kind: str
    filename: str
    path: str
    mime: str
    size_bytes: int
    sha256: str
    sheet_index: int | None = None
    width_px: int | None = None
    height_px: int | None = None


def _put(rel: str, data: bytes) -> tuple[str, int, str]:
    store().write(rel, data)
    return rel, len(data), hashlib.sha256(data).hexdigest()


def store_outputs(base_dir: str, result: RenderResult, output: dict[str, Any], filename: str) -> list[StoredFile]:
    fmt = output.get("format", "pdf")
    files: list[StoredFile] = []
    if fmt == "pdf":
        rel, size, sha = _put(f"{base_dir}/{filename}.pdf", result.pdf)
        files.append(StoredFile("pdf", f"{filename}.pdf", rel, "application/pdf", size, sha))
        return files
    ext = "jpg" if fmt == "jpg" else "png"
    mime = "image/jpeg" if ext == "jpg" else "image/png"
    images = result.images
    split = output.get("split") or ("per_sheet" if len(images) <= 1 else "zip")
    if split == "first":
        images = images[:1]
        split = "per_sheet"
    if split == "zip":
        buf = io.BytesIO()
        with zipfile.ZipFile(buf, "w", compression=zipfile.ZIP_STORED) as zf:
            for im in images:
                zf.writestr(f"{filename}_p{im.index + 1:02d}.{ext}", im.data)
        rel, size, sha = _put(f"{base_dir}/{filename}.zip", buf.getvalue())
        files.append(StoredFile("zip", f"{filename}.zip", rel, "application/zip", size, sha))
        return files
    for im in images:
        name = f"{filename}_p{im.index + 1:02d}.{ext}"
        rel, size, sha = _put(f"{base_dir}/{name}", im.data)
        files.append(StoredFile(ext, name, rel, mime, size, sha, im.index, im.width, im.height))
    return files
