#!/usr/bin/env python3
"""Conditional sampling for Kermany2018 class names using OCT RAE-main."""
from __future__ import annotations

import argparse
import math
from pathlib import Path

import torch
from torchvision.utils import save_image

from stage1 import RAE
from stage2.models import Stage2ModelProtocol
from stage2.transport import create_transport, Sampler
from utils.model_utils import instantiate_from_config
from utils.train_utils import parse_configs


CLASSES = ["CNV", "DME", "DRUSEN", "NORMAL"]


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", required=True)
    parser.add_argument("--output-dir", default="samples")
    parser.add_argument("--num-per-class", type=int, default=2000)
    parser.add_argument("--cfg-scales", type=float, nargs="+", default=[1.0])
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--batch-size", type=int, default=50)
    parser.add_argument("--device", default="cuda")
    parser.add_argument("--precision", choices=["fp32", "bf16"], default="bf16")
    args = parser.parse_args()

    torch.manual_seed(args.seed)
    device = torch.device(args.device)

    rae_config, model_config, transport_config, sampler_config, _, misc, _, _ = parse_configs(args.config)
    rae: RAE = instantiate_from_config(rae_config).to(device).eval()
    model: Stage2ModelProtocol = instantiate_from_config(model_config).to(device).eval()

    ckpt = model_config.get("ckpt", None)
    if ckpt is None:
        raise ValueError("stage_2.ckpt is required in the sampling config")
    state = torch.load(ckpt, map_location="cpu", weights_only=False)
    model.load_state_dict(state.get("ema", state.get("model", state)), strict=True)

    num_classes = int(misc.get("num_classes", len(CLASSES)))
    latent_size = tuple(int(d) for d in misc.get("latent_size"))
    null_label = num_classes
    shift_dim = misc.get("time_dist_shift_dim", math.prod(latent_size))
    shift_base = misc.get("time_dist_shift_base", 4096)
    time_dist_shift = math.sqrt(shift_dim / shift_base)

    transport_params = dict(transport_config.get("params", {}))
    transport_params.pop("time_dist_shift", None)
    transport = create_transport(**transport_params, time_dist_shift=time_dist_shift)
    sampler = Sampler(transport)
    sampler_params = dict(sampler_config.get("params", {}))
    if sampler_config.get("mode", "ODE").upper() == "ODE":
        sample_fn = sampler.sample_ode(**sampler_params)
    else:
        sample_fn = sampler.sample_sde(**sampler_params)

    use_bf16 = args.precision == "bf16"
    autocast_kwargs = dict(dtype=torch.bfloat16, enabled=use_bf16)

    for cfg_scale in args.cfg_scales:
        for class_idx in range(num_classes):
            class_name = CLASSES[class_idx] if class_idx < len(CLASSES) else f"class_{class_idx}"
            save_dir = Path(args.output_dir) / f"cfg_{cfg_scale}" / class_name
            save_dir.mkdir(parents=True, exist_ok=True)

            made = 0
            while made < args.num_per_class:
                n = min(args.batch_size, args.num_per_class - made)
                z = torch.randn(n, *latent_size, device=device)
                y = torch.full((n,), class_idx, device=device, dtype=torch.long)

                with torch.no_grad(), torch.cuda.amp.autocast(**autocast_kwargs):
                    if cfg_scale > 1.0:
                        z_cfg = torch.cat([z, z], dim=0)
                        y_null = torch.full((n,), null_label, device=device, dtype=torch.long)
                        y_cfg = torch.cat([y, y_null], dim=0)
                        samples = sample_fn(
                            z_cfg,
                            model.forward_with_cfg,
                            y=y_cfg,
                            cfg_scale=cfg_scale,
                            cfg_interval=(0.0, 1.0),
                        )[-1][:n]
                    else:
                        samples = sample_fn(z, model.forward, y=y)[-1]
                    images = rae.decode(samples.float()).clamp(0, 1)

                for i in range(n):
                    save_image(images[i], save_dir / f"{made + i:04d}.png")
                made += n
            print(f"{class_name}: {made} images saved to {save_dir}", flush=True)
    print("KERMANY_SAMPLING_DONE")


if __name__ == "__main__":
    main()