"""
V4: Test-Time Self-Consistency.

For each validation image:
  1. S(I) -> P_direct (standard segmentation)
  2. Binarize P_direct -> M0
  3. G(M0, z_1..z_N) -> generate N views
  4. S(view_i) -> P_i for each view
  5. P_ensemble = mean(sigmoid(P_i))
  6. P_combined = alpha * P_direct + (1-alpha) * P_ensemble

Compares: direct, ensemble, combined strategies.

Usage:
  python scripts/v4_test_time.py --condition cycle_consist --seed 42
  python scripts/v4_test_time.py --condition baseline --seed 42
"""
import sys
sys.path.insert(0, "/data/sichengli/Code/PixelGen")

import argparse
import os
import json
import random
import numpy as np
import torch
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
from PIL import Image
import torchvision.transforms as transforms
import torchvision.transforms.functional as TF
import segmentation_models_pytorch as smp

from src.models.transformer.JiT_medical import JiTMedical
from segmentation.metrics import compute_dice_iou_binary, MetricTracker


# ─── Config ───────────────────────────────────────────────────────────
KVASIR_ROOT = "/data2/sichengli/Data/test/Segmentation/Kvasir-SEG/Kvasir-SEG"
WORK_DIR = "/data/sichengli/Code/PixelGen/synergy_v4_workdir"
PIXELGEN_CKPT = "/data/sichengli/Code/PixelGen/medical_workdirs/exp_PixelGen_Medical_Kvasir/epoch=12499-step=100000.ckpt"

RESOLUTION = 256
TRAIN_RATIO = 0.9
SPLIT_SEED = 42

IMAGENET_MEAN = [0.485, 0.456, 0.406]
IMAGENET_STD = [0.229, 0.224, 0.225]

MODEL_KWARGS = dict(
    input_size=256, patch_size=16, in_channels=3,
    hidden_size=768, depth=12, num_heads=12, mlp_ratio=4.0,
    attn_drop=0.0, proj_drop=0.1, num_classes=1,
    use_bottleneck=True, bottleneck_dim=128,
    in_context_len=32, in_context_start=4, mask_in_channels=1,
    mask_mode="spatial"
)

NUM_STEPS = 50
CFG_SCALE = 2.0


# ─── Dataset ──────────────────────────────────────────────────────────
class KvasirValDataset(Dataset):
    """Kvasir validation set (100 images)."""
    def __init__(self):
        self.normalize = transforms.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD)

        img_dir = os.path.join(KVASIR_ROOT, "images")
        mask_dir = os.path.join(KVASIR_ROOT, "masks")

        all_files = sorted([
            f for f in os.listdir(img_dir)
            if f.endswith((".jpg", ".png", ".jpeg"))
        ])

        random.seed(SPLIT_SEED)
        indices = list(range(len(all_files)))
        random.shuffle(indices)
        split_idx = int(len(indices) * TRAIN_RATIO)
        val_indices = indices[split_idx:]

        self.files = [all_files[i] for i in sorted(val_indices)]
        self.img_dir = img_dir
        self.mask_dir = mask_dir
        print(f"[KvasirValDataset] {len(self.files)} validation samples")

    def __len__(self):
        return len(self.files)

    def __getitem__(self, idx):
        fname = self.files[idx]

        image = Image.open(os.path.join(self.img_dir, fname)).convert("RGB")
        mask = Image.open(os.path.join(self.mask_dir, fname)).convert("L")

        image = TF.resize(image, (RESOLUTION, RESOLUTION),
                          interpolation=transforms.InterpolationMode.BILINEAR)
        mask = TF.resize(mask, (RESOLUTION, RESOLUTION),
                         interpolation=transforms.InterpolationMode.NEAREST)

        image_tensor = self.normalize(TF.to_tensor(image))

        mask_np = np.array(mask)
        mask_np = (mask_np > 127).astype(np.float32)
        mask_tensor = torch.from_numpy(mask_np).unsqueeze(0)

        return image_tensor, mask_tensor


# ─── PixelGen Sampling ────────────────────────────────────────────────
def shift_respace_fn(t, shift=1.0):
    return t / (t + (1 - t) * shift)


