import argparse
import os
import sys
from typing import Dict, List, Optional, Tuple

import numpy as np
import yaml

import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
SRC_DIR = os.path.join(ROOT_DIR, "src")
if SRC_DIR not in sys.path:
    sys.path.append(SRC_DIR)

from gliomasam3_moe.data.brats_dataset import BraTSDataset, SegMambaNPZDataset
from gliomasam3_moe.data.transforms_segmamba_like import get_infer_transforms
from gliomasam3_moe.models.gliomasam3_moe import GliomaSAM3_MoE

from vis_utils import (
    ensure_dir,
    load_case,
    load_prediction,
    normalize_volume,
    label_to_regions,
    regions_to_label,
    select_slices_from_mask,
    fallback_slices,
    extract_slice,
    overlay_masks,
    boundary_error_map,
    mask_boundary,
    connected_components,
    bin_by_threshold,
    fft_amplitude_slice,
    fourier_amplitude_mix,
)


def load_config(path: str) -> Dict:
    with open(path, "r") as f:
        return yaml.safe_load(f)


def get_default_colors() -> Dict[str, Tuple[float, float, float]]:
    return {
        "WT": (1.0, 0.85, 0.0),
        "TC": (0.0, 1.0, 0.25),
        "ET": (1.0, 0.0, 0.0),
    }


class CaseLoader:
    def __init__(self, cfg: Dict):
        self.data_cfg = cfg.get("data", {})
        self.cache: Dict[Tuple[str, bool], Dict] = {}

    def _rename_modalities(self, images: Dict[str, np.ndarray]) -> Dict[str, np.ndarray]:
        modalities = self.data_cfg.get("modalities", [])
        if modalities and all(k.startswith("ch") for k in images.keys()):
            if len(modalities) == len(images):
                return {m: images[f"ch{i}"] for i, m in enumerate(modalities)}
        return images

    def get_case(self, case_id: str, include_label: bool = True) -> Dict:
        key = (case_id, include_label)
        if key in self.cache:
            return self.cache[key]
        images, label, affine = load_case(self.data_cfg, case_id, include_label=include_label)
        images = self._rename_modalities(images)
        images = {k: normalize_volume(v) for k, v in images.items()}
        out = {"images": images, "label": label, "affine": affine}
        self.cache[key] = out
        return out


class PredictionLoader:
    def __init__(self, cfg: Dict):
        pred_cfg = cfg.get("predictions", {})
        self.ours = pred_cfg.get("ours", {})
        self.baselines = pred_cfg.get("baselines", [])
        self.extra = pred_cfg.get("extra_methods", [])
        self.cross_year = pred_cfg.get("cross_year", {})

    def get_all_methods(self) -> List[Dict]:
        methods = []
        if self.ours:
            methods.append(self.ours)
        methods.extend(self.baselines)
        methods.extend(self.extra)
        return methods

    def load_method(self, method_cfg: Dict, case_id: str) -> Dict:
        pred_dir = method_cfg.get("dir", "")
        pred_type = method_cfg.get("type", "auto")
        return load_prediction(pred_dir, case_id, pred_type=pred_type)


class AuxCache:
    def __init__(self, aux_dir: Optional[str]):
        self.aux_dir = aux_dir

    def path(self, case_id: str) -> Optional[str]:
        if not self.aux_dir:
            return None
        return os.path.join(self.aux_dir, f"{case_id}_aux.npz")

    def load(self, case_id: str) -> Optional[Dict]:
        path = self.path(case_id)
        if path and os.path.isfile(path):
            data = np.load(path)
            return {k: data[k] for k in data.files}
        return None

    def save(self, case_id: str, data: Dict) -> None:
        if not self.aux_dir:
            return
        ensure_dir(self.aux_dir)
        path = self.path(case_id)
        np.savez_compressed(path, **data)


