"""Bulk audioldm2 ControlNet inference on the full 3919-pair test set, saved
as <root>/<rel_path>/{bg.wav, fg_pred.wav, mix.wav} to mirror the Frieren and
SA output layouts so the same eval pipeline can consume any of them.

LUFS protocol (identical to infer_frieren_test_set.py / infer_sa_test_set.py):
  - bg.wav      normalized to LUFS=-30 (FIXED).
  - fg_pred.wav saved at gain s s.t. LUFS(bg_norm + s*fg) = -23
                (binary search on s in dB via find_lufs_mixture_gains).
  - mix.wav     = bg_norm + fg_pred_scaled.

Output: 16 kHz mono, 10.24 s per file (matches Frieren format more than SA's
44.1 kHz stereo). Downstream eval pipeline resamples as needed.
"""
import argparse, json, sys
from pathlib import Path

import numpy as np
import torch
import torch.nn.functional as F
import torchaudio
import soundfile as sf

ROOT = Path("/nfs/turbo/coe-ahowens-nobackup/dingqy/AudioLDM-training-finetuning")
sys.path.insert(0, str(ROOT))
sys.path.insert(0, "/nfs/turbo/coe-ahowens-nobackup/dingqy")

from diffusers import AudioLDM2Pipeline, DDIMScheduler, DDPMScheduler        # noqa
from audioldm2_v2.empty_prompt_cache import expand_to_batch, load_cache      # noqa
from audioldm2_v2.model_controlnet import (
    AudioLDM2ControlNet, unet_forward_with_residuals,                        # noqa
)
from audioldm2_v2.dataset import waveform_to_log_mel, SAMPLING_RATE, TARGET_LEN  # noqa
from infer_bg2fg_variable import find_lufs_mixture_gains                     # noqa

SR = SAMPLING_RATE          # 16000


def load_bg(path: str) -> torch.Tensor:
    """Load + resample to 16k mono + pad/crop to TARGET_LEN (163840 = 10.24s)."""
    w, sr = torchaudio.load(str(path))
    if w.shape[0] > 1:
        w = w.mean(dim=0, keepdim=True)
    if sr != SR:
        w = torchaudio.functional.resample(w, sr, SR)
    T = w.shape[-1]
    if T < TARGET_LEN:
        w = F.pad(w, (0, TARGET_LEN - T))
    else:
        w = w[:, :TARGET_LEN]
    return w.squeeze(0)         # [T]


