"""Inference: SA best-val ckpt on 5 fixed val pairs → wav + mel-spectrogram PNG."""
import argparse, json, os, sys
from pathlib import Path
import numpy as np
import torch
import torch.nn.functional as F
import torchaudio

SA_ROOT = Path("/nfs/turbo/coe-ahowens-nobackup/dingqy/friendly-stable-audio-tools")
sys.path.insert(0, str(SA_ROOT))
from stable_audio_tools.models import create_model_from_config  # noqa
from stable_audio_tools.models.utils import load_ckpt_state_dict  # noqa
from stable_audio_tools.training import create_training_wrapper_from_config  # noqa
from stable_audio_tools.utils.audio_utils import load_bg_wav, crop_or_pad_to  # noqa
from stable_audio_tools.inference.generation import generate_diffusion_cond  # noqa

SR = 44100
CH = 2


def mel_spec(wav_ct, sr=44100, n_fft=2048, n_mels=128):
    """wav [C, T] → log mel [n_mels, T_mel] (mean across channels)."""
    from librosa.filters import mel as librosa_mel_fn
    w = wav_ct.mean(0, keepdim=True).float()   # mono for spec
    mb = torch.from_numpy(librosa_mel_fn(sr=sr, n_fft=n_fft, n_mels=n_mels, fmin=0, fmax=sr//2)).float()
    hann = torch.hann_window(n_fft)
    spec = torch.stft(w, n_fft=n_fft, hop_length=n_fft//4, win_length=n_fft,
                      window=hann, center=True, return_complex=True).abs()
    return (mb @ spec[0]).clamp(min=1e-5).log10().numpy()


def stacked_spectrogram(bg_mel, fg_gt_mel, fg_pred_mel, title, out_path,
                        sr=SR, hop_length=2048//4, fmax=None):
    """3-panel mel spec with librosa.display.specshow (time/Hz axes + colorbar)."""
    import matplotlib
    matplotlib.use("Agg")
    import matplotlib.pyplot as plt
    import librosa.display as ld
    fig, axes = plt.subplots(3, 1, figsize=(10, 7.5), dpi=110, sharex=True)
    fmax = fmax or sr // 2
    panels = [("bg", bg_mel), ("fg_gt", fg_gt_mel), ("fg_pred", fg_pred_mel)]
    # Use shared dB range so panels are visually comparable
    vmin = min(m.min() for _, m in panels)
    vmax = max(m.max() for _, m in panels)
    last_img = None
    for ax, (label, m) in zip(axes, panels):
        last_img = ld.specshow(m, x_axis="time", y_axis="mel",
                               sr=sr, hop_length=hop_length, fmax=fmax,
                               cmap="magma", ax=ax, vmin=vmin, vmax=vmax)
        ax.set_ylabel(f"{label}\nmel (Hz)", fontsize=9)
    axes[0].set_title(title, fontsize=11)
    axes[-1].set_xlabel("time (s)")
    fig.colorbar(last_img, ax=axes, format="%+.1f", label="log-mel (dB)",
                 shrink=0.9, pad=0.02)
    fig.savefig(out_path, bbox_inches="tight")
    plt.close(fig)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--ckpt", required=True)
    ap.add_argument("--model-config", default=str(SA_ROOT / "stable_audio_tools/configs/model_configs/txt2audio/stable_audio_open_1_0_bg2fg_rebalance.json"))
    ap.add_argument("--pairs", default="/nfs/turbo/coe-ahowens-nobackup/dingqy/inference_val_pairs.json")
    ap.add_argument("--out", default="/home/dingqy/inference_demo/sa")
    ap.add_argument("--steps", type=int, default=100)
    ap.add_argument("--cfg-scale", type=float, default=1.0)
    ap.add_argument("--seed", type=int, default=42)
    args = ap.parse_args()

    out = Path(args.out); out.mkdir(parents=True, exist_ok=True)
    pairs = json.load(open(args.pairs))
    mc = json.load(open(args.model_config))
    print(f"[sa] {len(pairs)} pairs -> {out}")

    # Build model + load weights via TrainingWrapper (ckpts are saved from
    # the Lightning wrapper, so state_dict keys carry a 'diffusion.' /
    # 'diffusion_ema.ema_model.' prefix). Loading into the bare model silently
    # drops all keys → random init → flat, identical outputs across inputs.
    print("instantiating model + training wrapper...", flush=True)
    base_model = create_model_from_config(mc)
    wrapper = create_training_wrapper_from_config(mc, base_model)
    sd = load_ckpt_state_dict(args.ckpt)
    missing, unexpected = wrapper.load_state_dict(sd, strict=False)
    print(f"  wrapper.load_state_dict: missing={len(missing)} unexpected={len(unexpected)}")
    if missing:
        print(f"    first 5 missing: {missing[:5]}")
    # Use EMA weights for inference (matches DiffusionCondBgDemoCallback).
    if getattr(wrapper, "diffusion_ema", None) is not None:
        print("  using EMA weights for inference")
        wrapper.diffusion.model = wrapper.diffusion_ema.ema_model
    model = wrapper.diffusion.cuda().eval()

    sample_size = mc["sample_size"]          # 440320 @ 44.1 kHz = ~9.98 s

    # Build conditioning list — 1 entry per pair (bg_audio + seconds_start/total)
    conditioning = []
    bg_cpu_list, fg_gt_cpu_list = [], []
    for p in pairs:
        bg = load_bg_wav(p["bg_wav"], target_sr=SR, target_channels=CH)
        bg = crop_or_pad_to(bg, sample_size).clamp(-1.0, 1.0)
        fg_gt = load_bg_wav(p["fg_wav"], target_sr=SR, target_channels=CH)
        fg_gt = crop_or_pad_to(fg_gt, sample_size).clamp(-1.0, 1.0)
        bg_cpu_list.append(bg)
        fg_gt_cpu_list.append(fg_gt)
        conditioning.append({
            "bg_audio": bg.unsqueeze(0),   # (1, C, T) — PretransformConditioner convention
            "seconds_start": 0,
            "seconds_total": 10,
        })

    print(f"sampling (steps={args.steps}, cfg={args.cfg_scale})...", flush=True)
    with torch.no_grad():
        with torch.cuda.amp.autocast():
            fakes = generate_diffusion_cond(
                model,
                steps=args.steps,
                cfg_scale=args.cfg_scale,
                conditioning=conditioning,
                sample_size=sample_size,
                seed=args.seed,
                disable_tqdm=True,
            )
    fakes = fakes.cpu().float()   # [N, C, T]

    for i, p in enumerate(pairs):
        tag = f"val_{p['sample_id']}"
        bg_wav = bg_cpu_list[i]
        fg_gt_wav = fg_gt_cpu_list[i]
        fg_pred_wav = fakes[i].clamp(-1, 1)

        torchaudio.save(str(out / f"{tag}_bg.wav"), bg_wav, SR)
        torchaudio.save(str(out / f"{tag}_fg_gt.wav"), fg_gt_wav, SR)
        torchaudio.save(str(out / f"{tag}_fg_pred.wav"), fg_pred_wav, SR)

        stacked_spectrogram(
            mel_spec(bg_wav, sr=SR),
            mel_spec(fg_gt_wav, sr=SR),
            mel_spec(fg_pred_wav, sr=SR),
            title=f"[SA] {p['sample_id']}",
            out_path=str(out / f"{tag}_spec.png"),
        )
        print(f"  wrote {tag}_{{bg,fg_gt,fg_pred}}.wav + spec.png")

    print("done")


if __name__ == "__main__":
    main()