class ModelRunner:
    def __init__(self, vis_cfg: Dict, model_cfg_path: str, ckpt_path: str, device: str):
        import torch
        import torch.nn.functional as F

        self.torch = torch
        self.F = F
        self.vis_cfg = vis_cfg
        self.cfg = load_config(model_cfg_path)
        self.device = torch.device(device if torch.cuda.is_available() else "cpu")
        self.model = GliomaSAM3_MoE(**self.cfg["model"]).to(self.device)
        ckpt = torch.load(ckpt_path, map_location="cpu")
        # Filter out freqs_cis which is dynamically computed and may have shape mismatch
        state_dict = {k: v for k, v in ckpt["model"].items() if "freqs_cis" not in k}
        self.model.load_state_dict(state_dict, strict=False)
        self.model.eval()

    def load_case_tensor(self, case_id: str) -> Tuple["torch.Tensor", str]:
        # Use vis_cfg for data paths, model cfg for other settings
        data_cfg = self.vis_cfg.get("data", {})
        data_format = data_cfg.get("format", "nifti")
        if data_format == "segmamba_npz":
            data_dir = data_cfg.get("npz_dir") or data_cfg.get("root_dir", "")
            if case_id.endswith(".npz"):
                npz_path = case_id
            else:
                npz_path = os.path.join(data_dir, case_id + ".npz")
            dataset = SegMambaNPZDataset(data_dir=data_dir, npz_paths=[npz_path], test=True, ensure_npy=True)
            sample = dataset[0]
            image = sample["image"].unsqueeze(0)
            case = sample["case_id"]
        else:
            root_dir = data_cfg.get("root_dir", "")
            modalities = data_cfg.get("modalities", ["t1n", "t1c", "t2f", "t2w"])
            image_keys = [f"image{i}" for i in range(len(modalities))]
            transforms = get_infer_transforms(self.cfg, image_keys=image_keys)
            dataset = BraTSDataset(
                root_dir=root_dir,
                modalities=modalities,
                seg_name=data_cfg.get("seg_name", "seg"),
                transforms=transforms,
                include_label=False,
                case_ids=[case_id],
                image_keys=image_keys,
            )
            sample = dataset[0]
            image = sample["image"].unsqueeze(0)
            case = sample["case_id"]
        return image, case

    def infer_basic(self, image: "torch.Tensor") -> Dict:
        torch = self.torch
        with torch.no_grad():
            logits, aux = self.model(image.to(self.device))
        probs = torch.sigmoid(logits)
        pi_et = aux["pi_et"].view(probs.shape[0], 1, 1, 1, 1)
        et_pre = probs[:, 2:3]
        et_post = aux.get("et_prob_gated", et_pre * pi_et)
        out = {
            "logits": logits,
            "pi_et": aux["pi_et"],
            "moe_gamma": aux.get("moe_gamma"),
            "spectral_stats": aux.get("spectral_stats"),
            "et_pre": et_pre,
            "et_post": et_post,
        }
        return out

    def forward_intermediate(self, image: "torch.Tensor") -> Dict:
        torch = self.torch
        F = self.F
        model = self.model
        with torch.no_grad():
            b, c, d, h, w = image.shape
            orig_h, orig_w = h, w
            pad_h = (model.patch_size - (h % model.patch_size)) % model.patch_size
            pad_w = (model.patch_size - (w % model.patch_size)) % model.patch_size
            ph0 = pad_h // 2
            ph1 = pad_h - ph0
            pw0 = pad_w // 2
            pw1 = pad_w - pw0
            if pad_h > 0 or pad_w > 0:
                image = F.pad(image, (pw0, pw1, ph0, ph1, 0, 0))
                h, w = image.shape[-2:]

            image = image.to(self.device)
            x_plus, _ = model.hfdi(image)
            x_spec, spectral_stats = model.spectral(image)

            x2d = x_plus.permute(0, 2, 1, 3, 4).reshape(b * d, 7, h, w)
            tokens, (gh, gw) = model.encoder2d(x2d)
            n = gh * gw
            tokens = tokens.view(b, d, n, -1)
            tokens = model.slice_adapter(tokens, direction="forward")

            z = tokens.mean(dim=(1, 2))
            pi_et = model.attr_head(z)["pi_et"]
            token_ids = model._select_concept_tokens(pi_et, label=None)
            prompt = model.prompt_encoder(token_ids)
            tokens = model.prompt_film(tokens, prompt)

            u = tokens.view(b, d, gh, gw, -1).permute(0, 4, 1, 2, 3)
            u_msda = model.dual_enhance.msda(u)
            u_lv1 = model.dual_enhance.fa_level(u)
            u_fa = model.dual_enhance.fa_fuse(torch.cat([u, u_lv1], dim=1))
            pool = torch.cat([u_fa, u_msda], dim=1).mean(dim=(2, 3, 4))
            eta = torch.sigmoid(model.dual_enhance.fcf_mlp(pool)).view(b, 1, 1, 1, 1)
            u_fuse = eta * u_fa + (1.0 - eta) * u_msda
            u_spec = model.dual_enhance.spec_stem(x_spec)
            u_out = model.dual_enhance.fuse_conv(torch.cat([u_fuse, u_spec], dim=1))

            logits, gamma = model.moe_decoder(u_out, z, prompt, spectral_stats, target_size=(d, h, w))
            if pad_h > 0 or pad_w > 0:
                logits = logits[:, :, :, ph0 : ph0 + orig_h, pw0 : pw0 + orig_w]

            et_pre = torch.sigmoid(logits[:, 2:3])
            et_post = et_pre * pi_et.view(b, 1, 1, 1, 1)

            u_up = F.interpolate(u_out, size=(d, h, w), mode="trilinear", align_corners=False)
            logits_all = torch.stack([exp(u_up) for exp in model.moe_decoder.experts], dim=1)
            prob_all = torch.sigmoid(logits_all)
            mean_prob = prob_all.mean(dim=(3, 4, 5))
            contrib = gamma.view(b, -1, 1) * mean_prob

            return {
                "pi_et": pi_et,
                "moe_gamma": gamma,
                "spectral_stats": spectral_stats,
                "et_pre": et_pre,
                "et_post": et_post,
                "expert_contrib": contrib,
                "x_spec": x_spec,
                "u_fuse": u_fuse,
                "u_spec": u_spec,
                "logits": logits,
            }


