"""Fit token-only programs from the 300k-sequence contingency tables and score
them on the UNCHANGED test split.

Design decisions that make this comparable to the shipped run:
  * Same selection pipeline (S.select_tokens): resolve_min_fires -> best_k(50)
    -> expand_roots -> prune_tail_families. Nothing is retuned for scale.
  * Same test split, untouched: owt_test_tokens.npz, 1,270,000 read positions.
    Only the FITTING corpus changes, so every delta is attributable to data.
  * Same scorer: S.score_batch runs the emitted programs over the corpus, which
    is what produced the shipped numbers.

The two rate-based constants carry over correctly by construction:
resolve_min_fires gates on firings/positions, and TAIL_SHARE is a share, so
both mean the same thing at 36.8M positions as at 1.27M. MIN_FIRES_IN_SET
stays absolute on purpose -- two observations is thin evidence however long you
looked, and a string seen once at 1.27M positions is seen ~29 times here and
stops being thin, which is the intended behaviour.

    python fit_programs.py --layer 6 --emit
"""
from __future__ import annotations
import argparse, csv, json, sys, time
from pathlib import Path
import numpy as np

HERE = Path(__file__).resolve().parent
ROOT = HERE.parent
for p in (ROOT / "lib", ROOT / "eda_phase0", ROOT):
    sys.path.insert(0, str(p))
import config as C
import sae_synthesis as S

THR, CAP, MIN_POS = 0.1, 50, 5


def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--layer", type=int, required=True)
    ap.add_argument("--emit", action="store_true")
    ap.add_argument("--jobs", type=int, default=8)
    ap.add_argument("--counts", default=str(HERE / "counts_300k.npz"))
    a = ap.parse_args()
    L = a.layer

    z = np.load(a.counts, allow_pickle=True)
    strings = z["strings"]
    occ_tr = z["occ"]
    NS = len(strings)
    n_seq, n_read = int(z["n_seq"]), int(z["n_read"])
    n_positions = n_seq * n_read
    keys, cnt = z[f"keys_{L}"], z[f"cnt_{L}"]
    feat = (keys // NS).astype(np.int64)
    sid = (keys % NS).astype(np.int64)
    print(f"[layer {L}] fitting corpus {n_seq:,} seqs = {n_positions:,} positions "
          f"({n_positions/1_270_000:.1f}x shipped); {len(keys):,} (feature,string) pairs",
          flush=True)

    bounds = np.searchsorted(feat, np.arange(24577))
    occ_lookup = {int(i): int(occ_tr[i]) for i in np.unique(sid)}

    out_dir = HERE / f"layer{L}_thr0p1" / "capped50"
    (out_dir / "programs").mkdir(parents=True, exist_ok=True)
    rows, items, meta = [], [], {}
    t0 = time.time()
    for f in range(24576):
        i0, i1 = int(bounds[f]), int(bounds[f + 1])
        n_pos = int(cnt[i0:i1].sum())
        if i1 <= i0 or n_pos < MIN_POS:
            rows.append({"layer": L, "feature": f, "status": "too_rare",
                         "f1": 0.0, "precision": 0.0, "recall": 0.0,
                         "n_pos_train": n_pos})
            continue
        s_ids, fires = sid[i0:i1], cnt[i0:i1].astype(np.int64)
        order = np.argsort(-fires)
        cum = 0
        rws = []
        for j in order:
            t = str(strings[s_ids[j]])
            fr = int(fires[j])
            ap_ = max(occ_lookup.get(int(s_ids[j]), fr), fr)
            cum += fr
            rws.append({"token": t, "token_ids": [int(s_ids[j])], "fires": fr,
                        "appears": ap_, "p_fire": fr / ap_,
                        "lift": (fr / ap_) / (n_pos / n_positions),
                        "cum_recall": cum / n_pos})
        opt_f1, opt_toks = S.token_optimum(rws, n_pos)
        ct = S.Contingency(L, f, THR, n_positions, n_pos, rws, [t["token"] for t in rws[:50]],
                           opt_f1, opt_toks)
        code = S.grouped_token_program(L, f, ct, cap=CAP)
        if code is None:
            rows.append({"layer": L, "feature": f, "status": "no_tokens",
                         "f1": 0.0, "precision": 0.0, "recall": 0.0,
                         "n_pos_train": n_pos})
            continue
        toks = S.select_tokens(ct, cap=CAP)
        items.append((f, code, S.prog_name(L, f)))
        meta[f] = {"layer": L, "feature": f, "status": "ok", "regime": ct.regime,
                   "token_optimum": round(opt_f1, 4), "n_tokens": len(toks),
                   "n_families": len({S.word_root(t) for t in toks}),
                   "n_tokens_uncapped": len(opt_toks), "n_pos_train": n_pos}
        if a.emit:
            d = out_dir / "programs" / f"{f // 1000:02d}"
            d.mkdir(parents=True, exist_ok=True)
            (d / f"{S.feature_key(L, f)}.py").write_text(code)
        if (f + 1) % 5000 == 0:
            print(f"  select {f+1:,}/24,576  {(time.time()-t0)/60:.1f} min", flush=True)

    print(f"[emit] {len(items):,} programs in {(time.time()-t0)/60:.1f} min; scoring "
          f"on the UNCHANGED test split...", flush=True)
    scores = S.score_batch(ROOT / f"synthesis/layer{L}_thr0p1/stores/store_L{L:02d}_test.npz",
                           C.CACHE / "owt_test_tokens.npz",
                           ROOT / "layer_plots" / "vocab_strings.npy",
                           items, THR, C.FIRST_READ_POSITION, workers=a.jobs)
    for f, _, _ in items:
        sc = dict(scores[f]); sc.update(meta[f]); rows.append(sc)

    cols = ["layer", "feature", "status", "regime", "token_optimum", "n_tokens",
            "n_families", "n_tokens_uncapped", "n_pos_train", "precision",
            "recall", "f1", "tp", "fp", "fn", "tn", "errors", "n_positions"]
    out = out_dir / "scores_test.csv"
    with open(out, "w", newline="") as fh:
        w = csv.DictWriter(fh, fieldnames=cols, extrasaction="ignore")
        w.writeheader(); w.writerows(rows)
    ok = [r for r in rows if r.get("status") == "ok"]
    f1 = np.array([r["f1"] for r in ok])
    nt = np.array([r["n_tokens"] for r in ok])
    print(f"\n=== layer {L}: {len(rows):,} features, {len(ok):,} scored, "
          f"{(time.time()-t0)/60:.1f} min ===")
    print(f"TEST F1  median {np.median(f1):.4f}  mean {f1.mean():.4f}  max {f1.max():.4f}")
    print(f"program size: median {np.median(nt):.0f} strings")
    print(f"above 0.8: {(f1>0.8).mean():.1%}")
    print(f"wrote {out}", flush=True)


if __name__ == "__main__":
    main()