#!/usr/bin/env python3
"""Build monorepo-level dashboard from models/*/derived/summary.json + registry.json.

stdlib only — offline safe (no pip/network).
"""
from __future__ import annotations

import csv
import io
import json
import sys
from datetime import datetime, timezone
from pathlib import Path

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT / "shared" / "scripts"))
from write_json_stable import write_json_stable  # noqa: E402
import sync_readme  # noqa: E402

MODELS_DIR = ROOT / "models"
OUT = ROOT / "derived"
REGISTRY = MODELS_DIR / "registry.json"


def load_registry() -> dict:
    if not REGISTRY.exists():
        return {"models": []}
    return json.loads(REGISTRY.read_text())


def discover_models() -> list[str]:
    return sorted(
        p.name
        for p in MODELS_DIR.iterdir()
        if p.is_dir() and (p / "Makefile").exists() and (p / "derived" / "summary.json").exists()
    )


def load_summary(model_id: str) -> dict:
    path = MODELS_DIR / model_id / "derived" / "summary.json"
    data = json.loads(path.read_text())
    data.setdefault("model_id", model_id)
    return data


def normalize_row(model_id: str, summary: dict, reg_entry: dict | None) -> dict:
    reg = reg_entry or {}
    # Prefer explicit common fields; fall back to model-specific shapes
    total = summary.get("total_params") or summary.get("total_parameters")
    if not total and summary.get("n_routed_experts"):
        # inkling-style: not in summary historically — use registry notes / fixed
        total = reg.get("total_params") or "975B (reported)"
    active = summary.get("active_params") or summary.get("active_parameters")
    if active is None and model_id == "inkling":
        active = "41B (reported)"
    if active is None and model_id == "kimi-k3":
        active = "undisclosed"

    context = summary.get("context_tokens") or summary.get("model_max_length")
    experts = None
    if summary.get("n_experts") and summary.get("experts_activated"):
        experts = f"{summary['experts_activated']}/{summary['n_experts']}"
        s = summary.get("n_shared_experts")
        if s:
            experts += f"+{s} shared"
    elif summary.get("n_routed_experts"):
        k = summary.get("num_experts_per_tok")
        s = summary.get("n_shared_experts")
        experts = f"{k}/{summary['n_routed_experts']}" + (f"+{s} shared" if s else "")

    return {
        "model_id": model_id,
        "display_name": summary.get("display_name")
        or summary.get("model")
        or reg.get("display_name")
        or model_id,
        "org": reg.get("org") or summary.get("org") or "—",
        "status": reg.get("status") or summary.get("status") or "unknown",
        "total_params": total or "—",
        "active_params": active or "—",
        "context_tokens": context,
        "experts": experts or "—",
        "hub": reg.get("hub"),
        "api_model_id": reg.get("api_model_id") or summary.get("api_model_id"),
        "generated_at_utc": summary.get("generated_at_utc"),
        "notes": reg.get("notes") or "",
        "path": f"models/{model_id}",
        "raw": summary,
    }


def render_md(rows: list[dict], generated: str) -> str:
    lines = [
        "# Study dashboard",
        "",
        f"> Auto-generated by `shared/scripts/build_dashboard.py` · {generated}",
        ">",
        "> Do not hand-edit. Run `make dashboard` or `make check`.",
        "",
        "## Models",
        "",
        "| ID | Name | Org | Status | Total | Active | Context | Experts | Package |",
        "|---|---|---|---|---|---|---:|---|---|",
    ]
    for r in rows:
        ctx = f"{r['context_tokens']:,}" if isinstance(r["context_tokens"], int) else (r["context_tokens"] or "—")
        hub = f"[hub](https://huggingface.co/{r['hub']})" if r.get("hub") else "—"
        lines.append(
            f"| `{r['model_id']}` | {r['display_name']} | {r['org']} | `{r['status']}` | "
            f"{r['total_params']} | {r['active_params']} | {ctx} | {r['experts']} | "
            f"[{r['path']}](../{r['path']}/) |"
        )
    lines += [
        "",
        "## Links",
        "",
    ]
    for r in rows:
        bits = [f"- **{r['display_name']}** (`{r['model_id']}`)"]
        bits.append(f"  - study: [`{r['path']}`](../{r['path']}/)")
        if r.get("hub"):
            bits.append(f"  - hub: https://huggingface.co/{r['hub']}")
        if r.get("api_model_id"):
            bits.append(f"  - api: `{r['api_model_id']}`")
        if r.get("notes"):
            bits.append(f"  - {r['notes']}")
        lines.extend(bits)

    cmp_dir = ROOT / "shared" / "comparisons"
    cmp_links = []
    for name, label in (
        ("laguna-s-vs-inkling-vs-kimi.md", "Laguna · Inkling · Kimi"),
        ("inkling-vs-kimi-k3.md", "Inkling · Kimi"),
    ):
        if (cmp_dir / name).exists():
            cmp_links.append(f"- [{label}](../shared/comparisons/{name})")
    if not cmp_links:
        cmp_links = ["- (no comparison notes yet)"]

    lines += [
        "",
        "## Cross-model",
        "",
        *cmp_links,
        "",
        "## Freshness",
        "",
        "| Model | summary generated_at_utc |",
        "|---|---|",
    ]
    for r in rows:
        lines.append(f"| `{r['model_id']}` | {r.get('generated_at_utc') or '—'} |")
    lines.append("")
    return "\n".join(lines)


