"""Read the subset: iterate windows (optionally by subset or taxon) or draw random training crops.

  python og2load.py [--root .] [--split train] [--subset ncbi_eukaryotic_genomes] [--taxon "S__HOMO SAPIENS"] [--n 3]

Library use:
  from og2load import Windows
  ds = Windows(root, "train", taxon=r"P__CHORDATA")      # memory-maps every shard's .npy
  for codes, meta in ds:                                    # uint8 codes of one window + its index row and subset
      ...
  x = ds.random_crops(batch=8, length=4096, rng=np.random.default_rng(0))   # [8, 4096] uint8, length-weighted

Codes: low 3 bits A=0 C=1 G=2 T=3 N=4, bit 7 (0x80) = lowercase (soft-masked repeat); `codes & 7` drops case.
"""

from __future__ import annotations

import argparse
import json
import re
from collections.abc import Iterator
from pathlib import Path

import numpy as np


class Windows:
    def __init__(self, root: Path | str, split: str, subset: str | None = None, taxon: str | None = None) -> None:
        root = Path(root)
        sel_path = root / split / "selected.json"
        sel = json.loads(sel_path.read_text())["shards"] if sel_path.exists() else None
        pat = re.compile(taxon) if taxon else None
        self.items: list[tuple[np.ndarray, dict]] = []
        for npy in sorted((root / split).glob("*/*.npy")):
            sub = npy.parent.name
            if subset and sub != subset:
                continue
            key = str(npy.with_suffix("").relative_to(root))
            rows = [json.loads(line) for line in npy.with_suffix(".jsonl").read_text().splitlines()]
            keep = range(len(rows)) if sel is None else sel.get(key, [])
            arr = np.load(npy, mmap_mode="r")
            for i in keep:
                r = rows[i]
                if pat is None or pat.search(r["tag"]):
                    self.items.append((arr, {**r, "subset": sub, "shard": key}))
        self.lengths = np.array([m["len"] for _, m in self.items], dtype=np.int64)

    def __len__(self) -> int:
        return len(self.items)

    def __iter__(self) -> Iterator[tuple[np.ndarray, dict]]:
        for arr, m in self.items:
            yield np.asarray(arr[m["offset"]: m["offset"] + m["len"]]), m

    def random_crops(self, batch: int, length: int, rng: np.random.Generator) -> np.ndarray:
        """Crops of `length` bases from windows chosen with probability proportional to their usable length."""
        usable = np.maximum(self.lengths - length + 1, 0)
        if usable.sum() == 0:
            raise ValueError(f"no window has {length} bases")
        idx = rng.choice(len(self.items), size=batch, p=usable / usable.sum())
        out = np.empty((batch, length), dtype=np.uint8)
        for j, i in enumerate(idx):
            arr, m = self.items[i]
            s = m["offset"] + int(rng.integers(0, usable[i]))
            out[j] = arr[s: s + length]
        return out


def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--root", default=".")
    ap.add_argument("--split", default="train")
    ap.add_argument("--subset", default=None)
    ap.add_argument("--taxon", default=None, help="regex on the window's taxonomy tag, e.g. 'S__HOMO SAPIENS'")
    ap.add_argument("--n", type=int, default=3)
    a = ap.parse_args()
    ds = Windows(a.root, a.split, a.subset, a.taxon)
    print(f"{len(ds)} windows, {int(ds.lengths.sum()):,} bases")
    up, low = np.frombuffer(b"ACGTN", dtype=np.uint8), np.frombuffer(b"acgtn", dtype=np.uint8)
    for k, (codes, m) in enumerate(ds):
        if k >= a.n:
            break
        s = np.where(codes & 0x80, low[codes & 7], up[codes & 7]).astype(np.uint8).tobytes().decode()
        print(f"{m['subset']} {m['len']} bp {m['tag'][:90]}\n  {s[:100]}...")


if __name__ == "__main__":
    main()