#!/usr/bin/env python3
"""Check resolution/fps/frame-count alignment across allegro_paired_data video dirs."""

from __future__ import annotations

import json
import pickle
import re
import subprocess
from concurrent.futures import ProcessPoolExecutor, as_completed
from pathlib import Path

ROOT = Path("/data/fanliaoyuan/wxy/allegro_paired_data")
FFPROBE = "/data/fanliaoyuan/miniconda3/envs/sam3/bin/ffprobe"
EXP_W, EXP_H, EXP_FPS = 832, 480, 30.0
TOL_FPS = 0.05

HUMAN_PAT = re.compile(r"^(.+)-human-view(\d+)\.mp4$")


def probe_video(path: str) -> dict:
    cmd = [
        FFPROBE,
        "-v",
        "error",
        "-select_streams",
        "v:0",
        "-show_entries",
        "stream=width,height,r_frame_rate,nb_frames,duration",
        "-of",
        "json",
        path,
    ]
    out = subprocess.check_output(cmd, text=True)
    st = json.loads(out)["streams"][0]
    w, h = int(st["width"]), int(st["height"])
    fps_s = st.get("r_frame_rate", "30/1")
    if "/" in fps_s:
        n, d = fps_s.split("/")
        fps = float(n) / float(d)
    else:
        fps = float(fps_s)
    nb = st.get("nb_frames")
    n_frames = int(nb) if nb and int(nb) > 0 else None
    dur = st.get("duration")
    if n_frames is None and dur:
        n_frames = max(1, int(float(dur) * fps + 0.5))
    return {"width": w, "height": h, "fps": fps, "n_frames": n_frames}


def check_one(args: tuple) -> dict:
    pack, view = args
    hv = ROOT / "human_video" / f"{pack}-human-view{view}.mp4"
    hm = ROOT / "human_video_hand_mask" / f"{pack}-mask-view{view}.mp4"
    rv = ROOT / "robot_video" / f"{pack}-allegro-view{view}.mp4"
    pkl = ROOT / "robot_low_dim" / f"{pack}-allegro-view{view}.pkl"

    row = {"pack": pack, "view": view, "issues": []}
    probes = {}
    for name, path in [("human", hv), ("mask", hm), ("robot", rv)]:
        try:
            probes[name] = probe_video(str(path))
        except Exception as e:
            row["issues"].append(f"{name}_probe:{e}")

    for name, pr in probes.items():
        if pr["width"] != EXP_W or pr["height"] != EXP_H:
            row["issues"].append(f"{name}_res:{pr['width']}x{pr['height']}")
        if abs(pr["fps"] - EXP_FPS) > TOL_FPS:
            row["issues"].append(f"{name}_fps:{pr['fps']:.3f}")

    nf = {k: v["n_frames"] for k, v in probes.items()}
    row["frames"] = nf

    if len(set(nf.values())) > 1:
        row["issues"].append(f"frame_mismatch:{nf}")

    try:
        with open(pkl, "rb") as f:
            meta = pickle.load(f)["meta"]
        row["pkl_frames"] = int(meta["num_frames"])
        if nf and row["pkl_frames"] not in nf.values():
            row["issues"].append(f"pkl_vs_video:pkl={row['pkl_frames']},videos={nf}")
    except Exception as e:
        row["issues"].append(f"pkl:{e}")

    return row


def main():
    keys = []
    for p in (ROOT / "human_video").glob("*.mp4"):
        m = HUMAN_PAT.match(p.name)
        if m:
            keys.append((m.group(1), m.group(2)))

    keys.sort()
    print(f"samples: {len(keys)}")

    bad_res = {"human": 0, "mask": 0, "robot": 0}
    bad_fps = {"human": 0, "mask": 0, "robot": 0}
    frame_triple_mismatch = 0
    pkl_mismatch = 0
    other = 0
    issue_rows = []
    res_counter = {}
    fps_counter = {}

    workers = 24
    with ProcessPoolExecutor(max_workers=workers) as ex:
        futs = [ex.submit(check_one, k) for k in keys]
        for i, fut in enumerate(as_completed(futs), 1):
            row = fut.result()
            if row.get("issues"):
                issue_rows.append(row)
                for iss in row["issues"]:
                    if iss.endswith(f":{EXP_W}x{EXP_H}") or "_res:" in iss:
                        pass
                    if "_res:" in iss:
                        for n in ("human", "mask", "robot"):
                            if f"{n}_res:" in iss:
                                bad_res[n] += 1
                    if "_fps:" in iss:
                        for n in ("human", "mask", "robot"):
                            if f"{n}_fps:" in iss:
                                bad_fps[n] += 1
                    if iss.startswith("frame_mismatch"):
                        frame_triple_mismatch += 1
                    if iss.startswith("pkl_vs_video"):
                        pkl_mismatch += 1
                    if "_probe:" in iss or iss.startswith("pkl:"):
                        other += 1

            # collect stats from first 200 for distribution
            if i <= 200 and row.get("frames"):
                for name, pr_key in [("human", "human"), ("mask", "mask"), ("robot", "robot")]:
                    pass

            if i % 500 == 0 or i == len(futs):
                print(f"  [{i}/{len(futs)}] issues so far: {len(issue_rows)}", flush=True)

    # Re-scan issues for detailed breakdown
    bad_res = {"human": 0, "mask": 0, "robot": 0}
    bad_fps = {"human": 0, "mask": 0, "robot": 0}
    res_vals = set()
    fps_vals = set()
    frame_triple_mismatch = 0
    pkl_mismatch = 0
    for row in issue_rows:
        for iss in row["issues"]:
            if "_res:" in iss:
                for n in ("human", "mask", "robot"):
                    if f"{n}_res:" in iss:
                        bad_res[n] += 1
                        res_vals.add(iss.split(":", 1)[1])
            if "_fps:" in iss:
                for n in ("human", "mask", "robot"):
                    if f"{n}_fps:" in iss:
                        bad_fps[n] += 1
                        fps_vals.add(iss.split(":", 1)[1])
            if iss.startswith("frame_mismatch"):
                frame_triple_mismatch += 1
            if iss.startswith("pkl_vs_video"):
                pkl_mismatch += 1

    out = ROOT / "pairing_audit" / "video_alignment_issues.txt"
    with out.open("w", encoding="utf-8") as f:
        for row in sorted(issue_rows, key=lambda r: (r["pack"], r["view"])):
            f.write(f"{row['pack']}\tview{row['view']}\t{'; '.join(row['issues'])}\n")

    print("\n=== 分辨率 (期望 832x480) ===")
    print(f"  human 非标准: {bad_res['human']}")
    print(f"  mask   非标准: {bad_res['mask']}")
    print(f"  robot  非标准: {bad_res['robot']}")
    if res_vals:
        print(f"  异常分辨率样例: {sorted(res_vals)[:10]}")

    print("\n=== 帧率 (期望 30fps) ===")
    print(f"  human 非30fps: {bad_fps['human']}")
    print(f"  mask   非30fps: {bad_fps['mask']}")
    print(f"  robot  非30fps: {bad_fps['robot']}")
    if fps_vals:
        print(f"  异常帧率样例: {sorted(fps_vals)[:10]}")

    print("\n=== 帧数对齐 ===")
    print(f"  三视频帧数不一致: {frame_triple_mismatch}")
    print(f"  pkl num_frames 与视频不符: {pkl_mismatch}")
    print(f"  总问题样本数: {len(issue_rows)} / {len(keys)}")
    print(f"  详情: {out}")


if __name__ == "__main__":
    main()