"""Direction extraction — v8b (dense Qwen3-8B, no MoE mask).

Per layer:
  1. mean-difference vector (positive class minus negative class)
  2. PCA-denoise it within the top-N principal components of all activations
  3. orthogonalize against the layer's general mean

The MoE expert-coordinate mask from the 30B pipeline is dropped entirely
— Qwen3-8B is dense, so there are no experts to select or mask.
"""
from typing import Dict
import torch


def _pca_topk(X, k):
    X = X.float()
    if X.shape[0] < 2 or X.shape[1] < 2:
        return (torch.zeros(0, X.shape[1] if X.dim() == 2 else 0),
                torch.zeros(0))
    U, S, Vh = torch.linalg.svd(X, full_matrices=False)
    k = min(k, Vh.shape[0])
    return Vh[:k], (S[:k] ** 2) / (X.shape[0] - 1)


def compute_pos_vs_neg_pca(acts, labels, n_pca_components):
    pos = acts[labels == 1].float()
    neg = acts[labels == 0].float()
    info = {"n_pos": int(pos.shape[0]), "n_neg": int(neg.shape[0])}
    h = acts.shape[1]
    if pos.shape[0] < 10 or neg.shape[0] < 10:
        info["error"] = "too_few_samples"
        return torch.zeros(h), info

    md_raw = pos.mean(0) - neg.mean(0)
    md_raw_norm = float(md_raw.norm())
    info["mean_diff_norm_raw"] = md_raw_norm
    if md_raw_norm < 1e-8:
        return torch.zeros(h), info

    all_acts = acts.float()
    if n_pca_components <= 0:
        info["var_explained_pca"] = []
        info["pca_n_returned"] = 0
        pca_components = torch.zeros(0, h)
    else:
        Xc = all_acts - all_acts.mean(0)
        pca_components, var_exp = _pca_topk(Xc, n_pca_components)
        info["var_explained_pca"] = var_exp.tolist()
        info["pca_n_returned"] = int(pca_components.shape[0])

    if pca_components.shape[0] == 0:
        md_filtered = md_raw
        info["pca_denoise_applied"] = False
    else:
        Q = pca_components
        md_filtered = ((Q @ md_raw).unsqueeze(0) @ Q).squeeze(0)
        info["pca_denoise_applied"] = True

    md_filt_norm = float(md_filtered.norm())
    info["mean_diff_norm_filtered"] = md_filt_norm
    info["denoise_keep_ratio"] = (
        md_filt_norm / md_raw_norm if md_raw_norm > 1e-8 else 0.0
    )
    if md_filt_norm < 1e-8:
        return torch.zeros(h), info

    return md_filtered / md_filt_norm, info


def orthogonalize_against_general(direction, general, min_residual=0.20):
    g = general.float()
    gn = g.norm()
    if gn < 1e-8:
        return direction
    g = g / gn
    d = direction.float()
    d = d - (d @ g) * g
    dn = d.norm()
    on = direction.float().norm()
    if dn < 1e-8 or (on > 1e-8 and dn / on < min_residual):
        return None
    return (d / dn).to(direction.dtype)


def build_layer_directions(per_layer_data,
                           n_pca_components=100,
                           min_residual_after_general=0.20,
                           disable_pca=False,
                           disable_ortho=False,
                           logger=None):
    directions = {}
    diagnostics = {}
    for L in sorted(per_layer_data.keys()):
        acts = per_layer_data[L]["acts"]
        labels = per_layer_data[L]["labels"]
        eff_pca = 0 if disable_pca else n_pca_components
        mean_diff, info = compute_pos_vs_neg_pca(acts, labels, eff_pca)
        if "error" in info or mean_diff.norm() < 1e-8:
            if logger:
                logger.info(f"  L{L}: SKIP ({info.get('error', 'low norm')})")
            diagnostics[L] = info
            continue
        if disable_ortho:
            md_n = mean_diff.float().norm()
            final = (mean_diff.float() / md_n).to(mean_diff.dtype) if md_n > 1e-8 else None
        else:
            general = acts.float().mean(0)
            final = orthogonalize_against_general(
                mean_diff, general, min_residual_after_general
            )
        if final is None:
            if logger:
                logger.info(f"  L{L}: SKIP (low residual after general)")
            info["skip_reason"] = "low_residual_after_general"
            diagnostics[L] = info
            continue
        directions[L] = final.unsqueeze(0)
        info["kept"] = True
        diagnostics[L] = info
        if logger:
            logger.info(
                f"  L{L}: kept norm_raw={info['mean_diff_norm_raw']:.2f} "
                f"keep_ratio={info['denoise_keep_ratio']:.3f}"
            )
    return directions, diagnostics