"""Assemble a size: python assemble.py 10M

Shuffles documents with a fixed seed, holds out 0.5% per genre as validation,
writes out/<size>/train.txt (docs separated by <|endoftext|>) and valid_<genre>.txt.
"""
import json
import random
import sys
from collections import defaultdict
from pathlib import Path

ROOT = Path(__file__).resolve().parent.parent
EOT = "<|endoftext|>"


# 1M is a prefix slice of the 10M build (million words per source)
QUOTAS_1M = {"tinystories": 0.19, "simplestories": 0.19, "tinydialogues": 0.12, "soda": 0.10,
             "tinyhelen": 0.15, "simplewiki": 0.10, "cosmo_v2": 0.10, "cosmo_v01": 0.05}


def load(size):
    docs = []
    if size == "1M":
        for name, q in QUOTAS_1M.items():
            n = 0
            for l in (ROOT / "work" / "10M" / f"{name}.jsonl").open(encoding="utf-8"):
                d = json.loads(l)
                if n >= q * 1e6:
                    break
                n += len(d["text"].split())
                docs.append(d)
        return docs
    for p in sorted((ROOT / "work" / size).glob("*.jsonl")):
        docs += [json.loads(l) for l in p.open(encoding="utf-8")]
    return docs


def main_big(size):
    """Same result as main() in the same shuffled order, without holding the documents in RAM (1000M)."""
    import numpy as np
    import pyarrow as pa
    import pyarrow.parquet as pq
    files = sorted((ROOT / "work" / size).glob("*.jsonl"))
    idx_f, idx_o, n_genre = [], [], defaultdict(int)
    for i, p in enumerate(files):
        pos = 0
        with p.open("rb") as f:
            for line in f:
                idx_f.append(i)
                idx_o.append(pos)
                pos += len(line)
                n_genre[json.loads(line)["genre"]] += 1
    idx_f, idx_o = np.array(idx_f, np.int32), np.array(idx_o, np.int64)
    order = list(range(len(idx_f)))
    random.Random(0).shuffle(order)
    out = ROOT / "out" / size
    pq_dir = out / "parquet"
    pq_dir.mkdir(parents=True, exist_ok=True)
    handles = [p.open("rb") for p in files]
    schema = pa.schema([("text", pa.string()), ("source", pa.string()), ("genre", pa.string())])
    sep = f"\n{EOT}\n"
    held, valid = defaultdict(int), defaultdict(list)
    words, n_train, by_genre, by_source = 0, 0, defaultdict(int), defaultdict(int)
    batch, shard, shard_words = [], 0, 0

    def flush():
        nonlocal batch, shard, shard_words
        if batch:
            pq.write_table(pa.table({"text": [d["text"] for d in batch],
                                     "source": [d["src"].split(".")[0] for d in batch],
                                     "genre": [d["genre"] for d in batch]}, schema=schema),
                           pq_dir / f"train-{shard:05d}.parquet", compression="zstd")
            batch, shard, shard_words = [], shard + 1, 0

    with (out / "train.txt").open("w", encoding="utf-8") as tf:
        for k in order:
            f = handles[idx_f[k]]
            f.seek(idx_o[k])
            d = json.loads(f.readline())
            g = d["genre"]
            if held[g] < max(1, n_genre[g] // 200):
                held[g] += 1
                valid[g].append(d)
                continue
            n = len(d["text"].split())
            tf.write(d["text"] + sep)
            batch.append(d)
            shard_words += n
            n_train += 1
            words += n
            by_genre[g] += n
            by_source[d["src"].split(".")[0]] += n
            if shard_words >= 50_000_000:
                flush()
        flush()
    for h in handles:
        h.close()
    for g, ds in valid.items():
        (out / f"valid_{g}.txt").write_text(sep.join(d["text"] for d in ds) + sep, encoding="utf-8")
        pq.write_table(pa.table({"text": [d["text"] for d in ds], "source": [d["src"].split(".")[0] for d in ds],
                                 "genre": [d["genre"] for d in ds]}), pq_dir / f"validation_{g}.parquet",
                       compression="zstd")
    summary = {"size": size, "train_docs": n_train, "train_words_M": round(words / 1e6, 2),
               "genre_share_%": {g: round(100 * w / words, 1) for g, w in by_genre.items()},
               "source_words_M": {s: round(w / 1e6, 3) for s, w in sorted(by_source.items())}}
    (out / "summary.json").write_text(json.dumps(summary, indent=1))
    print(json.dumps(summary, indent=1))


def main():
    size = sys.argv[1]
    if size == "1000M":
        return main_big(size)
    docs = load(size)
    random.Random(0).shuffle(docs)
    out = ROOT / "out" / size
    out.mkdir(parents=True, exist_ok=True)
    valid, held = defaultdict(list), defaultdict(int)
    n_genre = defaultdict(int)
    for d in docs:
        n_genre[d["genre"]] += 1
    train, words, by_genre, by_source = [], 0, defaultdict(int), defaultdict(int)
    valid_docs = defaultdict(list)
    for d in docs:
        g = d["genre"]
        if held[g] < max(1, n_genre[g] // 200):
            held[g] += 1
            valid[g].append(d["text"])
            valid_docs[g].append(d)
        else:
            train.append(d)
            n = len(d["text"].split())
            by_genre[g] += n
            by_source[d["src"].split(".")[0]] += n
            words += n
    sep = f"\n{EOT}\n"
    (out / "train.txt").write_text(sep.join(d["text"] for d in train) + sep, encoding="utf-8")
    for g, ts in valid.items():
        (out / f"valid_{g}.txt").write_text(sep.join(ts) + sep, encoding="utf-8")
    # parquet with provenance, for the Hugging Face release
    import pyarrow as pa
    import pyarrow.parquet as pq
    pq_dir = out / "parquet"
    pq_dir.mkdir(exist_ok=True)

    def write(name, ds):
        pq.write_table(pa.table({"text": [d["text"] for d in ds], "source": [d["src"].split(".")[0] for d in ds],
                                 "genre": [d["genre"] for d in ds]}), pq_dir / f"{name}.parquet", compression="zstd")

    write("train", train)
    for g, ds in valid_docs.items():
        write(f"validation_{g}", ds)
    summary = {"size": size, "train_docs": len(train), "train_words_M": round(words / 1e6, 2),
               "genre_share_%": {g: round(100 * w / words, 1) for g, w in by_genre.items()},
               "source_words_M": {s: round(w / 1e6, 3) for s, w in sorted(by_source.items())}}
    (out / "summary.json").write_text(json.dumps(summary, indent=1))
    print(json.dumps(summary, indent=1))


if __name__ == "__main__":
    main()