#!/usr/bin/env python3
"""Offline open-loop eval for smolvla_rm65_stack_30ep_s1000.

Stitches n_action_steps=16 from each chunk on three cleaned stacking episodes.
Joints: q_cmd[:6] = q_now[:6] + pred[:6]. Gripper: hysteresis 0.35 / 0.65.

    docker exec rm65_dev2 bash -lc 'cd /home/sdznkj/zkx_ws/sendlerobot && \\
      HF_HUB_OFFLINE=1 PYTHONPATH=. python3 scripts/eval_stack_30ep_offline.py'
"""

from __future__ import annotations

import json
import sys
from pathlib import Path

import numpy as np

ROOT = Path(__file__).resolve().parents[1]
CKPT = ROOT / "smolvla_rm65_stack_30ep_s1000"
DS = ROOT / "datasets/cleaned/rm65_stacking_blocks"
OUT = ROOT / "outputs/diag/stack_30ep_offline"
LOCAL_VLM = ROOT / "base_models/SmolVLM2-500M-Video-Instruct"
EPISODES = [0, 1, 2]
JOINT_NAMES = ["j1", "j2", "j3", "j4", "j5", "j6", "gripper"]
HEX = ["#50B4FF", "#50FFA0", "#FFC850", "#FF648C", "#B48CFF", "#78DCDC", "#F0F0F0"]


def _setup_cn_mpl():
    import matplotlib

    matplotlib.use("Agg")
    import matplotlib.pyplot as plt
    from matplotlib import font_manager

    cjk = Path("/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc")
    if cjk.is_file():
        font_manager.fontManager.addfont(str(cjk))
        name = font_manager.FontProperties(fname=str(cjk)).get_name()
        plt.rcParams["font.sans-serif"] = [name, "Noto Sans CJK JP", "DejaVu Sans"]
    plt.rcParams["font.family"] = "sans-serif"
    plt.rcParams["axes.unicode_minus"] = False
    plt.rcParams.update(
        {
            "figure.facecolor": "#111111",
            "axes.facecolor": "#161616",
            "axes.edgecolor": "#555555",
            "text.color": "#EEEEEE",
            "xtick.color": "#BBBBBB",
            "ytick.color": "#BBBBBB",
            "axes.labelcolor": "#DDDDDD",
            "legend.facecolor": "#1C1C1C",
            "legend.edgecolor": "#444444",
            "grid.color": "#2A2A2A",
            "savefig.facecolor": "#111111",
        }
    )
    return plt


class GripperHysteresis:
    def __init__(self, low: float = 0.35, high: float = 0.65, initial: float = 0.5) -> None:
        self.low = low
        self.high = high
        self.initial = initial
        self.state: float | None = None

    def reset(self) -> None:
        self.state = None

    def step(self, value: float) -> float:
        if self.state is None:
            self.state = 1.0 if value >= self.initial else 0.0
        elif self.state >= 0.5:
            if value <= self.low:
                self.state = 0.0
        elif value >= self.high:
            self.state = 1.0
        return self.state


def sanitize_config(ckpt: Path) -> None:
    sys.path.insert(0, str(ROOT))
    import dataclasses

    from lerobot.common.policies.smolvla.configuration_smolvla import SmolVLAConfig
    from lerobot.configs.policies import PreTrainedConfig

    allowed = {f.name for f in dataclasses.fields(SmolVLAConfig)}
    allowed |= {f.name for f in dataclasses.fields(PreTrainedConfig)}
    allowed.add("type")
    cfg_path = ckpt / "config.json"
    cfg = json.loads(cfg_path.read_text())
    dropped = sorted(k for k in cfg if k not in allowed)
    for k in dropped:
        cfg.pop(k, None)
    if LOCAL_VLM.is_dir():
        cfg["vlm_model_name"] = str(LOCAL_VLM)
    cfg_path.write_text(json.dumps(cfg, indent=4) + "\n")
    print("dropped config keys:", dropped)


