"""Exhaustive token-id scan of updates [50000,55000) of the frozen 50B stream.

Tracks EVERY girl name from scripts/name_lists.py whose " Name" form is a single
token (the only form the name-slot probe / generation slot can be reinforced on),
plus bare-form single tokens for a focus set, plus multi-token control patterns.

Outputs (out/alice_vs_megan/sites/):
  bincount_window.npy   int64[100352] exact count of EVERY token id in the window
  sites_all.npz         pos_<label> int64 arrays (global token offsets)
  contexts_all.npz      ctx_<label> int32[n,33] (site first-token at col 16)
  eos_positions.npy     positions of EOS 100257 in window (doc boundaries)
  h0_counts.json        exact raw + boundary-filtered counts per pattern

READ-ONLY on the stream. CPU only.
"""
import json, os, sys, time
import numpy as np

REPO = "/mnt/nlpgpu-io1/data/maggie/explain-m0de-collapse/replicate"
sys.path.insert(0, REPO)
from frozen_token_loader import FrozenTokenStream
from scripts.name_lists import GIRLS

OUT = os.path.join(REPO, "out/alice_vs_megan/sites")
os.makedirs(OUT, exist_ok=True)

W = 131072
U0, U1 = 50000, 55000
T0, T1 = U0 * W, U1 * W
EOS = 100257
K = 16
FOCUS = ["Alice", "Maria", "Mary", "Julia", "Ann", "Megan", "Karen", "Sarah"]


def lc_table(tok, vocab):
    is_lc = np.zeros(vocab, dtype=bool)
    for i in range(vocab):
        try:
            s = tok.decode([i])
        except Exception:
            continue
        if s and "a" <= s[0] <= "z":
            is_lc[i] = True
    return is_lc


