"""Corsa di conferma: punti 4, 6 (nota sessione), 7, 8 del brief + p esatti. Solo lettura, solo CPU.
Uso (dopo main_tables.py e diag.py): python3 confirm_extra.py > extra.md   -> scrive anche extra.json
"""
import json
import re
from collections import Counter
from pathlib import Path

import load as LD
import stats as S

OUT = Path(__file__).resolve().parent
MAIN_SUM = LD.ROOT.parent / "main-run" / "analysis" / "summary.json"
summ = json.load(open(OUT / "summary.json"))
diag = json.load(open(OUT / "diag.json"))
rows = LD.load_results()
by = {(r["L"], r["pol"], r["qid"]): r for r in rows}
mrows = LD.load_main()
mby = {(r["L"], r["pol"], r["qid"]): r for r in mrows}
X = {}
NAMES = {"A": "finestra piena", "D": "proxy", "B": "riassunto", "T": "troncamento"}


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


# ---- p esatti ------------------------------------------------------------------------------------------------
P("## E1. McNemar esatto, p con tutte le cifre (tabella principale)\n")
P("| confronto | insieme | solo 1 / solo 2 | p esatto |")
P("|---|---|---|---|")
for k, c in summ["compare"]["main"].items():
    p = S.binom_two_sided(c["b"], c["c"])
    X.setdefault("p_exact", {})[k] = p
    pair, s = k.split("/")
    P(f"| {pair.replace('-', ' vs ')} | {s} | {c['b']} / {c['c']} | {p:.3g} |")
P("")

# ---- validità: lettura "dopo" --------------------------------------------------------------------------------
P("## E2. Controllo di validità: risposte che seguono ancora la lettura \"dopo\"\n")
P("Domande distinguenti = quelle in cui l'uscita dello strumento PRIMA di \"Round N: Guess\" (convenzione del banco, "
  "spiegata ora nella nota) e quella DOPO danno risposte diverse (stesse 51 della corsa principale: le storie non "
  "cambiano). Per ogni metodo: quante risposte coincidono con la lettura \"dopo\" (gold alternativo) e quante con "
  "quella \"prima\" (gold ufficiale). Riferimento: \"sempre 0 / no\" sulle stesse domande.\n")
P("| insieme | metodo | corsa principale: = dopo | conferma: = dopo | conferma: = prima (giuste) | conferma: altro/nessuna |")
P("|---|---|---|---|---|---|")
for sname in ("64k", "128k", "unite"):
    V = [v for v in diag.values() if sname == "unite" or v["L"] == sname]
    dis = [v for v in V if v["conv_distinguishes"]]
    # baseline: sempre 0/no
    neg_alt = sum(1 for v in dis if v["gold_alt"] in (0, False))
    neg_gold = sum(1 for v in dis if v["gold"] in (0, False))
    for p in LD.POLS:
        alt = sum(1 for v in dis if v[p]["pred"] == v["gold_alt"])
        ok = sum(v[p]["ok"] for v in dis)
        X.setdefault("validity", {}).setdefault(sname, {})[p] = {"alt": alt, "ok": ok, "n_dis": len(dis)}
    X["validity"][sname]["baseline_always_neg"] = {"alt": neg_alt, "ok": neg_gold, "n_dis": len(dis)}


def _pn(r):
    p = r["pred"]
    if isinstance(p, bool):
        return p
    if isinstance(p, str) and p.strip().lower() in ("yes", "true", "no", "false"):
        return p.strip().lower() in ("yes", "true")
    try:
        return int(p)
    except (TypeError, ValueError):
        return p


main_diag = json.load(open(LD.ROOT.parent / "main-run" / "analysis" / "diag.json"))
for sname in ("64k", "128k", "unite"):
    V = [v for v in diag.values() if sname == "unite" or v["L"] == sname]
    dis = [v for v in V if v["conv_distinguishes"]]
    for p in LD.POLS:
        mv = [main_diag[f"{v['L']}/{v['qid']}"] for v in dis]
        malt = sum(1 for m in mv if m[p]["pred"] == m["gold_alt"])
        x = X["validity"][sname][p]
        x["main_alt"] = malt
        P(f"| {sname} | {NAMES[p]} | {malt}/{len(dis)} | {x['alt']}/{len(dis)} | {x['ok']}/{len(dis)} | "
          f"{len(dis) - x['alt'] - x['ok']}/{len(dis)} |")
    b = X["validity"][sname]["baseline_always_neg"]
    P(f"| {sname} | sempre 0 / no | {b['alt']}/{len(dis)} | {b['alt']}/{len(dis)} | {b['ok']}/{len(dis)} | — |")
P("")

