"""SHADOW picture codes for video: frames at 1 per second (at most 64), repeated frames dropped, the int8 eye run in fp16, 512-bit codes
sign(W^T (v - pic_mu)), written as shards (codes, image index, captions, text token counts).

Needs eye_int8.safetensors and shadow_table_v1.npz from the SHADOW release."""
import io, json, math, pathlib, tarfile, zipfile
import numpy as np, torch
from PIL import Image
from safetensors.torch import load_file
from transformers import AutoTokenizer

BUDGETS = (70, 140, 280, 560, 1120)
VIDEO_EXT = (".mp4", ".mov", ".mkv", ".webm", ".avi")


def budget(w, h, cap=140):
    native = max(w * h / 2304, 1.0)
    return min((b for b in BUDGETS if b <= cap), key=lambda b: abs(math.log(b / native)))


def fwht256(x):
    s = x.shape
    x = x.reshape(-1, 256).clone()
    h = 1
    while h < 256:
        x = x.view(-1, 256 // (2 * h), 2, h)
        a, c = x[:, :, 0, :].clone(), x[:, :, 1, :].clone()
        x[:, :, 0, :], x[:, :, 1, :] = a + c, a - c
        x = x.view(-1, 256)
        h *= 2
    return x.view(s)


def int8_weight(qweight, qscale):
    n, k = qweight.shape
    g = torch.Generator().manual_seed(k)
    sign = (torch.randint(0, 2, (k,), generator=g) * 2 - 1).float()
    w = (qweight.float().view(n, k // 256, 256) * qscale.float()[:, :, None]).reshape(n, k)
    return fwht256(w) / 16.0 * sign[None]


class Eye:
    def __init__(self, eye_path, table_path, dev="cuda"):
        from sentence_transformers import SentenceTransformer
        st = SentenceTransformer("google/embeddinggemma-2", device=dev, model_kwargs={"torch_dtype": torch.float32})
        self.hf, self.ip, self.dev = st[0].model, st[0].processor.image_processor, dev
        f = load_file(eye_path)
        self.hf.load_state_dict({k: v for k, v in f.items() if not k.endswith((".qweight", ".qscale"))}, strict=False)
        mods = dict(self.hf.named_modules())
        with torch.no_grad():
            for k in f:
                if k.endswith(".qweight"):
                    lin = mods[k[:-8]]
                    lin.weight.copy_(int8_weight(f[k], f[k[:-8] + ".qscale"]).to(lin.weight.device))
        self.hf.eval()
        z = np.load(table_path)
        self.W = torch.from_numpy(z["W"]).float().to(dev)
        self.mu = torch.from_numpy(z["pic_mu"]).float().to(dev)

    @torch.no_grad()
    def codes(self, images, budgets):
        out, groups = [None] * len(images), {}
        for i, b in enumerate(budgets):
            groups.setdefault(b, []).append(i)
        for b, idx in groups.items():
            x = self.ip([images[i] for i in idx], max_soft_tokens=b, return_tensors="pt")
            with torch.autocast("cuda", dtype=torch.float16, enabled=self.dev != "cpu"):
                r = self.hf.get_image_features(pixel_values=x["pixel_values"].to(self.dev),
                                               image_position_ids=x["image_position_ids"].to(self.dev)).pooler_output
            for i, v in zip(idx, r):
                v = v.float()
                v = v / v.norm(dim=1, keepdim=True)
                out[i] = np.packbits(((v - self.mu) @ self.W >= 0).cpu().numpy(), axis=1)
        return out


def drop_repeats(fr, times, same=4.0):
    keep, kt, last = [], [], None
    for f, t in zip(fr, times):
        g = np.asarray(f.convert("L").resize((32, 32), Image.BILINEAR), np.float32)
        if last is not None and np.abs(g - last).mean() < same:
            continue
        keep.append(f)
        kt.append(t)
        last = g
    return keep, kt


def frames(video, cap=64):
    import av
    c = av.open(io.BytesIO(video))
    s = c.streams.video[0]
    s.thread_type = "AUTO"
    dur = float(s.duration * s.time_base) if s.duration else float((c.duration or 0) / 1e6)
    if dur > 2 * cap:
        s.codec_context.skip_frame = "NONKEY"
    n = min(cap, max(1, int(dur)))
    want = [dur * (i + 0.5) / n for i in range(n)]
    out, times, k = [], [], 0
    for f in c.decode(s):
        t = float(f.pts * s.time_base) if f.pts is not None else 0.0
        if k < n and t >= want[k]:
            im = f.to_image().convert("RGB")
            while k < n and t >= want[k]:
                out.append(im)
                times.append(round(t, 2))
                k += 1
        if k >= n:
            break
    c.close()
    out, times = drop_repeats(out, times)
    return out, times, round(dur, 2)


def videos_in(path):
    if zipfile.is_zipfile(path):
        with zipfile.ZipFile(path) as z:
            for n in z.namelist():
                if n.lower().endswith(VIDEO_EXT):
                    yield n, z.read(n)
    else:
        with tarfile.open(path, "r:*") as t:
            for m in t:
                if m.isfile() and m.name.lower().endswith(VIDEO_EXT):
                    yield m.name, t.extractfile(m).read()


def stem(p):
    return pathlib.Path(p).name.rsplit(".", 1)[0]


def strings(x):
    if isinstance(x, str):
        return [x]
    if isinstance(x, dict):
        return [t for v in x.values() for t in strings(v)]
    if isinstance(x, (list, tuple)):
        return [t for v in x for t in strings(v)]
    return []


class Shards:
    def __init__(self, out, name, shard_tokens=4_000_000):
        self.dir = pathlib.Path(out) / name
        self.dir.mkdir(parents=True, exist_ok=True)
        self.name, self.shard_tokens, self.k = name, shard_tokens, 0
        self.tok = AutoTokenizer.from_pretrained("google/embeddinggemma-2")
        self._reset()

    def _reset(self):
        self.codes, self.img, self.lines, self.text, self.off = [], [], [], [], 0

    def add(self, sid, codes, budgets, sizes, texts, times, src):
        idx = []
        for c, b, (w, h) in zip(codes, budgets, sizes):
            self.codes.append(c)
            self.img.append((self.off, len(c), b, w, h))
            idx.append(len(self.img) - 1)
            self.off += len(c)
        self.text += [t for t in strings(texts) if t]
        self.lines.append(json.dumps({"id": sid, "src": src, "images": idx, "kind": "frame", "times": times, "texts": texts}, ensure_ascii=False, default=str))
        if self.off >= self.shard_tokens:
            self.write()

    def write(self):
        if not self.lines:
            return
        stem_ = self.dir / f"{self.name}_{self.k:05d}"
        np.savez_compressed(f"{stem_}.npz", codes=np.concatenate(self.codes), img=np.array(self.img, np.int64))
        counts = np.zeros(262144, np.int64)
        for ids in self.tok(self.text, add_special_tokens=False)["input_ids"] if self.text else []:
            counts += np.bincount(ids, minlength=262144)[:262144]
        np.savez_compressed(f"{stem_}.counts.npz", counts=counts.astype(np.uint32))
        pathlib.Path(f"{stem_}.jsonl").write_text("\n".join(self.lines) + "\n", encoding="utf-8")
        print(f"{stem_.name}: {len(self.lines)} videos, {self.off:,} picture tokens", flush=True)
        self._reset()
        self.k += 1


def encode_archive(eye, shards, path, ann, key, name, src):
    """every video in an archive that has annotations: frames, codes, one line each"""
    for n, b in videos_in(path):
        recs = ann.get(key(n))
        if not recs:
            continue
        try:
            fr, times, dur = frames(b)
        except Exception:
            continue
        bud = [budget(*im.size) for im in fr]
        shards.add(f"{name}/{n}", eye.codes(fr, bud), bud, [im.size for im in fr], recs, times, dict(src, member=n, duration=dur))