"""Read HandsOn measured observations, command chunks, three cameras and prompts."""
from bisect import bisect_right
from functools import lru_cache
from fractions import Fraction
import json
from pathlib import Path

from prompt_sampler import PromptSampler


class HandsOnDataset:
    def __init__(self, root, *, horizon=16, split="train", language_seed=0,
                 prompt_split=None, decode_images=True):
        self.root = Path(root)
        self.info = json.loads((self.root / "meta/info.json").read_text())
        self.rows = [json.loads(s) for s in
                     (self.root / "source_manifest.jsonl").read_text().splitlines()]
        assert split in ("train", "validation", "all")
        self.rows = [r for r in self.rows if split == "all" or r["split"] == split]
        self.horizon = int(horizon)
        assert self.horizon > 0
        self.language = PromptSampler(self.root / "language/prompt_paraphrases.json",
                                      seed=language_seed)
        self.prompt_split = prompt_split or ("train" if split == "train" else "canonical")
        self.decode_images = bool(decode_images)
        self.epoch = 0
        self.offsets = [0]
        for row in self.rows:
            assert row["representation"] == "world_palm_command_eef52_v1"
            self.offsets.append(self.offsets[-1] + row["frames"])

    def __len__(self):
        return self.offsets[-1]

    def set_epoch(self, epoch):
        """Set before constructing each epoch's loader/worker replicas."""
        self.epoch = int(epoch)

    @lru_cache(maxsize=8)
    def _numeric(self, relative):
        import numpy as np
        import pyarrow.parquet as pq
        table = pq.read_table(self.root / relative,
                              columns=["observation.state", "action", "timestamp", "frame_index"])
        result = {}
        for name in ("observation.state", "action"):
            result[name] = np.asarray(table[name].to_pylist(), dtype=np.float32)
        for name in ("timestamp", "frame_index"):
            result[name] = table[name].to_numpy()
        assert result["observation.state"].shape == result["action"].shape
        assert result["action"].shape[1] == 52
        assert np.isfinite(result["observation.state"]).all()
        assert np.isfinite(result["action"]).all()
        return result

    def _image(self, relative, source_frame):
        import av
        import numpy as np
        fps = self.info["fps"]
        with av.open(str(self.root / relative)) as container:
            stream = container.streams.video[0]
            target = Fraction(int(source_frame), fps)
            container.seek(int(target / stream.time_base), stream=stream,
                           backward=True, any_frame=False)
            for frame in container.decode(stream):
                at = frame.pts * stream.time_base
                if at + Fraction(1, fps * 2) < target:
                    continue
                assert abs(at - target) < Fraction(1, fps * 2), (
                    relative, source_frame, float(at))
                return np.asarray(frame.to_image(), dtype=np.uint8)
        raise RuntimeError(f"Missing frame {source_frame} in {relative}")

    def __getitem__(self, index):
        return self.sample(index, epoch=self.epoch)

    def sample(self, index, *, epoch, draw_index=0):
        import numpy as np
        index = int(index)
        if index < 0:
            index += len(self)
        if not 0 <= index < len(self):
            raise IndexError(index)
        ordinal = bisect_right(self.offsets, index) - 1
        row = self.rows[ordinal]
        frame = index - self.offsets[ordinal]
        numeric = self._numeric(row["data_path"])
        assert len(numeric["action"]) == row["frames"]
        end = min(frame + self.horizon, row["frames"])
        length = end - frame
        action = np.repeat(numeric["action"][end - 1:end], self.horizon, axis=0)
        action[:length] = numeric["action"][frame:end]
        padding = np.arange(self.horizon) >= length
        active = np.concatenate([np.repeat(side in row["active_sides"], 26)
                                 for side in ("right", "left")])
        sample = {
            "observation.state": numeric["observation.state"][frame].copy(),
            "action": action,
            "action_is_pad": padding,
            "active_dimension_mask": active,
            "episode_index": row["episode_index"],
            "frame_index": int(numeric["frame_index"][frame]),
            "timestamp": float(numeric["timestamp"][frame]),
            "source_task": row["source_task"],
        }
        sample.update(self.language.sample(
            row["source_task"], row["prompt"], row["episode_uid"],
            sample["frame_index"], epoch=epoch, draw_index=draw_index, split=self.prompt_split))
        if self.decode_images:
            for camera, relative in row["video_paths"].items():
                sample["observation.images." + camera] = self._image(
                    relative, sample["frame_index"])
        return sample