# il ragionamento cita la convenzione? (quante risposte con il ragionamento che nomina "before")
P("Ragionamento che cita la nota (\"before\" vicino a \"Round\"/\"tool\"), tutte le 100 domande:\n")
P("| metodo | corsa principale | conferma |")
P("|---|---|---|")
pat = re.compile(r"(just )?before[^.\n]{0,40}round|tool (output|result)s? (just )?before", re.I)
for p in LD.POLS:
    cnt = []
    for R in (mrows, rows):
        n = 0
        for r in R:
            if r["pol"] != p:
                continue
            rs = json.loads((Path(r["dir"]) / "result.json").read_text()).get("reasoning") or ""
            n += bool(pat.search(rs))
        cnt.append(n)
    X.setdefault("reasoning_cites_before", {})[p] = {"main": cnt[0], "confirm": cnt[1]}
    P(f"| {NAMES[p]} | {cnt[0]}/100 | {cnt[1]}/100 |")
P("")

# ---- risposte vuote del proxy --------------------------------------------------------------------------------
P("## E3. Risposte vuote del proxy\n")
P("| lunghezza | qid | gold | eventi finali nel giornale del proxy |")
P("|---|---|---|---|")
empt = []
for r in rows:
    if r["pol"] == "D" and r["empty"]:
        J = [json.loads(l) for l in open(Path(r["dir"]) / "proxy" / "journal.jsonl", errors="replace") if l.strip()]
        ev = Counter(x.get("event") for x in J)
        frr = [x for x in J if x.get("event") == "final_recall_retry"]
        rd = [x for x in J if x.get("event") == "recall_dropped"]
        info = (f"final_recall_retry ×{ev['final_recall_retry']} (reason {frr[0].get('reason') if frr else '—'}, "
                f"used {frr[0].get('used') if frr else '—'}), recall_dropped ×{ev['recall_dropped']} "
                f"(final {rd[0].get('final') if rd else '—'}, retry {rd[0].get('retry') if rd else '—'})")
        empt.append({"L": r["L"], "qid": r["qid"], "gold": r["gold"], "final_recall_retry": ev["final_recall_retry"],
                     "recall_dropped": ev["recall_dropped"]})
        P(f"| {r['L']} | {r['qid']} | {r['gold']} | {info} |")
X["empty_D"] = empt
P("")
P("Lettura: il tentativo finale (0.3.5) è stato usato; il modello ha chiamato di nuovo `recall`; il proxy ha scartato "
  "la chiamata (`recall_dropped`) e la risposta è rimasta vuota. Corretto in 0.3.6 (PR #11), ma queste domande NON "
  "sono state rifatte: contano come sbagliate.\n")

# ---- confronto corsa principale / conferma -------------------------------------------------------------------
P("## E4. Corsa principale (domanda ambigua) contro conferma (domanda con la nota)\n")
msum = json.load(open(MAIN_SUM))
P("| insieme | metodo | corsa principale | conferma | differenza |")
P("|---|---|---|---|---|")
for sname in ("64k", "128k", "unite"):
    for p in LD.POLS:
        a, n = msum["correct"]["off"][sname][p]
        b, _ = summ["correct"]["off"][sname][p]
        X.setdefault("main_vs_confirm", {}).setdefault(sname, {})[p] = {"main": a, "confirm": b, "n": n}
        P(f"| {sname} | {NAMES[p]} | {a:g}/{n} | {b:g}/{n} | {b - a:+g} |")
P("")
for k in ("D-B/unite", "D-B/64k", "D-B/128k", "D-T/unite", "D-A/unite", "B-A/unite"):
    m, c = msum["compare"]["main"][k], summ["compare"]["main"][k]
    X.setdefault("main_vs_confirm_pairs", {})[k] = {"main": [m["b"], m["c"], m["p_mcnemar"]],
                                                   "confirm": [c["b"], c["c"], c["p_mcnemar"]]}
P("| confronto | corsa principale: solo 1 / solo 2, p | conferma: solo 1 / solo 2, p |")
P("|---|---|---|")
for k, v in X["main_vs_confirm_pairs"].items():
    P(f"| {k} | {v['main'][0]} / {v['main'][1]}, {v['main'][2]:.3g} | {v['confirm'][0]} / {v['confirm'][1]}, "
      f"{v['confirm'][2]:.3g} |")
P("")
# stessa domanda, stessa risposta? (stabilità per metodo)
P("Risposte uguali tra le due corse (stessa domanda, stesso metodo; solo le non distinguenti, dove la nota non "
  "cambia la risposta giusta):\n")
P("| metodo | giuste corsa principale | giuste conferma | uguali |")
P("|---|---|---|---|")
for p in LD.POLS:
    nd = [v for v in diag.values() if not v["conv_distinguishes"]]
    g1 = sum(mby[(v["L"], p, v["qid"])]["off"] >= 1 for v in nd)
    g2 = sum(by[(v["L"], p, v["qid"])]["off"] >= 1 for v in nd)
    same = sum(_pn(mby[(v["L"], p, v["qid"])]) == _pn(by[(v["L"], p, v["qid"])]) for v in nd)
    X.setdefault("nondis_stability", {})[p] = {"main_ok": g1, "confirm_ok": g2, "same": same, "n": len(nd)}
    P(f"| {NAMES[p]} | {g1}/{len(nd)} | {g2}/{len(nd)} | {same}/{len(nd)} |")
P("")

