#!/usr/bin/env python
"""Exercise the RLinf CFG dataset/transform path without launching Ray/FSDP.

The script intentionally limits the local LeRobot view to the rows for which a
smoke advantage sidecar exists.  It validates the exact transform stack used by
``FSDPCfgWorker.build_dataloader`` and prints one collated CFG observation.
"""

from __future__ import annotations

import argparse
import json
import logging
from pathlib import Path

import numpy as np
import pandas as pd
import torch
from torch.utils.data import DataLoader

import lerobot.common.datasets.lerobot_dataset as lerobot_dataset
import openpi.training.data_loader as openpi_data_loader
import openpi.transforms as transforms
from rlinf.data.datasets.recap.cfg_model import (
    AdvantagePreservingDataset,
    TokenizePromptWithGuidance,
)
from rlinf.data.datasets.recap.utils import cast_image_features
from rlinf.data.lerobot_paths import resolve_lerobot_dataset_root
from rlinf.models.embodiment.openpi.dataconfig import get_openpi_config


class _LookupLimitedDataset:
    """Expose only sidecar-covered rows while retaining LeRobot lookahead.

    LeRobot's delta-timestamp query for row 0 reads the following nine rows.
    Keeping the full decoder as the delegate avoids truncating those rows, but
    the small ``hf_dataset`` view makes the advantage join check exactly the
    rows present in the smoke sidecar.
    """

    def __init__(self, delegate, count: int):
        self._delegate = delegate
        self.hf_dataset = delegate.hf_dataset.select(range(count))

    def __len__(self):
        return len(self.hf_dataset)

    def __getitem__(self, index):
        return self._delegate[index]


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--dataset",
        type=Path,
        default=Path(
            "/data/myx/RL_post_train/datasets/recap_value_smoke/"
            "libero10_task0_train"
        ),
    )
    parser.add_argument(
        "--model",
        type=Path,
        default=Path(
            "/data/myx/RL_post_train/checkpoints/base/RLinf-Pi05-LIBERO-SFT"
        ),
    )
    parser.add_argument("--advantage-tag", default="smoke")
    parser.add_argument("--max-samples", type=int, default=8)
    return parser.parse_args()


def main() -> int:
    args = parse_args()
    logging.basicConfig(level=logging.INFO)
    for name, path in (("dataset", args.dataset), ("model", args.model)):
        if not path.exists():
            raise FileNotFoundError(f"{name} path does not exist: {path}")
    if args.max_samples < 1:
        raise ValueError("--max-samples must be positive")

    data_path = str(args.dataset.resolve())
    model_path = str(args.model.resolve())
    train_config = get_openpi_config(
        "pi05_libero", model_path=model_path, batch_size=1, repo_id=data_path
    )
    data_config = train_config.data.create(train_config.assets_dirs, train_config.model)
    dataset_root = resolve_lerobot_dataset_root(data_path)
    dataset_meta = lerobot_dataset.LeRobotDatasetMetadata(
        data_path, root=dataset_root
    )
    base_dataset = lerobot_dataset.LeRobotDataset(
        data_path,
        root=dataset_root,
        delta_timestamps={
            key: [t / dataset_meta.fps for t in range(train_config.model.action_horizon)]
            for key in data_config.action_sequence_keys
        },
    )
    base_dataset.hf_dataset = cast_image_features(base_dataset.hf_dataset)

    # The smoke sidecar contains only the first N rows.  Restrict the lookup
    # view, while retaining the real decoder's full dataset for the 10-step
    # delta-timestamp query used by pi05_libero.
    n = min(args.max_samples, len(base_dataset.hf_dataset))
    base_dataset = _LookupLimitedDataset(base_dataset, n)

    if data_config.prompt_from_task:
        base_dataset = openpi_data_loader.TransformedDataset(
            base_dataset,
            [transforms.PromptFromLeRobotTask(dataset_meta.tasks)],
        )

    tokenizer = None
    for transform in data_config.model_transforms.inputs:
        if hasattr(transform, "tokenizer"):
            tokenizer = transform.tokenizer
            break
    if tokenizer is None:
        raise RuntimeError("Could not find tokenizer in pi05_libero model transforms")

    model_transforms = []
    for transform in data_config.model_transforms.inputs:
        if type(transform).__name__ == "TokenizePrompt":
            model_transforms.append(
                TokenizePromptWithGuidance(
                    tokenizer=tokenizer,
                    discrete_state_input=getattr(
                        transform, "discrete_state_input", False
                    ),
                )
            )
        else:
            model_transforms.append(transform)

    transforms_list = [
        *data_config.repack_transforms.inputs,
        *data_config.data_transforms.inputs,
        transforms.Normalize(
            data_config.norm_stats, use_quantiles=data_config.use_quantile_norm
        ),
        *model_transforms,
    ]
    transformed_dataset = openpi_data_loader.TransformedDataset(
        base_dataset, transforms_list
    )

    adv_path = args.dataset / "meta" / f"advantages_{args.advantage_tag}.parquet"
    adv_df = pd.read_parquet(adv_path)
    advantages_lookup = dict(
        zip(
            zip(
                adv_df["episode_index"].astype(int),
                adv_df["frame_index"].astype(int),
            ),
            adv_df["advantage"].astype(bool),
        )
    )
    final_dataset = AdvantagePreservingDataset(
        base_dataset=base_dataset,
        transformed_dataset=transformed_dataset,
        advantages_lookup=advantages_lookup,
    )
    loader = DataLoader(
        final_dataset,
        batch_size=1,
        shuffle=False,
        num_workers=0,
        drop_last=True,
    )
    batch = next(iter(loader))
    image_shapes = {key: list(value.shape) for key, value in batch["image"].items()}
    token_shapes = {
        key: list(value.shape)
        for key, value in batch.items()
        if key.startswith("tokenized_")
    }
    advantages = torch.as_tensor(batch["advantage"], dtype=torch.bool)
    print(
        "CFG_DATALOADER_PASS",
        json.dumps(
            {
                "dataset_rows": len(final_dataset),
                "image_shapes": image_shapes,
                "state_shape": list(batch["state"].shape),
                "actions_shape": list(batch["actions"].shape),
                "token_shapes": token_shapes,
                "advantage_shape": list(advantages.shape),
                "advantage_values": advantages.tolist(),
                "finite_images": all(
                    bool(np.isfinite(value.numpy()).all())
                    for value in batch["image"].values()
                ),
            },
            sort_keys=True,
        ),
    )
    return 0


if __name__ == "__main__":
    raise SystemExit(main())