import argparse
import os
import random
import sys

import torch
from diffusers import AutoencoderKL, DDPMScheduler, StableDiffusionXLPipeline
from huggingface_hub import hf_hub_download, login
from PIL import Image

RUN_DIR = os.environ.get("RUN_DIR", "/content")
DATA_DIR = os.environ.get("DATA_DIR", "").strip() or os.path.join(RUN_DIR, ".img")


def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--dataset_repo", default="RASHID778/king2-image-dataset")
    ap.add_argument("--lora_repo", default="RASHID778/king2-image")
    ap.add_argument("--base_model", default="stabilityai/stable-diffusion-xl-base-1.0")
    ap.add_argument("--vae", default="madebyollin/sdxl-vae-fp16-fix")
    ap.add_argument("--resolution", type=int, default=512)
    ap.add_argument("--lr", type=float, default=1e-4)
    ap.add_argument("--train_steps", type=int, default=3)
    ap.add_argument("--grad_accum", type=int, default=4)
    ap.add_argument("--seed", type=int, default=0)
    args = ap.parse_args()

    torch.manual_seed(args.seed)
    random.seed(args.seed)
    login(token=os.environ["HF_TOKEN"])

    device = "cuda"
    dtype = torch.float16

    sys.path.insert(0, RUN_DIR)
    import train_continue as tc

    data_dir = tc.download_dataset(args.dataset_repo)
    rows, actual = tc.load_rows(data_dir)

    vae = AutoencoderKL.from_pretrained(args.vae)
    pipe = StableDiffusionXLPipeline.from_pretrained(
        args.base_model,
        vae=vae,
        torch_dtype=dtype,
        variant="fp16",
        use_safetensors=True,
        safety_checker=None,
        requires_safety_checker=False,
    )
    pipe.load_lora_weights(args.lora_repo, weight_name="pytorch_lora_weights.safetensors")
    pipe.vae.to(dtype=torch.float32)
    scheduler = DDPMScheduler.from_pretrained(args.base_model, subfolder="scheduler")
    print("[steps] models loaded", flush=True)

    unet = pipe.unet.to(device)
    pipe.vae.to(device)
    pipe.text_encoder.to(device)
    pipe.text_encoder_2.to(device)

    for n, p in unet.named_parameters():
        p.requires_grad_(False)
    for n, p in unet.named_parameters():
        if tc._is_lora_weight(n):
            p.requires_grad_(True)
    trainable = [p for p in unet.parameters() if p.requires_grad]

    optimizer = torch.optim.AdamW(trainable, lr=args.lr, weight_decay=1e-2)
    res = args.resolution
    add_time_ids = torch.tensor([res, res, 0, 0, res, res]).unsqueeze(0).to(device)

    def preprocess(pil: Image.Image) -> torch.Tensor:
        w, h = pil.size
        s = min(w, h)
        pil = pil.crop(((w - s) // 2, (h - s) // 2, (w + s) // 2, (h + s) // 2))
        pil = pil.resize((res, res), Image.BILINEAR)
        import numpy as np

        return (torch.from_numpy(np.array(pil)).float() / 127.5 - 1.0).permute(2, 0, 1)

    def get_batch(idx: int):
        cap = rows[idx]["text"]
        fn = rows[idx]["file_name"]
        sub, name = fn.split("/", 1)
        img = os.path.join(actual.get(sub, os.path.join(data_dir, sub)), name)
        pil = Image.open(img).convert("RGB")
        pixels = preprocess(pil).unsqueeze(0).to(device)
        with torch.no_grad():
            out = pipe.encode_prompt(
                [cap], device, num_images_per_prompt=1, do_classifier_free_guidance=False
            )
        if isinstance(out, dict):
            pe, pooled = out["prompt_embeds"], out["pooled_prompt_embeds"]
        elif len(out) == 4:
            pe, pooled = out[0], out[2]
        else:
            pe, pooled = out[0], out[1]
        lat = pipe.vae.encode(pixels).latent_dist.sample() * pipe.vae.config.scaling_factor
        return lat.to(dtype), pe, pooled, fn

    def fin(x) -> str:
        if x is None:
            return "?"
        b = torch.isfinite(x).all().item()
        v = x.abs().max().item() if x.numel() else 0.0
        return f"fin={b}(a={v:.2f})"

    pos = 0
    print("[steps] running instrumented replication...", flush=True)
    for gstep in range(args.train_steps):
        optimizer.zero_grad(set_to_none=True)
        for micro in range(args.grad_accum):
            latents, pe, pooled, fn = get_batch(pos % len(rows))
            pos += 1
            noise = torch.randn_like(latents)
            timesteps = torch.randint(0, scheduler.config.num_train_timesteps, (1,), device=device).long()
            noisy = scheduler.add_noise(latents, noise, timesteps)
            t_val = int(timesteps.item())

            del latents
            torch.cuda.empty_cache()

            with torch.autocast(device_type="cuda", dtype=torch.float16):
                pred = unet(
                    noisy,
                    timesteps,
                    encoder_hidden_states=pe,
                    added_cond_kwargs={"text_embeds": pooled, "time_ids": add_time_ids},
                ).sample
            pred = pred.float()
            loss = torch.nn.functional.mse_loss(pred, noise.float()) / args.grad_accum
            loss_fin = torch.isfinite(loss).item()
            is_nan = not loss_fin
            print(
                f"[micro] gs={gstep} m={micro} row={pos - 1} {fn} t={t_val} "
                f"pe={fin(pe)} pooled={fin(pooled)} noisy={fin(noisy)} "
                f"pred={fin(pred)} loss={loss.item() * args.grad_accum:.6f}{' <-- NAN' if is_nan else ''}",
                flush=True,
            )
            if is_nan:
                return
            loss.backward()
            nan_g = sum(1 for p in trainable if p.grad is not None and not torch.isfinite(p.grad).all().item())
            if nan_g:
                print(f"[grad] NON-FINITE grads on {nan_g} params at gs={gstep} m={micro} t={t_val}", flush=True)
                return
        gnorm = torch.nn.utils.clip_grad_norm_(trainable, 1.0)
        print(f"[step] gs={gstep} gradnorm={gnorm:.4f} weights_fin="
              f"{all(torch.isfinite(p).all().item() for p in trainable)}", flush=True)
        optimizer.step()
    print("[steps] completed cleanly - no NaN within", args.train_steps * args.grad_accum,
          "micro-batches", flush=True)


if __name__ == "__main__":
    main()