def choose_overlay_modality(cfg: Dict, images: Dict[str, np.ndarray]) -> str:
    pref = cfg.get("visualization", {}).get("overlay_modality")
    if pref and pref in images:
        return pref
    for cand in ["t1c", "t2w", "t2f", "t1n"]:
        if cand in images:
            return cand
    return list(images.keys())[0]


def get_slices(mask_ref: Optional[np.ndarray], vol_shape: Tuple[int, int, int]) -> Dict[str, int]:
    idx = select_slices_from_mask(mask_ref)
    if any(v is None for v in idx.values()):
        idx = fallback_slices(vol_shape)
    return idx


def save_fig(path: str) -> None:
    ensure_dir(os.path.dirname(path))
    plt.tight_layout()
    plt.savefig(path, dpi=200)
    plt.close()


def make_qualitative(cfg: Dict, case_loader: CaseLoader, pred_loader: PredictionLoader, out_dir: str) -> None:
    cases = cfg.get("cases", {}).get("qualitative", [])
    if not cases:
        return
    colors = cfg.get("visualization", {}).get("colors", get_default_colors())
    alpha = cfg.get("visualization", {}).get("alpha", 0.45)
    methods = pred_loader.get_all_methods()
    for case_id in cases:
        case = case_loader.get_case(case_id, include_label=True)
        images = case["images"]
        label = case["label"]
        overlay_mod = choose_overlay_modality(cfg, images)
        base = images[overlay_mod]
        mask_ref = None
        if label is not None:
            mask_ref = label_to_regions(label)[2]
        else:
            try:
                ours_pred = pred_loader.load_method(pred_loader.ours, case_id)
                mask_ref = ours_pred["regions"][2]
            except Exception:
                mask_ref = None
        idx = get_slices(mask_ref, base.shape)
        planes = ["axial", "coronal", "sagittal"]
        rows = []
        row_labels = []
        for mod in images.keys():
            rows.append([extract_slice(images[mod], p, idx[p]) for p in planes])
            row_labels.append(mod.upper())

        if label is not None:
            regions = label_to_regions(label)
            row = []
            for p in planes:
                base2d = extract_slice(base, p, idx[p])
                masks = {
                    "WT": extract_slice(regions[0], p, idx[p]) > 0,
                    "TC": extract_slice(regions[1], p, idx[p]) > 0,
                    "ET": extract_slice(regions[2], p, idx[p]) > 0,
                }
                row.append(overlay_masks(base2d, masks, colors, alpha=alpha))
            rows.append(row)
            row_labels.append("GT")

        for method in methods:
            pred = pred_loader.load_method(method, case_id)
            regions = pred["regions"]
            row = []
            for p in planes:
                base2d = extract_slice(base, p, idx[p])
                masks = {
                    "WT": extract_slice(regions[0], p, idx[p]) > 0,
                    "TC": extract_slice(regions[1], p, idx[p]) > 0,
                    "ET": extract_slice(regions[2], p, idx[p]) > 0,
                }
                row.append(overlay_masks(base2d, masks, colors, alpha=alpha))
            rows.append(row)
            row_labels.append(method.get("name", "Method"))

        fig, axes = plt.subplots(len(rows), len(planes), figsize=(4 * len(planes), 3 * len(rows)))
        for r, row in enumerate(rows):
            for c, img in enumerate(row):
                ax = axes[r, c] if len(rows) > 1 else axes[c]
                if img.ndim == 2:
                    ax.imshow(img, cmap="gray")
                else:
                    ax.imshow(img)
                ax.axis("off")
                if r == 0:
                    ax.set_title(planes[c], fontsize=10)
            ax0 = axes[r, 0] if len(rows) > 1 else axes[0]
            ax0.set_ylabel(row_labels[r], rotation=0, labelpad=40, fontsize=9, va="center")
        save_fig(os.path.join(out_dir, "qualitative", f"{case_id}.png"))