def sync_hf_catalog(rows: list[dict]) -> None:
    cat_dir = ROOT.parent / "hf" / "dataset" / "catalog"
    if not cat_dir.exists():
        return
    # 1. Sync models.csv
    buf = io.StringIO()
    fieldnames = [
        "id",
        "display_name",
        "org",
        "status",
        "total_params",
        "active_params",
        "context_tokens",
        "experts",
        "hub",
        "api_model_id",
        "path",
        "notes",
    ]
    writer = csv.DictWriter(buf, fieldnames=fieldnames, lineterminator="\n")
    writer.writeheader()
    for r in rows:
        active = "" if r["active_params"] in (None, "undisclosed", "—") else r["active_params"]
        writer.writerow(
            {
                "id": r["model_id"],
                "display_name": r["display_name"],
                "org": r["org"],
                "status": r["status"],
                "total_params": r["total_params"],
                "active_params": active,
                "context_tokens": r["context_tokens"],
                "experts": r["experts"],
                "hub": r.get("hub") or "",
                "api_model_id": r.get("api_model_id") or "",
                "path": r["path"],
                "notes": r["notes"],
            }
        )
    csv_path = cat_dir / "models.csv"
    new_csv = buf.getvalue()
    if not csv_path.exists() or csv_path.read_text(encoding="utf-8") != new_csv:
        csv_path.write_text(new_csv, encoding="utf-8")
        print("  hf/dataset/catalog/models.csv updated")

    # 2. Sync registry.json
    cat_models = []
    for r in rows:
        raw = r.get("raw") or {}
        active = None if r["active_params"] in (None, "undisclosed", "—") else r["active_params"]
        entry: dict = {
            "id": r["model_id"],
            "display_name": r["display_name"],
            "path": r["path"],
            "org": r["org"],
            "hub": r.get("hub"),
        }
        if r.get("api_model_id"):
            entry["api_model_id"] = r["api_model_id"]
        entry.update(
            {
                "status": r["status"],
                "total_params": r["total_params"],
                "active_params": active,
                "context_tokens": r["context_tokens"],
                "experts": r["experts"],
            }
        )
        if raw.get("weights_eta"):
            entry["weights_eta"] = raw["weights_eta"]
        entry["notes"] = r["notes"]
        cat_models.append(entry)

    cat_reg = {
        "schema_version": 1,
        "monorepo": "lyffseba/xai",
        "space": "lyffseba/xai",
        "dataset": "lyffseba/xai-studies",
        "generated_for": "huggingface dataset mirror",
        "models": cat_models,
    }
    if write_json_stable(cat_dir / "registry.json", cat_reg):
        print("  hf/dataset/catalog/registry.json updated")


