import os
from typing import Dict, Iterable, List, Optional, Tuple

import numpy as np
import nibabel as nib
from scipy import ndimage as ndi


def ensure_dir(path: str) -> None:
    os.makedirs(path, exist_ok=True)


def _resolve_nii(case_dir: str, name: str) -> str:
    for ext in [".nii.gz", ".nii"]:
        path = os.path.join(case_dir, name + ext)
        if os.path.isfile(path):
            return path
    raise FileNotFoundError(f"Missing NIfTI: {case_dir}/{name}.nii(.gz)")


def load_nifti(path: str) -> Tuple[np.ndarray, np.ndarray]:
    img = nib.load(path)
    data = img.get_fdata()
    return np.asarray(data), img.affine


def normalize_volume(vol: np.ndarray, eps: float = 1e-6) -> np.ndarray:
    x = np.asarray(vol, dtype=np.float32)
    x = np.nan_to_num(x, nan=0.0, posinf=0.0, neginf=0.0)
    flat = x.reshape(-1)
    if flat.size == 0:
        return np.zeros_like(x, dtype=np.float32)
    lo, hi = np.percentile(flat, [1, 99])
    if hi - lo < eps:
        return np.zeros_like(x, dtype=np.float32)
    x = np.clip(x, lo, hi)
    x = (x - lo) / (hi - lo + eps)
    return x


def label_to_regions(label: np.ndarray) -> np.ndarray:
    label = np.asarray(label)
    wt = label > 0
    tc = (label == 1) | (label == 4)
    et = label == 4
    return np.stack([wt, tc, et], axis=0).astype(np.uint8)


def regions_to_label(regions: np.ndarray) -> np.ndarray:
    if regions.ndim != 4 or regions.shape[0] != 3:
        raise ValueError("regions must be [3, D, H, W]")
    wt = regions[0] > 0.5
    tc = regions[1] > 0.5
    et = regions[2] > 0.5
    label = np.zeros_like(wt, dtype=np.int16)
    label[wt] = 2
    label[tc] = 1
    label[et] = 4
    return label


def load_case_nifti(
    root_dir: str,
    case_id: str,
    modalities: List[str],
    seg_name: str = "seg",
    include_label: bool = True,
) -> Tuple[Dict[str, np.ndarray], Optional[np.ndarray], np.ndarray]:
    case_dir = os.path.join(root_dir, case_id)
    images: Dict[str, np.ndarray] = {}
    affine = None
    for mod in modalities:
        path = _resolve_nii(case_dir, mod)
        arr, affine = load_nifti(path)
        images[mod] = np.asarray(arr, dtype=np.float32)
    label = None
    if include_label:
        seg_path = _resolve_nii(case_dir, seg_name)
        label, _ = load_nifti(seg_path)
        label = np.asarray(label, dtype=np.int16)
    if affine is None:
        affine = np.eye(4)
    return images, label, affine


def _load_npz_arrays(npz_path: str, include_label: bool) -> Tuple[np.ndarray, Optional[np.ndarray]]:
    data = np.load(npz_path)
    image = data["data"]
    label = data["seg"] if include_label and "seg" in data else None
    return image, label


def load_case_npz(
    npz_dir: str,
    case_id: str,
    include_label: bool = True,
) -> Tuple[np.ndarray, Optional[np.ndarray]]:
    if case_id.endswith(".npz"):
        npz_path = case_id
    else:
        npz_path = os.path.join(npz_dir, case_id + ".npz")
    if not os.path.isfile(npz_path):
        raise FileNotFoundError(f"Missing npz: {npz_path}")

    npy_path = npz_path[:-3] + "npy"
    seg_path = npz_path[:-4] + "_seg.npy"
    if os.path.isfile(npy_path):
        image = np.load(npy_path, mmap_mode="r")
    else:
        image, _ = _load_npz_arrays(npz_path, include_label=False)

    label = None
    if include_label:
        if os.path.isfile(seg_path):
            label = np.load(seg_path, mmap_mode="r")
        else:
            _, label = _load_npz_arrays(npz_path, include_label=True)

    image = np.asarray(image, dtype=np.float32)
    if image.ndim == 5 and image.shape[0] == 1:
        image = image[0]
    if image.ndim == 4 and image.shape[0] != 4 and image.shape[-1] == 4:
        image = image.transpose(3, 0, 1, 2)

    if label is not None:
        label = np.asarray(label, dtype=np.int16)
        if label.ndim == 4 and label.shape[0] == 1:
            label = label[0]
    return image, label


