#!/usr/bin/env python3
"""Materialize the ISR-standardized teleop set as a native LeRobot v3.0 dataset.

`teleop_std_poc` only emits npz + report artifacts; SmolVLA needs a real dataset. This takes
    source frames : /workspace/mm_teleop            (LeRobot v3.0, SO-101, 30 fps)
    kept indices  : /workspace/std_mm_teleop/out/isr/ep{N}.npz  ["keep"]
and writes the kept frames — parquet rows AND the matching video frames — as a new v3.0 tree.

TIME: ISR frames are non-uniform in real time, so the original timestamps cannot be carried over
(LeRobot enforces timestamp ≈ frame_index / fps within tolerance_s). Frames are renumbered onto a
uniform grid at the dataset's EFFECTIVE rate (30 fps / mean compression ≈ 10 fps), which keeps
episode durations within a few percent of the real ones. Pass --fps 30 to renumber at the source
rate instead (episodes then play ~3x fast).

Videos are decoded sequentially per camera file (episodes are contiguous and ordered inside them),
so each source frame is touched exactly once.
"""
import argparse
import json
import os
import time
from pathlib import Path

os.environ.setdefault("HF_HUB_OFFLINE", "1")
os.environ.setdefault("HF_DATASETS_OFFLINE", "1")

import av
import numpy as np
import pyarrow.parquet as pq

from lerobot.datasets.lerobot_dataset import LeRobotDataset

SRC = Path("/workspace/mm_teleop")
ISR = Path("/workspace/std_mm_teleop/out/isr")
OUT = Path("/workspace/std_mm_teleop/lerobot_v30")


class CamReader:
    """Sequential decoder over one camera's concatenated v3.0 video files."""

    def __init__(self, root: Path, cam: str):
        self.dir = root / "videos" / cam / "chunk-000"
        self.file_index = None
        self.container = None
        self.iter = None

    def _open(self, file_index: int):
        if self.container is not None:
            self.container.close()
        path = self.dir / f"file-{file_index:03d}.mp4"
        self.container = av.open(str(path))
        self.iter = self.container.decode(video=0)
        self.file_index = file_index

    def take(self, file_index: int, count: int, keep_local: set[int]) -> dict[int, np.ndarray]:
        """Consume `count` frames of that file, returning only the ones in keep_local."""
        if file_index != self.file_index:
            self._open(file_index)
        out = {}
        for i in range(count):
            frame = next(self.iter)
            if i in keep_local:
                out[i] = frame.to_ndarray(format="rgb24")
        return out

    def close(self):
        if self.container is not None:
            self.container.close()


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--fps", type=int, default=0, help="0 = effective rate (source fps / compression)")
    ap.add_argument("--repo-id", default="angkul07/std_mm_teleop")
    ap.add_argument("--out", default=str(OUT))
    ap.add_argument("--limit", type=int, default=0, help="debug: only N episodes")
    a = ap.parse_args()

    out_root = Path(a.out)
    if out_root.exists():
        raise SystemExit(f"{out_root} exists — remove it first")

    info = json.loads((SRC / "meta" / "info.json").read_text())
    src_fps = int(info["fps"])
    features = {k: dict(v, shape=tuple(v["shape"]))   # info.json stores lists; validation wants tuples
                for k, v in info["features"].items()
                if k in ("action", "observation.state") or k.startswith("observation.images")}
    cams = [k for k in features if k.startswith("observation.images")]

    ep_meta = pq.read_table(SRC / "meta" / "episodes" / "chunk-000" / "file-000.parquet").to_pydict()
    n_eps = len(ep_meta["episode_index"])
    data = pq.read_table(SRC / "data" / "chunk-000" / "file-000.parquet")
    state_all = np.array(data["observation.state"].to_pylist(), dtype=np.float32)
    action_all = np.array(data["action"].to_pylist(), dtype=np.float32)
    task_by_index = dict(zip(*pq.read_table(SRC / "meta" / "tasks.parquet").to_pydict().values()))
    task_index_all = np.array(data["task_index"].to_pylist())

    keeps = {}
    for ep in range(n_eps):
        keeps[ep] = np.load(ISR / f"ep{ep}.npz")["keep"].astype(int)
    kept_total = sum(len(v) for v in keeps.values())
    src_total = int(info["total_frames"])
    compression = src_total / kept_total
    fps = a.fps or max(1, round(src_fps / compression))
    print(f"{src_total} -> {kept_total} frames ({100*kept_total/src_total:.1f}%), "
          f"compression {compression:.2f}x -> writing at {fps} fps "
          f"({'effective rate' if not a.fps else 'forced'})")

    ds = LeRobotDataset.create(
        repo_id=a.repo_id, fps=fps, features=features, root=out_root,
        robot_type=info.get("robot_type"), use_videos=True,
        image_writer_processes=0, image_writer_threads=4, vcodec="h264",
    )

    readers = {c: CamReader(SRC, c) for c in cams}
    t0 = time.time()
    todo = n_eps if not a.limit else min(a.limit, n_eps)
    for ep in range(todo):
        lo, hi = ep_meta["dataset_from_index"][ep], ep_meta["dataset_to_index"][ep]
        length = hi - lo
        keep = keeps[ep]
        keep_set = set(keep.tolist())
        frames = {}
        for cam in cams:
            fi = ep_meta[f"videos/{cam}/file_index"][ep]
            frames[cam] = readers[cam].take(fi, length, keep_set)
            if len(frames[cam]) != len(keep):
                raise SystemExit(f"ep{ep} {cam}: got {len(frames[cam])} frames, expected {len(keep)}")
        task = task_by_index[int(task_index_all[lo])]
        for j in keep:
            ds.add_frame({
                "observation.state": state_all[lo + j],
                "action": action_all[lo + j],
                **{c: frames[c][int(j)] for c in cams},
                "task": task,
            })
        ds.save_episode()
        if ep % 10 == 0 or ep == todo - 1:
            el = time.time() - t0
            print(f"  ep{ep:>3}: {length} -> {len(keep)} frames | {el:.0f}s elapsed, "
                  f"eta {el/(ep+1)*(todo-ep-1):.0f}s", flush=True)

    for r in readers.values():
        r.close()
    print(f"done in {time.time()-t0:.0f}s -> {out_root}")


if __name__ == "__main__":
    main()