"""kbench — one entry point for the kernel-generation suite.

Before this, the suite was eight loose scripts with different calling conventions (build.py took a spec
path, validate.sh took a GPU then task names, the audits took task names or nothing, publish took
nothing). Same operations, unified:

    kbench list    [--tier T3] [--family moe] [--metric GB/s] [--gpus 2] [--json]
    kbench show    <task>
    kbench build   <spec.py | task-name | --all>
    kbench validate <task...> [--gpu N]
    kbench audit   [--sizes] [--quality] [--gates] [--span] [--schema] [--all] [task...]
    kbench catalog                      regenerate CATALOG.json + README.md
    kbench publish [--dry-run]          stage the human-readable tree and push to the Hub
    kbench stats

Everything delegates to the existing tools; nothing is reimplemented.
"""
import argparse
import json
import pathlib
import subprocess
import sys

HERE = pathlib.Path(__file__).resolve().parent
LANE = HERE.parent
ROOT = LANE.parent


def _catalog():
    p = LANE / "CATALOG.json"
    return json.loads(p.read_text()) if p.exists() else []


def _run(cmd, **kw):
    return subprocess.run(cmd, shell=isinstance(cmd, str), **kw).returncode


def _spec_for(task):
    for sub in ("_factory", "_mega_factory", "_dist_factory"):
        p = LANE / sub / "specs" / (task.replace("-", "_") + ".py")
        if p.exists():
            return p
    return None


def cmd_list(a):
    rows = _catalog()
    for f, v in (("tier", a.tier), ("family", a.family), ("metric", a.metric)):
        if v:
            rows = [r for r in rows if (r.get(f) or "").lower().find(v.lower()) >= 0]
    if a.gpus:
        rows = [r for r in rows if r.get("gpus") == a.gpus]
    if a.json:
        print(json.dumps(rows, indent=2)); return 0
    for r in rows:
        us = f"{r['roofline_us']:.0f}us" if r.get("roofline_us") else "—"
        print(f"{r.get('tier','—'):<3} {r.get('metric') or '—':<8} {us:>8}  {r['name']}")
    print(f"\n{len(rows)} tasks", file=sys.stderr)
    return 0


def cmd_show(a):
    r = next((x for x in _catalog() if x["name"] == a.task), None)
    if not r:
        print(f"no such task: {a.task}", file=sys.stderr); return 1
    print(f"{r['name']}\n  family    {r['family']}\n  difficulty{'':1}{r.get('tier','—')}  "
          f"{r.get('tier_why','')}\n  metric    {r.get('metric')}\n  roofline  "
          f"{r.get('roofline_us')} us\n  gpus      {r.get('gpus')}")
    sp = _spec_for(a.task)
    print(f"  spec      {sp.relative_to(LANE) if sp else '(hand-written, no spec)'}")
    print(f"  keywords  {', '.join(r.get('keywords', []))}")
    print(f"\n{r.get('description','')}")
    return 0


def cmd_build(a):
    if a.all:
        n = f = 0
        for sub, b in (("_factory", "build.py"), ("_mega_factory", "build.py")):
            for s in sorted((LANE / sub / "specs").glob("*.py")):
                if s.name.startswith("_"):
                    continue
                ok = _run([sys.executable, str(LANE / sub / b), str(s)],
                          stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) == 0
                n, f = n + ok, f + (not ok)
                if not ok:
                    print(f"  BUILD FAILED {s.name}", file=sys.stderr)
        print(f"built {n}, failed {f}")
        return 1 if f else 0
    for t in a.target:
        p = pathlib.Path(t)
        if not p.exists():
            p = _spec_for(t)
        if p is None:
            print(f"no spec for {t}", file=sys.stderr); return 1
        b = LANE / ("_mega_factory" if "_mega_factory" in str(p) else "_factory") / "build.py"
        if _run([sys.executable, str(b), str(p)]) != 0:
            return 1
    return 0