def make_et_absent(cfg: Dict, case_loader: CaseLoader, pred_loader: PredictionLoader, aux: AuxCache, runner: Optional[ModelRunner], out_dir: str) -> None:
    cases = cfg.get("cases", {}).get("et_absent", [])
    if not cases:
        return
    colors = cfg.get("visualization", {}).get("colors", get_default_colors())
    alpha = cfg.get("visualization", {}).get("alpha", 0.5)
    for case_id in cases:
        case = case_loader.get_case(case_id, include_label=False)
        images = case["images"]
        overlay_mod = choose_overlay_modality(cfg, images)
        base = images[overlay_mod]

        aux_data = aux.load(case_id)
        needed_keys = ["pi_et", "et_pre", "et_post"]
        if aux_data is None or not all(k in aux_data for k in needed_keys):
            if runner is None:
                continue
            image, _ = runner.load_case_tensor(case_id)
            out = runner.forward_intermediate(image)
            new_data = {
                "pi_et": out["pi_et"].detach().cpu().numpy(),
                "et_pre": out["et_pre"].detach().cpu().numpy(),
                "et_post": out["et_post"].detach().cpu().numpy(),
            }
            if aux_data is not None:
                aux_data.update(new_data)
            else:
                aux_data = new_data
            aux.save(case_id, aux_data)
        if aux_data is None:
            continue

        et_pre = aux_data["et_pre"][0, 0]
        et_post = aux_data["et_post"][0, 0]
        pi_et = float(np.asarray(aux_data["pi_et"]).reshape(-1)[0])

        idx = get_slices(et_pre > 0.5, base.shape)
        planes = ["axial", "coronal", "sagittal"]
        fig, axes = plt.subplots(2, len(planes), figsize=(4 * len(planes), 6))
        for c, p in enumerate(planes):
            base2d = extract_slice(base, p, idx[p])
            pre2d = extract_slice(et_pre, p, idx[p])
            post2d = extract_slice(et_post, p, idx[p])
            for r, (prob, title) in enumerate([(pre2d, "ET before gate"), (post2d, "ET after gate")]):
                ax = axes[r, c]
                ax.imshow(base2d, cmap="gray")
                im = ax.imshow(prob, cmap="magma", alpha=0.6)
                mask = prob > 0.5
                overlay = overlay_masks(base2d, {"ET": mask}, colors, alpha=alpha)
                ax.imshow(overlay, alpha=0.4)
                ax.axis("off")
                if c == 0:
                    ax.set_ylabel(title, rotation=0, labelpad=40, fontsize=9, va="center")
                if r == 0:
                    ax.set_title(p, fontsize=10)
            fig.colorbar(im, ax=axes[:, c], fraction=0.02, pad=0.01)
        fig.suptitle(f"{case_id} | pi_ET={pi_et:.3f}", fontsize=11)
        save_fig(os.path.join(out_dir, "et_absent", f"{case_id}.png"))


def make_boundary(cfg: Dict, case_loader: CaseLoader, pred_loader: PredictionLoader, out_dir: str) -> None:
    cases = cfg.get("cases", {}).get("boundary", [])
    if not cases:
        return
    colors = cfg.get("visualization", {}).get("colors", get_default_colors())
    for case_id in cases:
        case = case_loader.get_case(case_id, include_label=True)
        if case["label"] is None:
            continue
        images = case["images"]
        overlay_mod = choose_overlay_modality(cfg, images)
        base = images[overlay_mod]
        gt_regions = label_to_regions(case["label"])
        pred = pred_loader.load_method(pred_loader.ours, case_id)
        pred_regions = pred["regions"]
        region_idx = {"WT": 0, "TC": 1, "ET": 2}[cfg.get("visualization", {}).get("boundary_region", "ET")]
        mask_ref = gt_regions[region_idx]
        idx = get_slices(mask_ref, base.shape)
        planes = ["axial", "coronal", "sagittal"]
        fig, axes = plt.subplots(3, len(planes), figsize=(4 * len(planes), 9))
        for c, p in enumerate(planes):
            base2d = extract_slice(base, p, idx[p])
            gt2d = extract_slice(gt_regions[region_idx], p, idx[p]) > 0
            pred2d = extract_slice(pred_regions[region_idx], p, idx[p]) > 0
            err2d = extract_slice(boundary_error_map(pred_regions[region_idx], gt_regions[region_idx]), p, idx[p])
            ax0 = axes[0, c]
            ax0.imshow(base2d, cmap="gray")
            ax0.axis("off")
            ax0.set_title(p, fontsize=10)

            ax1 = axes[1, c]
            ax1.imshow(base2d, cmap="gray")
            gt_b = mask_boundary(gt2d)
            pr_b = mask_boundary(pred2d)
            ax1.imshow(np.dstack([gt_b, np.zeros_like(gt_b), pr_b]).astype(float), alpha=0.8)
            ax1.axis("off")

            ax2 = axes[2, c]
            ax2.imshow(base2d, cmap="gray")
            max_err = float(np.max(np.abs(err2d)))
            if max_err <= 0:
                max_err = 1.0
            im = ax2.imshow(err2d, cmap="coolwarm", alpha=0.7, vmin=-max_err, vmax=max_err)
            ax2.axis("off")
            fig.colorbar(im, ax=ax2, fraction=0.03, pad=0.01)
        axes[0, 0].set_ylabel("Base", rotation=0, labelpad=35, va="center", fontsize=9)
        axes[1, 0].set_ylabel("GT vs Pred\nBoundary", rotation=0, labelpad=35, va="center", fontsize=9)
        axes[2, 0].set_ylabel("Signed Error", rotation=0, labelpad=35, va="center", fontsize=9)
        save_fig(os.path.join(out_dir, "boundary", f"{case_id}.png"))


