"""Inspect an original native re-filming study without importing WorldinWorld or model code."""

import argparse
import json
import subprocess
from pathlib import Path

import numpy as np

p = argparse.ArgumentParser(description=__doc__)
p.add_argument("directory", type=Path)
a = p.parse_args()
r = a.directory
m = json.loads((r / "wiw-native-measurements.json").read_text())
poses = np.load(r / "poses.npy", allow_pickle=False)
ks = np.load(r / "intrinsics.npy", allow_pickle=False)
assert poses.shape == (93, 4, 4) and ks.shape == (93, 4)
assert np.isfinite(poses).all() and np.isfinite(ks).all()
assert np.allclose(poses[0], np.eye(4), atol=1e-6)
assert np.allclose(poses[-4:], poses[-1], atol=1e-6)
K = ks[0].astype(np.float64)
assert np.allclose(ks, m["intrinsicsReference832x480"], atol=1e-4)
K[[1, 3]] *= 464 / 480
source = np.array(m["sourceCameraToWorldOpenCV"])
errors = []
for i, rel in enumerate(poses):
    assert np.allclose(rel[3], [0, 0, 0, 1], atol=1e-6)
    assert np.allclose(rel[:3, :3].T @ rel[:3, :3], np.eye(3), atol=1e-6)
    assert abs(np.linalg.det(rel[:3, :3]) - 1) < 1e-6
    record = m["frames"][i]
    point = np.array([*record["ballWorld"], 1])
    camera = np.linalg.inv(source @ rel) @ point
    assert camera[2] > 0
    px = [K[0] * camera[0] / camera[2] + K[2], K[1] * camera[1] / camera[2] + K[3]]
    err = float(np.max(np.abs(np.asarray(px) - record["nativePixels"])))
    assert err < 0.001
    errors.append(err)
remap = list(range(40)) + [40] * 16 + list(range(40, 85))
assert m["remap"] == remap and remap.count(40) == 17
assert len(remap) == 101 and poses.shape[0] == len(remap) - 8
for name, count in [("wiw-native-source.mp4", 85), ("wiw-native-target.mp4", 93)]:
    media = json.loads(
        subprocess.check_output(
            [
                "ffprobe",
                "-v",
                "error",
                "-select_streams",
                "v:0",
                "-show_frames",
                "-show_entries",
                "frame=best_effort_timestamp_time",
                "-of",
                "json",
                str(r / name),
            ],
            text=True,
        )
    )
    stream = json.loads(
        subprocess.check_output(
            [
                "ffprobe",
                "-v",
                "error",
                "-select_streams",
                "v:0",
                "-show_entries",
                "stream=width,height,sample_aspect_ratio",
                "-of",
                "json",
                str(r / name),
            ],
            text=True,
        )
    )["streams"][0]
    assert (stream["width"], stream["height"]) == (832, 464)
    assert stream["sample_aspect_ratio"] == "1:1"
    assert len(media["frames"]) == count
    for i, frame in enumerate(media["frames"]):
        assert abs(float(frame["best_effort_timestamp_time"]) - i / 16) < 1e-6
print(
    json.dumps(
        {
            "poses": list(poses.shape),
            "referenceIntrinsics": list(ks.shape),
            "preparedFreezeFrames": len(remap),
            "plannedGeneratedFrames": poses.shape[0],
            "freezeFrameOccurrences": remap.count(40),
            "maxProjectionErrorPixels": max(errors),
            "firstPoseIdentity": True,
            "lastFourPoseDwell": True,
            "scope": "Independent authored native geometry and frame ledger only; not a prepared model case or model execution",
        },
        indent=2,
    )
)