#!/usr/bin/env python3
"""Classify completed C++ corpus probes into actionable DecBench tiers.

Tier A: linked project ELF + DWARF + saved preprocessed C++ (.ii).
Tier B: linked project ELF + DWARF, but .ii needs regeneration/replay.
Tier C: clone/configure/build reached the project but needs a small build adapter.
Tier D: unsuitable/failed before producing a usable debug binary.

The final shortlist prefers A, then B, and ranks by approximate DWARF function
coverage plus number of usable debug images. Tier C is reported but never used
to fill the final 50 because it has not actually produced a qualified binary.
"""
from __future__ import annotations

import argparse
import csv
import json
from pathlib import Path
from typing import Any


def artifact_score(row: dict[str, Any]) -> float:
    a = row.get("artifacts") or {}
    funcs = int(a.get("dwarf_subprogram_count_sample") or 0)
    bins = int(a.get("dwarf_elf_count") or 0)
    ii = int(a.get("ii_count") or 0)
    return min(funcs, 5000) + min(bins, 30) * 30 + min(ii, 200) * 5


def classify(row: dict[str, Any]) -> tuple[str, str]:
    a = row.get("artifacts") or {}
    linked = int(a.get("linked_elf_count") or 0)
    dwarf = int(a.get("dwarf_elf_count") or 0)
    ii = int(a.get("ii_count") or 0)
    if linked > 0 and dwarf > 0 and ii > 0:
        return "A", "oracle-ready: ELF + DWARF + .ii"
    if linked > 0 and dwarf > 0:
        return "B", "build+DWARF ready; regenerate .ii from compile commands"

    clone_ok = int((row.get("clone") or {}).get("returncode", 1)) == 0
    stage = row.get("failure_stage")
    if clone_ok and stage in {"build", "artifact_oracle"}:
        return "C", f"adapter candidate ({stage})"
    return "D", f"rejected ({stage or 'unknown'})"


def load_rows(root: Path) -> list[dict[str, Any]]:
    rows: list[dict[str, Any]] = []
    seen: set[str] = set()
    for p in sorted(root.rglob("*.json")):
        try:
            row = json.loads(p.read_text())
        except Exception:
            continue
        if not isinstance(row, dict) or "repo" not in row:
            continue
        repo = str(row["repo"])
        if repo in seen:
            continue
        seen.add(repo)
        tier, reason = classify(row)
        row["tier"] = tier
        row["tier_reason"] = reason
        row["selection_score"] = artifact_score(row)
        rows.append(row)
    return rows


def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("--probes", required=True)
    ap.add_argument("--out", required=True)
    ap.add_argument("--limit", type=int, default=50)
    args = ap.parse_args()

    out = Path(args.out)
    out.mkdir(parents=True, exist_ok=True)
    rows = load_rows(Path(args.probes))
    rows.sort(key=lambda r: (r["tier"], -r["selection_score"], r["repo"].lower()))

    tier_a = [r for r in rows if r["tier"] == "A"]
    tier_b = [r for r in rows if r["tier"] == "B"]
    tier_c = [r for r in rows if r["tier"] == "C"]
    tier_d = [r for r in rows if r["tier"] == "D"]
    final = (tier_a + tier_b)[: args.limit]

    (out / "all-probes-classified.json").write_text(json.dumps(rows, indent=2) + "\n")
    (out / "tier-a-oracle-ready.json").write_text(json.dumps(tier_a, indent=2) + "\n")
    (out / "tier-b-build-dwarf.json").write_text(json.dumps(tier_b, indent=2) + "\n")
    (out / "tier-c-adapter.json").write_text(json.dumps(tier_c, indent=2) + "\n")
    (out / "final-50.json").write_text(json.dumps(final, indent=2) + "\n")

    fields = ["rank", "repo", "tier", "selection_score", "linked_elf", "dwarf_elf", "ii", "dwarf_subprogram_sample", "revision", "build_system", "reason"]
    with (out / "final-50.csv").open("w", newline="") as f:
        w = csv.DictWriter(f, fieldnames=fields)
        w.writeheader()
        for i, r in enumerate(final, 1):
            a = r.get("artifacts") or {}
            w.writerow({
                "rank": i,
                "repo": r["repo"],
                "tier": r["tier"],
                "selection_score": r["selection_score"],
                "linked_elf": a.get("linked_elf_count", 0),
                "dwarf_elf": a.get("dwarf_elf_count", 0),
                "ii": a.get("ii_count", 0),
                "dwarf_subprogram_sample": a.get("dwarf_subprogram_count_sample", 0),
                "revision": r.get("revision"),
                "build_system": r.get("build_system"),
                "reason": r["tier_reason"],
            })

    summary = {
        "attempted_available": len(rows),
        "tier_a_oracle_ready": len(tier_a),
        "tier_b_build_dwarf": len(tier_b),
        "tier_c_adapter": len(tier_c),
        "tier_d_rejected": len(tier_d),
        "build_qualified_a_plus_b": len(tier_a) + len(tier_b),
        "final_selected": len(final),
        "final_repos": [r["repo"] for r in final],
    }
    (out / "summary.json").write_text(json.dumps(summary, indent=2) + "\n")

    lines = [
        "# DecBench C++ corpus funnel — build qualification summary",
        "",
        f"- completed probe artifacts available: **{len(rows)}**",
        f"- Tier A (ELF + DWARF + `.ii`): **{len(tier_a)}**",
        f"- Tier B (ELF + DWARF; `.ii` replay needed): **{len(tier_b)}**",
        f"- Tier C (small build adapter needed): **{len(tier_c)}**",
        f"- Tier D (rejected): **{len(tier_d)}**",
        f"- actual build-qualified (A+B): **{len(tier_a)+len(tier_b)}**",
        f"- selected: **{len(final)}**",
        "",
        "## Selected build-qualified targets",
        "",
        "| # | repository | tier | DWARF ELF | `.ii` | sampled DWARF subprograms |",
        "|---:|---|:---:|---:|---:|---:|",
    ]
    for i, r in enumerate(final, 1):
        a = r.get("artifacts") or {}
        lines.append(
            f"| {i} | `{r['repo']}` | {r['tier']} | {a.get('dwarf_elf_count',0)} | {a.get('ii_count',0)} | {a.get('dwarf_subprogram_count_sample',0)} |"
        )
    lines += ["", "## Tier C — adapter candidates", ""]
    for r in tier_c[:30]:
        lines.append(f"- `{r['repo']}` — {r['tier_reason']}")
    (out / "summary.md").write_text("\n".join(lines) + "\n")

    print(json.dumps(summary))
    return 0


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