def main():
    from transformers import AutoTokenizer
    stream = FrozenTokenStream(os.path.join(REPO, "data/olmo3_prefix_hfstream_50b"))
    tok = AutoTokenizer.from_pretrained(
        os.path.join(REPO, "data/olmo3_prefix_hfstream_50b/tokenizer"), trust_remote_code=True)
    enc = lambda s: tok(s, add_special_tokens=False)["input_ids"]
    vocab = 100352

    # ---- build tracked patterns ----
    single = {}   # label -> token id
    multi = {}    # label -> [ids]
    tok_len_sp = {}  # name -> len of " Name" encoding
    for n in GIRLS:
        ids = enc(" " + n)
        tok_len_sp[n] = len(ids)
        if len(ids) == 1:
            single[f"sp_{n}"] = ids[0]
        else:
            multi[f"sp_{n}"] = ids          # multi-token " Name" (probe can't own it)
    for n in FOCUS:
        b = enc(n)
        if len(b) == 1:
            single[f"bare_{n}"] = b[0]
        else:
            multi[f"bare_{n}"] = b
    named, called = enc(" named"), enc(" called")
    assert len(named) == 1 and len(called) == 1
    for n in FOCUS:
        multi[f"named_{n}"] = named + enc(" " + n)
        multi[f"called_{n}"] = called + enc(" " + n)
    # de-dup safety
    assert len({tuple([v]) if isinstance(v, int) else tuple(v)
                for v in list(single.values()) + list(multi.values())}) == len(single) + len(multi)

    id2lab = np.full(vocab, -1, dtype=np.int32)
    slabels = list(single)
    for i, lab in enumerate(slabels):
        assert id2lab[single[lab]] == -1, f"dup id {lab}"
        id2lab[single[lab]] = i
    print(f"{len(single)} single-token patterns, {len(multi)} multi-token patterns")
    print("multi-token ' Name' girls (NOT single-slot reinforceable):",
          [k for k in multi if k.startswith('sp_')])

    print("building lowercase-continuation table...", flush=True)
    is_lc = lc_table(tok, vocab)

    bc = np.zeros(vocab, dtype=np.int64)
    pos = {k: [] for k in list(single) + list(multi)}
    ctxs = {k: [] for k in pos}
    fallback = []   # (label, global_pos) needing post-hoc context read
    eos_pos = []

    def grab_ctx(label, local_p, global_p, a, read):
        ok = (local_p >= K) & (local_p + K + 1 <= read)
        if ok.any():
            idx = local_p[ok]
            ctxs[label].append(a[idx[:, None] + np.arange(-K, K + 1)[None, :]].astype(np.int32))
        for g in global_p[~ok]:
            fallback.append((label, int(g)))
        return ok

    CH = 1 << 24
    maxlen = max([1] + [len(v) for v in multi.values()])
    t = T0
    t_start = time.time()
    while t < T1:
        L = min(CH, T1 - t)
        read = min(L + maxlen + K, stream.stored_tokens - t)
        a = stream.get_tokens(t, read).astype(np.int64)
        bc += np.bincount(a[:L], minlength=vocab)
        labs = id2lab[a[:L]]
        hits = np.flatnonzero(labs >= 0)
        hl = labs[hits]
        order = np.argsort(hl, kind="stable")
        hits, hl = hits[order], hl[order]
        bounds = np.searchsorted(hl, np.arange(len(slabels) + 1))
        for li, lab in enumerate(slabels):
            p = hits[bounds[li]:bounds[li + 1]]
            if len(p):
                pos[lab].append(p + t)
                grab_ctx(lab, p, p + t, a, read)
        for lab, ids in multi.items():
            m = np.flatnonzero(a[:L] == ids[0])
            for j in range(1, len(ids)):
                m = m[m + j < read]
                m = m[a[m + j] == ids[j]]
            if len(m):
                pos[lab].append(m + t)
                grab_ctx(lab, m, m + t, a, read)
        p = np.flatnonzero(a[:L] == EOS)
        if len(p):
            eos_pos.append(p + t)
        t += L
        done = (t - T0) / (T1 - T0)
        el = time.time() - t_start
        print(f"  {t-T0:>13,}/{T1-T0:,} ({100*done:5.1f}%) elapsed {el:5.0f}s eta {el/done-el:4.0f}s",
              flush=True)

    pos = {k: (np.concatenate(v) if v else np.empty(0, np.int64)) for k, v in pos.items()}
    eos_pos = np.concatenate(eos_pos) if eos_pos else np.empty(0, np.int64)
    np.save(os.path.join(OUT, "bincount_window.npy"), bc)
    np.save(os.path.join(OUT, "eos_positions.npy"), eos_pos)
    print(f"EOS (doc boundaries) in window: {len(eos_pos):,}; fallback ctx sites: {len(fallback)}")

    # assemble contexts in position order (chunk order == position order except fallbacks)
    fb_by_lab = {}
    for lab, g in fallback:
        fb_by_lab.setdefault(lab, []).append(g)
    ctx_final = {}
    for lab in pos:
        mats = ctxs[lab]
        base = np.concatenate(mats, axis=0) if mats else np.zeros((0, 2 * K + 1), np.int32)
        fbg = fb_by_lab.get(lab, [])
        if fbg:
            extra = np.zeros((len(fbg), 2 * K + 1), np.int32)
            for i, g in enumerate(fbg):
                s = max(0, g - K)
                e = min(stream.stored_tokens, g + K + 1)
                buf = stream.get_tokens(s, e - s)
                extra[i, (s - (g - K)):(s - (g - K)) + len(buf)] = buf
            # merge: base rows correspond to non-fallback sites in order; rebuild by position
            nonfb_pos = np.array(sorted(set(pos[lab].tolist()) - set(fbg)), dtype=np.int64)
            allpos = pos[lab]
            row_of = {int(g): i for i, g in enumerate(nonfb_pos)}
            fbrow_of = {int(g): i for i, g in enumerate(fbg)}
            full = np.zeros((len(allpos), 2 * K + 1), np.int32)
            for i, g in enumerate(allpos):
                g = int(g)
                full[i] = extra[fbrow_of[g]] if g in fbrow_of else base[row_of[g]]
            ctx_final[lab] = full
        else:
            ctx_final[lab] = base
        assert len(ctx_final[lab]) == len(pos[lab]), lab

    np.savez_compressed(os.path.join(OUT, "sites_all.npz"),
                        **{f"pos_{k}": v for k, v in pos.items()})
    np.savez_compressed(os.path.join(OUT, "contexts_all.npz"),
                        **{f"ctx_{k}": v for k, v in ctx_final.items()})

    # ---- exact H0 counts ----
    h0 = {"window_updates": [U0, U1], "window_tokens": [T0, T1],
          "n_eos_docs_in_window": int(len(eos_pos)),
          "boundary_rule": "next token after matched sequence does not start with a-z",
          "girl_sp_token_len": tok_len_sp, "patterns": {}}
    for lab in pos:
        ids = [single[lab]] if lab in single else multi[lab]
        sl = len(ids)
        ctx = ctx_final[lab]
        nxt = ctx[:, K + sl] if len(ctx) else np.zeros(0, np.int32)
        bok = ~is_lc[nxt] if len(ctx) else np.zeros(0, bool)
        h0["patterns"][lab] = {"ids": ids, "piece": tok.decode(ids),
                               "raw": int(len(pos[lab])),
                               "boundary_filtered": int(bok.sum())}
    with open(os.path.join(OUT, "h0_counts.json"), "w") as f:
        json.dump(h0, f, indent=1)
    top = sorted(((v["raw"], k) for k, v in h0["patterns"].items()), reverse=True)[:25]
    for c, k in top:
        print(f"  {k:>16}: raw={c:,} boundary={h0['patterns'][k]['boundary_filtered']:,}")
    print("done")


if __name__ == "__main__":
    main()