def make_tiny_et(cfg: Dict, case_loader: CaseLoader, pred_loader: PredictionLoader, out_dir: str) -> None:
    cases = cfg.get("cases", {}).get("tiny_et", [])
    if not cases:
        return
    colors = cfg.get("visualization", {}).get("colors", get_default_colors())
    alpha = cfg.get("visualization", {}).get("alpha", 0.5)
    methods = pred_loader.get_all_methods()
    for case_id in cases:
        case = case_loader.get_case(case_id, include_label=True)
        images = case["images"]
        overlay_mod = choose_overlay_modality(cfg, images)
        base = images[overlay_mod]
        gt_regions = label_to_regions(case["label"]) if case["label"] is not None else None
        mask_ref = gt_regions[2] if gt_regions is not None else None
        idx = get_slices(mask_ref, base.shape)
        planes = ["axial", "coronal", "sagittal"]
        rows = []
        row_labels = []
        if gt_regions is not None:
            row = []
            for p in planes:
                base2d = extract_slice(base, p, idx[p])
                et2d = extract_slice(gt_regions[2], p, idx[p]) > 0
                row.append(overlay_masks(base2d, {"ET": et2d}, colors, alpha=alpha))
            rows.append(row)
            row_labels.append("GT")
        for method in methods:
            pred = pred_loader.load_method(method, case_id)
            regions = pred["regions"]
            row = []
            for p in planes:
                base2d = extract_slice(base, p, idx[p])
                et2d = extract_slice(regions[2], p, idx[p]) > 0
                row.append(overlay_masks(base2d, {"ET": et2d}, colors, alpha=alpha))
            rows.append(row)
            row_labels.append(method.get("name", "Method"))

        fig, axes = plt.subplots(len(rows), len(planes), figsize=(4 * len(planes), 3 * len(rows)))
        for r, row in enumerate(rows):
            for c, img in enumerate(row):
                ax = axes[r, c] if len(rows) > 1 else axes[c]
                ax.imshow(img)
                ax.axis("off")
                if r == 0:
                    ax.set_title(planes[c], fontsize=10)
            ax0 = axes[r, 0] if len(rows) > 1 else axes[0]
            ax0.set_ylabel(row_labels[r], rotation=0, labelpad=35, va="center", fontsize=9)
        save_fig(os.path.join(out_dir, "tiny_et", f"{case_id}.png"))


def make_cross_year(cfg: Dict, case_loader: CaseLoader, pred_loader: PredictionLoader, out_dir: str) -> None:
    cross_cfg = cfg.get("cases", {}).get("cross_year", {})
    if not cross_cfg:
        return
    colors = cfg.get("visualization", {}).get("colors", get_default_colors())
    alpha = cfg.get("visualization", {}).get("alpha", 0.45)
    for direction, entry in cross_cfg.items():
        cases = entry.get("cases", [])
        method = entry.get("method", pred_loader.ours)
        if not cases or not method:
            continue
        for case_id in cases:
            case = case_loader.get_case(case_id, include_label=True)
            images = case["images"]
            overlay_mod = choose_overlay_modality(cfg, images)
            base = images[overlay_mod]
            gt_regions = label_to_regions(case["label"]) if case["label"] is not None else None
            pred = pred_loader.load_method(method, case_id)
            pred_regions = pred["regions"]
            mask_ref = gt_regions[2] if gt_regions is not None else pred_regions[2]
            idx = get_slices(mask_ref, base.shape)
            planes = ["axial", "coronal", "sagittal"]

            fig, axes = plt.subplots(3 if gt_regions is not None else 2, len(planes), figsize=(4 * len(planes), 8))
            for c, p in enumerate(planes):
                base2d = extract_slice(base, p, idx[p])
                ax0 = axes[0, c]
                ax0.imshow(base2d, cmap="gray")
                ax0.axis("off")
                ax0.set_title(p, fontsize=10)
                if gt_regions is not None:
                    gt2d = {
                        "WT": extract_slice(gt_regions[0], p, idx[p]) > 0,
                        "TC": extract_slice(gt_regions[1], p, idx[p]) > 0,
                        "ET": extract_slice(gt_regions[2], p, idx[p]) > 0,
                    }
                    axes[1, c].imshow(overlay_masks(base2d, gt2d, colors, alpha=alpha))
                    axes[1, c].axis("off")
                    pred_row = 2
                else:
                    pred_row = 1
                pred2d = {
                    "WT": extract_slice(pred_regions[0], p, idx[p]) > 0,
                    "TC": extract_slice(pred_regions[1], p, idx[p]) > 0,
                    "ET": extract_slice(pred_regions[2], p, idx[p]) > 0,
                }
                axes[pred_row, c].imshow(overlay_masks(base2d, pred2d, colors, alpha=alpha))
                axes[pred_row, c].axis("off")
            axes[0, 0].set_ylabel("Image", rotation=0, labelpad=35, va="center", fontsize=9)
            if gt_regions is not None:
                axes[1, 0].set_ylabel("GT", rotation=0, labelpad=35, va="center", fontsize=9)
                axes[2, 0].set_ylabel(method.get("name", "Method"), rotation=0, labelpad=35, va="center", fontsize=9)
            else:
                axes[1, 0].set_ylabel(method.get("name", "Method"), rotation=0, labelpad=35, va="center", fontsize=9)
            save_fig(os.path.join(out_dir, "cross_year", direction, f"{case_id}.png"))


