"""Read Astra/RoboDojo releases without a simulator, GPU, pickle, or ZIP extraction."""
from __future__ import annotations

from dataclasses import dataclass
import hashlib
import io
import json
from pathlib import Path
import zipfile

import numpy as np


CAMERAS = ('cam_high', 'cam_left_wrist', 'cam_right_wrist')


def sha256(path):
    digest = hashlib.sha256()
    with Path(path).open('rb') as stream:
        for chunk in iter(lambda: stream.read(8 * 1024 * 1024), b''):
            digest.update(chunk)
    return digest.hexdigest()


def arrays(data):
    with np.load(io.BytesIO(data), allow_pickle=False) as archive:
        return {name: archive[name] for name in archive.files}


def safe_path(root, relative):
    path = (root / relative).resolve()
    if Path(relative).is_absolute() or not path.is_relative_to(root.resolve()):
        raise ValueError('Dataset path escapes root')
    return path


class Dataset:
    def __init__(self, directory):
        self.root = Path(directory).resolve()
        self.manifest = json.loads((self.root / 'manifest.json').read_text())
        if self.manifest['schema'] != 'astra.robodojo.dataset.v1':
            raise ValueError('Unsupported release schema')
        self.episodes = self.manifest['episodes']
        if len({r['episode_id'] for r in self.episodes}) != len(self.episodes):
            raise ValueError('Duplicate episode identifiers')

    def select(self, method=None, task=None):
        return [r for r in self.episodes if (method is None or r['method'] == method)
                and (task is None or r['task'] == task)]

    def open(self, episode_id, verify=False):
        record = next(r for r in self.episodes if r['episode_id'] == episode_id)
        return Episode(self.root, record, verify=verify)

    def verify_files(self, include_observations=False):
        for record in self.episodes:
            for name, info in record['files'].items():
                if name == 'observations' and not include_observations:
                    continue
                path = safe_path(self.root, info['path'])
                if path.stat().st_size != info['bytes'] or sha256(path) != info['sha256']:
                    raise ValueError('File checksum mismatch: ' + info['path'])


@dataclass
class Decision:
    episode: 'Episode'
    record: dict

    @property
    def index(self):
        return self.record['decision']

    @property
    def executed_actions(self):
        return self.episode.trajectory['actions'][self.record['start_tick']:self.record['end_tick']]

    @property
    def pi05_proposal(self):
        """Both raw_actions and gripper-clipped actions; None for direct control."""
        member = self.record.get('proposal_member')
        return arrays(self.episode.core.read(member)) if member else None

    @property
    def eef_targets(self):
        """Per-step targets actually attempted, including IK diagnostics; [] for student."""
        return self.record.get('correction_trace', [])

    @property
    def requested_response(self):
        return self.record['response']

    def observation(self, images='preview'):
        return self.episode.observation(self.record['start_tick'], images=images,
                                        observation_index=self.record['observation_index'])


class Episode:
    def __init__(self, root, record, verify=False):
        self.root, self.record = Path(root), record
        info = record['files']['core']
        path = safe_path(self.root, info['path'])
        if verify and (path.stat().st_size != info['bytes'] or sha256(path) != info['sha256']):
            raise ValueError('Core checksum mismatch')
        self.core = zipfile.ZipFile(path)
        self.metadata = self.read_json('episode.json')
        self.trajectory = arrays(self.core.read('trajectory.npz'))
        self.observation_index = self.read_json('observation_index.json')
        self._decisions = self.read_jsonl('decisions.jsonl')
        self._raw = None

    def read_json(self, member):
        return json.loads(self.core.read(member))

    def read_jsonl(self, member):
        return [json.loads(line) for line in self.core.read(member).splitlines() if line.strip()]

    @property
    def decisions(self):
        return [Decision(self, row) for row in self._decisions]

    def observation(self, step, images='none', observation_index=None):
        """s[t] is before action[t]. Raw camera arrays require the optional full ZIP."""
        if not 0 <= step <= self.metadata['control_steps']:
            raise IndexError(step)
        if images == 'raw':
            return self.raw_observation(step)
        if images not in {'none', 'preview'}:
            raise ValueError('images must be none, preview, or raw')
        result = {k: v[step] for k, v in self.trajectory.items()
                  if k in ('states', 'eef_positions', 'eef_quaternions_wxyz', 'remaining_steps', 'instruction')}
        if images == 'preview':
            from PIL import Image
            matches = [r for r in self.observation_index if r['step_id'] == step
                       and (observation_index is None or r['index'] == observation_index)]
            if not matches:
                raise ValueError('No decision-time preview at this control step; use images="raw"')
            for camera, member in matches[0]['preview_members'].items():
                with Image.open(io.BytesIO(self.core.read(member))) as img:
                    result[camera] = np.asarray(img.convert('RGB')).copy()
        return result

    def raw_observation(self, step):
        if not 0 <= step <= self.metadata['control_steps']:
            raise IndexError(step)
        if self._raw is None:
            info = self.record['files'].get('observations')
            if info is None:
                raise FileNotFoundError('This export has no full-resolution observation bundle')
            self._raw = zipfile.ZipFile(safe_path(self.root, info['path']))
        return arrays(self._raw.read(f'observations/{step:06d}.npz'))

    def close(self):
        self.core.close()
        if self._raw is not None:
            self._raw.close()

    def __enter__(self):
        return self

    def __exit__(self, *args):
        self.close()