def load_case(
    data_cfg: Dict,
    case_id: str,
    include_label: bool = True,
) -> Tuple[Dict[str, np.ndarray], Optional[np.ndarray], np.ndarray]:
    data_format = data_cfg.get("format", "nifti")
    if data_format == "segmamba_npz":
        npz_dir = data_cfg.get("npz_dir") or data_cfg.get("root_dir", "")
        image, label = load_case_npz(npz_dir, case_id, include_label=include_label)
        images = {f"ch{i}": image[i] for i in range(image.shape[0])}
        affine = np.eye(4)
        return images, label, affine
    root_dir = data_cfg.get("root_dir", "")
    modalities = data_cfg.get("modalities", ["t1n", "t1c", "t2f", "t2w"])
    seg_name = data_cfg.get("seg_name", "seg")
    return load_case_nifti(root_dir, case_id, modalities, seg_name=seg_name, include_label=include_label)


def load_prediction(
    pred_dir: str,
    case_id: str,
    pred_type: str = "auto",
) -> Dict[str, Optional[np.ndarray]]:
    def _find(base: str) -> Optional[str]:
        for ext in [".nii.gz", ".nii"]:
            path = os.path.join(pred_dir, base + ext)
            if os.path.isfile(path):
                return path
        return None

    pred_type = pred_type.lower()
    paths = {
        "regions_prob": _find(f"{case_id}_regions_prob"),
        "regions_bin": _find(f"{case_id}_regions_bin"),
        "label": _find(f"{case_id}_label"),
        "segmamba_3c": _find(f"{case_id}"),
    }
    if pred_type == "auto":
        for key in ["regions_prob", "regions_bin", "label", "segmamba_3c"]:
            if paths[key] is not None:
                pred_type = key
                break
    path = paths.get(pred_type)
    if path is None:
        raise FileNotFoundError(f"No prediction found for {case_id} in {pred_dir}")

    arr, _ = load_nifti(path)
    arr = np.asarray(arr)
    out: Dict[str, Optional[np.ndarray]] = {"label": None, "regions": None, "prob": None}
    if pred_type in {"regions_prob", "regions_bin"}:
        if arr.ndim != 4 or arr.shape[-1] != 3:
            raise ValueError(f"Expected (D,H,W,3) for regions, got {arr.shape}")
        regions = arr.transpose(3, 0, 1, 2)
        out["prob"] = regions.astype(np.float32) if pred_type == "regions_prob" else None
        out["regions"] = (regions > 0.5).astype(np.uint8) if pred_type == "regions_prob" else regions.astype(np.uint8)
        out["label"] = regions_to_label(out["regions"])
    elif pred_type == "segmamba_3c":
        if arr.ndim != 4 or arr.shape[-1] != 3:
            raise ValueError(f"Expected (D,H,W,3) for SegMamba 3c, got {arr.shape}")
        regions = arr.transpose(3, 0, 1, 2).astype(np.uint8)
        out["regions"] = regions
        out["label"] = regions_to_label(regions)
    else:
        label = arr.astype(np.int16)
        out["label"] = label
        out["regions"] = label_to_regions(label)
    return out


def select_slices_from_mask(mask: Optional[np.ndarray]) -> Dict[str, int]:
    if mask is None or mask.sum() == 0:
        return {"axial": None, "coronal": None, "sagittal": None}
    m = mask.astype(np.uint8)
    axial = int(np.argmax(m.sum(axis=(1, 2))))
    coronal = int(np.argmax(m.sum(axis=(0, 2))))
    sagittal = int(np.argmax(m.sum(axis=(0, 1))))
    return {"axial": axial, "coronal": coronal, "sagittal": sagittal}