def make_moe_routing(cfg: Dict, case_loader: CaseLoader, aux: AuxCache, runner: Optional[ModelRunner], out_dir: str) -> None:
    cases = cfg.get("cases", {}).get("moe", [])
    if not cases:
        return
    for case_id in cases:
        aux_data = aux.load(case_id)
        needed_keys = ["moe_gamma", "expert_contrib"]
        if aux_data is None or not all(k in aux_data for k in needed_keys):
            if runner is None:
                continue
            image, _ = runner.load_case_tensor(case_id)
            out = runner.forward_intermediate(image)
            new_data = {
                "moe_gamma": out["moe_gamma"].detach().cpu().numpy(),
                "expert_contrib": out["expert_contrib"].detach().cpu().numpy(),
            }
            # Merge with existing data
            if aux_data is not None:
                aux_data.update(new_data)
            else:
                aux_data = new_data
            aux.save(case_id, aux_data)
        if aux_data is None:
            continue
        gamma = np.asarray(aux_data["moe_gamma"])[0]
        contrib = np.asarray(aux_data["expert_contrib"])[0]
        m = contrib.shape[0]
        x = np.arange(m)
        fig, ax = plt.subplots(figsize=(6, 3))
        width = 0.25
        ax.bar(x - width, contrib[:, 0], width, label="WT")
        ax.bar(x, contrib[:, 1], width, label="TC")
        ax.bar(x + width, contrib[:, 2], width, label="ET")
        ax.plot(x, gamma, "k--", label="gamma")
        ax.set_xlabel("Expert")
        ax.set_ylabel("Contribution")
        ax.set_title(case_id)
        ax.legend(fontsize=8)
        save_fig(os.path.join(out_dir, "moe_routing", f"{case_id}.png"))


def make_concept_tokens(cfg: Dict, case_loader: CaseLoader, pred_loader: PredictionLoader, out_dir: str) -> None:
    cases = cfg.get("cases", {}).get("concept_tokens", [])
    if not cases:
        return
    frag_bins = cfg.get("visualization", {}).get("frag_bins", [1, 3, 5])
    scale_bins = cfg.get("visualization", {}).get("scale_bins", [50, 200, 500])
    for case_id in cases:
        case = case_loader.get_case(case_id, include_label=True)
        pred = pred_loader.load_method(pred_loader.ours, case_id)
        pred_regions = pred["regions"]
        gt_regions = label_to_regions(case["label"]) if case["label"] is not None else None

        def tokens_from_regions(regions: np.ndarray) -> Dict[str, int]:
            et = regions[2] > 0
            et_count = int(et.sum())
            _, comp = connected_components(et)
            frag_bin = bin_by_threshold(comp, frag_bins)
            scale_bin = bin_by_threshold(et_count, scale_bins)
            return {
                "WT": int(regions[0].sum() > 0),
                "TC": int(regions[1].sum() > 0),
                "ET": int(et_count > 0),
                "FRAG_BIN": frag_bin,
                "SCALE_BIN": scale_bin,
            }

        pred_tokens = tokens_from_regions(pred_regions)
        gt_tokens = tokens_from_regions(gt_regions) if gt_regions is not None else None

        fig, ax = plt.subplots(figsize=(6, 2))
        ax.axis("off")
        lines = [
            f"Pred: WT={pred_tokens['WT']} TC={pred_tokens['TC']} ET={pred_tokens['ET']} "
            f"FRAG={pred_tokens['FRAG_BIN']} SCALE={pred_tokens['SCALE_BIN']}"
        ]
        if gt_tokens is not None:
            lines.append(
                f"GT:   WT={gt_tokens['WT']} TC={gt_tokens['TC']} ET={gt_tokens['ET']} "
                f"FRAG={gt_tokens['FRAG_BIN']} SCALE={gt_tokens['SCALE_BIN']}"
            )
        ax.text(0.01, 0.6, "\n".join(lines), fontsize=10, family="monospace")
        ax.set_title(case_id)
        save_fig(os.path.join(out_dir, "concept_tokens", f"{case_id}.png"))


def make_dual_domain(cfg: Dict, case_loader: CaseLoader, aux: AuxCache, runner: Optional[ModelRunner], out_dir: str) -> None:
    cases = cfg.get("cases", {}).get("dual_domain", [])
    if not cases:
        return
    for case_id in cases:
        case = case_loader.get_case(case_id, include_label=False)
        images = case["images"]
        overlay_mod = choose_overlay_modality(cfg, images)
        base = images[overlay_mod]
        aux_data = aux.load(case_id)
        needed_keys = ["x_spec", "u_fuse", "u_spec"]
        if aux_data is None or not all(k in aux_data for k in needed_keys):
            if runner is None:
                continue
            image, _ = runner.load_case_tensor(case_id)
            out = runner.forward_intermediate(image)
            new_data = {
                "x_spec": out["x_spec"].detach().cpu().numpy(),
                "u_fuse": out["u_fuse"].detach().cpu().numpy(),
                "u_spec": out["u_spec"].detach().cpu().numpy(),
            }
            if aux_data is not None:
                aux_data.update(new_data)
            else:
                aux_data = new_data
            aux.save(case_id, aux_data)
        x_spec = aux_data["x_spec"][0]
        u_fuse = aux_data["u_fuse"][0].mean(axis=0)
        u_spec = aux_data["u_spec"][0].mean(axis=0)

        amp_orig = fft_amplitude_slice(base, plane="axial")
        amp_spec = fft_amplitude_slice(x_spec[0], plane="axial")

        mid = base.shape[0] // 2
        u_fuse2d = extract_slice(normalize_volume(u_fuse), "axial", mid)
        u_spec2d = extract_slice(normalize_volume(u_spec), "axial", mid)

        fig, axes = plt.subplots(2, 2, figsize=(6, 6))
        axes[0, 0].imshow(amp_orig, cmap="inferno")
        axes[0, 0].set_title("Amplitude (orig)")
        axes[0, 1].imshow(amp_spec, cmap="inferno")
        axes[0, 1].set_title("Amplitude (enhanced)")
        axes[1, 0].imshow(u_fuse2d, cmap="viridis")
        axes[1, 0].set_title("Spatial-fused features")
        axes[1, 1].imshow(u_spec2d, cmap="viridis")
        axes[1, 1].set_title("Spectral features")
        for ax in axes.flat:
            ax.axis("off")
        save_fig(os.path.join(out_dir, "dual_domain", f"{case_id}.png"))


