"""
Claim 3 mechanism validation on the real LLaVA-1.5 vision tower
(openai/clip-vit-large-patch14-336). Confirms:
  - temporal-shift importance is computable from ViT per-layer hidden states,
  - it is NOT position-biased (unlike CLS attention, which over-concentrates),
  - SPLIT selection runs end-to-end and spreads tokens across regions.
Outputs a JSON summary + heatmap PNGs.
"""
import os, sys, json
import numpy as np
import torch
from PIL import Image
sys.path.insert(0, os.path.join(os.path.dirname(__file__)))
from split_prune import (temporal_shift_importance, region_ids_grid,
                         allocate_region_budgets, diversity_scores, split_select,
                         attention_select, random_select)

MODEL = "openai/clip-vit-large-patch14-336"
DEVICE = "mps" if torch.backends.mps.is_available() else "cpu"
GRID = (24, 24)
REGION = (4, 4)


def gini(x):
    x = np.sort(np.asarray(x, dtype=float)); n = len(x)
    if x.sum() == 0: return 0.0
    return (2 * np.arange(1, n + 1) - n - 1).dot(x) / (n * x.sum())


def region_spread(idx, N=576, grid=GRID, region=REGION):
    rid = region_ids_grid(N, grid, region).numpy()
    counts = np.bincount(rid[idx.cpu().numpy()], minlength=region[0]*region[1])
    return counts


def main():
    from transformers import CLIPVisionModel, CLIPImageProcessor
    proc = CLIPImageProcessor.from_pretrained(MODEL)
    model = CLIPVisionModel.from_pretrained(MODEL, torch_dtype=torch.float32,
                                            attn_implementation="eager").to(DEVICE).eval()
    imgs = ["outputs/sample_images/cats.jpg", "outputs/sample_images/dogball.jpg"]
    summary = {"model": MODEL, "device": DEVICE, "grid": GRID, "regions": REGION, "images": {}}
    for path in imgs:
        img = Image.open(path).convert("RGB")
        px = proc(images=img, return_tensors="pt")["pixel_values"].to(DEVICE)
        with torch.no_grad():
            out = model(px, output_hidden_states=True, output_attentions=True)
        # hidden_states: tuple(L+1) each [1, 577, 1024]; drop CLS (index 0)
        hs = [h[0, 1:, :].float().cpu() for h in out.hidden_states]
        N = hs[0].shape[0]
        # final patch embeddings for diversity (last hidden state, pre-projection)
        emb = hs[-1]
        imp = temporal_shift_importance(hs)                        # [576]
        # CLS -> patch attention averaged over heads & layers (FastV/HiRED signal)
        att = torch.stack([a[0, :, 0, 1:].mean(0) for a in out.attentions]).mean(0).float().cpu()

        res = {"N": N}
        # importance vs attention: position bias measured by center-of-mass row
        def com_row(w):
            w = w.numpy(); w = w / w.sum()
            rows = np.arange(N) // GRID[1]
            return float((w * rows).sum())
        res["imp_com_row"] = com_row(imp)          # ~11.5 = centered/unbiased
        res["att_com_row"] = com_row(att)
        res["imp_gini"] = float(gini(imp.numpy()))
        res["att_gini"] = float(gini(att.numpy()))
        res["imp_att_spearman"] = float(np.corrcoef(
            imp.numpy().argsort().argsort(), att.numpy().argsort().argsort())[0, 1])

        # region spread at budget 64: SPLIT vs attention-topk vs random
        for B in [192, 64]:
            s_idx = split_select(hs, emb, B, GRID, REGION)
            a_idx = attention_select(att, B)
            r_idx = random_select(N, B, generator=torch.Generator().manual_seed(0))
            res[f"regions_nonempty_split_B{B}"] = int((region_spread(s_idx) > 0).sum())
            res[f"regions_nonempty_attn_B{B}"] = int((region_spread(a_idx) > 0).sum())
            res[f"region_gini_split_B{B}"] = float(gini(region_spread(s_idx)))
            res[f"region_gini_attn_B{B}"] = float(gini(region_spread(a_idx)))
        summary["images"][os.path.basename(path)] = res
        print(os.path.basename(path), json.dumps(res, indent=2))

    os.makedirs("outputs", exist_ok=True)
    with open("outputs/mechanism_validation.json", "w") as f:
        json.dump(summary, f, indent=2)
    print("wrote outputs/mechanism_validation.json")


if __name__ == "__main__":
    main()