"""MWP — MLP-Write Topology (admissible cross-layer on MLP substrate).

HalluZig lists "blind to MLP layer failures" as an explicit limitation
of attention-only methods. MWP addresses this. For each layer:
  m_ell^t in R^D  is the MLP block's write to the residual stream at
                  token t (read from ForwardCache.mlp_out).

Per layer we build a sparse top-k cosine-similarity graph among the T
MLP-write vectors, then apply ZAP-style zigzag (#CC, #cycles,
shared-edge, Jaccard, cumulative) over the depth sequence.

Per-sample features: same 21-scalar structure as ZAP, computed on the
MLP-write graph sequence instead of the attention graph sequence.

Admissible: pure MLP-output geometry, no W_cls, no softmax outputs.
Different substrate from ZAP (MLP writes vs attention edges).
"""
from __future__ import annotations
import numpy as np


def _columns():
    cols = []
    for name in ("cc", "cyc"):
        for stat in ("mean", "std", "max", "argmax", "late", "early"):
            cols.append(f"mwp_{name}_{stat}")
    for name in ("shared", "jacc"):
        for stat in ("mean", "std", "min", "argmin"):
            cols.append(f"mwp_{name}_{stat}")
    cols.append("mwp_cum_shared_ratio")
    return cols


COLUMNS = _columns()
DIM = len(COLUMNS)


def _connected_components(edges_set, V):
    parent = list(range(V))
    def find(x):
        while parent[x] != x:
            parent[x] = parent[parent[x]]
            x = parent[x]
        return x
    def union(x, y):
        rx, ry = find(x), find(y)
        if rx != ry: parent[rx] = ry
    for (u, v) in edges_set: union(u, v)
    return len({find(i) for i in range(V)})


def extract_mwp(model, input_ids, attention_mask, cache, pred_label=None):
    """Return (features (B, DIM), columns).

    Reads cache.mlp_out: list of L tensors of shape (B, T, D).
    """
    B = input_ids.shape[0]
    if not getattr(cache, "mlp_out", None):
        return np.zeros((B, DIM), dtype=np.float32), COLUMNS
    L = len(cache.mlp_out)
    feats = np.zeros((B, DIM), dtype=np.float32)

    for b in range(B):
        T_b = int(attention_mask[b].sum().item())
        T_max = cache.mlp_out[0].shape[1]
        T = max(min(T_b, T_max), 3)

        cc = np.zeros(L, dtype=np.float32)
        cyc = np.zeros(L, dtype=np.float32)
        edges_per_layer = []
        for l in range(L):
            M = cache.mlp_out[l][b, :T].detach().float().cpu().numpy()  # (T, D)
            norms = np.linalg.norm(M, axis=-1, keepdims=True)
            U = M / np.maximum(norms, 1e-9)
            sim = U @ U.T
            np.fill_diagonal(sim, 0.0)
            iu = np.triu_indices(T, k=1)
            w = sim[iu]
            if w.size == 0:
                edges_per_layer.append(set())
                cc[l] = T; cyc[l] = 0.0; continue
            k = max(int(0.10 * w.size), 1)
            thr = np.partition(w, -k)[-k]
            mask = w >= thr
            us = iu[0][mask].tolist()
            vs = iu[1][mask].tolist()
            es = {(min(u, v), max(u, v)) for u, v in zip(us, vs)}
            cc_l = _connected_components(es, T)
            cc[l] = cc_l; cyc[l] = len(es) - T + cc_l
            edges_per_layer.append(es)

        shared = np.zeros(max(L - 1, 1), dtype=np.float32)
        jacc = np.zeros(max(L - 1, 1), dtype=np.float32)
        for l in range(L - 1):
            a = edges_per_layer[l]; b_ = edges_per_layer[l + 1]
            inter = len(a & b_); union = len(a | b_)
            shared[l] = inter / max(union, 1); jacc[l] = inter / max(union, 1)
        cum_inter = set.intersection(*edges_per_layer) if all(edges_per_layer) else set()
        cum_union = set.union(*edges_per_layer) if any(edges_per_layer) else set()
        cum_ratio = len(cum_inter) / max(len(cum_union), 1)

        half = L // 2
        idx = 0
        for arr in (cc, cyc):
            feats[b, idx + 0] = float(arr.mean())
            feats[b, idx + 1] = float(arr.std())
            feats[b, idx + 2] = float(arr.max())
            feats[b, idx + 3] = float(np.argmax(arr))
            feats[b, idx + 4] = float(arr[half:].mean())
            feats[b, idx + 5] = float(arr[:half].mean())
            idx += 6
        for arr in (shared, jacc):
            if arr.size == 0: idx += 4; continue
            feats[b, idx + 0] = float(arr.mean())
            feats[b, idx + 1] = float(arr.std())
            feats[b, idx + 2] = float(arr.min())
            feats[b, idx + 3] = float(np.argmin(arr))
            idx += 4
        feats[b, idx] = float(cum_ratio)
    return feats, COLUMNS