# ---- nota sessione: token del rigioco del proxy ---------------------------------------------------------------
P("## E5. Token per domanda: proxy (fase di rigioco + fase alla domanda) e finestra piena\n")
P("Sulla singola domanda isolata il proxy rilegge la storia attraverso il rigioco. Qui riporto solo ciò che è "
  "misurato; i token della finestra piena su una sessione lunga NON sono stati misurati e non li stimo.\n")
P("| lunghezza | metodo | prompt totali / dom. (mediana, k) | prompt nuovi / dom. (mediana, k) | di cui rigioco: prompt nuovi (mediana, k) | di cui rigioco: riusati dalla cache (mediana, k) |")
P("|---|---|---|---|---|---|")
import statistics as st  # noqa: E402
for L in LD.LENGTHS:
    for p in ("A", "D"):
        tot, new, rnew, rreu = [], [], [], []
        for r in rows:
            if r["L"] != L or r["pol"] != p:
                continue
            ec = LD.load_engine_calls(r["dir"])
            tot.append(sum(c.get("prompt_tokens") or 0 for c in ec))
            new.append(sum(max(0, (c.get("prompt_tokens") or 0) - (c.get("cached_tokens") or 0))
                           if not (c.get("stream") and (c.get("completion_tokens") or 0) >= 3072
                                   and (c.get("ttft_s") or 0) > 3) else (c.get("prompt_tokens") or 0) for c in ec))
            rp = [c for c in ec if c["kind"] == "replay"]
            rnew.append(sum(max(0, (c.get("prompt_tokens") or 0) - (c.get("cached_tokens") or 0)) for c in rp))
            rreu.append(sum(c.get("cached_tokens") or 0 for c in rp))
        m = st.median
        X.setdefault("tokens", {})[f"{L}/{p}"] = {"prompt_tot_med": m(tot), "prompt_new_med": m(new),
                                                 "replay_new_med": m(rnew), "replay_cached_med": m(rreu)}
        P(f"| {L} | {NAMES[p]} | {m(tot) / 1000:.1f} | {m(new) / 1000:.1f} | {m(rnew) / 1000:.1f} | {m(rreu) / 1000:.1f} |")
P("")
P("Fase alla domanda del proxy (chiamate round + final), prompt nuovi per domanda, contro la finestra piena:\n")
P("| lunghezza | proxy alla domanda: prompt nuovi / dom. (media, k) | proxy rigioco: prompt nuovi / dom. (media, k) | finestra piena: prompt nuovi / dom. (media, k) |")
P("|---|---|---|---|")
for L in LD.LENGTHS:
    ck = summ["cost_kinds"]
    q = sum(ck.get(f"{L}/D/{k}", {}).get("prompt_new", 0) for k in ("round", "final")) / 50
    rp = ck[f"{L}/D/replay"]["prompt_new"] / 50
    a = ck[f"{L}/A/answer"]["prompt_new"] / 50
    X.setdefault("tokens_phase", {})[L] = {"D_question_new_mean": q, "D_replay_new_mean": rp, "A_new_mean": a}
    P(f"| {L} | {q / 1000:.1f} | {rp / 1000:.1f} | {a / 1000:.1f} |")
P("")

# ---- totali e prove nel prompt finale ------------------------------------------------------------------------
P("## E6. Totali per metodo (50 domande per lunghezza)\n")
P("| lunghezza | metodo | tempo totale (h) | prompt nuovi totali (M) | generati totali (k) |")
P("|---|---|---|---|---|")
for L in LD.LENGTHS:
    for p in LD.POLS:
        c = summ["cost"][f"{L}/{p}"]
        X.setdefault("totals", {})[f"{L}/{p}"] = {"wall_h": c["wall_tot_h"], "prompt_new_M": c["prompt_new_tot"] / 1e6,
                                                 "gen_k": c["gen_tot"] / 1e3}
        P(f"| {L} | {NAMES[p]} | {c['wall_tot_h']:.2f} | {c['prompt_new_tot'] / 1e6:.1f} | {c['gen_tot'] / 1e3:.0f} |")
P("")
P("## E7. La prova del banco è nel prompt finale? (tutte le prove della domanda: vive, lette intere o, per il "
  "riassunto, intere nel riassunto)\n")
P("| lunghezza | proxy: prova viva o letta intera | proxy: prova almeno toccata da un richiamo | riassunto: prova viva o intera nel riassunto |")
P("|---|---|---|---|")
for L in LD.LENGTHS:
    V = [v for v in diag.values() if v["L"] == L]
    dfull = sum(all(x in ("vivo", "letto intero") for x in v["D_diag"]["ev_in_final"]) for v in V)
    dtouch = sum(all(x != "assente" for x in v["D_diag"]["ev_in_final"]) for v in V)
    bfull = sum(all(x in ("vivo", "nel riassunto intero") for x in v["B_diag"]["ev_in_final"]) for v in V)
    X.setdefault("evidence_final", {})[L] = {"D_full": dfull, "D_touched": dtouch, "B_full": bfull, "n": len(V)}
    P(f"| {L} | {dfull}/{len(V)} | {dtouch}/{len(V)} | {bfull}/{len(V)} |")
P("")

(OUT / "extra.json").write_text(json.dumps(X, indent=1, ensure_ascii=False, default=str))