"""Build the Hugging Face dataset folder and the Space's data file from the recorded runs.

    python scripts/figures.py && python scripts/export.py

The clean run (runs/day2) is the result; the earlier runs (day1, day1b, day1c) are the pilot and are published
separately. Writes:
  hf/dataset/episodes.jsonl        every clean-run episode (reasoning trimmed to 2,000 characters per step)
  hf/dataset/pilot_episodes.jsonl  the pilot runs, before the harness fixes
  hf/dataset/verdicts.json         the learnability checks and verdict per task suite
  hf/dataset/census/               the Hub census (both passes) and Beam-written community setups
  hf/dataset/fixes/                Beam's diagnosis, reasoning and patch for each fixed environment
  hf/space/data.json               what the Space shows (numbers from hf/numbers.json)
"""

import base64
import json
import shutil
import sys
from collections import defaultdict
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
from shortlist.checks import check_suite, harness_error, score, suite_config  # noqa: E402
from shortlist.serve import ROOT  # noqa: E402

HF = ROOT / "hf"


def load(runs: list[Path]) -> dict[str, list[dict]]:
    pooled: dict[str, list[dict]] = defaultdict(list)
    for run in runs:
        for path in sorted(run.glob("*.jsonl")):
            for line in path.read_text().splitlines():
                if line.strip():
                    r = json.loads(line)
                    r["run"] = run.name
                    pooled[path.stem].append(r)
    return pooled


def trim(r: dict) -> dict:
    r = dict(r)
    r.pop("traceback", None)
    steps = []
    for s in r.get("steps", []):
        s = dict(s)
        if "beam" in s:
            b = dict(s["beam"])
            if b.get("reasoning"):
                b["reasoning"] = b["reasoning"][:2000]
            s["beam"] = b
        steps.append(s)
    r["steps"] = steps
    return r


def connect4_story(numbers: dict) -> dict:
    reply = (ROOT / "runs/fixes/connect4_env.beam-reply.md").read_text()
    return {"env": "connect4_env", "as_shipped": numbers["connect4"]["as_shipped"],
            "with_beams_fix": numbers["connect4"]["with_beams_fix"], "diagnosis": reply.split("### FILE:")[0].strip()}


def dipg_story(pooled: dict[str, list[dict]]) -> dict | None:
    """How often Beam's answer clears DIPG's format gate under each marker style."""
    variants = [("dipg_safety_env", "Harmony markers (default)", "<|channel|>analysis<|message|> … <|end|>"),
                ("dipg_safety_env-plain", "Angle-bracket markers", "<analysis> … <end>"),
                ("dipg_safety_env-brackets", "Square-bracket markers", "[analysis] … [end]")]
    out = []
    for suite, label, example in variants:
        rows = [r for r in pooled.get(suite, []) if r["policy"].startswith("beam") and not r.get("error")]
        if rows:
            passed = sum(r["return"] > -10 for r in rows)  # -10 is the format-mismatch penalty
            out.append({"suite": suite, "label": label, "example": example, "passed": passed, "answers": len(rows)})
    return {"variants": out} if out else None


def rail(v: dict, rows: list[dict]) -> dict:
    """Place each rung's mean score on one axis: 0 = the worst episode seen, 1 = the best possible (or best episode seen)."""
    tiers = v["tiers"]
    scores = [score(r) for r in rows if not r.get("error")] or [0.0]
    cfg = suite_config(v["suite"])
    cfg_top = cfg.max_score if cfg and not v.get("declared_max_wrong") else None  # a beaten guess is no maximum
    hi = cfg_top if cfg_top is not None else max(scores)
    lo = min(scores)
    if hi - lo < 1e-9:  # every episode scored the same
        if cfg_top is not None and not cfg.setup_by:
            lo = hi - 1.0  # and that score is the known maximum: put the rungs at the top
        else:
            cfg_top = None  # a guessed maximum (community setups) that nobody moved off says nothing
    span = (hi - lo) or 1.0
    order = ["null", "random", "small", "beam-low", "beam-medium", "beam-high", "beam-xhigh", "beam-max"]
    return {"rungs": [{"policy": p, "x": round((tiers[p]["mean"] - lo) / span, 4), "mean": tiers[p]["mean"],
                       "solved": tiers[p].get("pass@1"), "grpo": tiers[p].get("grpo_signal"), "n": tiers[p]["episodes"]}
                      for p in order if p in tiers],
            "top_known": cfg_top is not None}


def pelicans(rows: list[dict]) -> list[dict]:
    out = []
    for r in rows:
        if not r["policy"].startswith("beam") or not r.get("steps"):
            continue
        raw = (r["steps"][0].get("action") or {}).get("response", "")
        start, end = raw.find("<svg"), raw.rfind("</svg>")
        if start < 0 or end < 0:
            continue
        svg = raw[start:end + len("</svg>")]  # drop any text or fences around the drawing
        head = svg[:svg.find(">") + 1]
        if "xmlns=" not in head:  # an <img> only renders SVG that declares its namespace
            svg = svg.replace("<svg", '<svg xmlns="http://www.w3.org/2000/svg"', 1)
        fo = r.get("final_observation", {})
        out.append({"svg_b64": base64.b64encode(svg.encode()).decode(), "reward": r["return"],
                    "structure": fo.get("structure_score"), "judged": fo.get("judged"), "policy": r["policy"]})
    return out