@torch.no_grad()
def sample_batch_cfg(model, noise, mask, num_steps=50, cfg_scale=2.0, t_eps=0.05):
    """Euler ODE sampler with CFG."""
    batch_size = noise.shape[0]
    timesteps = torch.linspace(0.0, 1 - 1.0 / num_steps, num_steps)
    timesteps = torch.cat([timesteps, torch.tensor([1.0])], dim=0)
    timesteps = shift_respace_fn(timesteps, 1.0).to(noise.device)
    y = torch.zeros(batch_size, dtype=torch.long, device=noise.device)
    x = noise
    for i in range(len(timesteps) - 1):
        t_cur = timesteps[i]
        t_next = timesteps[i + 1]
        dt = t_next - t_cur
        t_batch = t_cur.repeat(batch_size)
        cfg_x = torch.cat([x, x], dim=0)
        cfg_t = t_batch.repeat(2)
        cfg_y = torch.cat([y, y], dim=0)
        cfg_mask = torch.cat([torch.zeros_like(mask), mask], dim=0)
        pred = model(cfg_x, cfg_t, cfg_y, mask=cfg_mask)
        pred_v = (pred - cfg_x) / (1.0 - cfg_t.view(-1, 1, 1, 1)).clamp_min(t_eps)
        v_uncond, v_cond = pred_v.chunk(2)
        v = v_uncond + cfg_scale * (v_cond - v_uncond)
        x = x + v * dt
    return x


def load_pixelgen(ckpt_path, device):
    ckpt = torch.load(ckpt_path, map_location="cpu", weights_only=False)
    state_dict = ckpt["state_dict"]
    ema_state = {}
    for k, v in state_dict.items():
        if k.startswith("ema_denoiser."):
            new_k = k.replace("ema_denoiser.", "").replace("_orig_mod.", "")
            ema_state[new_k] = v
    model = JiTMedical(**MODEL_KWARGS)
    result = model.load_state_dict(ema_state, strict=False)
    print(f"PixelGen loaded ({len(ema_state)} keys), missing: {result.missing_keys}, unexpected: {result.unexpected_keys}")
    model = model.to(device).eval().to(torch.float32)
    return model


def load_segmentor(condition, seed, device):
    ckpt_path = os.path.join(WORK_DIR, "checkpoints", f"{condition}_seed{seed}", "best.pth")
    model = smp.Unet(
        encoder_name="resnet34",
        encoder_weights="imagenet",
        in_channels=3,
        classes=1,
    )
    ckpt = torch.load(ckpt_path, map_location="cpu", weights_only=False)
    model.load_state_dict(ckpt["model_state_dict"])
    model = model.to(device).eval()
    print(f"Segmentor loaded: {ckpt_path} (best_dice={ckpt['best_dice']:.4f})")
    return model


# ─── Test-Time Self-Consistency ───────────────────────────────────────
@torch.no_grad()
def test_time_consistency(segmentor, pixelgen, val_loader, device,
                          n_views=5, alpha=0.5):
    """
    For each val image:
      direct: S(I)
      ensemble: mean(S(G(S(I)->M0, z_i))) for i=1..n_views
      combined: alpha * direct + (1-alpha) * ensemble
    """
    normalize = transforms.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD)

    tracker_direct = MetricTracker()
    tracker_ensemble = MetricTracker()
    tracker_combined = MetricTracker()

    for batch_idx, (images, gt_masks) in enumerate(val_loader):
        images = images.to(device)
        gt_masks = gt_masks.to(device)
        bs = images.shape[0]

        # Step 1: Direct prediction
        logits_direct = segmentor(images)
        p_direct = torch.sigmoid(logits_direct)  # [B, 1, H, W]

        dice_d, iou_d = compute_dice_iou_binary(logits_direct, gt_masks)
        tracker_direct.update(dice_d, iou_d, bs)

        # Step 2: Binarize -> M0 (for PixelGen, mask in [0, 1])
        m0 = (p_direct > 0.5).float()  # [B, 1, H, W]

        # Step 3: Generate N views and re-segment
        ensemble_probs = torch.zeros_like(p_direct)  # [B, 1, H, W]

        for v in range(n_views):
            noise = torch.randn(bs, 3, RESOLUTION, RESOLUTION, device=device)
            gen_images = sample_batch_cfg(pixelgen, noise, m0, NUM_STEPS, CFG_SCALE)
            gen_images = gen_images.clamp(-1, 1) * 0.5 + 0.5  # [-1,1] -> [0,1]

            # Normalize for segmentor
            gen_normalized = torch.stack([normalize(img) for img in gen_images])
            logits_v = segmentor(gen_normalized)
            p_v = torch.sigmoid(logits_v)
            ensemble_probs += p_v

        ensemble_probs /= n_views  # [B, 1, H, W]

        # Evaluate ensemble
        ensemble_preds = (ensemble_probs > 0.5).float()
        smooth = 1e-6
        inter_e = (ensemble_preds.view(bs, -1) * gt_masks.view(bs, -1)).sum(1)
        pred_sum_e = ensemble_preds.view(bs, -1).sum(1)
        gt_sum_e = gt_masks.view(bs, -1).sum(1)
        dice_e = ((2 * inter_e + smooth) / (pred_sum_e + gt_sum_e + smooth)).mean().item()
        iou_e = ((inter_e + smooth) / (pred_sum_e + gt_sum_e - inter_e + smooth)).mean().item()
        tracker_ensemble.update(dice_e, iou_e, bs)

        # Combined
        p_combined = alpha * p_direct + (1 - alpha) * ensemble_probs
        combined_preds = (p_combined > 0.5).float()
        inter_c = (combined_preds.view(bs, -1) * gt_masks.view(bs, -1)).sum(1)
        pred_sum_c = combined_preds.view(bs, -1).sum(1)
        gt_sum_c = gt_masks.view(bs, -1).sum(1)
        dice_c = ((2 * inter_c + smooth) / (pred_sum_c + gt_sum_c + smooth)).mean().item()
        iou_c = ((inter_c + smooth) / (pred_sum_c + gt_sum_c - inter_c + smooth)).mean().item()
        tracker_combined.update(dice_c, iou_c, bs)

        print(f"  Batch {batch_idx+1}/{len(val_loader)} | "
              f"Direct: {dice_d:.4f} | Ensemble: {dice_e:.4f} | Combined: {dice_c:.4f}")

    return {
        "direct": {"dice": tracker_direct.avg_dice, "iou": tracker_direct.avg_iou},
        "ensemble": {"dice": tracker_ensemble.avg_dice, "iou": tracker_ensemble.avg_iou},
        "combined": {"dice": tracker_combined.avg_dice, "iou": tracker_combined.avg_iou},
    }


