#!/usr/bin/env python3
"""Dataset comparison card for two LeRobot v3.0 trees (the abc-teleop-style table).

Every row is measured from the files, not read off a README: format/robot/rate/counts come from
meta, video shape+codec from ffprobe, and the action convention / gripper encoding rows are
computed from the parquet columns.

    python stats_compare.py --a NAME=/path/to/ds --b NAME=/path/to/ds [--json out.json]
"""
import argparse
import json
import subprocess
from pathlib import Path

import numpy as np
import pyarrow.parquet as pq


def load_meta(root: Path) -> dict:
    return json.loads((root / "meta" / "info.json").read_text())


def read_frames(root: Path) -> dict:
    files = sorted((root / "data").glob("*/*.parquet"))
    tabs = [pq.read_table(f) for f in files]
    cols = {}
    for name in ("observation.state", "action", "episode_index", "timestamp", "task_index"):
        vals = [t[name].to_pylist() for t in tabs if name in t.column_names]
        flat = [x for v in vals for x in v]
        arr = np.array([x[0] if isinstance(x, list) and len(x) == 1 and name != "observation.state"
                        and name != "action" else x for x in flat])
        cols[name] = arr
    return cols


def ffprobe(path: Path) -> dict:
    out = subprocess.run(
        ["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries",
         "stream=codec_name,width,height,pix_fmt,avg_frame_rate,nb_frames", "-of", "json", str(path)],
        capture_output=True, text=True).stdout
    try:
        return json.loads(out)["streams"][0]
    except Exception:
        return {}


def action_convention(state: np.ndarray, action: np.ndarray, ep: np.ndarray) -> dict:
    """Is action[t] the next state (absolute target), the current state, or a lagging command?"""
    res = {}
    for lag in range(0, 7):
        errs = []
        for e in np.unique(ep):
            m = ep == e
            s, a = state[m], action[m]
            if len(s) <= lag + 1:
                continue
            errs.append(np.abs(a[: len(a) - lag] - s[lag:]).mean())
        res[lag] = float(np.mean(errs)) if errs else float("nan")
    best = min(res, key=lambda k: res[k])
    return {"mae_vs_state_at_lag": {str(k): round(v, 4) for k, v in res.items()},
            "best_lag_frames": int(best), "best_lag_mae_deg": round(res[best], 4)}


def gripper_stats(state: np.ndarray, action: np.ndarray, names: list[str]) -> dict:
    gi = [i for i, n in enumerate(names) if "gripper" in n]
    if not gi:
        return {}
    g = state[:, gi[0]]
    ga = action[:, gi[0]]
    lo, hi = float(g.min()), float(g.max())
    span = hi - lo if hi > lo else 1.0
    norm = (g - lo) / span
    return {"state_range": [round(lo, 3), round(hi, 3)],
            "action_range": [round(float(ga.min()), 3), round(float(ga.max()), 3)],
            "looks_normalized_01": bool(lo >= -0.01 and hi <= 1.01),
            "mean": round(float(g.mean()), 3),
            "mean_normalized": round(float(norm.mean()), 3),
            "p05_p50_p95": [round(float(np.percentile(g, p)), 3) for p in (5, 50, 95)],
            "pct_below_25pct_of_span": round(100 * float((norm < 0.25).mean()), 1),
            "pct_above_75pct_of_span": round(100 * float((norm > 0.75).mean()), 1)}


def describe(name: str, root: Path) -> dict:
    info = load_meta(root)
    cols = read_frames(root)
    state, action, ep = cols["observation.state"], cols["action"], cols["episode_index"]
    state = np.array(state.tolist(), dtype=np.float64)
    action = np.array(action.tolist(), dtype=np.float64)
    cams = [k for k, v in info["features"].items() if v.get("dtype") == "video"]
    vid = {}
    for c in cams:
        f = sorted((root / "videos" / c).glob("*/*.mp4"))
        if f:
            p = ffprobe(f[0])
            vid[c] = {"codec": p.get("codec_name"), "size": f"{p.get('width')}x{p.get('height')}",
                      "pix_fmt": p.get("pix_fmt"), "fps": p.get("avg_frame_rate"),
                      "n_files": len(f)}
    lens = np.array([int((ep == e).sum()) for e in np.unique(ep)])
    fps = info["fps"]
    names = info["features"]["action"].get("names") or []
    # the task string is stored as the pandas index, so the column is "task" or "__index_level_0__"
    tt = pq.read_table(root / "meta" / "tasks.parquet").to_pydict()
    tasks = {"task": next(v for k, v in tt.items() if k != "task_index")}
    return {
        "name": name, "root": str(root),
        "format": f"LeRobot {info['codebase_version']}",
        "robot_type": info.get("robot_type"),
        "fps": fps,
        "episodes": int(info["total_episodes"]), "frames": int(info["total_frames"]),
        "tasks": int(info["total_tasks"]),
        "task_examples": tasks["task"][:3],
        "duration_s": round(int(info["total_frames"]) / fps, 1),
        "duration_hms": f"{int(info['total_frames'])/fps/60:.1f} min",
        "episode_len": {"mean": round(float(lens.mean()), 1), "min": int(lens.min()),
                        "max": int(lens.max()), "median": int(np.median(lens))},
        "camera_keys": cams, "video": vid,
        "state_dtype": f"{info['features']['observation.state']['dtype']}"
                       f"[{info['features']['observation.state']['shape'][0]}]",
        "action_dtype": f"{info['features']['action']['dtype']}[{info['features']['action']['shape'][0]}]",
        "state_layout": names,
        "state_range_deg": [[round(float(state[:, i].min()), 1), round(float(state[:, i].max()), 1)]
                            for i in range(state.shape[1])],
        "action_convention": action_convention(state, action, ep),
        "gripper": gripper_stats(state, action, names),
    }


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--a", required=True, help="NAME=/path")
    ap.add_argument("--b", required=True, help="NAME=/path")
    ap.add_argument("--json", default=None)
    args = ap.parse_args()
    out = []
    for spec in (args.a, args.b):
        n, p = spec.split("=", 1)
        out.append(describe(n, Path(p)))
    print(json.dumps(out, indent=2))
    if args.json:
        Path(args.json).write_text(json.dumps(out, indent=2))
        print(f"\nwrote {args.json}")


if __name__ == "__main__":
    main()