def make_ampmix(cfg: Dict, case_loader: CaseLoader, runner: Optional[ModelRunner], out_dir: str) -> None:
    pairs = cfg.get("cases", {}).get("ampmix", [])
    if not pairs:
        return
    colors = cfg.get("visualization", {}).get("colors", get_default_colors())
    alpha = cfg.get("visualization", {}).get("alpha", 0.45)
    for pair in pairs:
        case_a = pair.get("base")
        case_b = pair.get("mix")
        lam = float(pair.get("lam", 0.5))
        if not case_a or not case_b:
            continue
        if runner is None:
            continue

        img_a, _ = runner.load_case_tensor(case_a)
        img_b, _ = runner.load_case_tensor(case_b)
        mixed = fourier_amplitude_mix(img_a[0].cpu().numpy(), img_b[0].cpu().numpy(), lam)
        mixed_t = runner.torch.from_numpy(mixed).unsqueeze(0).to(runner.device)

        out_a = runner.infer_basic(img_a)
        out_m = runner.infer_basic(mixed_t)
        pred_a = (out_a["logits"].sigmoid() > 0.5).detach().cpu().numpy()[0]
        pred_m = (out_m["logits"].sigmoid() > 0.5).detach().cpu().numpy()[0]

        case = case_loader.get_case(case_a, include_label=False)
        images = case["images"]
        overlay_mod = choose_overlay_modality(cfg, images)
        base = images[overlay_mod]
        idx = get_slices(pred_a[2] > 0, base.shape)
        plane = "axial"
        base2d = extract_slice(base, plane, idx[plane])
        mix2d = extract_slice(normalize_volume(mixed[0]), plane, idx[plane])

        fig, axes = plt.subplots(2, 2, figsize=(6, 6))
        axes[0, 0].imshow(base2d, cmap="gray")
        axes[0, 0].set_title("Original")
        axes[0, 1].imshow(mix2d, cmap="gray")
        axes[0, 1].set_title("AmpMix")

        axes[1, 0].imshow(overlay_masks(base2d, {
            "WT": extract_slice(pred_a[0], plane, idx[plane]) > 0,
            "TC": extract_slice(pred_a[1], plane, idx[plane]) > 0,
            "ET": extract_slice(pred_a[2], plane, idx[plane]) > 0,
        }, colors, alpha=alpha))
        axes[1, 0].set_title("Pred (orig)")

        axes[1, 1].imshow(overlay_masks(mix2d, {
            "WT": extract_slice(pred_m[0], plane, idx[plane]) > 0,
            "TC": extract_slice(pred_m[1], plane, idx[plane]) > 0,
            "ET": extract_slice(pred_m[2], plane, idx[plane]) > 0,
        }, colors, alpha=alpha))
        axes[1, 1].set_title("Pred (AmpMix)")
        for ax in axes.flat:
            ax.axis("off")
        save_fig(os.path.join(out_dir, "ampmix", f"{case_a}_mix_{case_b}.png"))


