#!/usr/bin/env python3
"""Does the ACT encoder representation actually carry cable identity?

2-D PCA is unsupervised: if cable type is not among the top variance directions
it stays invisible even when the information is present. So measure it directly
with a linear probe, then visualise with LDA (a supervised projection).

Critical: the split is by EPISODE, not by frame. Frames inside one episode are
near-duplicates, so a frame-level split leaks the answer and any probe scores
~100% regardless of what the model learned. Held-out episodes are the only
honest test. LDA is likewise fit on train episodes and plotted on test episodes,
otherwise a supervised projection manufactures clusters that do not generalise.
"""
import argparse
import numpy as np
import torch
import torch.nn.functional as F
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline

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(ds, policy, device, eps_per_task, frames_per_ep, seed=0):
    captured = {}
    policy.model.encoder.register_forward_hook(
        lambda m, i, o: captured.__setitem__("enc", o.detach().mean(0).squeeze(0).float().cpu().numpy()))
    by_task = {}
    for ep in range(ds.meta.total_episodes):
        by_task.setdefault(episode_task(ds, ep), []).append(ep)
    rng = np.random.default_rng(seed)
    feats, pix, labels, epids = [], [], [], []
    for task, eps in sorted(by_task.items()):
        chosen = rng.choice(eps, size=min(eps_per_task, len(eps)), 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(frames_per_ep, hi - lo), replace=False):
                item = ds[int(i)]
                batch = {k: v.unsqueeze(0).to(device) for k, v in item.items()
                         if isinstance(v, torch.Tensor)}
                batch["task"] = [task]
                with torch.no_grad():
                    policy.select_action(batch)
                policy.reset()
                feats.append(captured["enc"])
                gs = item["observation.images.gelsight1"].unsqueeze(0).float()
                pix.append(F.adaptive_avg_pool2d(gs, 16).flatten().numpy())
                labels.append(task); epids.append(ep)
    return np.array(feats), np.array(pix), np.array(labels), np.array(epids)


def probe(X, y, ep, seed=0):
    """Logistic-regression accuracy on held-out EPISODES."""
    rng = np.random.default_rng(seed)
    tr = np.zeros(len(y), bool)
    for task in np.unique(y):
        eps = np.unique(ep[y == task])
        keep = rng.choice(eps, size=int(len(eps) * 0.7), replace=False)
        tr |= np.isin(ep, keep)
    clf = make_pipeline(StandardScaler(), LogisticRegression(max_iter=2000, C=1.0))
    clf.fit(X[tr], y[tr])
    return clf.score(X[~tr], y[~tr]), tr


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("--out", default="outputs/pca/cable_repr_analysis.png")
    args = ap.parse_args()

    ds = LeRobotDataset(args.repo_id)
    policy = ACTPolicy.from_pretrained(args.policy_path).to(args.device).eval()
    feats, pix, y, ep = collect(ds, policy, args.device, args.eps_per_task, args.frames_per_ep)
    print(f"collected {len(y)} frames; encoder dim {feats.shape[1]}\n", flush=True)

    chance = 1.0 / len(np.unique(y))
    results = {}
    for name, X in (("ACT encoder", feats), ("GelSight pixels", pix)):
        acc, tr = probe(X, y, ep)
        results[name] = (X, acc, tr)
        print(f"  {name:16s} held-out episode accuracy: {acc:.1%}  (chance {chance:.1%})", flush=True)

    fig, axes = plt.subplots(1, 3, figsize=(16.5, 5.2))
    # Panel 1+2: LDA fitted on train episodes, plotted on held-out episodes.
    for ax, name in zip(axes[:2], ("ACT encoder", "GelSight pixels")):
        X, acc, tr = results[name]
        lda = LDA(n_components=2).fit(X[tr], y[tr])
        xy = lda.transform(X[~tr])
        yt = y[~tr]
        for task in sorted(set(y)):
            m = yt == task
            ax.scatter(xy[m, 0], xy[m, 1], s=9, alpha=0.55, edgecolors="none",
                       c=COLORS.get(task, "#666"), label=task)
        ax.set_title(f"{name} — LDA (held-out episodes)\nprobe accuracy {acc:.1%} vs chance {chance:.1%}",
                     fontsize=10.5)
        ax.set_xlabel("LD1"); ax.set_ylabel("LD2")
        ax.spines[["top", "right"]].set_visible(False)
    axes[0].legend(frameon=False, fontsize=9)

    # Panel 3: which PCA component carries cable identity, if any.
    X = results["ACT encoder"][0]
    Xc = X - X.mean(0)
    p = PCA(n_components=30).fit(Xc)
    Z = p.transform(Xc)
    sep = []
    for k in range(30):
        groups = [Z[y == t, k] for t in sorted(set(y))]
        between = np.var([g.mean() for g in groups])
        within = np.mean([g.var() for g in groups])
        sep.append(between / (within + 1e-12))
    axes[2].bar(range(1, 31), sep, color="#2B6CB0")
    axes[2].set_title("ACT encoder — cable separability per PC\n(between-class / within-class variance)",
                      fontsize=10.5)
    axes[2].set_xlabel("principal component"); axes[2].set_ylabel("separability ratio")
    axes[2].spines[["top", "right"]].set_visible(False)

    fig.suptitle("Does the ACT internal representation encode cable identity?", fontsize=13)
    fig.tight_layout()
    fig.savefig(args.out, dpi=150)
    print(f"\nwrote {args.out}", flush=True)


if __name__ == "__main__":
    main()