"""Shared helpers for the published RHD shared-v1.0 tools."""
from pathlib import Path
import codecs, collections, hashlib, io, json, pickle, subprocess

import imageio_ffmpeg
import numpy as np
import torch

SCRIPT_DIR = Path(__file__).resolve().parent
RELEASE_ROOT = SCRIPT_DIR.parent
DATASET_ROOT = RELEASE_ROOT.parent
RAW_ROOT = DATASET_ROOT / "raw" / "data"
TMP_ROOT = DATASET_ROOT / "tmp" / "rhd-tools"
FFMPEG = imageio_ffmpeg.get_ffmpeg_exe()
FF = FFMPEG

def load(path):
    return json.loads(Path(path).read_text(encoding="utf-8"))

def save(path, value):
    path = Path(path); path.parent.mkdir(parents=True, exist_ok=True)
    tmp = path.with_suffix(path.suffix + ".tmp")
    tmp.write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False), encoding="utf-8")
    tmp.replace(path)

def write_jsonl(path, rows):
    path = Path(path); path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text("".join(json.dumps(x, ensure_ascii=False, allow_nan=False) + "\n" for x in rows), encoding="utf-8")

def save_tensor(path, value):
    path = Path(path); path.parent.mkdir(parents=True, exist_ok=True)
    torch.save(torch.as_tensor(np.asarray(value).copy()), path)

lines = write_jsonl
tensor = save_tensor

def ffmpeg(args, data=None):
    result = subprocess.run([FFMPEG, "-v", "error", "-y", *map(str, args)], input=data, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    if result.returncode:
        raise RuntimeError(result.stderr.decode(errors="replace"))
    return result.stdout

def storage(profile, codec, pixel_format, size, source_lossy, parameters):
    version = ffmpeg(["-version"]).decode().splitlines()[0]
    return {"profile": profile, "codec": codec, "pixel_format": pixel_format,
            "encoded_size": size, "source_lossy": source_lossy,
            "decoder": version, "encoder_parameters": parameters}

class RestrictedUnpickler(pickle.Unpickler):
    def find_class(self, module, name):
        allowed = {
            ("numpy.core.multiarray", "_reconstruct"): np.core.multiarray._reconstruct,
            ("numpy._core.multiarray", "_reconstruct"): np.core.multiarray._reconstruct,
            ("numpy", "ndarray"): np.ndarray, ("numpy", "dtype"): np.dtype,
            ("numpy.core.numeric", "_frombuffer"): np.core.numeric._frombuffer,
            ("numpy._core.numeric", "_frombuffer"): np.core.numeric._frombuffer,
            ("_codecs", "encode"): codecs.encode,
            ("collections", "OrderedDict"): collections.OrderedDict,
        }
        if (module, name) not in allowed:
            raise pickle.UnpicklingError(f"Unsupported class: {module}.{name}")
        return allowed[(module, name)]

Restricted = RestrictedUnpickler

class View:
    def __init__(self, dataset, sequence, camera, frame_ids, size, source, kind="image", split="unknown"):
        assert dataset == "RHD" and camera == "camera" and kind == "image"
        self.root = RELEASE_ROOT
        self.path = RELEASE_ROOT / "data" / sequence / camera
        self.path.mkdir(parents=True, exist_ok=True)
        self.count = len(frame_ids)
        archive = Path(source["archive"]).name
        self.source = dict(source)
        self.checks = []
        self.meta = {
            "schema_version": "hand-warehouse/1.0", "dataset_id": "RHD",
            "release_id": "shared-v1.0", "sequence_id": sequence, "camera_id": "camera",
            "sample_type": "image", "num_frames": self.count,
            "hand_slots": ["left", "right"], "split": split,
            "split_scheme": "RHD_official_training_evaluation",
            "split_source_locator": {"archive": "raw/data/" + archive, "member_prefix": split + "/"},
            "sampling": {"type": "independent", "source_fps": None, "frames_ref": "camera/frames.jsonl",
                         "shard_max_images": 512,
                         "selection": "all source independent images sorted by source ID"},
            "camera": {"model": "unknown", "schema_id": None, "image_size": size},
            "components": {}, "storage_revision": "lossless-video-2026-09-18"}
        self.frames = [{"frame_index": i, "source_frame_id": str(fid), "timestamp_ns": None,
                        "clock_domain": None, "source_locator": {**self.source, "source_frame_id": str(fid)}}
                       for i, fid in enumerate(frame_ids)]

    @property
    def p(self): return self.path
    @property
    def T(self): return self.count
    @property
    def m(self): return self.meta

    def add(self, name, ref, schema, axes, valid, method="source values retained", **metadata):
        valid_ref = Path(ref).with_name(Path(ref).stem + "_valid.pt").as_posix()
        save_tensor(self.path / valid_ref, valid)
        self.meta["components"][name] = {
            "available": True, "schema_id": schema, "data_ref": ref, "axes": axes,
            "valid_ref": valid_ref, "valid_axes": axes[:np.asarray(valid).ndim],
            "provenance": {"kind": "format_conversion", "method": method},
            "source_locator": dict(self.source), **metadata}

    def array(self, name, ref, schema, value, valid, axes, **metadata):
        value = np.asarray(value, np.float32).copy(); valid = np.asarray(valid, bool)
        assert value.shape[:valid.ndim] == valid.shape and value.shape[0] == self.count
        assert np.isfinite(value[valid]).all()
        value[~valid] = np.nan; save_tensor(self.path / ref, value)
        self.add(name, ref, schema, axes, valid, **metadata)
        restored = torch.load(self.path / ref, map_location="cpu", weights_only=True).numpy()
        assert np.array_equal(restored, value, equal_nan=True)
        self.checks.append({"test": "tensor_serialization_exact", "file": ref,
                            "shape": list(value.shape), "valid_count": int(valid.sum())})

    def intrinsic(self, value):
        self.meta["camera"].update(model="pinhole", schema_id="camera/pinhole/v1")
        self.array("intrinsic", "camera/intrinsic.pt", "camera/pinhole/v1", value,
                   np.ones(self.count, bool), ["T", "row", "column"])

    def finish(self):
        write_jsonl(self.path / "camera/frames.jsonl", self.frames)
        save(self.path / "metainfo.json", self.meta)
        save(TMP_ROOT / "checks" / f'{self.meta["sequence_id"]}__camera.checks.json',
             {"checks": self.checks, "frames": self.count, "input": self.source})

def sha256(path):
    h = hashlib.sha256()
    with Path(path).open("rb") as stream:
        for block in iter(lambda: stream.read(8 << 20), b""): h.update(block)
    return h.hexdigest()