def cmd_validate(a):
    mega = [t for t in a.task if (LANE / t / "tests" / "verify_env.py").exists()
            and "canonical_work" not in (LANE / t / "tests" / "verify_env.py").read_text()]
    std = [t for t in a.task if t not in mega]
    rc = 0
    if std:
        rc |= _run(["bash", str(HERE / "validate.sh"), str(a.gpu), *std])
    if mega:
        print("megakernel-family tasks need the mega harness "
              "(reference as pass-through submission); see _mega_factory/CALIBRATION.md §7:",
              ", ".join(mega), file=sys.stderr)
    return rc


def cmd_audit(a):
    which = [k for k in ("sizes", "quality", "gates", "span", "schema") if getattr(a, k)] or (
        ["sizes", "quality", "schema"] if not a.all else ["sizes", "quality", "gates", "span", "schema"])
    rc = 0
    if "sizes" in which:
        print("== sizing =="); rc |= _run([sys.executable, str(HERE / "audit_sizes.py"), *a.task])
    if "quality" in which:
        print("== quality =="); rc |= _run([sys.executable, str(HERE / "audit_quality.py"), *a.task])
    if "schema" in which:
        print("== schema =="); rc |= _run([sys.executable, str(HERE / "audit_schema.py"), *a.task])
    if "gates" in which:
        print("== gate discrimination ==")
        lst = pathlib.Path("/tmp/_kb_gates.txt")
        lst.write_text("\n".join(a.task or [r["name"] for r in _catalog()]) + "\n")
        rc |= _run(f"GPU={a.gpu} bash {HERE/'gate_probe.sh'} {lst}")
    if "span" in which:
        print("== input span ==  (run per task inside its container; see _factory/span_check.py)")
    return rc


def cmd_catalog(a):
    return _run([sys.executable, str(HERE / "make_catalog.py")])


def cmd_publish(a):
    if _run([sys.executable, str(HERE / "publish_kbench.py")]) != 0:
        return 1
    if a.dry_run:
        print("staged only (--dry-run); not pushed"); return 0
    push = ROOT.parent / "scripts" / "push_kbench.py"
    print(f"stage complete. push with the Hub uploader ({push if push.exists() else 'see RUN.md'})")
    return 0


def cmd_stats(a):
    rows = _catalog()
    from collections import Counter
    for field, label in (("tier", "difficulty"), ("family", "family"), ("metric", "metric")):
        c = Counter(r.get(field) or "—" for r in rows)
        print(f"\n{label}:")
        for k, v in c.most_common():
            print(f"  {v:5d}  {k}")
    print(f"\ntotal in kernels/: {len(rows)}")
    return 0


def main():
    p = argparse.ArgumentParser(prog="kbench", description=__doc__.split("\n")[0])
    sub = p.add_subparsers(dest="cmd", required=True)

    q = sub.add_parser("list"); q.set_defaults(fn=cmd_list)
    q.add_argument("--tier"); q.add_argument("--family"); q.add_argument("--metric")
    q.add_argument("--gpus", type=int); q.add_argument("--json", action="store_true")

    q = sub.add_parser("show"); q.set_defaults(fn=cmd_show); q.add_argument("task")

    q = sub.add_parser("build"); q.set_defaults(fn=cmd_build)
    q.add_argument("target", nargs="*"); q.add_argument("--all", action="store_true")

    q = sub.add_parser("validate"); q.set_defaults(fn=cmd_validate)
    q.add_argument("task", nargs="+"); q.add_argument("--gpu", type=int, default=1)

    q = sub.add_parser("audit"); q.set_defaults(fn=cmd_audit)
    q.add_argument("task", nargs="*"); q.add_argument("--gpu", type=int, default=1)
    for k in ("sizes", "quality", "gates", "span", "schema", "all"):
        q.add_argument(f"--{k}", action="store_true")

    sub.add_parser("catalog").set_defaults(fn=cmd_catalog)

    q = sub.add_parser("publish"); q.set_defaults(fn=cmd_publish)
    q.add_argument("--dry-run", action="store_true")

    sub.add_parser("stats").set_defaults(fn=cmd_stats)

    a = p.parse_args()
    sys.exit(a.fn(a))


if __name__ == "__main__":
    main()