def main() -> None:
    clean = load([ROOT / "runs" / "day2"])
    clean = {k: [r for r in v if not harness_error(r)] for k, v in clean.items()}
    pilot = load([ROOT / "runs" / d for d in ("day1", "day1b", "day1c")])
    numbers = json.loads((HF / "numbers.json").read_text())
    verdicts = [check_suite(s, rows) for s, rows in sorted(clean.items()) if rows]
    gaming = {g["suite"]: g for g in json.loads((HF / "gaming.json").read_text())} if (HF / "gaming.json").exists() else {}
    for x in verdicts:  # RFC 008 #26, our procedure (shortlist/gaming.py); added after the training proof
        g = gaming.get(x["suite"])
        if g:
            b = g["best"]
            x["checks"]["statistical.adversarial_floor"] = {
                "pass": not g["gameable"], "strategy": b["strategy"], "label": b["label"], "answer": b["answer"], "score": b["score"],
                "learner_mean": g["learner_mean"], "added_after_training": True}
            x["gameable"] = g["gameable"]
    for d in ("fixes", "census", "census/setups"):
        (HF / "dataset" / d).mkdir(parents=True, exist_ok=True)
    (HF / "space").mkdir(parents=True, exist_ok=True)

    for name, pooled in (("episodes.jsonl", clean), ("pilot_episodes.jsonl", pilot)):
        with (HF / "dataset" / name).open("w") as f:
            for suite, rows in sorted(pooled.items()):
                for r in rows:
                    f.write(json.dumps(trim(r), default=str) + "\n")
    (HF / "dataset" / "verdicts.json").write_text(json.dumps(verdicts, indent=2))
    for p in (ROOT / "runs" / "fixes").glob("*.*"):
        if p.is_file():
            shutil.copy(p, HF / "dataset" / "fixes" / p.name)
    for p in ("census.jsonl", "census2.jsonl", "chosen.json"):
        if (ROOT / "runs" / "hub" / "sweep" / p).exists():
            shutil.copy(ROOT / "runs" / "hub" / "sweep" / p, HF / "dataset" / "census" / p)
    for p in (ROOT / "runs" / "hub" / "setups").glob("*.json"):
        shutil.copy(p, HF / "dataset" / "census" / "setups" / p.name)

    shown = [x for x in verdicts if not x["suite"].startswith("dipg_safety_env-")]  # marker experiments go in the DIPG story
    training = json.loads((ROOT / "training" / "kaggle" / "analysis.json").read_text())
    maze_dir = ROOT / "training" / "maze"
    forward = None
    if (maze_dir / "predictions.json").exists():
        pred = json.loads((maze_dir / "predictions.json").read_text())
        forward = {"family": "maze", "written_at": pred["written_at"], "claims": pred["predictions"][0]["claims"],
                   "evidence": pred["predictions"][0]["evidence_before_training"],
                   "sha256": (maze_dir / "predictions.sha256").read_text().split()[0],
                   "result": json.loads((maze_dir / "results" / "analysis.json").read_text()) if (maze_dir / "results" / "analysis.json").exists() else None}
    data = {
        "numbers": {k: numbers[k] for k in ("environments", "task_suites", "community_environments", "episodes",
                                             "beam_episodes", "small_episodes", "beam_output_tokens", "suites_played_by")},
        "verdicts": [{**{k: v for k, v in x.items() if k != "error_examples"}, "rail": rail(x, clean[x["suite"]])} for x in shown],
        "connect4": connect4_story(numbers), "dipg": numbers["dipg"], "effort": numbers["effort_ladder"], "effort_summary": numbers["effort_summary"],
        "census": numbers["census"], "training": training, "forward_test": forward,
        "pelicans": pelicans(clean.get("pelican_svg_env", [])),
        "links": {"dataset": "https://huggingface.co/datasets/JagritGumber/shortlist",
                  "code": "https://huggingface.co/datasets/JagritGumber/shortlist/tree/main/code",
                  "patch": "https://huggingface.co/datasets/JagritGumber/shortlist/blob/main/fixes/connect4_env.patch",
                  "training": "https://huggingface.co/datasets/JagritGumber/shortlist/blob/main/training/RESULTS.md",
                  "rfc": "https://github.com/openenv/OpenEnv/blob/main/rfcs/008-environment-auto-validation.md"},
    }
    (HF / "space" / "data.json").write_text(json.dumps(data, indent=1, default=str))
    print(json.dumps(data["numbers"]), f"\nverdicts: {len(shown)}  pelicans: {len(data['pelicans'])}  training rows: {len(training['rows'])}")


if __name__ == "__main__":
    main()