def fallback_slices(shape: Tuple[int, int, int]) -> Dict[str, int]:
    d, h, w = shape
    return {"axial": d // 2, "coronal": h // 2, "sagittal": w // 2}


def extract_slice(vol: np.ndarray, plane: str, idx: int) -> np.ndarray:
    if plane == "axial":
        img = vol[idx, :, :]
    elif plane == "coronal":
        img = vol[:, idx, :]
    elif plane == "sagittal":
        img = vol[:, :, idx]
    else:
        raise ValueError(f"Unknown plane: {plane}")
    return np.rot90(img)


def mask_boundary(mask2d: np.ndarray, iterations: int = 1) -> np.ndarray:
    if mask2d.sum() == 0:
        return mask2d.astype(bool)
    eroded = ndi.binary_erosion(mask2d.astype(bool), iterations=iterations)
    return np.logical_xor(mask2d.astype(bool), eroded)


def overlay_masks(
    base2d: np.ndarray,
    masks: Dict[str, np.ndarray],
    colors: Dict[str, Tuple[float, float, float]],
    alpha: float = 0.5,
    draw_boundary: bool = True,
    boundary_width: int = 1,
) -> np.ndarray:
    base = np.clip(base2d, 0.0, 1.0)
    rgb = np.stack([base, base, base], axis=-1)
    order = ["WT", "TC", "ET"]
    for key in order:
        if key not in masks:
            continue
        m = masks[key].astype(bool)
        # Handle shape mismatch by resizing mask to match base
        if m.shape != base.shape:
            from scipy.ndimage import zoom
            zoom_factors = (base.shape[0] / m.shape[0], base.shape[1] / m.shape[1])
            m = zoom(m.astype(float), zoom_factors, order=0) > 0.5
        if m.sum() == 0:
            continue
        color = np.array(colors.get(key, (1.0, 0.0, 0.0)), dtype=np.float32)
        rgb[m] = (1.0 - alpha) * rgb[m] + alpha * color
        if draw_boundary:
            b = mask_boundary(m, iterations=boundary_width)
            rgb[b] = color
    return rgb


def signed_distance(mask: np.ndarray) -> np.ndarray:
    mask = mask.astype(bool)
    if mask.sum() == 0:
        return np.zeros_like(mask, dtype=np.float32)
    outside = ndi.distance_transform_edt(~mask)
    inside = ndi.distance_transform_edt(mask)
    return (inside - outside).astype(np.float32)


def boundary_error_map(pred: np.ndarray, gt: np.ndarray) -> np.ndarray:
    pred = pred.astype(bool)
    gt = gt.astype(bool)
    dist = np.abs(signed_distance(gt))
    err = np.zeros_like(dist, dtype=np.float32)
    err[pred & ~gt] = dist[pred & ~gt]
    err[~pred & gt] = -dist[~pred & gt]
    return err


def connected_components(mask: np.ndarray) -> Tuple[np.ndarray, int]:
    labeled, num = ndi.label(mask.astype(np.uint8))
    return labeled, int(num)


def bin_by_threshold(value: float, thresholds: Iterable[float]) -> int:
    for i, t in enumerate(thresholds):
        if value <= t:
            return i
    return len(list(thresholds))


def fft_amplitude_slice(vol: np.ndarray, plane: str = "axial") -> np.ndarray:
    fft = np.fft.fftn(vol)
    amp = np.abs(fft)
    amp = np.fft.fftshift(amp)
    d, h, w = amp.shape
    if plane == "axial":
        sl = amp[d // 2, :, :]
    elif plane == "coronal":
        sl = amp[:, h // 2, :]
    else:
        sl = amp[:, :, w // 2]
    sl = np.log1p(sl)
    return normalize_volume(sl)


def fourier_amplitude_mix(a: np.ndarray, b: np.ndarray, lam: float) -> np.ndarray:
    # If shapes differ, crop/pad b to match a
    if a.shape != b.shape:
        from scipy.ndimage import zoom
        # Resize b to match a shape
        b_resized = np.zeros_like(a)
        for c in range(min(a.shape[0], b.shape[0])):
            zoom_factors = tuple(a.shape[i+1] / b.shape[i+1] for i in range(3))
            b_resized[c] = zoom(b[c], zoom_factors, order=1)
        b = b_resized
    fft_a = np.fft.fftn(a, axes=(1, 2, 3))
    fft_b = np.fft.fftn(b, axes=(1, 2, 3))
    amp_a = np.abs(fft_a)
    amp_b = np.abs(fft_b)
    phase = np.exp(1j * np.angle(fft_a))
    amp_mix = (1.0 - lam) * amp_a + lam * amp_b
    mixed = np.fft.ifftn(amp_mix * phase, axes=(1, 2, 3)).real
    return mixed.astype(np.float32)