import shutil
import av
import argparse
from pathlib import Path

import traceback

import h5py

from lerobot.datasets.dataset_metadata import LeRobotDatasetMetadata
from lerobot.datasets.lerobot_dataset import LeRobotDataset

import tqdm

TRANSFORM_FIELDS = ('camera', 'hip', 'leftArm', 'leftForearm', 'leftHand', 'leftIndexFingerIntermediateBase', 'leftIndexFingerIntermediateTip', 'leftIndexFingerKnuckle', 'leftIndexFingerMetacarpal', 'leftIndexFingerTip', 'leftLittleFingerIntermediateBase', 'leftLittleFingerIntermediateTip', 'leftLittleFingerKnuckle', 'leftLittleFingerMetacarpal', 'leftLittleFingerTip', 'leftMiddleFingerIntermediateBase', 'leftMiddleFingerIntermediateTip', 'leftMiddleFingerKnuckle', 'leftMiddleFingerMetacarpal', 'leftMiddleFingerTip', 'leftRingFingerIntermediateBase', 'leftRingFingerIntermediateTip', 'leftRingFingerKnuckle', 'leftRingFingerMetacarpal', 'leftRingFingerTip', 'leftShoulder', 'leftThumbIntermediateBase', 'leftThumbIntermediateTip', 'leftThumbKnuckle', 'leftThumbTip', 'neck1', 'neck2', 'neck3', 'neck4', 'rightArm', 'rightForearm', 'rightHand', 'rightIndexFingerIntermediateBase', 'rightIndexFingerIntermediateTip', 'rightIndexFingerKnuckle', 'rightIndexFingerMetacarpal', 'rightIndexFingerTip', 'rightLittleFingerIntermediateBase', 'rightLittleFingerIntermediateTip', 'rightLittleFingerKnuckle', 'rightLittleFingerMetacarpal', 'rightLittleFingerTip', 'rightMiddleFingerIntermediateBase', 'rightMiddleFingerIntermediateTip', 'rightMiddleFingerKnuckle', 'rightMiddleFingerMetacarpal', 'rightMiddleFingerTip', 'rightRingFingerIntermediateBase', 'rightRingFingerIntermediateTip', 'rightRingFingerKnuckle', 'rightRingFingerMetacarpal', 'rightRingFingerTip', 'rightShoulder', 'rightThumbIntermediateBase', 'rightThumbIntermediateTip', 'rightThumbKnuckle', 'rightThumbTip', 'spine1', 'spine2', 'spine3', 'spine4', 'spine5', 'spine6', 'spine7')

EGODEX_FPS = 30

class EgoDexToLeRobotReader:
    def __init__(self, file_path_stem: Path):
        self.file_path_stem = file_path_stem

        self.file = h5py.File(self.file_path_stem.with_suffix(".hdf5"), "r")
        self.av_container = av.open(self.file_path_stem.with_suffix(".mp4"))
        self.video_frame_iter = self.av_container.decode(video=0)
    
        which_llm_description = self.file.attrs['which_llm_description'] if 'which_llm_description' in self.file.attrs else '1'
        if which_llm_description == '1':
            which_llm_description = ''
        self.llm_description = self.file.attrs[f"llm_description{which_llm_description}"]
        self.task = f"{self.file.attrs['task']}: {self.llm_description}"

        self.camera_intrinsics = self.file['camera']['intrinsic'][:]

        self.current_idx = 0
    
    def __iter__(self): 
        return self

    def __next__(self) -> dict:
        if self.current_idx >= len(self):
            self.file.close()
            self.av_container.close()
            raise StopIteration

        frame = {
            'observation.images.camera': next(self.video_frame_iter).to_ndarray(True, format="rgb24"),
            **{
                f"observation.state.{field}": v[self.current_idx] for field, v in self.file['transforms'].items()
            },
            # **{
            #     f"{field}_confidence": v[self.current_idx:self.current_idx+1] for field, v in self.file['confidences'].items()
            # },
            'camera_intrinsics': self.camera_intrinsics,
            "task": self.task
        }
        self.current_idx += 1
        return frame
    
    def __len__(self) -> int:
        return self.file['transforms']['camera'].shape[0]

