"""
pca_3d.py - Generate 3D PCA visualizations from existing NPZ files.

Finds all results/{model}/plots/{condition}/pca/ directories and creates
corresponding results/{model}/plots/{condition}/pca_3d/ directories with
3D PCA plots computed from results/{model}/npz/vectors_{scale}.npz.

Processes all models and all scales by default.

Usage:
    python pca_3d.py
"""

import os
import re
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D  # noqa: F401
from sklearn.decomposition import PCA

RESULTS_DIR = os.path.join(os.path.dirname(__file__), 'results')

CATEGORY_ORDER = ['left', 'right', 'above', 'under', 'far', 'close']
GROUP_ORDER    = ['horizontal', 'vertical', 'distance']

# Category colors match their group: horizontal=green, vertical=orange, distance=purple
CAT_COLORS = {
    'left':  '#2ca02c', 'right':  '#98df8a',  # horizontal → green
    'above': '#ff7f0e', 'under':  '#ffbb78',  # vertical   → orange
    'far':   '#9467bd', 'close':  '#c5b0d5',  # distance   → purple
}
GROUP_COLORS = {
    'horizontal': '#2ca02c',  # green
    'vertical':   '#ff7f0e',  # orange
    'distance':   '#9467bd',  # purple
}


def scatter3d(ax, xs, ys, zs, c, label, alpha=0.45, s=12, marker='o'):
    ax.scatter(xs, ys, zs, c=c, label=label, alpha=alpha, s=s, marker=marker)


def plot_pca_3d(vectors_npz_path, scale, model_type, save_dir):
    """Generate 3-panel 3D PCA figure per layer and save to save_dir."""
    data = np.load(vectors_npz_path, allow_pickle=True)
    layer_keys = [k for k in data.files if k.startswith('orig_L')]
    layers = sorted([int(k.replace('orig_L', '')) for k in layer_keys])

    if not layers:
        print(f"  [skip] No orig_L* keys found in {vectors_npz_path}")
        return

    os.makedirs(save_dir, exist_ok=True)

    for layer in layers:
        orig   = data.get(f'orig_L{layer}')
        swap   = data.get(f'swap_L{layer}')
        labels = data.get(f'labels_L{layer}')
        deltas = data.get(f'delta_L{layer}')
        cats   = data.get(f'categories_L{layer}')
        groups = data.get(f'groups_L{layer}')

        if orig is None or swap is None:
            continue

        # ── Subplot 1: embeddings (orig + swap) ──────────────────────────────
        pca_emb = PCA(n_components=3)
        all_vecs = np.vstack([orig, swap])
        all_proj = pca_emb.fit_transform(all_vecs)
        orig_proj = all_proj[:len(orig)]
        swap_proj = all_proj[len(orig):]
        ev1 = pca_emb.explained_variance_ratio_

        # ── Subplot 2/3: delta vectors ────────────────────────────────────────
        has_delta = (deltas is not None and len(deltas) >= 3)
        if has_delta:
            pca_d = PCA(n_components=3)
            delta_proj = pca_d.fit_transform(deltas)
            ev2 = pca_d.explained_variance_ratio_
        else:
            delta_proj = None
            ev2 = None

        fig = plt.figure(figsize=(24, 8))

        # ── Panel 1 ───────────────────────────────────────────────────────────
        ax1 = fig.add_subplot(131, projection='3d')
        for cat in CATEGORY_ORDER:
            mask = np.array([str(l) == cat for l in labels])
            if not mask.any():
                continue
            c = CAT_COLORS.get(cat, 'gray')
            scatter3d(ax1, orig_proj[mask, 0], orig_proj[mask, 1], orig_proj[mask, 2],
                      c=c, label=f'{cat} (orig)', marker='o')
            scatter3d(ax1, swap_proj[mask, 0], swap_proj[mask, 1], swap_proj[mask, 2],
                      c=c, label=f'{cat} (swap)', marker='^')
        ax1.set_title('Embeddings by Category\n(o=orig, ^=swap)', fontsize=10)
        ax1.set_xlabel(f'PC1 ({ev1[0]:.1%})', fontsize=8)
        ax1.set_ylabel(f'PC2 ({ev1[1]:.1%})', fontsize=8)
        ax1.set_zlabel(f'PC3 ({ev1[2]:.1%})', fontsize=8)
        ax1.legend(fontsize=6, ncol=2, loc='upper left')

        # ── Panel 2 ───────────────────────────────────────────────────────────
        ax2 = fig.add_subplot(132, projection='3d')
        if has_delta and groups is not None:
            for group in GROUP_ORDER:
                mask = np.array([str(g) == group for g in groups])
                if not mask.any():
                    continue
                scatter3d(ax2, delta_proj[mask, 0], delta_proj[mask, 1], delta_proj[mask, 2],
                          c=GROUP_COLORS.get(group, 'gray'), label=group)
            ax2.set_title('Delta Vectors by Group', fontsize=10)
            ax2.set_xlabel(f'PC1 ({ev2[0]:.1%})', fontsize=8)
            ax2.set_ylabel(f'PC2 ({ev2[1]:.1%})', fontsize=8)
            ax2.set_zlabel(f'PC3 ({ev2[2]:.1%})', fontsize=8)
            ax2.legend(fontsize=8)
        else:
            ax2.set_title('Delta Vectors by Group\n(no data)', fontsize=10)

        # ── Panel 3 ───────────────────────────────────────────────────────────
        ax3 = fig.add_subplot(133, projection='3d')
        if has_delta and cats is not None:
            for cat in CATEGORY_ORDER:
                mask = np.array([str(c) == cat for c in cats])
                if not mask.any():
                    continue
                scatter3d(ax3, delta_proj[mask, 0], delta_proj[mask, 1], delta_proj[mask, 2],
                          c=CAT_COLORS.get(cat, 'gray'), label=cat)
            ax3.set_title('Delta Vectors by Category', fontsize=10)
            ax3.set_xlabel(f'PC1 ({ev2[0]:.1%})', fontsize=8)
            ax3.set_ylabel(f'PC2 ({ev2[1]:.1%})', fontsize=8)
            ax3.set_zlabel(f'PC3 ({ev2[2]:.1%})', fontsize=8)
            ax3.legend(fontsize=7, ncol=2)
        else:
            ax3.set_title('Delta Vectors by Category\n(no data)', fontsize=10)

        fig.suptitle(f'{model_type.upper()} ({scale}) - Layer {layer} - 3D PCA', fontweight='bold')
        plt.tight_layout()
        out_path = os.path.join(save_dir, f'pca_{scale}_L{layer}.png')
        plt.savefig(out_path, dpi=200, bbox_inches='tight')
        plt.close()
        print(f"  Saved {out_path}")


