import argparse
import glob
import os
import re
import sys
from typing import List, Sequence, Tuple

import torch
from torch.utils.data import DataLoader

sys.path.append(os.path.join(os.path.dirname(__file__), "src"))

from gliomasam3_moe.data.brats_dataset import SegMambaNPZDataset, split_npz_paths
from gliomasam3_moe.models.gliomasam3_moe import GliomaSAM3_MoE
from train import evaluate_test, load_config


def _find_latest_ckpt(ckpt_dir: str) -> str:
    pattern = os.path.join(ckpt_dir, "ckpt_step*.pt")
    matches = []
    for path in glob.glob(pattern):
        m = re.search(r"ckpt_step(\d+)\.pt$", path)
        if m:
            matches.append((int(m.group(1)), path))
    if not matches:
        raise FileNotFoundError(f"No checkpoints found under {ckpt_dir}.")
    matches.sort(key=lambda x: x[0])
    return matches[-1][1]


def _select_train_subset(
    data_dir: str,
    train_rate: float,
    val_rate: float,
    test_rate: float,
    seed: int,
) -> Tuple[Sequence[str], int, int]:
    train_paths, _, test_paths = split_npz_paths(
        data_dir, train_rate=train_rate, val_rate=val_rate, test_rate=test_rate, seed=seed
    )
    test_n = len(test_paths)
    if test_n == 0:
        raise ValueError("Test split size is 0; cannot match train subset size.")
    subset_n = min(len(train_paths), test_n)
    rng = torch.Generator().manual_seed(seed)
    perm = torch.randperm(len(train_paths), generator=rng).tolist()
    subset_paths = [train_paths[i] for i in perm[:subset_n]]
    return subset_paths, test_n, len(train_paths)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", type=str, default="configs/train.yaml")
    parser.add_argument("--checkpoint", type=str, default=None, help="Path to ckpt_step*.pt (default: latest in ckpt_dir).")
    parser.add_argument("--max_cases", type=int, default=0, help="Optional cap on subset size.")
    args = parser.parse_args()

    cfg = load_config(args.config)
    data_dir = cfg.data.root_dir
    if not os.path.isdir(data_dir):
        raise FileNotFoundError(f"data.root_dir does not exist: {data_dir}")

    if getattr(cfg.data, "format", "nifti") != "segmamba_npz":
        raise ValueError("Only segmamba_npz format is supported for this evaluation script.")

    ckpt_path = args.checkpoint or _find_latest_ckpt(cfg.train.ckpt_dir)
    if not os.path.isfile(ckpt_path):
        raise FileNotFoundError(f"Checkpoint not found: {ckpt_path}")

    subset_paths, test_n, train_n = _select_train_subset(
        data_dir,
        train_rate=getattr(cfg.data, "train_rate", 0.7),
        val_rate=getattr(cfg.data, "val_rate", 0.1),
        test_rate=getattr(cfg.data, "test_rate", 0.2),
        seed=cfg.seed,
    )
    if args.max_cases and args.max_cases > 0:
        subset_paths = subset_paths[: min(len(subset_paths), args.max_cases)]

    device = torch.device(cfg.device if torch.cuda.is_available() else "cpu")
    model = GliomaSAM3_MoE(**cfg.model.__dict__).to(device)
    ckpt = torch.load(ckpt_path, map_location=device)
    model.load_state_dict(ckpt["model"], strict=True)

    ensure_npy = bool(getattr(cfg.data, "segmamba_unpack", True))
    dataset = SegMambaNPZDataset(
        data_dir=data_dir,
        npz_paths=subset_paths,
        test=False,
        ensure_npy=ensure_npy,
        map_et_to_4=True,
    )
    loader = DataLoader(
        dataset,
        batch_size=1,
        shuffle=False,
        num_workers=max(0, int(cfg.train.num_workers)),
    )

    metrics = evaluate_test(model, loader, cfg, device)
    print(f"[TRAIN-SUBSET] ckpt={ckpt_path}")
    print(f"[TRAIN-SUBSET] total_train={train_n} test_count={test_n} subset={len(subset_paths)}")
    print(
        f"[TRAIN-SUBSET] dice[WT,TC,ET]={metrics['dice']} "
        f"hd95[WT,TC,ET]={metrics['hd95']}"
    )


if __name__ == "__main__":
    main()