# ─── Main ─────────────────────────────────────────────────────────────
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--condition", type=str, default="cycle_consist",
                        choices=["no_aug", "baseline", "cycle", "consist", "cycle_consist"])
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--n_views", type=int, default=5)
    parser.add_argument("--alpha", type=float, default=0.5)
    parser.add_argument("--gpu", type=int, default=0)
    args = parser.parse_args()

    device = torch.device(f"cuda:{args.gpu}")

    print(f"\n{'='*60}")
    print(f"  V4 Test-Time Self-Consistency")
    print(f"  Condition: {args.condition}, Seed: {args.seed}")
    print(f"  N_views: {args.n_views}, Alpha: {args.alpha}")
    print(f"{'='*60}\n")

    # Load models
    segmentor = load_segmentor(args.condition, args.seed, device)
    pixelgen = load_pixelgen(PIXELGEN_CKPT, device)

    # Load validation set
    val_dataset = KvasirValDataset()
    val_loader = DataLoader(val_dataset, batch_size=4, shuffle=False,
                            num_workers=4, pin_memory=True)

    # Run test-time consistency
    results = test_time_consistency(
        segmentor, pixelgen, val_loader, device,
        n_views=args.n_views, alpha=args.alpha
    )

    # Print results
    print(f"\n{'='*60}")
    print(f"  TEST-TIME SELF-CONSISTENCY RESULTS")
    print(f"  Condition: {args.condition}, Seed: {args.seed}")
    print(f"{'='*60}")
    print(f"{'Strategy':<12s} | {'Dice':>8s} | {'IoU':>8s}")
    print("-" * 35)
    for strategy in ["direct", "ensemble", "combined"]:
        r = results[strategy]
        print(f"{strategy:<12s} | {r['dice']:>8.4f} | {r['iou']:>8.4f}")
    print("=" * 35)

    # Save results
    output = {
        "condition": args.condition,
        "seed": args.seed,
        "n_views": args.n_views,
        "alpha": args.alpha,
        "results": results,
    }
    out_path = os.path.join(WORK_DIR, "test_time_results.json")

    # Merge with existing
    all_results = {}
    if os.path.exists(out_path):
        with open(out_path, "r") as f:
            all_results = json.load(f)

    key = f"{args.condition}_seed{args.seed}"
    all_results[key] = output

    with open(out_path, "w") as f:
        json.dump(all_results, f, indent=2)
    print(f"\nResults saved: {out_path}")


if __name__ == "__main__":
    main()