"""Rebuild board.json from the dataset: bodies/*.yaml, tasks/*/card.yaml, tasks/*/results/*.json.

    python scripts/board.py          (needs pyyaml)

board.json holds:
  bodies        the body registry (carrier, rigs with their hand count, status, the goal predicates it runs)
  tasks         per task: its results ranked, the best per (body, world) on the reference simulator
  matrix        task x body: one cell per pair, the best score if any, else whether the body could run it
                (runs: unscored / missing: the predicates it lacks / needs 2 hands / coming)
  skills        predicate x body: which body runs which goal predicate, and how many cards use each predicate
Only results on the reference simulator compete for best (see cablepilot.cardrun.REFERENCE_SIM).
"""
from __future__ import annotations

import json
from datetime import datetime, timezone
from pathlib import Path

import yaml

ROOT = Path(__file__).resolve().parents[1]
TWO_HANDS = {"left_hand", "right_hand", "other_hand"}


def rank_key(r: dict):
    s = r["score"]
    return (-s["done_frac"], s.get("furniture_contact_ticks", 0), s.get("s_per_item") or 1e9)


def card_needs(card: dict) -> dict:
    """The goal predicates a card's stages and done test use, and how many hands it needs."""
    preds = set()
    for st in card.get("stages") or []:
        for g in st.get("goals") or []:
            preds |= set(g) - {"tol"}
    if card.get("done"):
        preds |= set(card["done"]) - {"tol"}
    hands = 2 if TWO_HANDS & set(card.get("roles") or []) else 1
    return {"predicates": sorted(preds), "hands": hands}


def load_results(task_dir: Path) -> list[dict]:
    out = []
    for f in sorted((task_dir / "results").glob("*.json")):
        r = json.loads(f.read_text())
        if r.get("format") != "pilot-result/1":
            continue
        env = r.get("env") or {}
        out.append({"id": f.stem, "body": r["body"], "world": r["world"], "seed": r["seed"], "episodes": r["episodes"],
                    "score": r["score"], "compute": r["compute"], "card_sha": r["card_sha"],
                    "tuning_sha": r.get("tuning_sha"), "lineage": r.get("lineage"), "by": r["by"], "date": r["date"],
                    "sim": env.get("mujoco"), "reference_sim": bool(env.get("reference_sim")),
                    "result": f"tasks/{task_dir.name}/results/{f.name}",
                    "media": f"tasks/{task_dir.name}/media/{f.stem}.mp4"
                    if (task_dir / "media" / f"{f.stem}.mp4").exists() else None})
    return sorted(out, key=rank_key)


def cell(task: dict, body: dict) -> dict:
    best = [r for r in task["best"] if r["body"] == body["body"]]
    if best:
        b = best[0]
        return {"state": "scored", "done": b["score"]["done"], "of": b["score"]["of"], "world": b["world"],
                "result": b["result"]}
    if body["status"] != "open":
        return {"state": "coming"}
    max_hands = max((rg["hands"] for rg in body.get("rigs", []) if rg.get("status") == "open"), default=0)
    if task["needs"]["hands"] > max_hands:
        return {"state": "gap", "missing": [f"{task['needs']['hands']} hands"]}
    missing = [p for p in task["needs"]["predicates"] if p not in set(body.get("predicates") or [])]
    return {"state": "gap", "missing": missing} if missing else {"state": "runs"}


def main():
    bodies = [yaml.safe_load(p.read_text()) for p in sorted((ROOT / "bodies").glob("*.yaml"))]
    order = {"open": 0, "coming": 1}
    bodies.sort(key=lambda b: (order.get(b["status"], 2), b["body"]))
    tasks = {}
    for task_dir in sorted((ROOT / "tasks").iterdir()):
        if not (task_dir / "card.yaml").exists():
            continue
        card = yaml.safe_load((task_dir / "card.yaml").read_text())
        results = load_results(task_dir)
        best = {}
        for r in results:
            if r["reference_sim"]:
                best.setdefault(f"{r['body']}|{r['world']}", r)
        tasks[task_dir.name] = {"needs": card_needs(card), "lineage": card.get("lineage"),
                                "tunings": sorted(p.stem for p in (task_dir / "tuning").glob("*.yaml")),
                                "results": results, "best": list(best.values())}
    matrix = {t: {b["body"]: cell(v, b) for b in bodies} for t, v in tasks.items()}
    used = {}
    for t, v in tasks.items():
        for p in v["needs"]["predicates"]:
            used.setdefault(p, []).append(t)
    skills = {p: {"cards": sorted(ts), "bodies": [b["body"] for b in bodies if p in set(b.get("predicates") or [])]}
              for p, ts in sorted(used.items())}
    board = {"format": "pilot-board/2", "built": datetime.now(timezone.utc).isoformat(timespec="seconds"),
             "bodies": bodies, "tasks": tasks, "matrix": matrix, "skills": skills}
    (ROOT / "board.json").write_text(json.dumps(board, indent=1))
    w = max(len(t) for t in tasks) + 2
    print(" " * w + "".join(f"{b['body']:<14}" for b in bodies))
    for t, row in matrix.items():
        txt = []
        for b in bodies:
            c = row[b["body"]]
            txt.append({"scored": lambda: f"{c['done']}/{c['of']}", "coming": lambda: "coming", "runs": lambda: "runs",
                        "gap": lambda: "-" + ",".join(c["missing"])}[c["state"]]()[:13])
        print(f"{t:<{w}}" + "".join(f"{x:<14}" for x in txt))


if __name__ == "__main__":
    main()