"""Bulk Frieren inference on the full 3919-pair test set, saved as
<root>/<rel_path>/{bg.wav, fg_pred.wav, mix.wav} for the eval pipeline.

LUFS protocol:
  - bg.wav   normalized to LUFS=-30 (FIXED).
  - fg_pred.wav saved at the gain s s.t. LUFS(bg_norm + s*fg) = -23
    (binary search on s in dB).  fg_pred.wav itself stores s*fg, so
    the eval pipeline can sum bg + fg_pred and reproduce mix LUFS=-23.
  - mix.wav   = bg_norm + fg_pred_scaled.
"""
import argparse, json, os, sys
from pathlib import Path
import numpy as np
import torch
import torch.nn.functional as F
import torchaudio

FR_ROOT = Path("/nfs/turbo/coe-ahowens-nobackup/dingqy/Frieren-V2A")
sys.path.insert(0, str(FR_ROOT / "Frieren"))
sys.path.insert(0, "/nfs/turbo/coe-ahowens-nobackup/dingqy")

from cfm.util import instantiate_from_config                              # noqa
from vocoder.bigvgan.models import VocoderBigVGAN                          # noqa
from omegaconf import OmegaConf                                             # noqa
from infer_bg2fg_variable import find_lufs_mixture_gains                   # noqa

SR = 16000
CROP = 131072  # 8.19s @ 16k — Frieren's fixed input window


def load_bg(bg_wav_path):
    """Load + resample to 16k mono + crop/pad to CROP samples (8.19s)."""
    w, sr = torchaudio.load(str(bg_wav_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 < CROP:
        w = F.pad(w, (0, CROP - T))
    else:
        w = w[:, :CROP]
    return w.squeeze(0)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--ckpt", required=True)
    ap.add_argument("--config", default=str(FR_ROOT / "Frieren/configs/ldm_training/hidingsound_bg2fg_rebalance.yaml"))
    ap.add_argument("--manifest", default="/nfs/turbo/coe-ahowens-nobackup/ymdou/hidingsound/data/noise_guidance_out_latent/manifest.json")
    ap.add_argument("--out", default="/home/dingqy/inference_demo/frieren_test_set")
    ap.add_argument("--steps", type=int, default=26)
    ap.add_argument("--cfg-scale", type=float, default=1.0)
    ap.add_argument("--batch-size", type=int, default=32)
    ap.add_argument("--bg-lufs", type=float, default=-30.0)
    ap.add_argument("--mix-lufs", type=float, default=-23.0)
    ap.add_argument("--limit", type=int, default=0, help="for testing: only N pairs")
    args = ap.parse_args()

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

    print(f"loading manifest: {args.manifest}")
    m = json.load(open(args.manifest))
    pairs = [p for p in m["pairs"] if p["split"] == "test"]
    print(f"  {len(pairs)} test pairs")
    if args.limit:
        pairs = pairs[: args.limit]
        print(f"  limiting to first {len(pairs)}")

    cfg = OmegaConf.load(args.config)
    print("instantiating model...", flush=True)
    model = instantiate_from_config(cfg.model)
    sd = torch.load(args.ckpt, map_location="cpu", weights_only=False)
    state_dict = sd.get("state_dict", sd)
    missing, unexpected = model.load_state_dict(state_dict, strict=False)
    print(f"  load: missing={len(missing)} unexpected={len(unexpected)}")
    model = model.cuda().eval()

    vocoder = VocoderBigVGAN(str(FR_ROOT / "checkpoints/vocoder/bigvnat"), device="cuda")

    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]

        # Skip pairs whose output already exists (resume-friendly)
        todo = [p for p in batch if not (out_root / p["rel_path"] / "mix.wav").exists()]
        if not todo:
            n_skip += len(batch)
            print(f"  [skip] {batch_start}..{batch_start+len(batch)} all done", flush=True)
            continue

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

        with torch.no_grad():
            bg_for_cond = bg.unsqueeze(-1)                                  # [N, T, 1]
            cond = model.cond_stage_model(bg_for_cond)
            shape = (N, model.mel_dim, model.mel_length)
            z_pred, _ = model.sample_param_cfg(
                cond=cond, cfg_scale=args.cfg_scale, batch_size=N,
                timesteps=args.steps, solver="euler", shape=shape,
            )
            vae = getattr(model.first_stage_model, "vae", model.first_stage_model)
            mel_pred = vae.decode(z_pred)                                   # [N, 80, T_mel]
        mel_pred_np = mel_pred.cpu().numpy()
        bg_cpu = bg.cpu()

        for i, p in enumerate(todo):
            rel = p["rel_path"]
            sub = out_root / rel
            sub.mkdir(parents=True, exist_ok=True)

            wav_pred = vocoder.vocode(mel_pred_np[i])                       # [T] np
            wav_pred = np.asarray(wav_pred, dtype=np.float32)
            # Trim/pad fg_pred to CROP (vocoder may emit slightly off length)
            if len(wav_pred) >= CROP:
                wav_pred = wav_pred[:CROP]
            else:
                wav_pred = np.pad(wav_pred, (0, CROP - len(wav_pred)))

            bg_np = bg_cpu[i].numpy().astype(np.float32)
            # Binary-search LUFS gains
            bg_g, fg_g = find_lufs_mixture_gains(
                bg_np, wav_pred, SR,
                bg_lufs=args.bg_lufs, mix_lufs=args.mix_lufs,
            )
            bg_norm = (bg_np * bg_g).astype(np.float32)
            fg_pred_scaled = (wav_pred * 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

            torchaudio.save(str(sub / "bg.wav"),
                            torch.from_numpy(bg_norm).clamp(-1, 1).unsqueeze(0), SR)
            torchaudio.save(str(sub / "fg_pred.wav"),
                            torch.from_numpy(fg_pred_scaled).clamp(-1, 1).unsqueeze(0), SR)
            torchaudio.save(str(sub / "mix.wav"),
                            torch.from_numpy(mix).clamp(-1, 1).unsqueeze(0), SR)
            n_done += 1

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

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


if __name__ == "__main__":
    main()