@torch.no_grad()
def sample_batch(pipe, cn, bg_batch, cache, sched_cfg, ddim_steps,
                 device, generator):
    """Generate fg_pred for a batch of bg waveforms. Returns [N, T_out] np float32.

    Mirrors `train_controlnet.py:_sample_one_pair` but batched. Forward path:
    bg → mel → VAE encode → z_bg → ControlNet residuals → UNet ε(z_t) →
    DDIM step → eventually z_0 → VAE decode → vocoder.
    """
    bs = bg_batch.shape[0]
    mel_bg = waveform_to_log_mel(bg_batch)              # [N, 1, T_mel, n_mels]
    vae_scale = pipe.vae.config.scaling_factor
    z_bg = pipe.vae.encode(mel_bg).latent_dist.mean * vae_scale

    sched = DDIMScheduler.from_config(sched_cfg)
    sched.set_timesteps(ddim_steps)
    z_t = torch.randn(z_bg.shape, generator=generator, device=device,
                      dtype=z_bg.dtype)

    cond = expand_to_batch(cache, bs)
    cn.eval()
    with torch.cuda.amp.autocast(dtype=torch.float16):
        for t in sched.timesteps:
            t_b = t.repeat(bs).to(device).long()
            down_res, mid_res = cn(
                z_bg, t_b,
                encoder_hidden_states=cond["encoder_hidden_states"],
                encoder_hidden_states_1=cond["encoder_hidden_states_1"],
                encoder_attention_mask_1=cond["encoder_attention_mask_1"],
            )
            eps = unet_forward_with_residuals(
                pipe.unet, z_t, t_b,
                encoder_hidden_states=cond["encoder_hidden_states"],
                encoder_hidden_states_1=cond["encoder_hidden_states_1"],
                encoder_attention_mask_1=cond["encoder_attention_mask_1"],
                down_block_additional_residuals=down_res,
                mid_block_additional_residual=mid_res,
            )
            z_t = sched.step(eps, t, z_t).prev_sample

        mel_pred = pipe.vae.decode(z_t / vae_scale).sample
        wav_pred = pipe.vocoder(mel_pred.squeeze(1))     # [N, T_out]
    return wav_pred.cpu().float().numpy()


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--ckpt", required=True,
                    help="path to controlnet.pt, OR HF dataset path under AE-W/ckpt")
    ap.add_argument("--model-id", default="cvssp/audioldm2-large")
    ap.add_argument("--empty-cache",
                    default=str(ROOT / "audioldm2_v2/empty_prompt_cache_large.pt"))
    ap.add_argument("--manifest",
                    default="/nfs/turbo/coe-ahowens-nobackup/ymdou/hidingsound/data/noise_guidance_out_latent/manifest.json")
    ap.add_argument("--out",
                    default="/nfs/turbo/coe-ahowens-nobackup/dingqy/inference_demo/audioldm2_test_set",
                    help="root dir; output goes to <root>/<rel_path>/{bg,fg_pred,mix}.wav")
    ap.add_argument("--steps", type=int, default=50)
    ap.add_argument("--batch-size", type=int, default=4)
    ap.add_argument("--bg-lufs", type=float, default=-30.0)
    ap.add_argument("--mix-lufs", type=float, default=-23.0)
    ap.add_argument("--seed", type=int, default=42)
    ap.add_argument("--limit", type=int, default=0,
                    help="for testing: only N pairs")
    ap.add_argument("--shard", type=int, default=0,
                    help="this job's shard index (0-based)")
    ap.add_argument("--num-shards", type=int, default=1,
                    help="total number of parallel shards; each takes pairs[shard::num_shards]")
    args = ap.parse_args()

    device = "cuda"

    print(f"loading manifest: {args.manifest}")
    pairs = [p for p in json.load(open(args.manifest))["pairs"] if p["split"] == "test"]
    print(f"  {len(pairs)} test pairs (full)")
    if args.limit:
        pairs = pairs[: args.limit]
        print(f"  limiting to first {len(pairs)}")
    if args.num_shards > 1:
        # Stride sharding so each shard sees a balanced spread across the
        # manifest (rather than contiguous slices, which would correlate
        # ckpt I/O / dataset read patterns).
        pairs = pairs[args.shard::args.num_shards]
        print(f"  shard {args.shard}/{args.num_shards}: {len(pairs)} pairs")

    out_root = Path(args.out)
    out_root.mkdir(parents=True, exist_ok=True)

    print(f"loading pipeline {args.model_id}...", flush=True)
    pipe = AudioLDM2Pipeline.from_pretrained(args.model_id)
    pipe.vae.eval(); pipe.unet.eval()

    # Build controlnet on CPU first (matches training order — _build_zero_convs
    # runs a CPU dummy through base_unet.time_embedding), then move to device.
    print("instantiating + loading controlnet...", flush=True)
    cn = AudioLDM2ControlNet(pipe.unet)
    pipe.to(device)
    cn.to(device)

    # Resolve ckpt path: HF dataset path or local file
    if Path(args.ckpt).is_file():
        ckpt_path = args.ckpt
    else:
        from huggingface_hub import hf_hub_download
        ckpt_path = hf_hub_download(repo_id="AE-W/ckpt",
                                    filename=f"{args.ckpt}/controlnet.pt",
                                    repo_type="dataset",
                                    cache_dir="/nfs/turbo/coe-ahowens-nobackup/dingqy/.cache/huggingface")
    sd = torch.load(ckpt_path, map_location="cpu", weights_only=False)
    cn.load_state_dict(sd)
    cn.eval()
    print(f"  loaded {sum(v.numel() for v in sd.values()):,} params from {ckpt_path}")
    del sd

    sched_cfg = DDPMScheduler.from_pretrained(args.model_id, subfolder="scheduler").config
    cache = load_cache(args.empty_cache, device=device)

    n_done = n_skip = n_clipped = 0
    total = len(pairs)
    for batch_start in range(0, total, args.batch_size):
        batch = pairs[batch_start: batch_start + args.batch_size]

        # Resume-friendly: skip pairs whose mix.wav already exists.
        todo = [p for p in batch if not (out_root / p["rel_path"] / "mix.wav").exists()]
        if not todo:
            n_skip += len(batch)
            continue

        # Stack batched bg
        bg_list = [load_bg(p["bg_wav"]) for p in todo]
        bg = torch.stack(bg_list).to(device)            # [N, T]

        # Different seed per batch for variety
        gen = torch.Generator(device=device).manual_seed(args.seed + batch_start)
        fg_preds = sample_batch(pipe, cn, bg, cache, sched_cfg, args.steps,
                                device, gen)            # [N, T_out] np float32

        bg_np = bg.cpu().numpy()                        # [N, T]
        for i, p in enumerate(todo):
            sub = out_root / p["rel_path"]
            sub.mkdir(parents=True, exist_ok=True)
            bg_i = bg_np[i]
            fg_i = fg_preds[i].astype(np.float32)
            # Normalize lengths if vocoder slightly off (e.g. TARGET_LEN-1).
            T_min = min(bg_i.shape[0], fg_i.shape[0])
            bg_i, fg_i = bg_i[:T_min], fg_i[:T_min]

            bg_g, fg_g = find_lufs_mixture_gains(
                bg_i, fg_i, SR,
                bg_lufs=args.bg_lufs, mix_lufs=args.mix_lufs,
            )
            bg_norm        = (bg_i * bg_g).astype(np.float32)
            fg_pred_scaled = (fg_i * fg_g).astype(np.float32)
            mix            = (bg_norm + fg_pred_scaled).astype(np.float32)

            peak = float(np.max(np.abs(mix)))
            if peak > 1.0:
                n_clipped += 1

            sf.write(str(sub / "bg.wav"),      np.clip(bg_norm,        -1, 1), SR)
            sf.write(str(sub / "fg_pred.wav"), np.clip(fg_pred_scaled, -1, 1), SR)
            sf.write(str(sub / "mix.wav"),     np.clip(mix,            -1, 1), SR)
            n_done += 1

        if (batch_start // args.batch_size) % 20 == 0 or batch_start + args.batch_size >= total:
            print(f"  [{batch_start + len(batch)}/{total}] done={n_done} "
                  f"skip={n_skip} clipped={n_clipped}",
                  flush=True)

    print(f"\n=== DONE ===\n  total: {total}\n  generated: {n_done}\n  "
          f"pre-existing skipped: {n_skip}\n  clipped (peak > 1.0): {n_clipped}")


if __name__ == "__main__":
    main()