#!/usr/bin/env python
"""Manifest builder + optional server for the simpleeval per-prompt viewer.

Scans the parent dir (test/simpleeval_sampled_inference) for run folders named
'..._ep-<N>_..._cfg<X>', one column per run (labeled 'ep<N> . cfg<X>', sorted by
ep then cfg). For each prompt index it lists the image stems present (union) and
the prompt text (from the first run's .txt sidecars). Lets you step through the
same prompt across runs, one by one.

Usage:
    python test/simpleeval_sampled_inference/viewer/gen_manifest.py            # write manifest.json
    python test/simpleeval_sampled_inference/viewer/gen_manifest.py --serve    # write + serve + print URL
"""
import argparse
import functools
import http.server
import json
import re
import socket
from pathlib import Path

import numpy as np

LABEL_RE = re.compile(r"_ep-(\d+).*_cfg(\d+(?:\.\d+)?)$")
SCORE_NAME = "vqascore_qwen3-vl-8b"      # per-image scores, one .npy per run dir


def build_manifest(base, rel_prefix: str) -> dict:
    base = Path(base)
    pad = 5
    available: set[int] = set()
    items = []
    for d in sorted(base.iterdir()) if base.exists() else []:
        if not d.is_dir() or d.name == "viewer":
            continue
        pngs = list(d.glob("*.png"))
        if not pngs:
            continue
        m = LABEL_RE.search(d.name)
        if m:
            ep, cfg = int(m.group(1)), m.group(2)
            key, label = (ep, float(cfg)), f"ep{ep} · cfg{cfg}"
        else:
            key, label = (0, 0.0), d.name
        idxs = []
        for p in pngs:
            try:
                idxs.append(int(p.stem))
                pad = len(p.stem)
            except ValueError:
                pass
        available |= set(idxs)

        # per-image scores (index i -> score for image i), if present
        scores, mean = None, None
        sp = d / f"{SCORE_NAME}.npy"
        if sp.exists():
            arr = np.load(sp).ravel()
            scores = [float(x) for x in arr.tolist()]
            mean = float(arr.mean()) if arr.size else None

        items.append((key, {"label": label, "dir": d.name, "count": len(idxs),
                            "scores": scores, "mean": mean}))

    items.sort(key=lambda x: x[0])
    runs = [it[1] for it in items]

    prompts_by_idx = {}
    if runs:
        ref = base / runs[0]["dir"]
        for p in ref.glob("*.txt"):
            try:
                prompts_by_idx[int(p.stem)] = p.read_text().strip()
            except ValueError:
                pass
    nmax = max(available) if available else -1
    prompts = [prompts_by_idx.get(i, "") for i in range(nmax + 1)]

    return {"rel_prefix": rel_prefix, "pad": pad, "runs": runs,
            "available": sorted(available), "prompts": prompts, "score_name": SCORE_NAME}


def serve(repo_root: Path, base, rel_prefix: str, manifest_url: str, port: int):
    class Handler(http.server.SimpleHTTPRequestHandler):
        def __init__(self, *a, **k):
            super().__init__(*a, directory=str(repo_root), **k)

        def log_message(self, *a):
            return

        def do_GET(self):
            if self.path.split("?")[0] == manifest_url:
                body = json.dumps(build_manifest(base, rel_prefix)).encode()
                self.send_response(200)
                self.send_header("Content-Type", "application/json")
                self.send_header("Content-Length", str(len(body)))
                self.send_header("Cache-Control", "no-store")
                self.end_headers()
                self.wfile.write(body)
                return
            super().do_GET()

    host = socket.gethostname()
    page = manifest_url.rsplit("/", 1)[0] + "/index.html"
    httpd = http.server.ThreadingHTTPServer(("0.0.0.0", port), Handler)
    print("\n" + "=" * 60 + f"""
  SimpleEval viewer is live. Open:
    http://{host}:{port}{page}
    http://localhost:{port}{page}
  (remote? forward first:  ssh -L {port}:localhost:{port} {host})
  Ctrl-C to stop.
""" + "=" * 60, flush=True)
    try:
        httpd.serve_forever()
    except KeyboardInterrupt:
        print("\nstopped")
        httpd.server_close()


def main():
    here = Path(__file__).resolve().parent          # .../viewer
    base = here.parent                               # .../simpleeval_sampled_inference
    repo_root = here.parents[2]                      # repo root (test/<dir>/viewer -> repo)
    manifest_url = "/" + str(here.relative_to(repo_root)).replace("\\", "/") + "/manifest.json"

    ap = argparse.ArgumentParser()
    ap.add_argument("--base", default=str(base))
    ap.add_argument("--rel-prefix", default="..")    # images are one dir up from viewer/
    ap.add_argument("--out", default=str(here / "manifest.json"))
    ap.add_argument("--serve", action="store_true")
    ap.add_argument("--port", type=int, default=8000)
    args = ap.parse_args()

    m = build_manifest(args.base, args.rel_prefix)
    Path(args.out).write_text(json.dumps(m))
    print(f"Wrote {args.out}  ({len(m['runs'])} runs, {len(m['available'])} prompts)")
    for r in m["runs"]:
        print(f"  {r['label']:16s} {r['dir']}  ({r['count']} images)")

    if args.serve:
        serve(repo_root, args.base, args.rel_prefix, manifest_url, args.port)


if __name__ == "__main__":
    main()