"""Build a 300,000-sequence OpenWebText training corpus, disjoint from the
existing test split.

Follows the conventions of eda_phase0/stage1_02b exactly, so the new corpus is
the same KIND of data as the 10,000-sequence train split it replaces:
  * stream Skylion007/openwebtext with shuffle(seed=SEED, buffer=30,000)
  * tokenise each document with truncation to 127 content tokens
  * keep only documents that yield exactly 127 (i.e. long enough)
  * prepend the BOS token to make a 128-token sequence

DISJOINTNESS is enforced structurally at the end: any sequence byte-identical
to a test sequence is dropped and the count is reported. The test split is NOT
regenerated -- it stays exactly as shipped, so every number produced from this
corpus is directly comparable to the numbers already in the repo.
"""
from __future__ import annotations
import json, sys, time
from pathlib import Path
import numpy as np

HERE = Path(__file__).resolve().parent
ROOT = HERE.parent
sys.path.insert(0, str(ROOT / "eda_phase0"))
import config as C

TARGET = 300_000
OUT = HERE / "corpus_300k.npz"


def main() -> None:
    from transformers import AutoTokenizer
    from datasets import load_dataset

    tok = AutoTokenizer.from_pretrained("gpt2")
    ds = load_dataset(C.OWT_DATASET, split="train", streaming=True)
    ds = ds.shuffle(seed=C.SEED, buffer_size=C.OWT_SHUFFLE_BUFFER)

    seqs: list[np.ndarray] = []
    pulled = discarded = 0
    t0 = time.time()
    for ex in ds:
        pulled += 1
        ids = tok(ex["text"], truncation=True,
                  max_length=C.OWT_CONTENT_TOKENS)["input_ids"]
        if len(ids) == C.OWT_CONTENT_TOKENS:
            seqs.append(np.asarray(ids, dtype=np.int32))
        else:
            discarded += 1
        if pulled % 25_000 == 0:
            print(f"  pulled {pulled:,}  kept {len(seqs):,}  "
                  f"{(time.time()-t0)/60:.1f} min", flush=True)
        if len(seqs) >= TARGET:
            break

    pool = np.stack(seqs)
    full = np.zeros((len(pool), C.OWT_SEQ_LEN), dtype=np.int32)
    full[:, 0] = C.BOS_TOKEN_ID
    full[:, 1:] = pool
    print(f"\nbuilt {len(full):,} sequences from {pulled:,} documents "
          f"({discarded:,} too short), {(time.time()-t0)/60:.1f} min")

    # structural disjointness from the shipped test split, and self-dedup
    te = np.load(C.CACHE / "owt_test_tokens.npz")["tokens"]
    sig_te = set(map(bytes, np.ascontiguousarray(te)))
    sig_seen: set[bytes] = set()
    keep = np.ones(len(full), bool)
    dup_test = dup_self = 0
    for i, row in enumerate(np.ascontiguousarray(full)):
        b = bytes(row)
        if b in sig_te:
            keep[i] = False; dup_test += 1
        elif b in sig_seen:
            keep[i] = False; dup_self += 1
        else:
            sig_seen.add(b)
    full = full[keep]
    print(f"dropped {dup_test:,} duplicates of TEST and {dup_self:,} internal "
          f"duplicates -> {len(full):,} sequences")

    tr = np.load(C.CACHE / "owt_train_tokens.npz")["tokens"]
    overlap_tr = len(set(map(bytes, np.ascontiguousarray(tr))) &
                     set(map(bytes, np.ascontiguousarray(full))))
    n_read = len(full) * (C.OWT_SEQ_LEN - C.FIRST_READ_POSITION)
    print(f"contains {overlap_tr:,} of the original 10,000 train sequences "
          f"(expected: it is a superset of the same stream)")
    print(f"read positions: {n_read:,}  "
          f"({n_read / 1_270_000:.1f}x the shipped train corpus)")

    np.savez_compressed(OUT, tokens=full)
    (HERE / "corpus_info.json").write_text(json.dumps({
        "dataset": C.OWT_DATASET, "seed": C.SEED,
        "shuffle_buffer": C.OWT_SHUFFLE_BUFFER,
        "documents_pulled": pulled, "documents_too_short": discarded,
        "sequences": int(len(full)), "seq_len": C.OWT_SEQ_LEN,
        "read_positions": int(n_read),
        "dropped_dup_of_test": dup_test, "dropped_dup_internal": dup_self,
        "overlap_with_test": 0, "overlap_with_old_train": overlap_tr,
        "test_split": "owt_test_tokens.npz, unchanged",
    }, indent=2))
    print(f"wrote {OUT}")


if __name__ == "__main__":
    main()