def make_failure_cases(cfg: Dict, case_loader: CaseLoader, pred_loader: PredictionLoader, out_dir: str) -> None:
    cases = cfg.get("cases", {}).get("failure", [])
    if not cases:
        return
    notes = cfg.get("cases", {}).get("failure_notes", {})
    colors = cfg.get("visualization", {}).get("colors", get_default_colors())
    alpha = cfg.get("visualization", {}).get("alpha", 0.45)
    for case_id in cases:
        case = case_loader.get_case(case_id, include_label=True)
        images = case["images"]
        overlay_mod = choose_overlay_modality(cfg, images)
        base = images[overlay_mod]
        gt_regions = label_to_regions(case["label"]) if case["label"] is not None else None
        pred = pred_loader.load_method(pred_loader.ours, case_id)
        pred_regions = pred["regions"]
        mask_ref = gt_regions[2] if gt_regions is not None else pred_regions[2]
        idx = get_slices(mask_ref, base.shape)
        plane = "axial"
        base2d = extract_slice(base, plane, idx[plane])
        fig, axes = plt.subplots(1, 3 if gt_regions is not None else 2, figsize=(9, 3))
        axes[0].imshow(base2d, cmap="gray")
        axes[0].set_title("Image")
        axes[0].axis("off")
        col = 1
        if gt_regions is not None:
            axes[1].imshow(overlay_masks(base2d, {
                "WT": extract_slice(gt_regions[0], plane, idx[plane]) > 0,
                "TC": extract_slice(gt_regions[1], plane, idx[plane]) > 0,
                "ET": extract_slice(gt_regions[2], plane, idx[plane]) > 0,
            }, colors, alpha=alpha))
            axes[1].set_title("GT")
            axes[1].axis("off")
            col = 2
        axes[col].imshow(overlay_masks(base2d, {
            "WT": extract_slice(pred_regions[0], plane, idx[plane]) > 0,
            "TC": extract_slice(pred_regions[1], plane, idx[plane]) > 0,
            "ET": extract_slice(pred_regions[2], plane, idx[plane]) > 0,
        }, colors, alpha=alpha))
        axes[col].set_title(pred_loader.ours.get("name", "Ours"))
        axes[col].axis("off")
        fig.suptitle(notes.get(case_id, ""), fontsize=9)
        save_fig(os.path.join(out_dir, "failure", f"{case_id}.png"))


def make_efficiency(cfg: Dict, case_loader: CaseLoader, out_dir: str) -> None:
    info = cfg.get("efficiency", {})
    case_id = info.get("case_id")
    if not case_id:
        return
    roi = info.get("roi_size", [128, 128, 128])
    overlap = float(info.get("overlap", 0.5))
    case = case_loader.get_case(case_id, include_label=False)
    images = case["images"]
    overlay_mod = choose_overlay_modality(cfg, images)
    base = images[overlay_mod]
    d, h, w = base.shape
    rz, ry, rx = roi
    stride = [max(1, int(r * (1.0 - overlap))) for r in roi]
    centers = []
    for z in range(0, max(1, d - rz + 1), stride[0]):
        for y in range(0, max(1, h - ry + 1), stride[1]):
            for x in range(0, max(1, w - rx + 1), stride[2]):
                centers.append((z + rz // 2, y + ry // 2, x + rx // 2))
    mid = d // 2
    base2d = extract_slice(base, "axial", mid)
    fig, ax = plt.subplots(figsize=(5, 5))
    ax.imshow(base2d, cmap="gray")
    for z, y, x in centers:
        if abs(z - mid) <= rz // 2:
            yy = y
            xx = x
            ax.scatter(xx, base2d.shape[0] - yy, s=2, c="yellow", alpha=0.6)
    ax.set_title("Sliding-window centers")
    ax.axis("off")
    save_fig(os.path.join(out_dir, "efficiency", f"{case_id}.png"))


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", required=True, help="Visualization config yaml.")
    parser.add_argument("--model-config", default=os.path.join(ROOT_DIR, "configs/train.yaml"), help="Model config yaml.")
    parser.add_argument("--checkpoint", default="", help="Checkpoint for model-based visualizations.")
    parser.add_argument("--device", default="cuda")
    parser.add_argument("--run", default="all", help="Comma list or 'all'.")
    args = parser.parse_args()

    cfg = load_config(args.config)
    out_dir = cfg.get("visualization", {}).get("output_dir", os.path.join(ROOT_DIR, "visualizations", "outputs"))
    ensure_dir(out_dir)

    case_loader = CaseLoader(cfg)
    pred_loader = PredictionLoader(cfg)
    aux_cache = AuxCache(cfg.get("predictions", {}).get("aux_dir"))
    runner = ModelRunner(cfg, args.model_config, args.checkpoint, args.device) if args.checkpoint else None

    run_set = set([s.strip() for s in args.run.split(",")]) if args.run != "all" else None

    def should_run(name: str) -> bool:
        return run_set is None or name in run_set

    if should_run("qualitative"):
        make_qualitative(cfg, case_loader, pred_loader, out_dir)
    if should_run("et_absent"):
        make_et_absent(cfg, case_loader, pred_loader, aux_cache, runner, out_dir)
    if should_run("boundary"):
        make_boundary(cfg, case_loader, pred_loader, out_dir)
    if should_run("tiny_et"):
        make_tiny_et(cfg, case_loader, pred_loader, out_dir)
    if should_run("cross_year"):
        make_cross_year(cfg, case_loader, pred_loader, out_dir)
    if should_run("moe"):
        make_moe_routing(cfg, case_loader, aux_cache, runner, out_dir)
    if should_run("concept_tokens"):
        make_concept_tokens(cfg, case_loader, pred_loader, out_dir)
    if should_run("dual_domain"):
        make_dual_domain(cfg, case_loader, aux_cache, runner, out_dir)
    if should_run("ampmix"):
        make_ampmix(cfg, case_loader, runner, out_dir)
    if should_run("failure"):
        make_failure_cases(cfg, case_loader, pred_loader, out_dir)
    if should_run("efficiency"):
        make_efficiency(cfg, case_loader, out_dir)


if __name__ == "__main__":
    main()