#!/usr/bin/env python3
"""Score the multi-tool set with the SAME slot and recall functions as score.py.

    python3 mt_score.py --ref compositional/test.jsonl --pred preds.jsonl [--route qrm_preds.jsonl] [--out-json x.json]

Answer metrics (per 2-/3-backend group and overall): slot accuracy = every number
in the reference answer and the module name appear in the prediction; rec80;
mean content recall. Routing (optional): the predicted call list must equal the
reference call set (tool and parameters, order ignored); also reports
backend-set accuracy ignoring parameters.
"""
import argparse, json, collections, sys, os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from score import slot_match, recall, wilson

def calls_of(x):
    if isinstance(x, str):
        from mt_e2e import parse_calls
        x = parse_calls(x) or None
    if isinstance(x, dict): x = [x]
    if not isinstance(x, list): return None
    try: return sorted(json.dumps({"tool": c["tool"], "parameters": c.get("parameters") or {}}, sort_keys=True) for c in x)
    except Exception: return None

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--ref", required=True); ap.add_argument("--pred"); ap.add_argument("--route")
    ap.add_argument("--out-json")
    a = ap.parse_args()
    ref = {json.loads(l)["question_hash"]: json.loads(l) for l in open(a.ref)}
    out = {"ref": a.ref, "n": len(ref)}
    if a.pred:
        preds = {}
        for l in open(a.pred):
            d = json.loads(l); preds[d["question_hash"]] = d.get("prediction", "")
        g = collections.defaultdict(lambda: collections.Counter())
        for h, r in ref.items():
            for key in ("all", f"{r['n_calls']}-backend"):
                p = preds.get(h, ""); s = g[key]; s["n"] += 1
                sm = slot_match(p, r["answer"], r["module_name"])
                if sm is not None: s["slot_n"] += 1; s["slot_ok"] += bool(sm)
                rc = recall(p, r["answer"])
                if rc is not None: s["rec_n"] += 1; s["rec_sum"] += rc; s["rec80"] += rc >= 0.8
        out["missing"] = len(set(ref) - set(preds)); out["answer"] = {}
        for k, s in sorted(g.items()):
            lo, hi = wilson(s["slot_ok"], s["slot_n"])
            out["answer"][k] = {"n": s["n"], "slot_ok": s["slot_ok"], "slot_n": s["slot_n"],
                                "slot": 100 * s["slot_ok"] / max(1, s["slot_n"]), "slot_ci": [lo, hi],
                                "rec80": 100 * s["rec80"] / max(1, s["rec_n"]), "recall": 100 * s["rec_sum"] / max(1, s["rec_n"])}
            print(f"{k:10} n={s['n']:4}  slot {s['slot_ok']}/{s['slot_n']} = {out['answer'][k]['slot']:.1f}% [{lo:.1f}, {hi:.1f}]"
                  f"  rec80 {out['answer'][k]['rec80']:.1f}%  recall {out['answer'][k]['recall']:.1f}%")
    if a.route:
        rp = {}
        for l in open(a.route):
            d = json.loads(l); rp[d["question_hash"]] = d.get("raw", d.get("calls"))
        exact = tools_only = 0
        for h, r in ref.items():
            gt = calls_of(r["stage1_target"]); pr = calls_of(rp.get(h))
            exact += pr == gt
            tools_only += pr is not None and sorted(json.loads(c)["tool"] for c in pr) == sorted(json.loads(c)["tool"] for c in gt)
        n = len(ref); lo, hi = wilson(exact, n)
        out["routing"] = {"exact": exact, "tools_only": tools_only, "n": n, "exact_pct": 100 * exact / n, "ci": [lo, hi]}
        print(f"routing    exact {exact}/{n} = {100*exact/n:.1f}% [{lo:.1f}, {hi:.1f}]   backend set {tools_only}/{n} = {100*tools_only/n:.1f}%")
    if a.out_json: json.dump(out, open(a.out_json, "w"), indent=1)

if __name__ == "__main__":
    main()