def load_episode(ep: int) -> dict:
    import pandas as pd

    info = json.loads((DS / "meta/info.json").read_text())
    tasks = {}
    for line in (DS / "meta/tasks.jsonl").read_text().splitlines():
        if line.strip():
            row = json.loads(line)
            tasks[int(row["task_index"])] = row["task"]
    pq = DS / info["data_path"].format(episode_chunk=0, episode_index=ep)
    df = pd.read_parquet(pq)
    state = np.stack(df["observation.state"].to_numpy()).astype(np.float32)
    action = np.stack(df["action"].to_numpy()).astype(np.float32)
    task_index = df["task_index"].to_numpy().astype(np.int64)
    return {
        "state": state,
        "action": action,
        "task_index": task_index,
        "tasks": tasks,
        "info": info,
        "n": len(df),
    }


def read_video_frames(path: Path, indices: list[int]) -> dict[int, np.ndarray]:
    import av

    want = set(int(i) for i in indices)
    out: dict[int, np.ndarray] = {}
    container = av.open(str(path))
    for i, frame in enumerate(container.decode(video=0)):
        if i in want:
            out[i] = frame.to_ndarray(format="rgb24")
        if len(out) == len(want):
            break
    container.close()
    missing = want - set(out)
    if missing:
        raise FileNotFoundError(f"{path} missing frames {sorted(missing)[:8]}")
    return out


def rgb_tensor(img: np.ndarray, torch):
    t = torch.from_numpy(img).permute(2, 0, 1).float() / 255.0
    return t.unsqueeze(0)


def infer_episode(policy, ep: int, device) -> dict:
    import torch

    data = load_episode(ep)
    info = data["info"]
    n = data["n"]
    step = int(policy.config.n_action_steps)
    starts = list(range(0, n, step))
    front = read_video_frames(
        DS / info["video_path"].format(episode_chunk=0, episode_index=ep, video_key="observation.images.front"),
        starts,
    )
    astra = read_video_frames(
        DS / info["video_path"].format(episode_chunk=0, episode_index=ep, video_key="observation.images.astra"),
        starts,
    )
    hyst = GripperHysteresis()
    policy.reset()
    pred_abs = np.full((n, 7), np.nan, dtype=np.float32)
    with torch.no_grad():
        for fi, t0 in enumerate(starts):
            state_np = data["state"][t0, :7].copy()
            task = data["tasks"][int(data["task_index"][t0])]
            batch = {
                "task": task,
                "observation.state": torch.from_numpy(state_np).unsqueeze(0).to(device),
                "observation.images.camera1": rgb_tensor(front[t0], torch).to(device),
                "observation.images.camera2": rgb_tensor(astra[t0], torch).to(device),
            }
            pred = policy.predict_action_chunk(batch)[0].detach().float().cpu().numpy()
            take = pred[: min(step, n - t0)]
            # Policy returns robot commands when use_relative_actions is set.
            if not getattr(policy.config, "use_relative_actions", False):
                take = take.copy()
                take[:, :6] = state_np[:6] + take[:, :6]
                for i in range(take.shape[0]):
                    take[i, 6] = hyst.step(float(take[i, 6]))
            pred_abs[t0 : t0 + take.shape[0]] = take
            print(
                f"ep{ep:03d} {fi + 1}/{len(starts)} f={t0} "
                f"|dq|={np.abs(take[:, :6] - state_np[:6]).mean():.3f} grip={take[0, 6]:.0f}",
                flush=True,
            )
            del batch
            if device.type == "cuda":
                torch.cuda.empty_cache()
    data["pred"] = pred_abs
    data["episode"] = ep
    return data


