"""
Build the Manim-Slides presentation and export the reveal.js HTML bundle.

See manim/README.md for setup, dev loop, and deck structure.

Usage (run from manim/ directory):
    python -m src.slides                 # render all + export HTML to ../web/static/generated/
    python -m src.slides 01 08 14        # render only specified keys
    python -m src.slides --dev           # low quality (854x480 15fps)
    python -m src.slides --present       # interactive presenter
    python -m src.slides --no-export     # render only, skip HTML export
    python -m src.slides --preview       # alias for --dev (writes -dev.html)
    python -m src.slides --force         # force re-render even if unchanged
    python -m src.slides --verify        # LQ render + extract last frame of every
                                         # sub-slide as PNG into verify/ for visual
                                         # inspection (overlap, clipping, etc.)
    python -m src.slides 12 --verify     # verify single scene
"""

import shutil
import subprocess
import sys
from pathlib import Path

from src.slides._scenes import SCENES


MANIM_DIR    = Path(__file__).resolve().parent.parent.parent
PROJECT_ROOT = MANIM_DIR.parent
WEB_STATIC   = PROJECT_ROOT / "web" / "static" / "generated"

OUT_HTML     = WEB_STATIC / "write-primitive-exploits-2026.html"
OUT_HTML_DEV = WEB_STATIC / "write-primitive-exploits-2026-dev.html"
SLIDES_DIR   = MANIM_DIR / "slides"

SHARED_DEPS = [
    MANIM_DIR / "src/slides/_theme.py",
    MANIM_DIR / "src/slides/_layout.py",
    MANIM_DIR / "src/slides/_core.py",
    MANIM_DIR / "src/slides/_refs.py",
    MANIM_DIR / "src/slides/_scenes.py",
]


def existing_keys():
    return [(k, f, c) for k, f, c in SCENES if (MANIM_DIR / f).exists()]


def _max_mtime(paths) -> float:
    best = 0.0
    for p in paths:
        pp = Path(p)
        if pp.exists():
            m = pp.stat().st_mtime
            if m > best:
                best = m
    return best


def needs_rerender(scene_file: str, scene_name: str) -> bool:
    json_path = SLIDES_DIR / f"{scene_name}.json"
    if not json_path.exists():
        return True
    json_mtime = json_path.stat().st_mtime
    src_mtime  = _max_mtime([MANIM_DIR / scene_file, *SHARED_DEPS])
    return src_mtime > json_mtime


def render(scene_file: str, scene_name: str, quality: str):
    print(f"  Rendering {scene_name}  [-q {quality}]...")
    subprocess.run(
        ["manim-slides", "render", "-q", quality, scene_file, scene_name],
        check=True, cwd=MANIM_DIR,
    )


def export_html(scene_names: list[str], out_path: Path):
    out_path.parent.mkdir(parents=True, exist_ok=True)
    print(f"  Exporting HTML -> {out_path}")
    subprocess.run(
        ["manim-slides", "convert",
         "--to", "html", "--one-file",
         *scene_names, str(out_path)],
        check=True, cwd=MANIM_DIR,
    )
    strip_wait_for_video_guard(out_path)


def strip_wait_for_video_guard(out_path: Path) -> bool:
    """Remove a legacy wait-for-video <script> block if present in the bundle."""
    try:
        html = out_path.read_text(encoding="utf-8")
    except OSError:
        return False
    needle = "<!-- wait-for-video guard"
    start = html.find(needle)
    if start == -1:
        return False
    end_marker = "</script>"
    end = html.find(end_marker, start)
    if end == -1:
        return False
    end += len(end_marker)
    if end < len(html) and html[end] == "\n":
        end += 1
    out_path.write_text(html[:start] + html[end:], encoding="utf-8")
    return True


def present(scene_names: list[str]):
    subprocess.run(["manim-slides", "present", *scene_names], cwd=MANIM_DIR)


