"""Benchmark runner shared by ``manage.py snapfile_bench`` and the pytest benchmark."""

from __future__ import annotations

import resource
import statistics
import sys
import tempfile
import time
from collections.abc import Callable
from pathlib import Path
from typing import Any

from ..compiler import compile_document
from ..plancache import PlanCache, plan_key
from ..providers import FontLibrary, MappingAssetResolver
from ..renderer import RenderOptions, render
from ..testing import bundled_library
from .kp17 import build_kp17, photo_jpeg


def _rss_mb() -> float:
    rss = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
    return rss / (1024 * 1024) if sys.platform == "darwin" else rss / 1024


def _stats(samples: list[float]) -> dict[str, float]:
    s = sorted(samples)
    p95 = s[min(len(s) - 1, round(0.95 * (len(s) - 1)))]
    return {
        "p50_ms": round(statistics.median(s) * 1000, 1),
        "p95_ms": round(p95 * 1000, 1),
        "min_ms": round(s[0] * 1000, 1),
        "n": len(s),
    }


def _measure(fn: Callable[[], Any], iterations: int, warmup: int) -> tuple[dict[str, float], Any]:
    result = None
    for _ in range(warmup):
        result = fn()
    samples = []
    for _ in range(iterations):
        t0 = time.perf_counter()
        result = fn()
        samples.append(time.perf_counter() - t0)
    return _stats(samples), result


def setup(work_dir: Path | None = None) -> tuple[FontLibrary, MappingAssetResolver, Path]:
    work = work_dir or Path(tempfile.mkdtemp(prefix="snapfile-bench-"))
    fonts = bundled_library(work / "fonts")
    (work / "photo1.jpg").write_bytes(photo_jpeg(1, (900, 1400)))
    (work / "photo2.jpg").write_bytes(photo_jpeg(2))
    assets = MappingAssetResolver({"photo1": str(work / "photo1.jpg"), "photo2": str(work / "photo2.jpg")})
    return fonts, assets, work


def run(iterations: int = 20, warmup: int = 3, raster: bool = True) -> dict[str, Any]:
    t0 = time.perf_counter()
    fonts, assets, work = setup()
    setup_s = time.perf_counter() - t0
    doc, data = build_kp17()
    report: dict[str, Any] = {"python": sys.version.split()[0], "font_prepare_s": round(setup_s, 2)}
    # P4: cold — compile the plan + first render (fonts registered in ReportLab during it)
    t0 = time.perf_counter()
    plan, _ = compile_document(doc)
    compile_ms = (time.perf_counter() - t0) * 1000
    first = render(plan, data, RenderOptions(locale="en"), fonts, assets)
    report["P4_cold_first_render_ms"] = round((time.perf_counter() - t0) * 1000, 1)
    report["compile_ms"] = round(compile_ms, 1)
    report["pages"] = first.page_count
    # Plan cache load from disk (marshal + HMAC)
    cache = PlanCache(work / "plans", b"bench")
    key = plan_key("bench", "kp17")
    cache.store(key, plan)
    cache.clear_memory()
    t0 = time.perf_counter()
    cache.get_or_compile(key, lambda: plan)
    report["plan_disk_load_ms"] = round((time.perf_counter() - t0) * 1000, 2)
    opts = RenderOptions(locale="en")
    stats, res = _measure(lambda: render(plan, data, opts, fonts, assets), iterations, warmup)
    report["P1_pdf_kp17_warm"] = {**stats, "layout_ms": res.timings["layout_ms"], "draw_ms": res.timings["draw_ms"]}
    report["P14_pdf_size_kb"] = round(len(res.pdf) / 1024, 1)
    small_doc = {**doc, "sheets": [doc["sheets"][2]]}
    small_plan, _ = compile_document(small_doc)
    report["P3_pdf_1_page_warm"], _ = _measure(
        lambda: render(small_plan, data, opts, fonts, assets), iterations, warmup
    )
    if raster:
        o150 = RenderOptions(locale="en", format="png", dpi=150, pages="1")
        report["P5_png_1_page_150dpi"], _ = _measure(lambda: render(plan, data, o150, fonts, assets), 5, 1)
        o300 = RenderOptions(locale="en", format="png", dpi=300, pages="3")
        report["P7_png_1_page_300dpi"], _ = _measure(lambda: render(plan, data, o300, fonts, assets), 3, 1)
        oall = RenderOptions(locale="en", format="png", dpi=150)
        report["P6_png_17_pages_150dpi"], _ = _measure(lambda: render(plan, data, oall, fonts, assets), 2, 1)
    report["P8_peak_rss_mb"] = round(_rss_mb(), 1)
    t0 = time.perf_counter()
    n = 0
    while time.perf_counter() - t0 < 5:
        render(plan, data, opts, fonts, assets)
        n += 1
    report["P9_throughput_docs_per_min_1_process"] = round(n / (time.perf_counter() - t0) * 60)
    return report