SE3_AXES = [
    "r00", "r01", "r02", "t_x",
    "r10", "r11", "r12", "t_y",
    "r20", "r21", "r22", "t_z",
    "zero0", "zero1", "zero2", "one",
]

transform_features = {
    f"observation.state.{field}": {
        "dtype": "float32",
        "shape": (4, 4),
        "names": {
            "axes": SE3_AXES,
        },
    }
    for field in TRANSFORM_FIELDS
}
# confidence_features = {
#     f"{field}_confidence": {
#         "dtype": "float32",
#         "shape": (1,),
#         "names": None,
#     }
#     for field in CONFIDENCE_FIELDS
# }
camera_features = {
    "camera_intrinsics": {
        "dtype": "float32",
        "shape": (3, 3),
        "names": None,
    }
}
video_features = {
    "observation.images.camera": {
        "dtype": "video",
        "shape": (1080, 1920, 3),
        "names": [
            "height",
            "width",
            "channels",
        ],
    }
}
egodex_features = {
    **video_features,
    **transform_features,
    **camera_features,
    # **confidence_features,
}


def port_egodex_subset(
    raw_dir: Path,
    output_dir: Path,
):
    if output_dir.exists():
        print(f"Removing existing output directory: {output_dir}")
        shutil.rmtree(output_dir)

    lerobot_dataset = LeRobotDataset.create(
        repo_id=f"egodex/{raw_dir.name}",
        fps=EGODEX_FPS,
        features=egodex_features,
        root=output_dir,
    )

    video_file_basenames = {p.stem for p in raw_dir.glob("*.mp4")}
    h5_file_basenames = {p.stem for p in raw_dir.glob("*.hdf5")}
    if video_file_basenames != h5_file_basenames:
        raise ValueError(f"Video and h5 file basenames do not match: {video_file_basenames} != {h5_file_basenames}")

    for video_file_basename in tqdm.tqdm(sorted(video_file_basenames), desc="Processing episodes", mininterval=10):
        for frame in EgoDexToLeRobotReader(raw_dir / f"{video_file_basename}"):
            lerobot_dataset.add_frame(frame)
        lerobot_dataset.save_episode()

    lerobot_dataset.finalize()

    validate_dataset(f"egodex/{raw_dir.name}", output_dir)

def validate_dataset(repo_id, root: Path):
    """Sanity check that ensure meta data can be loaded and all files are present."""
    meta = LeRobotDatasetMetadata(repo_id, root=root)

    if meta.total_episodes == 0:
        raise ValueError("Number of episodes is 0.")

    for ep_idx in range(meta.total_episodes):
        data_path = meta.root / meta.get_data_file_path(ep_idx)

        if not data_path.exists():
            raise ValueError(f"Parquet file is missing in: {data_path}")

        for vid_key in meta.video_keys:
            vid_path = meta.root / meta.get_video_file_path(ep_idx, vid_key)
            if not vid_path.exists():
                raise ValueError(f"Video file is missing in: {vid_path}")


def main():
    parser = argparse.ArgumentParser()

    parser.add_argument(
        "raw_dir",
        type=Path,
        help="Directory containing input raw datasets (e.g. `path/to/dataset` or `path/to/dataset/version`).",
    )
    parser.add_argument(
        "output_dir",
        type=Path,
        help="Directory to write the output dataset to.",
    )

    args = parser.parse_args()

    try:
        port_egodex_subset(**vars(args))
    except:
        with open(args.output_dir / "error.txt", "w") as f:
            f.write(traceback.format_exc())
        raise

if __name__ == "__main__":
    main()