#!/usr/bin/env python3
"""PCA of the ACT encoder representation, on the components that carry cable identity.

PCA is unsupervised: it ranks axes by variance, not by how well they separate
classes. In this model the cable axis is not PC1/PC2 -- those are dominated by
arm pose and grasp phase -- so the default projection hides it. Here the same
PCA is computed, then the two components with the highest between-class /
within-class variance ratio are plotted. Nothing is fitted to the labels; the
labels only choose which of the existing axes to look along.

Features are cached so the projection can be re-plotted without re-running the
policy over the dataset.
"""
import argparse, os
import numpy as np
import torch
import torch.nn.functional as F
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
plt.rcParams["font.family"] = ["Noto Sans CJK JP", "DejaVu Sans"]
from sklearn.decomposition import PCA

from lerobot.datasets.lerobot_dataset import LeRobotDataset
from lerobot.policies.act.modeling_act import ACTPolicy

COLORS = {"blue cable": "#2B6CB0", "cable 1.70 sq": "#C05621", "cable 3.30 sq": "#2F855A"}


def episode_task(ds, ep):
    t = ds.meta.episodes["tasks"][ep]
    return t[0] if isinstance(t, (list, np.ndarray)) else str(t)


def collect(args):
    ds = LeRobotDataset(args.repo_id)
    policy = ACTPolicy.from_pretrained(args.policy_path).to(args.device).eval()
    cap = {}
    policy.model.encoder.register_forward_hook(
        lambda m, i, o: cap.__setitem__("e", o.detach().mean(0).squeeze(0).float().cpu().numpy()))
    by = {}
    for ep in range(ds.meta.total_episodes):
        by.setdefault(episode_task(ds, ep), []).append(ep)
    rng = np.random.default_rng(0)
    feats, pix, lab, eps = [], [], [], []
    for task, e in sorted(by.items()):
        chosen = rng.choice(e, size=min(args.eps_per_task, len(e)), replace=False)
        print(f"  {task}: {len(chosen)} episodes", flush=True)
        for ep in chosen:
            lo = int(ds.meta.episodes["dataset_from_index"][ep])
            hi = int(ds.meta.episodes["dataset_to_index"][ep])
            for i in rng.choice(np.arange(lo, hi), size=min(args.frames_per_ep, hi - lo), replace=False):
                item = ds[int(i)]
                b = {k: v.unsqueeze(0).to(args.device) for k, v in item.items() if isinstance(v, torch.Tensor)}
                b["task"] = [task]
                with torch.no_grad():
                    policy.select_action(b)
                policy.reset()
                feats.append(cap["e"])
                gs = item["observation.images.gelsight1"].unsqueeze(0).float()
                pix.append(F.adaptive_avg_pool2d(gs, 16).flatten().numpy())
                lab.append(task); eps.append(ep)
    return np.array(feats), np.array(pix), np.array(lab), np.array(eps)


def sep_ratio(Z, y, k):
    g = [Z[y == t, k] for t in sorted(set(y))]
    return np.var([x.mean() for x in g]) / (np.mean([x.var() for x in g]) + 1e-12)


def panel(ax, Z, y, i, j, ratios, evr, title):
    for t in sorted(set(y)):
        m = y == t
        ax.scatter(Z[m, i], Z[m, j], s=9, alpha=0.55, edgecolors="none",
                   c=COLORS.get(t, "#666"), label=t)
    ax.set_xlabel(f"PC{i+1}  ({evr[i]:.1%} var, sep {ratios[i]:.2f})")
    ax.set_ylabel(f"PC{j+1}  ({evr[j]:.1%} var, sep {ratios[j]:.2f})")
    ax.set_title(title, fontsize=11)
    ax.spines[["top", "right"]].set_visible(False)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--repo-id", default="Kaz55/dg5f_ur5e_bluev2_cable170_330_270ep")
    ap.add_argument("--policy-path", required=True)
    ap.add_argument("--eps-per-task", type=int, default=30)
    ap.add_argument("--frames-per-ep", type=int, default=25)
    ap.add_argument("--device", default="cuda")
    ap.add_argument("--cache", default="outputs/pca/cache_cable_feats.npz")
    ap.add_argument("--out", default="outputs/pca/pca_cable_informative.png")
    args = ap.parse_args()

    if os.path.exists(args.cache):
        d = np.load(args.cache, allow_pickle=True)
        feats, pix, y = d["feats"], d["pix"], d["y"]
        print(f"cache から読み込み: {len(y)} frames", flush=True)
    else:
        feats, pix, y, eps = collect(args)
        np.savez_compressed(args.cache, feats=feats, pix=pix, y=y, eps=eps)
        print(f"collected {len(y)} frames -> {args.cache}", flush=True)

    fig, axes = plt.subplots(1, 3, figsize=(16.5, 5.2))
    Xc = feats - feats.mean(0)
    p = PCA(n_components=30).fit(Xc)
    Z = p.transform(Xc)
    evr = p.explained_variance_ratio_
    ratios = np.array([sep_ratio(Z, y, k) for k in range(30)])
    best = np.argsort(ratios)[::-1][:2]
    print(f"  分離に効く主成分: PC{best[0]+1} (sep {ratios[best[0]]:.2f}), PC{best[1]+1} (sep {ratios[best[1]]:.2f})",
          flush=True)

    panel(axes[0], Z, y, 0, 1, ratios, evr, "既定の PC1 vs PC2\nケーブル軸が乗っていない")
    panel(axes[1], Z, y, int(best[0]), int(best[1]), ratios, evr,
          f"分離に効く PC{best[0]+1} vs PC{best[1]+1}\n同じPCAの別の軸")
    axes[1].legend(frameon=False, fontsize=9)

    axes[2].bar(range(1, 31), ratios, color=["#C05621" if k in best else "#2B6CB0" for k in range(30)])
    axes[2].set_title("主成分ごとのケーブル分離度\n(クラス間分散 / クラス内分散)", fontsize=11)
    axes[2].set_xlabel("principal component"); axes[2].set_ylabel("separability")
    axes[2].spines[["top", "right"]].set_visible(False)

    fig.suptitle("PCA: どの主成分がケーブルを符号化しているか（ACT encoder, 512次元）", fontsize=13)
    fig.tight_layout()
    fig.savefig(args.out, dpi=150)
    print(f"wrote {args.out}", flush=True)


if __name__ == "__main__":
    main()