"""Corsa di conferma. §6–§7: tabelle dalle diagnosi (analysis/diag.json). Uso: python3 analysis/diag_report.py > analysis/diag.md"""
import json
from collections import Counter
from pathlib import Path

import load as LD

OUT = Path(__file__).resolve().parent
d = json.load(open(OUT / "diag.json"))
rows = {(r["L"], r["pol"], r["qid"]): r for r in LD.load_results()}
SUM = {}


def P(*a):
    print(*a)


def short(st):
    return "; ".join(x.replace("toccato ", "tocc. ") for x in st)


P("## 6a. Convenzione dei round: controllo di validità preregistrato (i punteggi restano quelli ufficiali, nessuna rivalutazione)\n")
P("Nel banco \"the tool results for round N\" è l'uscita dello strumento che **precede** il messaggio utente "
  "\"Round N: Guess …\" (verificato su tutte le 100 domande: la risposta ufficiale si ricalcola esattamente così). "
  "La lettura naturale per il modello è l'uscita che **segue** \"Round N\" (la query fatta dopo il feedback del "
  "round N). Domande in cui le due letture danno risposte diverse = \"distinguenti\".\n")
P("| insieme | politica | distinguenti giuste | non distinguenti giuste | risposte = lettura alternativa sulle distinguenti |")
P("|---|---|---|---|---|")
for L in ("64k", "128k", "unite"):
    R = [v for v in d.values() if L == "unite" or v["L"] == L]
    dis = [v for v in R if v["conv_distinguishes"]]
    nd = [v for v in R if not v["conv_distinguishes"]]
    for p in LD.POLS:
        alt = sum(1 for v in dis if v[p]["pred"] == v["gold_alt"])
        P(f"| {L} | {p} | {sum(v[p]['ok'] for v in dis)}/{len(dis)} | {sum(v[p]['ok'] for v in nd)}/{len(nd)} | "
          f"{alt}/{len(dis)} |")
        SUM.setdefault("conv", {}).setdefault(L, {})[p] = {
            "dis_ok": sum(v[p]["ok"] for v in dis), "n_dis": len(dis), "nd_ok": sum(v[p]["ok"] for v in nd),
            "n_nd": len(nd), "alt": alt}
P("")
P("Dove D ha cercato (giornale del proxy: richiami che hanno restituito o interrogato il messaggio), tutte le 100 "
  "domande:\n")
ce, ca = Counter(), Counter()
for v in d.values():
    for x in v["D_diag"]["ev_in_final"]:
        ce[x.split(" (")[0]] += 1
    for x in v["D_diag"]["alt_in_final"]:
        ca[x.split(" (")[0]] += 1
P("| messaggio | vivo nel prompt finale | letto intero | toccato (risultato o interrogazione per id) | assente |")
P("|---|---|---|---|---|")
P(f"| prova del banco (prima di \"Round N\") | {ce['vivo']} | {ce['letto intero']} | {ce['toccato']} | {ce['assente']} |")
P(f"| lettura alternativa (dopo \"Round N\") | {ca['vivo']} | {ca['letto intero']} | {ca['toccato']} | {ca['assente']} |")
P("")

