"""Render facade (TZ 2.6.1 ``Renderer.render``): plan + data + options -> PDF / raster pages."""

from __future__ import annotations

import time
from collections.abc import Callable
from dataclasses import dataclass, field
from datetime import datetime, timezone
from typing import Any

from .draw.pdf import PdfWriter
from .errors import RenderError, Warnings
from .expr.evaluator import MISSING, EvalEnv, Scope, evaluate, render_template
from .expr.parser import ExprSyntaxError, parse_expression
from .layout_engine import DocumentLayout, LayoutOptions
from .model import Page
from .providers import AssetResolver, FontProvider
from .raster import RasterPage, parse_page_ranges, rasterize


@dataclass
class RenderOptions:
    format: str = "pdf"  # pdf | png | jpg
    dpi: int = 150
    quality: int = 85
    pages: str | list[int] | None = None
    background: str = "#FFFFFF"
    deterministic: bool = False
    locale: str = "ru"
    kerning: bool = True
    missing_placeholder: bool = False
    max_pages: int = 200
    timeout_s: float | None = None
    check: Callable[[], None] | None = None
    doc_vars: dict[str, Any] = field(default_factory=dict)
    watermark: str | None = None
    max_pixels: int = 40_000_000
    tz_offset_minutes: int | None = None
    derived: list[tuple[str, str]] = field(default_factory=list)


@dataclass
class RenderResult:
    pdf: bytes
    page_count: int
    pages: list[Page]
    images: list[RasterPage] = field(default_factory=list)
    warnings: list[dict[str, Any]] = field(default_factory=list)
    timings: dict[str, Any] = field(default_factory=dict)


def _ms(t0: float) -> int:
    return round((time.perf_counter() - t0) * 1000)


def apply_derived(
    data: dict[str, Any], derived: list[tuple[str, str]], env: EvalEnv, system: dict[str, Any] | None = None
) -> dict[str, Any]:
    """Compute derived variables in schema order; each one can use the previous ones. Never mutates ``data``."""
    if not derived:
        return data
    out = dict(data)
    scope = Scope(out, Scope(system or {}))
    for key, source in derived:
        env.node_id = f"derived:{key}"
        try:
            value = evaluate(parse_expression(source), scope, env)
        except ExprSyntaxError:
            env.warnings.add("DERIVED_INVALID", path=key)
            continue
        out[key] = None if value is MISSING else value
    return out


def render(
    plan: dict[str, Any],
    data: dict[str, Any] | None,
    options: RenderOptions,
    fonts: FontProvider,
    assets: AssetResolver,
) -> RenderResult:
    t_start = time.perf_counter()
    deadline = time.monotonic() + options.timeout_s if options.timeout_s else None
    warnings = Warnings()
    data = data or {}
    doc_vars = {"generatedAt": datetime.now(timezone.utc).isoformat(), **options.doc_vars}
    locale = options.locale or plan.get("locale") or "ru"
    data = apply_derived(
        data, options.derived, EvalEnv(locale=locale, warnings=warnings), {"now": doc_vars["generatedAt"]}
    )
    layout_opts = LayoutOptions(
        locale=locale,
        kerning=options.kerning,
        missing_placeholder=options.missing_placeholder,
        max_pages=options.max_pages,
        deadline=deadline,
        check=options.check,
        doc_vars=doc_vars,
        tz_offset_minutes=options.tz_offset_minutes,
    )
    t0 = time.perf_counter()
    pages = DocumentLayout(plan, data, fonts, assets, layout_opts, warnings).run()
    layout_ms = _ms(t0)
    if not pages:
        raise RenderError("DOCUMENT_EMPTY", "No pages to render (all sheets hidden or repeated over empty arrays)")
    if options.check:
        options.check()
    env = EvalEnv(locale=locale, warnings=warnings)
    scope = Scope({"doc": doc_vars}, Scope(data, Scope({"now": doc_vars["generatedAt"]})))
    meta = {k: render_template(parts, scope, env) for k, parts in (plan.get("meta") or {}).items()}
    t0 = time.perf_counter()
    writer = PdfWriter(
        fonts,
        warnings,
        deterministic=options.deterministic,
        kerning=options.kerning,
        meta=meta,
        watermark=options.watermark,
    )
    pdf = writer.write(pages)
    draw_ms = _ms(t0)
    images: list[RasterPage] = []
    raster_ms = 0
    if options.format in ("png", "jpg"):
        if options.check:
            options.check()
        t0 = time.perf_counter()
        selected = parse_page_ranges(options.pages, len(pages))
        selected = [i for i in selected if pages[i].raster] or selected
        images = rasterize(
            pdf,
            fmt=options.format,
            dpi=options.dpi,
            quality=options.quality,
            pages=selected,
            background=options.background,
            max_pixels=options.max_pixels,
        )
        raster_ms = _ms(t0)
    timings = {
        "layout_ms": layout_ms,
        "draw_ms": draw_ms,
        "raster_ms": raster_ms,
        "total_ms": _ms(t_start),
    }
    return RenderResult(
        pdf=pdf, page_count=len(pages), pages=pages, images=images, warnings=warnings.items, timings=timings
    )
