"""Сверка НАШЕЙ проприоцепции с распределением, на котором обучался чекпойнт.

Гоняем реальную политику несколько эпизодов, копим состояния ДО нормировки и
сравниваем поканально с norm_stats чекпойнта. Канал, уходящий далеко за
[q01, q99], модель видит как экстремальный выброс — целиться ей нечем.
"""
import json, os, sys, glob
import numpy as np
import torch

os.environ.setdefault("MUJOCO_GL", "egl")
import simpler_env
from simpler_env.utils.env.observation_utils import get_image_from_maniskill2_obs_dict
from scipy.spatial.transform import Rotation
from transforms3d.euler import euler2axangle
from lerobot.common.policies.factory import load_pretrained_policy
from lerobot.common.utils.torch_observation import (
    move_dict_to_batch_for_inference, torch_preprocess_dict_inference)

CKPT = sys.argv[1] if len(sys.argv) > 1 else "SberRoboticsCenter/GreenVLA-5b-stride-1-R1-bridge"
NEP = int(sys.argv[2]) if len(sys.argv) > 2 else 4

policy, itf, otf = load_pretrained_policy(CKPT, data_config_name="bridge")
policy.to("cuda:0").eval()

from lerobot.common.policies.factory import _resolve_norm_stats_dir
import pathlib
ns = None
_d = pathlib.Path(_resolve_norm_stats_dir(CKPT, "bridge")) / "bridge" / "norm_stats.json"
if _d.exists():
    ns = json.load(open(_d))
    print("norm_stats: %s" % _d)
else:
    print("norm_stats НЕ НАЙДЕН по %s" % _d)


def build_state(env, base_frame=True):
    agent = env.unwrapped.agent
    link = [l for l in agent.robot.get_links() if l.get_name() == "ee_gripper_link"][0]
    pose = link.get_pose()
    if base_frame:
        pose = agent.robot.get_root_pose().inv() * pose
    q = pose.q
    rpy = Rotation.from_quat([q[1], q[2], q[3], q[0]]).as_euler("xyz")
    g = float(agent.get_gripper_closedness())
    return np.array([pose.p[0], pose.p[1], pose.p[2],
                     rpy[0], rpy[1], rpy[2], 0.0, 1.0 - g], np.float32)


states, acts = [], []
for ep in range(NEP):
    env = simpler_env.make("widowx_spoon_on_towel")
    obs, _ = env.reset(options={"obj_init_options": {"episode_id": ep}})
    prompt = env.get_language_instruction()
    if hasattr(policy, "reset"):
        policy.reset()
    for step in range(40):
        st = build_state(env)
        states.append(st)
        raw = {"observation/state": st,
               "observation/image": get_image_from_maniskill2_obs_dict(env, obs),
               "prompt": prompt}
        with torch.inference_mode():
            batch = move_dict_to_batch_for_inference(
                torch_preprocess_dict_inference(itf(raw)), device="cuda:0")
            a = policy.select_action(batch).cpu().numpy()
            a = np.asarray(otf({"actions": a,
                                "state": batch["state"].cpu().numpy()})["actions"]).reshape(-1, 7)
        acts.append(a[0])
        act = a[0].astype(np.float64).copy()
        axis, ang = euler2axangle(act[3], act[4], act[5])
        act[3:6] = axis * ang
        act[6] = 2.0 * (act[6] > 0.5) - 1.0
        obs, r, term, trunc, info = env.step(act)
        if term or trunc:
            break
    env.close()

S = np.array(states)
A = np.array(acts)
names = ["x", "y", "z", "roll", "pitch", "yaw", "gripper"]
mask = [0, 1, 2, 3, 4, 5, 7]
S7 = S[:, mask]
print("")
print("состояний собрано: %d" % len(S7))

if ns is not None:
    print("ключи norm_stats: %s" % sorted(ns.keys()))
    ns = ns.get("norm_stats", ns)
    print("вложенные ключи: %s" % sorted(ns.keys()))
    st = ns.get("state") or {}
    print("поля state: %s" % sorted(st.keys()))
    q01 = np.array(st.get("q01", []), float)
    q99 = np.array(st.get("q99", []), float)
    mean = np.array(st.get("mean", []), float)
    std = np.array(st.get("std", []), float)
    hdr = "%-9s%10s%10s%10s%10s   %s" % ("канал", "наш min", "наш max", "q01", "q99", "вердикт")
    print(hdr)
    for i, n in enumerate(names):
        lo, hi = float(S7[:, i].min()), float(S7[:, i].max())
        if i < len(q01):
            a_, b_ = float(q01[i]), float(q99[i])
            rng = max(b_ - a_, 1e-6)
            out = max((a_ - lo) / rng, (hi - b_) / rng, 0.0)
            verdict = "ок" if out < 0.25 else ("ВНЕ ДИАПАЗОНА на %.1f ширины" % out)
            print("%-9s%10.3f%10.3f%10.3f%10.3f   %s" % (n, lo, hi, a_, b_, verdict))
        elif i < len(mean):
            print("%-9s%10.3f%10.3f%10.3f%10.3f   (mean/std)" % (n, lo, hi, float(mean[i]), float(std[i])))

print("")
print("действия после денормализации, поканально min/max:")
for i, n in enumerate(names):
    print("  %-8s%9.4f%9.4f" % (n, float(A[:, i].min()), float(A[:, i].max())))