# ---- discordanti D/B --------------------------------------------------------------------------------------
for L in ("128k", "64k"):
    P(f"## 6b. Discordanti D/B a {L}\n")
    P("| qid | tipo | vince | gold | gold alt. | distingue | A | D | B | T | D: giri | D: richiami | D: chiusure | "
      "D: cambi segm. / note | D: prova nel prompt finale | D: lettura alt. | B: compattazioni | B: prova nel prompt finale | "
      "B: id nel riassunto |")
    P("|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|")
    disc = [v for v in d.values() if v["L"] == L and v["D"]["ok"] != v["B"]["ok"]]
    disc.sort(key=lambda v: (v["D"]["ok"], int(v["qid"].split("_")[0])))
    for v in disc:
        D, B = v["D_diag"], v["B_diag"]
        clo = [c[1] for c in D["close"] if c[0] == "final"] or ["—"]
        P(f"| {v['qid']} | {v['qt']} | {'D' if v['D']['ok'] else 'B'} | {v['gold']} | {v['gold_alt']} | "
          f"{'sì' if v['conv_distinguishes'] else 'no'} | {v['A']['pred']} | {v['D']['pred']} | {v['B']['pred']} | "
          f"{v['T']['pred']} | {D['rounds']} | {D['recall_n']} | {', '.join(clo)} | {D['switches']} / "
          f"{','.join(D['notes_finish']) or '—'} | {short(D['ev_in_final'])} | {short(D['alt_in_final'])} | "
          f"{B['compactions']} | {short(B['ev_in_final'])} | {'sì' if B['target_in_summary'] else 'no'} |")
    P("")

    # cause candidate
    bw = [v for v in disc if v["B"]["ok"]]
    dw = [v for v in disc if v["D"]["ok"]]

    def b_has_ev(v):
        return all(s == "vivo" or s.startswith("nel riassunto intero") for s in v["B_diag"]["ev_in_final"])

    def d_alt(v):
        return v["conv_distinguishes"] and v["D"]["pred"] == v["gold_alt"]

    def d_bad(v):
        r = rows[(L, "D", v["qid"])]
        return r["empty"] or r["trunc"] or r["resid"] or r["invalid"]

    def b_bad(v):
        r = rows[(L, "B", v["qid"])]
        return r["empty"] or r["trunc"] or r["resid"] or r["invalid"]

    def closed(v):
        return any(c[0] == "final" for c in v["D_diag"]["close"])

    def ev_seen(v):
        return all(s in ("vivo", "letto intero") for s in v["D_diag"]["ev_in_final"])
    causes = [
        ("D risponde secondo la lettura alternativa dei round (domanda distinguente, risposta D = gold alternativo)",
         sum(d_alt(v) for v in bw), sum(d_alt(v) for v in dw)),
        ("B senza la prova nel prompt finale (né viva né intera nel riassunto): risposta non sostenuta dai dati",
         sum(not b_has_ev(v) for v in bw), sum(not b_has_ev(v) for v in dw)),
        ("B risponde \"assente\" (0 / no) e la risposta giusta è negativa",
         sum(v["B"]["neg_answer"] and v["neg"] for v in bw), sum(v["D"]["neg_answer"] and v["neg"] for v in dw)),
        ("Ricerca di D chiusa dal proxy (round_limit / spazio / no_room) prima della risposta",
         sum(closed(v) for v in bw), sum(closed(v) for v in dw)),
        ("Prova del banco vista per intero da D (viva o letta intera)",
         sum(ev_seen(v) for v in bw), sum(ev_seen(v) for v in dw)),
        ("Risposta non valida / troncata / con chiamate residue (D nelle vittorie di B; B nelle vittorie di D)",
         sum(d_bad(v) for v in bw), sum(b_bad(v) for v in dw)),
    ]
    P(f"### Cause candidate a {L} (una domanda può avere più cause)\n")
    P(f"| causa | casi fra le {len(bw)} vinte da B | casi fra le {len(dw)} vinte da D |")
    P("|---|---|---|")
    for c, a, b in causes:
        P(f"| {c} | {a} | {b} |")
    P("")
    SUM.setdefault("causes", {})[L] = {"B_wins": len(bw), "D_wins": len(dw), "causes": causes}

# ---- chiusure della ricerca di D: tutte le domande ------------------------------------------------------
P("## 6c. Chiusure della ricerca di D e risultato (tutte le domande)\n")
P("| lunghezza | chiusura | domande | D giuste |")
P("|---|---|---|---|")
for L in ("64k", "128k"):
    c = Counter()
    ok = Counter()
    for v in d.values():
        if v["L"] != L:
            continue
        k = ",".join(sorted({x[1] for x in v["D_diag"]["close"] if x[0] == "final"})) or "nessuna (risposta spontanea)"
        c[k] += 1
        ok[k] += v["D"]["ok"]
    for k in sorted(c):
        P(f"| {L} | {k} | {c[k]} | {ok[k]} |")
P("")

# ---- §7 A a 128k ----------------------------------------------------------------------------------------
P("## 7. A (finestra piena) a 128k\n")
P("| lunghezza | politica | ragionamento al budget (≥3072 generati nella risposta) | troncate | non valide | "
  "TTFT mediano risposta (s) | giuste non distinguenti | giuste distinguenti |")
P("|---|---|---|---|---|---|---|---|")
for L in ("64k", "128k"):
    for p in LD.POLS:
        rs = [r for k, r in rows.items() if k[0] == L and k[1] == p]
        bud, tt = 0, []
        for r in rs:
            ec = LD.load_engine_calls(r["dir"])
            a = [c for c in ec if c["kind"] in ("answer", "final", "round")][-1]
            bud += (a.get("completion_tokens") or 0) >= 3072
            tt.append(a.get("ttft_s") or 0)
        tt.sort()
        cv = SUM["conv"][L][p]
        P(f"| {L} | {p} | {bud}/50 | {sum(r['trunc'] for r in rs)} | {sum(r['invalid'] for r in rs)} | "
          f"{tt[len(tt) // 2]:.1f} | {cv['nd_ok']}/{cv['n_nd']} | {cv['dis_ok']}/{cv['n_dis']} |")
P("")
P("A a 128k, domande non distinguenti sbagliate:\n")
for v in d.values():
    if v["L"] == "128k" and not v["conv_distinguishes"] and not v["A"]["ok"]:
        r = rows[("128k", "A", v["qid"])]
        P(f"- {v['qid']} ({v['qt']}): gold {v['gold']}, A {v['A']['pred']}, troncata {r['trunc']}, "
          f"finish {r['finish']}, D {v['D']['pred']}, B {v['B']['pred']}")
P("")
(OUT / "diag_summary.json").write_text(json.dumps(SUM, indent=1, default=str))