def plot_episode(data: dict) -> Path:
    plt = _setup_cn_mpl()
    st = data["state"][:, :7]
    ac = data["action"][:, :7]
    pr = data["pred"]
    n = data["n"]
    ep = data["episode"]
    x = np.arange(n)
    fig, axes = plt.subplots(7, 1, figsize=(16.5, 12.4), sharex=True, gridspec_kw={"hspace": 0.08})
    fig.subplots_adjust(top=0.88, bottom=0.07, left=0.08, right=0.98)
    fig.suptitle(
        f"stack 30ep/s1000 open-loop  ep{ep:03d}",
        fontsize=18,
        fontweight="bold",
        y=0.995,
    )
    fig.text(
        0.01,
        0.965,
        "solid=encoder    dashed=demo action    orange=open-loop (joints: q + dq, gripper hysteresis 0.35/0.65)\n"
        "infer every 16 frames, execute the first 16 steps of each chunk",
        fontsize=11,
        color="#C8C8C8",
        va="top",
    )
    legend_done = False
    for j, ax in enumerate(axes):
        c = HEX[j]
        (h_line,) = ax.plot(x, ac[:, j], ls="--", lw=1.2, color=c, alpha=0.55, zorder=2)
        (s_line,) = ax.plot(x, st[:, j], ls="-", lw=2.0, color=c, zorder=3)
        (vla,) = ax.plot(x, pr[:, j], color="#FF9F1C", lw=1.8, zorder=4)
        ax.set_ylabel(JOINT_NAMES[j], fontsize=12, color=c, rotation=0, ha="right", va="center", labelpad=14)
        ax.grid(True, axis="x", alpha=0.25)
        if not legend_done:
            ax.legend([s_line, h_line, vla], ["encoder", "demo", "open-loop VLA"], loc="upper right", fontsize=10)
            legend_done = True
    axes[-1].set_xlabel("frame (20 Hz)", fontsize=12)
    axes[-1].set_xlim(0, n - 1)
    valid = np.isfinite(pr[:, 0])
    mae = float(np.abs(pr[valid, :6] - ac[valid, :6]).mean())
    grip_acc = float(np.mean(np.abs(pr[valid, 6] - ac[valid, 6]) < 0.5))
    fig.text(
        0.01,
        0.008,
        f"joint |pred-demo| mean {mae:.2f} deg    gripper agree {grip_acc:.0%}    frames {n}",
        fontsize=10.5,
        color="#D2C878",
    )
    OUT.mkdir(parents=True, exist_ok=True)
    path = OUT / f"ep{ep:03d}_trajectory.png"
    fig.savefig(path, dpi=140, bbox_inches="tight", pad_inches=0.22)
    plt.close(fig)
    print("wrote", path)
    return path


def main() -> None:
    import os

    os.environ["HF_HUB_OFFLINE"] = "1"
    os.environ["TRANSFORMERS_OFFLINE"] = "1"
    os.environ["HF_DATASETS_OFFLINE"] = "1"
    sys.path.insert(0, str(ROOT))
    import torch

    from lerobot.common.policies.smolvla.modeling_smolvla import SmolVLAPolicy
    from lerobot.configs.policies import PreTrainedConfig
    from smolvla_diag_visualize import load_stats

    sanitize_config(CKPT)
    config = PreTrainedConfig.from_pretrained(str(CKPT))
    stats = load_stats(CKPT, config)
    policy = SmolVLAPolicy.from_pretrained(str(CKPT), config=config, dataset_stats=stats)
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    policy.to(device)
    policy.eval()
    print("device", device, "chunk", policy.config.chunk_size, "n_action_steps", policy.config.n_action_steps)

    paths = []
    for ep in EPISODES:
        data = infer_episode(policy, ep, device)
        paths.append(plot_episode(data))
        del data
        if device.type == "cuda":
            torch.cuda.empty_cache()

    items = "".join(f"<li><a href='{p.name}'>{p.name}</a></li>" for p in paths)
    idx = OUT / "index.html"
    idx.write_text(
        "<html><body style='background:#111;color:#eee;font-family:sans-serif'>"
        "<h3>叠块 30ep/s1000 离线开环（ep000–002）</h3><ul>"
        + items
        + "</ul></body></html>\n",
        encoding="utf-8",
    )
    print("index", idx)


if __name__ == "__main__":
    main()