src/data/unified_dataset.py

"""
Unified multi-skeleton motion dataset for TopoSlots (Scheme C).

Motion representation:
  Slot token input : per-joint [local_pos(3) + velocity(3)] = 6D  (cross-skeleton)
  Decoder GT       : per-joint local_rotations_6d               (skeleton-specific, FK supervision)
  Root track       : root_position(3) + root_velocity(3)         (separate)
  Auxiliary        : foot_contact(4), bone_lengths, accelerations (losses)
"""

import numpy as np
import torch
from torch.utils.data import Dataset
from pathlib import Path
from typing import Optional


class UnifiedMotionDataset(Dataset):
    """
    Multi-skeleton motion dataset with unified format.

    Each sample returns:
        - motion_features: [T, J, D] padded to max_joints
        - skeleton_features: [J, D_skel] padded to max_joints
        - joint_mask: [J] boolean mask (True = valid joint)
        - adjacency: [J, J] padded adjacency matrix
        - geodesic_dist: [J, J] padded geodesic distances
        - text: str (empty if unavailable)
        - metadata: dict
    """

    def __init__(
        self,
        data_dirs: list[str | Path],
        split: str = 'train',
        max_joints: int = 128,
        max_frames: int = 196,
        target_fps: float = 20.0,
        motion_dim: int = 6,  # local_pos (3) + velocity (3)
    ):
        self.data_dirs = [Path(d) for d in data_dirs]
        self.split = split
        self.max_joints = max_joints
        self.max_frames = max_frames
        self.target_fps = target_fps
        self.motion_dim = motion_dim

        # Load all samples
        self.samples = []
        self.skeletons = {}  # skeleton_id -> skeleton data
        self.stats = {}  # skeleton_id -> normalization stats

        for data_dir in self.data_dirs:
            self._load_data_source(data_dir)

        print(f"UnifiedMotionDataset [{split}]: {len(self.samples)} motions, "
              f"{len(self.skeletons)} skeleton types")

    def _load_data_source(self, data_dir: Path):
        """Load one data source (e.g., processed/humanml3d)."""
        if not data_dir.exists():
            print(f"  Warning: {data_dir} not found, skipping")
            return

        # Load skeleton
        skel_path = data_dir / 'skeleton.npz'
        if skel_path.exists():
            skel_data = dict(np.load(skel_path, allow_pickle=True))
            skeleton_id = data_dir.name
            self.skeletons[skeleton_id] = skel_data

        # Load stats
        stats_path = data_dir / 'stats.npz'
        if stats_path.exists():
            self.stats[data_dir.name] = dict(np.load(stats_path))

        # Load split
        split_path = data_dir / 'splits' / f'{self.split}.txt'
        if not split_path.exists():
            # Fall back to all.txt
            split_path = data_dir / 'splits' / 'all.txt'
            if not split_path.exists():
                print(f"  Warning: no split file for {data_dir.name}, skipping")
                return

        motion_ids = []
        with open(split_path, 'r') as f:
            for line in f:
                line = line.strip()
                if line:
                    motion_ids.append(line)

        for mid in motion_ids:
            motion_path = data_dir / 'motions' / f'{mid}.npz'
            if motion_path.exists():
                self.samples.append({
                    'motion_path': str(motion_path),
                    'motion_id': mid,
                    'data_source': data_dir.name,
                    'skeleton_id': data_dir.name,
                })

    def __len__(self) -> int:
        return len(self.samples)

    def __getitem__(self, idx: int) -> dict:
        sample_info = self.samples[idx]

        # Load motion data
        data = dict(np.load(sample_info['motion_path'], allow_pickle=True))

        # Get skeleton info
        skeleton_id = sample_info['skeleton_id']
        skel_data = self.skeletons.get(skeleton_id, {})

        # Extract motion features
        local_pos = data['local_positions']  # [T, J, 3]
        velocities = data['velocities']       # [T, J, 3]
        T, J, _ = local_pos.shape

        # Normalize if stats available
        if skeleton_id in self.stats:
            stats = self.stats[skeleton_id]
            local_pos = (local_pos - stats['local_pos_mean']) / stats['local_pos_std']
            velocities = (velocities - stats['velocity_mean']) / stats['velocity_std']

        # Concatenate motion features: [T, J, 6]
        motion_features = np.concatenate([local_pos, velocities], axis=-1)

        # Crop/pad temporal dimension
        if T > self.max_frames:
            # Random crop during training
            if self.split == 'train':
                start = np.random.randint(0, T - self.max_frames)
            else:
                start = 0
            motion_features = motion_features[start:start + self.max_frames]
            actual_frames = self.max_frames
        else:
            actual_frames = T
            # Pad with zeros
            pad = np.zeros(
                (self.max_frames - T, J, self.motion_dim),
                dtype=np.float32,
            )
            motion_features = np.concatenate([motion_features, pad], axis=0)

        # Pad joint dimension
        padded_motion = np.zeros(
            (self.max_frames, self.max_joints, self.motion_dim),
            dtype=np.float32,
        )
        padded_motion[:, :J, :] = motion_features

        # Joint mask
        joint_mask = np.zeros(self.max_joints, dtype=np.bool_)
        joint_mask[:J] = True

        # Frame mask
        frame_mask = np.zeros(self.max_frames, dtype=np.bool_)
        frame_mask[:actual_frames] = True

        # Skeleton features
        skeleton_features = np.zeros(
            (self.max_joints, 9), dtype=np.float32
        )
        if 'joint_names' in skel_data:
            from .skeleton_graph import SkeletonGraph
            sg = SkeletonGraph.from_dict(skel_data)
            skel_feats = sg.get_joint_features()  # [J, 9]
            skeleton_features[:J] = skel_feats

        # Adjacency and geodesic distance matrices
        adjacency = np.zeros(
            (self.max_joints, self.max_joints), dtype=np.float32
        )
        geodesic_dist = np.zeros(
            (self.max_joints, self.max_joints), dtype=np.float32
        )
        if 'adjacency' in skel_data:
            adj = skel_data['adjacency']
            adjacency[:J, :J] = adj
        if 'geodesic_dist' in skel_data:
            gdist = skel_data['geodesic_dist']
            geodesic_dist[:J, :J] = gdist

        # Text
        text = ''
        if 'texts' in data:
            texts_str = str(data['texts'])
            if texts_str:
                text_list = texts_str.split('|||')
                if text_list and text_list[0]:
                    # Random text during training
                    if self.split == 'train':
                        text = text_list[np.random.randint(len(text_list))]
                    else:
                        text = text_list[0]

        # --- Root track (separate from slot tokens) ---
        root_pos = data.get('root_position', np.zeros((T, 3), dtype=np.float32))
        root_vel = data.get('root_velocity', np.zeros((T, 3), dtype=np.float32))
        padded_root_pos = np.zeros((self.max_frames, 3), dtype=np.float32)
        padded_root_vel = np.zeros((self.max_frames, 3), dtype=np.float32)
        padded_root_pos[:actual_frames] = root_pos[:actual_frames]
        padded_root_vel[:actual_frames] = root_vel[:actual_frames]

        # --- Foot contact: [T, 4] (l_heel, l_toe, r_heel, r_toe) ---
        fc_raw = data.get('foot_contact', np.zeros((T, 4), dtype=np.float32))
        if fc_raw.shape[-1] == 2:
            # Legacy 2-channel → duplicate into 4-channel
            fc_4ch = np.zeros((fc_raw.shape[0], 4), dtype=np.float32)
            fc_4ch[:, 0] = fc_4ch[:, 1] = fc_raw[:, 0]
            fc_4ch[:, 2] = fc_4ch[:, 3] = fc_raw[:, 1]
            fc_raw = fc_4ch
        padded_contact = np.zeros((self.max_frames, 4), dtype=np.float32)
        padded_contact[:actual_frames] = fc_raw[:actual_frames]

        # --- Decoder GT: local rotations 6D (skeleton-specific, for FK supervision) ---
        rot_6d = data.get('local_rotations_6d', None)
        if rot_6d is not None:
            # [T, J-1, 6] → pad to [T_max, J_max, 6]
            Jr = rot_6d.shape[1]  # J-1 (non-root)
            padded_rot = np.zeros((self.max_frames, self.max_joints, 6), dtype=np.float32)
            T_rot = min(rot_6d.shape[0], actual_frames)
            padded_rot[:T_rot, :Jr, :] = rot_6d[:T_rot]
            has_rotations = True
        else:
            padded_rot = np.zeros((self.max_frames, self.max_joints, 6), dtype=np.float32)
            has_rotations = False

        # --- Bone lengths [T, J] ---
        bone_raw = data.get('bone_lengths', np.zeros((T, J), dtype=np.float32))
        padded_bones = np.zeros((self.max_frames, self.max_joints), dtype=np.float32)
        padded_bones[:actual_frames, :J] = bone_raw[:actual_frames]

        return {
            # Slot token input: per-joint [local_pos(3) + velocity(3)] = 6D
            'motion_features': torch.from_numpy(padded_motion),         # [T, J_max, 6]
            # Skeleton graph
            'skeleton_features': torch.from_numpy(skeleton_features),   # [J_max, 9]
            'joint_mask': torch.from_numpy(joint_mask),                 # [J_max]
            'frame_mask': torch.from_numpy(frame_mask),                 # [T_max]
            'adjacency': torch.from_numpy(adjacency),                   # [J_max, J_max]
            'geodesic_dist': torch.from_numpy(geodesic_dist),           # [J_max, J_max]
            # Root track (separate)
            'root_position': torch.from_numpy(padded_root_pos),         # [T_max, 3]
            'root_velocity': torch.from_numpy(padded_root_vel),         # [T_max, 3]
            # Decoder GT (skeleton-specific)
            'local_rotations_6d': torch.from_numpy(padded_rot),         # [T_max, J_max, 6]
            'has_rotations': has_rotations,
            # Auxiliary
            'foot_contact': torch.from_numpy(padded_contact),           # [T_max, 4]
            'bone_lengths': torch.from_numpy(padded_bones),             # [T_max, J_max]
            # Metadata
            'text': text,
            'num_joints': J,
            'num_frames': actual_frames,
            'skeleton_id': skeleton_id,
            'motion_id': sample_info['motion_id'],
        }


def collate_fn(batch: list[dict]) -> dict:
    """Custom collate function for variable-length text."""
    result = {}
    for key in batch[0]:
        if key == 'text':
            result[key] = [b[key] for b in batch]
        elif isinstance(batch[0][key], torch.Tensor):
            result[key] = torch.stack([b[key] for b in batch])
        elif isinstance(batch[0][key], (int, float)):
            result[key] = torch.tensor([b[key] for b in batch])
        else:
            result[key] = [b[key] for b in batch]
    return result