def verify(scene_list):
    """
    Render at low quality and extract last frame of every CURRENT sub-slide
    as PNG. Reads slides/<SceneClass>.json to know which mp4s belong to the
    current render (the sub-dir can accumulate stale mp4s from earlier edits).
    """
    import json as _json
    verify_dir = MANIM_DIR / "verify"
    verify_dir.mkdir(exist_ok=True)
    # Clean stale PNGs for the scenes we are about to (re)write.
    scene_keys_being_verified = {k for k, _, _ in scene_list}
    for old in verify_dir.glob("*.png"):
        # Filename format: <key>_<SceneClass>_<idx>.png
        head_key = old.stem.split("_", 1)[0]
        if head_key in scene_keys_being_verified:
            old.unlink()

    quality = "l"
    print(f"=== VERIFY: rendering {len(scene_list)} scene(s) at low quality ===\n")
    total_frames = 0
    for k, scene_file, scene_name in scene_list:
        render(scene_file, scene_name, quality)

        json_path = MANIM_DIR / "slides" / f"{scene_name}.json"
        if not json_path.exists():
            print(f"  WARN: no JSON for {scene_name}")
            continue
        meta = _json.loads(json_path.read_text(encoding="utf-8"))
        sub_files = [MANIM_DIR / s["file"] for s in meta.get("slides", [])]

        for i, mp4 in enumerate(sub_files):
            if not mp4.exists():
                print(f"  WARN: missing mp4 {mp4}")
                continue
            png_out = verify_dir / f"{k}_{scene_name}_{i:02d}.png"
            try:
                subprocess.run([
                    "ffmpeg", "-y", "-sseof", "-0.2", "-i", str(mp4),
                    "-update", "1", "-q:v", "2", "-loglevel", "error",
                    str(png_out)
                ], check=True, cwd=MANIM_DIR)
                total_frames += 1
            except subprocess.CalledProcessError as e:
                print(f"  ffmpeg FAILED on {mp4.name}: {e}")
        print(f"  {scene_name}: {len(sub_files)} sub-slide(s) -> verify/{k}_*.png")

    print(f"\n=== Verification done. {total_frames} PNGs in {verify_dir} ===")
    print(f"Sorted by scene key + sub-slide index.  Inspect with any image viewer.")


if __name__ == "__main__":
    args = sys.argv[1:]

    if "--help" in args or "-h" in args:
        print(__doc__)
        sys.exit(0)

    dev       = "--dev"       in args; args = [a for a in args if a != "--dev"]
    pres      = "--present"   in args; args = [a for a in args if a != "--present"]
    no_export = "--no-export" in args; args = [a for a in args if a != "--no-export"]
    preview   = "--preview"   in args; args = [a for a in args if a != "--preview"]
    force     = "--force"     in args; args = [a for a in args if a != "--force"]
    verify_mode = "--verify"  in args; args = [a for a in args if a != "--verify"]
    if preview:
        dev = True

    quality = "l" if dev else "h"

    if pres:
        names = [c for _, _, c in existing_keys()]
        present(names)
        sys.exit(0)

    available = existing_keys()

    if verify_mode:
        if args:
            keys_wanted = set(args)
            target = [(k, f, c) for k, f, c in available if k in keys_wanted]
        else:
            target = available
        verify(target)
        sys.exit(0)

    if args:
        keys_wanted = set(args)
        to_render = [(k, f, c) for k, f, c in available if k in keys_wanted]
        missing = keys_wanted - {k for k, *_ in available}
        if missing:
            print(f"Note: skipping non-existent scenes: {sorted(missing)}")
    else:
        to_render = available

    if not to_render:
        print("No scenes to render.")
        sys.exit(0)

    SLIDES_DIR.mkdir(exist_ok=True)

    explicit_request = bool(args)
    actually_rendered = []
    skipped = []
    for k, scene_file, scene_name in to_render:
        if force or explicit_request or needs_rerender(scene_file, scene_name):
            render(scene_file, scene_name, quality)
            actually_rendered.append((k, scene_file, scene_name))
        else:
            print(f"  Skipping {scene_name}  (unchanged)")
            skipped.append((k, scene_file, scene_name))

    if no_export:
        print("\nDone (no HTML export).")
    else:
        names = [c for _, _, c in available]
        out_path = OUT_HTML_DEV if preview else OUT_HTML
        export_html(names, out_path=out_path)
        n_re = len(actually_rendered)
        n_sk = len(skipped)
        route = "/slides-dev" if preview else "/slides"
        print(f"\nDone. {n_re} rendered, {n_sk} skipped (unchanged). Bundle: {len(names)} scenes.")
        print(f"Open in browser:")
        print(f"    http://localhost:5000{route}")
        print(f"Output: {out_path}")
        if preview:
            print("Tip: pass --force to re-render even unchanged scenes.")