def render_compare_matrix(rows: list[dict], generated: str) -> str:
    lines = [
        "# Derived Cross-Model Architecture Matrix",
        "",
        f"> Auto-generated by `shared/scripts/build_dashboard.py` · {generated}",
        ">",
        "> Synthesized directly from each package's `derived/summary.json`.",
        "",
        "| Field | " + " | ".join(f"`{r['model_id']}`" for r in rows) + " |",
        "|---|" + "|".join("---" for _ in rows) + "|",
    ]

    def fmt_layers(r: dict) -> str:
        raw = r.get("raw") or {}
        n = raw.get("num_hidden_layers")
        swa = raw.get("n_swa_layers")
        glo = raw.get("n_global_layers")
        if n and swa is not None and glo is not None:
            return f"{n} ({glo}G / {swa} SWA)"
        return str(n) if n else "TBD (pre-weights)"

    def fmt_hidden(r: dict) -> str:
        raw = r.get("raw") or {}
        h = raw.get("hidden_size")
        return str(h) if h else "TBD"

    def fmt_window(r: dict) -> str:
        raw = r.get("raw") or {}
        w = raw.get("sliding_window_size")
        if w:
            return f"SWA {w}"
        if raw.get("primary_attention"):
            return str(raw["primary_attention"])
        return "hybrid"

    matrix_fields = [
        ("Display name", lambda r: r["display_name"]),
        ("Organization", lambda r: r["org"]),
        ("Status", lambda r: f"`{r['status']}`"),
        ("Total params", lambda r: f"**{r['total_params']}**"),
        ("Active params", lambda r: f"**{r['active_params']}**"),
        ("Context tokens", lambda r: f"{r['context_tokens']:,}" if isinstance(r["context_tokens"], int) else str(r["context_tokens"])),
        ("MoE routing", lambda r: r["experts"]),
        ("Layers (G / SWA)", fmt_layers),
        ("Hidden size", fmt_hidden),
        ("Attention / window", fmt_window),
        ("Hub repo", lambda r: f"`{r['hub']}`" if r.get("hub") else "—"),
        ("API model id", lambda r: f"`{r['api_model_id']}`" if r.get("api_model_id") else "—"),
    ]
    for label, fn in matrix_fields:
        vals = " | ".join(fn(r) for r in rows)
        lines.append(f"| **{label}** | {vals} |")
    lines.append("")
    return "\n".join(lines)


def main() -> int:
    reg = load_registry()
    reg_by_id = {m["id"]: m for m in reg.get("models") or [] if "id" in m}
    model_ids = discover_models()
    if not model_ids:
        print("No model summaries found", file=sys.stderr)
        return 1

    rows = []
    for mid in model_ids:
        summary = load_summary(mid)
        rows.append(normalize_row(mid, summary, reg_by_id.get(mid)))

    generated = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
    OUT.mkdir(parents=True, exist_ok=True)

    status = {
        "generated_at_utc": generated,
        "models": [{k: v for k, v in r.items() if k != "raw"} for r in rows],
    }
    if write_json_stable(OUT / "STATUS.json", status):
        print("  STATUS.json updated")
    else:
        print("  STATUS.json unchanged (semantic)")
        if (OUT / "STATUS.json").exists():
            status = json.loads((OUT / "STATUS.json").read_text())
            generated = status.get("generated_at_utc", generated)

    md_rows = rows
    if status.get("models") and len(status["models"]) == len(rows):
        # prefer stored models list when reusing timestamp
        md_rows = [{**m, "raw": {}} for m in status["models"]]

    new_dash = render_md(md_rows, generated)
    dash_path = OUT / "DASHBOARD.md"
    if not dash_path.exists() or dash_path.read_text() != new_dash:
        dash_path.write_text(new_dash)
        print("  DASHBOARD.md updated")
    else:
        print("  DASHBOARD.md unchanged")

    # Use live rows (with raw summary fields) for COMPARE_MATRIX.md
    new_matrix = render_compare_matrix(rows, generated)
    matrix_path = OUT / "COMPARE_MATRIX.md"
    if not matrix_path.exists() or matrix_path.read_text() != new_matrix:
        matrix_path.write_text(new_matrix)
        print("  COMPARE_MATRIX.md updated")

    (OUT / "README.md").write_text(
        "# Monorepo derived/\n\n"
        "> Generated. Do not hand-edit.\n\n"
        "| File | Purpose |\n"
        "|---|---|\n"
        "| [DASHBOARD.md](DASHBOARD.md) | Human status table |\n"
        "| [COMPARE_MATRIX.md](COMPARE_MATRIX.md) | Auto-generated cross-model spec matrix |\n"
        "| [STATUS.json](STATUS.json) | Machine status |\n"
    )
    sync_hf_catalog(rows)
    sync_readme.main()
    print(f"✓ dashboard: {len(rows)} models")
    for r in rows:
        print(f"  - {r['model_id']}: {r['display_name']} [{r['status']}]")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())