"""Regenerate spectrogram PNGs for inference_demo/ using librosa.display.specshow
(matches AudioLDM's _plot_combined style).

Each pair produces a 3-row figure (BG / FG Pred / FG GT) with:
  - time (s) on x-axis
  - mel bin on y-axis
  - dB-scale colorbar
  - model + sample_id title
"""
from pathlib import Path
import sys
import numpy as np
import torchaudio
import librosa
import librosa.display
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt


def load_mono(path, target_sr):
    wav, sr = torchaudio.load(str(path))
    if wav.shape[0] > 1:
        wav = wav.mean(0, keepdim=True)
    if sr != target_sr:
        wav = torchaudio.functional.resample(wav, sr, target_sr)
    return wav.squeeze(0).numpy()


def mel_db(wav, sr, n_fft, hop, n_mels, fmax):
    return librosa.power_to_db(
        librosa.feature.melspectrogram(
            y=wav, sr=sr, n_fft=n_fft, hop_length=hop,
            n_mels=n_mels, fmin=0, fmax=fmax,
        ),
        ref=np.max,
    )


def plot_triple(bg_wav, fg_pred_wav, fg_gt_wav, sr, title, out_png,
                n_fft=1024, hop=256, n_mels=80):
    fmax = sr // 2
    fig, axes = plt.subplots(3, 1, figsize=(10, 7.2), dpi=120, sharex=True)
    fig.suptitle(title, fontsize=12, fontweight="bold")
    for ax, wav, label in zip(
        axes,
        [bg_wav, fg_pred_wav, fg_gt_wav],
        ["BG (input)", "FG Pred (model output)", "FG GT (target)"],
    ):
        mel = mel_db(np.asarray(wav, dtype=np.float32), sr,
                     n_fft=n_fft, hop=hop, n_mels=n_mels, fmax=fmax)
        img = librosa.display.specshow(
            mel, sr=sr, hop_length=hop, fmin=0, fmax=fmax,
            x_axis="time", y_axis="mel", ax=ax,
        )
        ax.set_title(label, fontsize=10, loc="left")
        ax.set_ylabel("Hz (mel)", fontsize=9)
        plt.colorbar(img, ax=ax, format="%+2.0f dB", pad=0.01)
    axes[-1].set_xlabel("Time (s)", fontsize=10)
    fig.tight_layout(rect=(0, 0, 1, 0.96))
    out_png.parent.mkdir(parents=True, exist_ok=True)
    fig.savefig(out_png, bbox_inches="tight")
    plt.close(fig)


def main():
    root = Path("/home/dingqy/inference_demo")
    configs = [
        ("sa", 44100, "Stable Audio Open 1.0"),          # SA renders 44.1 kHz stereo; we plot mono-summed
        ("frieren", 16000, "Frieren-V2A"),               # 16 kHz mono
    ]
    for subdir, sr, model_label in configs:
        d = root / subdir
        if not d.exists():
            print(f"skip {d} (missing)")
            continue
        # Group by sample_id by stripping _bg.wav suffix
        bg_files = sorted(d.glob("*_bg.wav"))
        print(f"[{subdir}] {len(bg_files)} pairs (sr={sr})")
        for bg_p in bg_files:
            stem = bg_p.name[:-len("_bg.wav")]
            fg_gt_p = d / f"{stem}_fg_gt.wav"
            fg_pred_p = d / f"{stem}_fg_pred.wav"
            if not (fg_gt_p.exists() and fg_pred_p.exists()):
                print(f"  skip {stem} (missing gt/pred)")
                continue
            bg = load_mono(bg_p, sr)
            fg_pred = load_mono(fg_pred_p, sr)
            fg_gt = load_mono(fg_gt_p, sr)
            out = d / f"{stem}_spec.png"
            sid = stem.replace("val_", "", 1)
            plot_triple(
                bg, fg_pred, fg_gt, sr,
                title=f"{model_label} — {sid}",
                out_png=out,
            )
            print(f"  wrote {out.name}")
    print("done")


if __name__ == "__main__":
    main()