def scale_from_npz_name(name):
    """'vectors_80k.npz' -> '80k'"""
    m = re.match(r'vectors_(.+)\.npz$', name)
    return m.group(1) if m else None


def main():
    if not os.path.isdir(RESULTS_DIR):
        print(f"Results directory not found: {RESULTS_DIR}")
        return

    for model in sorted(os.listdir(RESULTS_DIR)):
        model_dir = os.path.join(RESULTS_DIR, model)
        if not os.path.isdir(model_dir):
            continue

        plots_dir = os.path.join(model_dir, 'plots')
        npz_dir   = os.path.join(model_dir, 'npz')

        if not os.path.isdir(plots_dir):
            print(f"[{model}] no plots/ dir, skipping")
            continue
        if not os.path.isdir(npz_dir):
            print(f"[{model}] no npz/ dir, skipping")
            continue

        npz_files = sorted(
            f for f in os.listdir(npz_dir)
            if f.startswith('vectors_') and f.endswith('.npz')
        )
        if not npz_files:
            print(f"[{model}] no vectors_*.npz files, skipping")
            continue

        # Find all pca/ dirs under plots/ (handles all/ , all_with_validity/ , etc.)
        pca_dirs = []
        for dirpath, dirnames, _ in os.walk(plots_dir):
            if os.path.basename(dirpath) == 'pca':
                pca_dirs.append(dirpath)

        if not pca_dirs:
            print(f"[{model}] no pca/ dirs found under plots/, skipping")
            continue

        for npz_file in npz_files:
            scale = scale_from_npz_name(npz_file)
            if scale is None:
                continue
            npz_path = os.path.join(npz_dir, npz_file)

            for pca_dir in pca_dirs:
                parent    = os.path.dirname(pca_dir)       # e.g. plots/all
                pca_3d_dir = os.path.join(parent, 'pca_3d')
                print(f"[{model}] scale={scale}  -> {pca_3d_dir}")
                plot_pca_3d(npz_path, scale, model, pca_3d_dir)


if __name__ == '__main__':
    main()