run_smart_sweep.py

"""
run_smart_sweep.py  —  Hybrid SPADE  (v11 HF + Unrolled LF)  ·  Bayesian sweep
===============================================================================

Architettura ibrida
-------------------
  segnale limitato
       ↓
  LR crossover split a BAND_CROSSOVER_HZ (default 8000 Hz)
       ├── HF (> 8 kHz) → SPADE v11 S-SPADE  H_k  (hard thresh, identico, invariato)
       └── LF (< 8 kHz) → SPADEUnrolled model       (soft thresh appreso, context GRU)
       ↓
  somma LF_rec + HF_rec  →  segnale recuperato

Razionale
---------
SPADE v11 recupera bene i transienti HF (cymbal snap, hi-hat attack, snap):
i coefficienti DCT sopra 8 kHz sono sparsi e H_k li trova in poche iterazioni.
Sotto 8 kHz (corpo kick, fondamentale del basso) v11 sotto-recupera perché:
  • il livello di sparsità k corretto è content-dipendente e il piano fisso
    s/r/max_iter non lo indovina
  • i contenuti tonali/sustain non sono globalmente sparsi → H_k spreca
    budget su coefficienti HF irrilevanti
Il modello appreso risolve entrambi i problemi via lambda_lf adattivo e g_max.

Pipeline di valutazione (6 tracce, standard run_smart_sweep)
-------------------------------------------------------------
  01_orig_with_noise   drum + pink noise @0 dBFS (ingresso pipeline)
  02_limited           uscita limiter (ingresso SPADE)  ≈ −LIMITER_THRESHOLD_DB dBFS
  03_gt_residual       GT residual @RESIDUAL_DBFS       (include attenuazione noise)
  04_spade_output      uscita ibrida (float32, può >0 dBFS)
  05_res_iter          residual ibrido @RESIDUAL_DBFS    (solo componente sparsa)
  06_diff_residuals    GT_res − res_iter @RESIDUAL_DBFS  (silenzio ideale)
                       → annotato con cos_sim, diff/GT dB, noise_floor

Sweep Bayesiano
---------------
Il modello ML è fisso (pesi caricati da checkpoint).
Il TPE ottimizza i parametri classici indipendentemente per ogni banda:
  LF: lf_delta_db, lf_max_gain_db, lf_release_ms
  HF: hf_delta_db, hf_win, hf_hop, hf_release_ms, hf_max_gain_db, hf_eps, hf_max_iter

USO
---
  python run_smart_sweep.py --model checkpoints/phase1_best.pt
  python run_smart_sweep.py --model checkpoints/phase1_best.pt --trials 100
  python run_smart_sweep.py --model checkpoints/phase1_best.pt --debug-export 5
  python run_smart_sweep.py --model checkpoints/phase1_best.pt --resume
  python run_smart_sweep.py --model checkpoints/phase1_best.pt --report

  # baseline: solo v11 broadband (senza modello ML)
  python run_smart_sweep.py --baseline-v11

DIPENDENZE
----------
  pip install numpy scipy soundfile optuna rich torch
  spade_declip_v11.py  — deve essere nel Python path
  spade_unrolled.py    — deve essere nel Python path (per HybridSPADEInference)
"""

from __future__ import annotations

import argparse
import logging
import sys
import time
import warnings
from dataclasses import asdict
from pathlib import Path
from typing import Dict, List, Optional, Tuple

import numpy as np
import scipy.signal as sig
import soundfile as sf

logging.getLogger("optuna").setLevel(logging.WARNING)

# ── optuna ───────────────────────────────────────────────────────────────────
try:
    import optuna
    from optuna.samplers import TPESampler
    from optuna.pruners  import MedianPruner
    _HAS_OPTUNA = True
except ImportError:
    _HAS_OPTUNA = False
    warnings.warn("optuna non trovato — pip install optuna")

# ── rich ─────────────────────────────────────────────────────────────────────
try:
    from rich.console import Console
    from rich.table   import Table
    _console  = Console()
    _HAS_RICH = True
except ImportError:
    _HAS_RICH = False
    _console  = None

# ── spade v11 ────────────────────────────────────────────────────────────────
try:
    from spade_declip_v11 import declip as _v11_declip, DeclipParams as _V11Params
    _HAS_V11 = True
except ImportError:
    _HAS_V11 = False
    warnings.warn("spade_declip_v11.py non trovato — processing HF non disponibile")

# ── spade_unrolled ────────────────────────────────────────────────────────────
try:
    import torch
    from spade_unrolled import (
        SPADEUnrolled, UnrolledConfig, SPADEUnrolledInference,
        HybridSPADEInference,
    )
    _HAS_UNROLLED = True
except ImportError:
    _HAS_UNROLLED = False
    warnings.warn("spade_unrolled.py / torch non trovati — modello ML non disponibile")


# =============================================================================
# CONFIG
# =============================================================================

DRUM_DIRS = ["Kicks", "Snares", "Perc", "Tops"]

# Limiter sintetico (identico a run_smart_sweep_old)
LIMITER_THRESHOLD_DB = 1.5      # dB sotto il ceiling (positivo)
LIMITER_RELEASE_MS   = 80.0     # release del limiter sintetico (ms)

RESIDUAL_DBFS       = -3.0      # normalizzazione residual per comparabilità cross-file
PINK_NOISE_LEVEL_DB = -20.0     # noise di sottofondo (dB rel. al peak del drum)

# Crossover LF/HF: HF usa v11 invariato, LF usa modello appreso
BAND_CROSSOVER_HZ = 8000.0

# Parametri FISSI del solver v11 (HF)
HF_FIXED = dict(
    algo          = "sspade",
    frame         = "rdft",
    mode          = "soft",
    n_jobs        = 1,
    verbose       = False,
    show_progress = False,
    use_gpu       = True,
)

STUDY_NAME = "hybrid_spade_v1"
OUT_CSV    = "hybrid_sweep_results.csv"

# Parametri debug di default (usati da --debug-export senza sweep)
DEBUG_HF = dict(
    hf_delta_db      = 1.5,
    hf_window_length = 2048,
    hf_hop_length    = 512,
    hf_release_ms    = 80.0,
    hf_max_gain_db   = 9.0,
    hf_eps           = 0.05,
    hf_max_iter      = 500,
)
DEBUG_LF = dict(
    lf_delta_db    = 1.5,
    lf_max_gain_db = 9.0,
    lf_release_ms  = 80.0,
)


# =============================================================================
# HELPERS  (identici a run_smart_sweep_old)
# =============================================================================

def ensure_2d(a: np.ndarray) -> np.ndarray:
    return a[:, None] if a.ndim == 1 else a


def normalize_to_0dBFS(a: np.ndarray) -> np.ndarray:
    pk = np.max(np.abs(a))
    return a / pk if pk > 1e-12 else a


def normalize_peak(a: np.ndarray, target_dbfs: float) -> np.ndarray:
    pk = np.max(np.abs(a))
    return a * (10 ** (target_dbfs / 20.0) / pk) if pk > 1e-12 else a


def generate_pink_noise(
    n_samples: int, n_channels: int, rng: np.random.Generator
) -> np.ndarray:
    b = np.array([0.049922035, -0.095993537,  0.050612699, -0.004408786])
    a = np.array([1.0,         -2.494956002,  2.017265875, -0.522189400])
    out = np.empty((n_samples, n_channels))
    for c in range(n_channels):
        white = rng.standard_normal(n_samples)
        pink  = sig.lfilter(b, a, white)
        rms   = np.sqrt(np.mean(pink ** 2))
        out[:, c] = pink / (rms + 1e-12)
    return out


def mix_pink_noise(
    audio_0dBFS: np.ndarray,
    sr:          int,
    level_db:    float,
    rng:         np.random.Generator,
) -> np.ndarray:
    audio = ensure_2d(audio_0dBFS)
    N, C  = audio.shape
    noise = generate_pink_noise(N, C, rng)
    peak  = np.max(np.abs(audio))
    gain  = peak * (10 ** (level_db / 20.0))
    mixed = audio + noise * gain
    return mixed[:, 0] if audio_0dBFS.ndim == 1 else mixed


def apply_brickwall_limiter(
    audio_0dBFS:  np.ndarray,
    sr:           int,
    threshold_db: float = LIMITER_THRESHOLD_DB,
    release_ms:   float = LIMITER_RELEASE_MS,
) -> np.ndarray:
    thr_lin = 10 ** (-abs(threshold_db) / 20.0)
    rc      = np.exp(-1.0 / max(release_ms * sr / 1000.0, 1e-9))
    audio   = ensure_2d(audio_0dBFS).copy()
    N, C    = audio.shape
    out     = np.empty_like(audio)
    for c in range(C):
        ch  = audio[:, c]
        env = 1.0
        g   = np.empty(N)
        for n in range(N):
            pk     = abs(ch[n])
            target = thr_lin / pk if pk > thr_lin else 1.0
            env    = target if target < env else rc * env + (1.0 - rc) * target
            g[n]   = env
        out[:, c] = ch * g
    return out[:, 0] if audio_0dBFS.ndim == 1 else out


def cosine_sim_tf(
    gt:          np.ndarray,
    est:         np.ndarray,
    sr:          int,
    win_samples: int = 1024,
    hop_samples: int = 256,
    n_bands:     int = 12,
) -> float:
    L = min(gt.shape[0], est.shape[0])
    g = (gt[:L, 0]  if gt.ndim  == 2 else gt[:L]).copy()
    e = (est[:L, 0] if est.ndim == 2 else est[:L]).copy()
    win = min(win_samples, max(32, L // 4))
    hop = min(hop_samples, win // 2)
    if L < win or win < 32:
        denom = np.linalg.norm(g) * np.linalg.norm(e) + 1e-12
        return float(np.dot(g, e) / denom)
    _, _, Zg = sig.stft(g, fs=sr, window="hann", nperseg=win,
                        noverlap=win - hop, boundary=None, padded=False)
    _, _, Ze = sig.stft(e, fs=sr, window="hann", nperseg=win,
                        noverlap=win - hop, boundary=None, padded=False)
    n_freqs, n_frames = Zg.shape
    if n_frames == 0:
        return float(np.dot(g, e) / (np.linalg.norm(g) * np.linalg.norm(e) + 1e-12))
    edges = np.unique(np.round(
        np.logspace(0, np.log10(max(n_freqs, 2)), min(n_bands, n_freqs) + 1)
    ).astype(int))
    edges = np.clip(edges, 0, n_freqs)
    sims  = []
    for i in range(len(edges) - 1):
        f0, f1 = int(edges[i]), int(edges[i + 1])
        if f1 <= f0: continue
        Mg = np.abs(Zg[f0:f1, :])
        Me = np.abs(Ze[f0:f1, :])
        dot    = np.sum(Mg * Me, axis=0)
        norm_g = np.sqrt(np.sum(Mg ** 2, axis=0)) + 1e-12
        norm_e = np.sqrt(np.sum(Me ** 2, axis=0)) + 1e-12
        sims.extend((dot / (norm_g * norm_e)).tolist())
    return float(np.mean(sims)) if sims else 0.0


def _pk_dbfs(a: np.ndarray) -> float:
    pk = float(np.max(np.abs(a)))
    return 20.0 * np.log10(pk) if pk > 1e-12 else -999.0


def _rms_dbfs(a: np.ndarray) -> float:
    rms = float(np.sqrt(np.mean(np.asarray(a).astype(float) ** 2)))
    return 20.0 * np.log10(rms) if rms > 1e-12 else -999.0


def _write_wav(path: Path, audio: np.ndarray, sr: int) -> None:
    a2d = ensure_2d(audio).astype(np.float32)
    pk  = float(np.max(np.abs(a2d)))
    if pk > 1.0:
        print(f"    [WARN] {path.name}: peak={pk:.4f} (+{20*np.log10(pk):.2f} dBFS) — float32")
    sf.write(str(path), a2d, sr, subtype="FLOAT")


# =============================================================================
# CORPUS
# =============================================================================

def build_corpus(base_dir: Path, max_files: Optional[int] = None) -> List[Dict]:
    """
    Per ogni drum sample:
      1. Carica e normalizza a 0 dBFS peak
      2. Mixa rumore rosa a PINK_NOISE_LEVEL_DB
      3. Normalizza il mix a 0 dBFS peak
      4. Applica limiter sintetico → limited
      5. GT_res_raw = orig_with_noise − limited
      6. Scarta file dove il limiter non interviene
      7. Normalizza GT_res a RESIDUAL_DBFS

    Nuovo rispetto alla versione precedente:
      • orig_with_noise viene salvato nel corpus (evita ricalcolo in debug_export)
    """
    corpus     = []
    extensions = {".wav", ".flac", ".aif", ".aiff"}
    file_index = 0

    for folder in DRUM_DIRS:
        d = base_dir / folder
        if not d.exists():
            print(f"  [WARN] Cartella non trovata: {d}")
            continue
        for f in sorted(d.glob("*")):
            if f.suffix.lower() not in extensions:
                continue
            try:
                audio, sr = sf.read(str(f), always_2d=True)
                audio = audio.astype(float)
            except Exception as exc:
                print(f"  [WARN] {f.name}: {exc}")
                continue
            if audio.shape[0] < 64:
                continue

            orig  = normalize_to_0dBFS(audio)
            rng   = np.random.default_rng(seed=file_index)
            mixed = ensure_2d(mix_pink_noise(orig, sr, PINK_NOISE_LEVEL_DB, rng))
            file_index += 1
            orig_with_noise = ensure_2d(normalize_to_0dBFS(mixed))
            limited         = ensure_2d(apply_brickwall_limiter(orig_with_noise, sr))
            gt_res_raw      = orig_with_noise - limited

            if np.max(np.abs(gt_res_raw)) < 1e-6:
                print(f"  [SKIP] {f.name} — limiter inattivo")
                continue

            gt_res = normalize_peak(gt_res_raw, RESIDUAL_DBFS)

            corpus.append({
                "file":           f.name,
                "sr":             sr,
                "orig_with_noise": orig_with_noise,   # ← nuovo: già pronto
                "limited":        limited,
                "gt_res":         gt_res,
                "gt_res_raw":     gt_res_raw,         # ← nuovo: scala assoluta
            })
            if max_files and len(corpus) >= max_files:
                return corpus

    return corpus


# =============================================================================
# HYBRID PROCESSOR
# =============================================================================

def _lr_split_np(x: np.ndarray, crossover_hz: float, sr: int
                 ) -> Tuple[np.ndarray, np.ndarray]:
    """Phase-perfect LR crossover.  lp + hp == x esattamente."""
    from scipy.signal import butter, sosfiltfilt
    fc  = float(np.clip(crossover_hz, 1.0, sr / 2.0 - 1.0))
    sos = butter(2, fc, btype="low", fs=sr, output="sos")
    lp  = sosfiltfilt(sos, x)
    hp  = x - lp
    return lp, hp


def process_hybrid(
    limited:       np.ndarray,    # (N,) o (N, C) — segnale limitato
    sr:            int,
    hf_params:     dict,           # parametri per v11 HF
    lf_model:      Optional["HybridSPADEInference"],  # None = solo v11
    lf_params:     dict,           # parametri per LF (delta_db, max_gain_db, …)
    crossover_hz:  float = BAND_CROSSOVER_HZ,
) -> np.ndarray:
    """
    Processa un segnale con la pipeline ibrida:
      HF (> crossover_hz): v11 S-SPADE invariato
      LF (< crossover_hz): SPADEUnrolled (o v11 se lf_model is None)

    Se lf_model is None → usa v11 anche per LF (modalità baseline).

    Restituisce lo stesso shape di limited.
    """
    if not _HAS_V11:
        raise RuntimeError("spade_declip_v11.py non trovato — impossibile processare HF")

    mono = limited.ndim == 1
    if mono:
        limited = limited[:, None]
    _, C   = limited.shape
    output = np.zeros_like(limited, dtype=np.float64)

    for ch in range(C):
        yc = limited[:, ch].astype(np.float64)

        # ── LR split ────────────────────────────────────────────────────
        lf_band, hf_band = _lr_split_np(yc, crossover_hz, sr)

        # ── HF: v11 S-SPADE identico ─────────────────────────────────────
        hf_win  = hf_params.get("hf_window_length", 2048)
        hf_hop  = hf_params.get("hf_hop_length",    hf_win // 4)
        hf_p = _V11Params(
            sample_rate   = sr,
            delta_db      = hf_params.get("hf_delta_db",    1.5),
            window_length = hf_win,
            hop_length    = hf_hop,
            s             = hf_params.get("hf_s",           1),
            r             = hf_params.get("hf_r",           1),
            eps           = hf_params.get("hf_eps",         0.05),
            max_iter      = hf_params.get("hf_max_iter",    500),
            max_gain_db   = hf_params.get("hf_max_gain_db", 9.0),
            release_ms    = hf_params.get("hf_release_ms",  0.0),
            **HF_FIXED,
        )
        hf_rec, _ = _v11_declip(hf_band.astype(np.float32), hf_p)

        # ── LF: modello appreso o v11 fallback ────────────────────────────
        if lf_model is not None:
            # Aggiorna i parametri LF nel wrapper (ricrea SPADEUnrolledInference)
            lf_infer = SPADEUnrolledInference(
                lf_model.model,
                delta_db    = lf_params.get("lf_delta_db",    1.5),
                max_gain_db = lf_params.get("lf_max_gain_db", 9.0),
                device      = lf_model.device,
            )
            lf_rec = lf_infer.process(lf_band.astype(np.float32), sr)
        else:
            # Baseline: v11 anche per LF
            lf_win = hf_params.get("hf_window_length", 2048)
            lf_hop = lf_win // 4
            lf_p = _V11Params(
                sample_rate   = sr,
                delta_db      = lf_params.get("lf_delta_db",    1.5),
                window_length = lf_win,
                hop_length    = lf_hop,
                eps           = hf_params.get("hf_eps",         0.05),
                max_iter      = hf_params.get("hf_max_iter",    500),
                max_gain_db   = lf_params.get("lf_max_gain_db", 9.0),
                release_ms    = lf_params.get("lf_release_ms",  0.0),
                **HF_FIXED,
            )
            lf_rec, _ = _v11_declip(lf_band.astype(np.float32), lf_p)

        # ── Somma ─────────────────────────────────────────────────────────
        L = min(len(lf_rec), len(hf_rec))
        output[:L, ch] = lf_rec[:L].astype(np.float64) + hf_rec[:L]

    return output[:, 0] if mono else output


# =============================================================================
# VALUTAZIONE SINGOLO FILE
# =============================================================================

def evaluate_one(
    item:         Dict,
    hf_params:    dict,
    lf_params:    dict,
    lf_model:     Optional["HybridSPADEInference"],
) -> Optional[float]:
    """
    Esegue la pipeline ibrida su un item del corpus e restituisce il punteggio
    cosine_sim_tf(gt_res, res_iter) in [0, 1].  1.0 = recupero perfetto.
    """
    try:
        sr      = item["sr"]
        limited = item["limited"].copy()
        gt_res  = item["gt_res"]

        fixed_2d = ensure_2d(process_hybrid(limited, sr, hf_params, lf_model, lf_params))
        res_raw  = fixed_2d - limited
        res_iter = normalize_peak(res_raw, RESIDUAL_DBFS)

        return cosine_sim_tf(gt_res, res_iter, sr)
    except Exception as exc:
        warnings.warn(f"evaluate_one ({item['file']}): {exc}")
        return None


# =============================================================================
# OBIETTIVO OPTUNA
# =============================================================================

def make_objective(
    corpus:   List[Dict],
    lf_model: Optional["HybridSPADEInference"],
):
    def objective(trial: "optuna.Trial") -> float:

        # ── Parametri HF (v11 S-SPADE) ───────────────────────────────────
        hf_delta  = trial.suggest_float("hf_delta_db",    0.5,  3.0, step=0.1)
        hf_win_e  = trial.suggest_int  ("hf_win_exp",     9,    11)
        hf_hop_d  = trial.suggest_categorical("hf_hop_div", [4, 8])
        hf_rel    = trial.suggest_float("hf_release_ms",  0.0, 150.0, step=5.0)
        hf_gain   = trial.suggest_float("hf_max_gain_db", 2.0,  12.0, step=0.5)
        hf_eps    = trial.suggest_categorical("hf_eps",   [0.03, 0.05, 0.1])
        hf_iter   = trial.suggest_categorical("hf_max_iter", [250, 500, 1000])
        hf_win    = 2 ** hf_win_e
        hf_hop    = hf_win // hf_hop_d

        # ── Parametri LF (SPADEUnrolled) ─────────────────────────────────
        # Il modello è fisso; ottimizziamo soglia/gain per la banda LF.
        lf_delta  = trial.suggest_float("lf_delta_db",    0.5,  3.0, step=0.1)
        lf_gain   = trial.suggest_float("lf_max_gain_db", 3.0,  12.0, step=0.5)
        lf_rel    = trial.suggest_float("lf_release_ms",  0.0, 150.0, step=5.0)

        hf_params = dict(
            hf_delta_db      = hf_delta,
            hf_window_length = hf_win,
            hf_hop_length    = hf_hop,
            hf_release_ms    = hf_rel,
            hf_max_gain_db   = hf_gain,
            hf_eps           = hf_eps,
            hf_max_iter      = hf_iter,
        )
        lf_params = dict(
            lf_delta_db    = lf_delta,
            lf_max_gain_db = lf_gain,
            lf_release_ms  = lf_rel,
        )

        scores   = []
        midpoint = len(corpus) // 2

        for step, item in enumerate(corpus):
            sc = evaluate_one(item, hf_params, lf_params, lf_model)
            if sc is not None:
                scores.append(sc)
            if step == midpoint and scores:
                trial.report(float(np.mean(scores)), step=step)
                if trial.should_prune():
                    raise optuna.TrialPruned()

        if not scores:
            return 0.0
        mean_score = float(np.mean(scores))
        trial.report(mean_score, step=len(corpus))
        return mean_score

    return objective


# =============================================================================
# DEBUG EXPORT  (6 tracce + analisi spettrale)
# =============================================================================

def debug_export(
    corpus:    list,
    base_dir:  Path,
    out_dir:   Path,
    n_files:   int,
    hf_params: dict,
    lf_params: dict,
    lf_model:  Optional["HybridSPADEInference"],
) -> None:
    """
    Esporta 6 WAV float32 per i primi n_files item del corpus.

    Tracce esportate
    ----------------
    01_orig_with_noise  drum + pink noise @0 dBFS (prima del limiter)
    02_limited          uscita limiter (ingresso SPADE)
    03_gt_residual      GT residual @RESIDUAL_DBFS
    04_spade_output     uscita ibrida (può >0 dBFS)
    05_res_iter         residual ibrido @RESIDUAL_DBFS
    06_diff_residuals   GT_res − res_iter @RESIDUAL_DBFS
                        → annotato: cos_sim, diff/GT dB, noise_floor dB

    Metrica ideale: 06 = silenzio (diff → −∞ dB)
    Floor fisico  : ~ PINK_NOISE_LEVEL_DB + RESIDUAL_DBFS (rumore irrecuperabile)
    """
    out_dir.mkdir(parents=True, exist_ok=True)
    items  = corpus[:n_files]
    col_w  = max(len(it["file"]) for it in items) + 2

    HDR = (f"  {'file':<{col_w}}  {'traccia':<22}"
           f"  {'peak dBFS':>10}  {'RMS dBFS':>9}  note")
    SEP = "  " + "─" * (len(HDR) - 2)

    mode_str = "IBRIDO (v11 HF + ML LF)" if lf_model is not None else "BASELINE v11 broadband"

    print()
    if _HAS_RICH:
        _console.rule(f"[bold cyan]DEBUG EXPORT — {mode_str}[/]")
    else:
        print("=" * 72)
        print(f"DEBUG EXPORT — {mode_str}")
        print("=" * 72)

    print(f"  Output dir    : {out_dir}")
    print(f"  Modalità      : {mode_str}")
    print(f"  Crossover     : {BAND_CROSSOVER_HZ:.0f} Hz")
    print(f"  HF params     : delta={hf_params.get('hf_delta_db',1.5):.2f}"
          f"  win={hf_params.get('hf_window_length',2048)}"
          f"  rel={hf_params.get('hf_release_ms',0):.0f}ms"
          f"  gain={hf_params.get('hf_max_gain_db',9):.1f}dB"
          f"  eps={hf_params.get('hf_eps',0.05)}"
          f"  iter={hf_params.get('hf_max_iter',500)}")
    print(f"  LF params     : delta={lf_params.get('lf_delta_db',1.5):.2f}"
          f"  gain={lf_params.get('lf_max_gain_db',9):.1f}dB"
          f"  rel={lf_params.get('lf_release_ms',0):.0f}ms")
    print(f"  File esportati: {len(items)}")
    print()
    print(f"  Livelli attesi:")
    print(f"    01  ≈   0.00 dBFS  (normalizzato prima del limiter)")
    print(f"    02  ≈ {-LIMITER_THRESHOLD_DB:+.2f} dBFS  (uscita limiter)")
    print(f"    03  = {RESIDUAL_DBFS:+.2f} dBFS  (GT residual normalizzato)")
    print(f"    04  può >0 dBFS    (transiente recuperato)")
    print(f"    05  = {RESIDUAL_DBFS:+.2f} dBFS  (residual ibrido normalizzato)")
    print(f"    06  << 0 dBFS      (più basso = migliore)")
    print()
    print(HDR)

    diff_stats = []

    for file_idx, item in enumerate(items):
        sr               = item["sr"]
        limited          = item["limited"].copy()
        gt_res           = item["gt_res"]
        gt_res_raw       = item["gt_res_raw"]
        orig_with_noise  = item["orig_with_noise"]
        stem             = Path(item["file"]).stem

        # ── Esegui pipeline ibrida ────────────────────────────────────────
        try:
            fixed_2d = ensure_2d(
                process_hybrid(limited.copy(), sr, hf_params, lf_model, lf_params)
            )
        except Exception as exc:
            print(f"  [ERRORE] {item['file']}: {exc}")
            continue

        # ── Residual iterazione (scala assoluta) ─────────────────────────
        res_raw = fixed_2d - limited

        # ── Metriche sulla scala raw (non normalizzata) ───────────────────
        gt_arr  = gt_res_raw
        est_arr = res_raw
        L       = min(gt_arr.shape[0], est_arr.shape[0])

        # Cosine similarity temporale (canale L)
        g_flat = gt_arr[:L, 0]  if gt_arr.ndim  == 2 else gt_arr[:L]
        e_flat = est_arr[:L, 0] if est_arr.ndim == 2 else est_arr[:L]
        cos_sim_td = float(
            np.dot(g_flat, e_flat) /
            (np.linalg.norm(g_flat) * np.linalg.norm(e_flat) + 1e-12)
        )

        # diff/GT dB: quanto il residuo dell'errore è grande rispetto al GT
        diff_raw      = gt_arr[:L] - est_arr[:L]
        diff_rms_db   = _rms_dbfs(diff_raw)
        gt_rms_db     = _rms_dbfs(gt_arr[:L])
        diff_vs_gt_db = diff_rms_db - gt_rms_db    # 0 dB = diff uguale a GT; << 0 = buono

        # Floor teorico: il rumore rosa fa parte del GT_res ma è irrecuperabile
        noise_floor_db = PINK_NOISE_LEVEL_DB + RESIDUAL_DBFS   # ≈ −23 dBFS

        # ── Normalizza per l'export WAV ────────────────────────────────────
        res_iter  = normalize_peak(res_raw, RESIDUAL_DBFS)
        diff_norm = (normalize_peak(diff_raw, RESIDUAL_DBFS)
                     if np.max(np.abs(diff_raw)) > 1e-12
                     else diff_raw)

        diff_stats.append((diff_vs_gt_db, cos_sim_td))

        # ── Definizione tracce  (pipeline standard run_smart_sweep) ──────
        tracks = [
            ("01_orig_with_noise",
             orig_with_noise,
             f"drum+noise @0dBFS (input pipeline)"),
            ("02_limited",
             limited,
             f"uscita limiter (input SPADE)  atteso: ~{-LIMITER_THRESHOLD_DB:+.2f}dBFS"),
            ("03_gt_residual",
             gt_res,
             f"GT residual @{RESIDUAL_DBFS:.0f}dBFS  (include noise attenuation)"),
            ("04_spade_output",
             fixed_2d,
             f"SPADE output (float32, puo' >0dBFS)"),
            ("05_res_iter",
             res_iter,
             f"residual SPADE @{RESIDUAL_DBFS:.0f}dBFS  (solo componente sparsa)"),
            ("06_diff_residuals",
             diff_norm,
             f"GT - iter @{RESIDUAL_DBFS:.0f}dBFS  "
             f"cos_sim={cos_sim_td:.3f}  diff/GT={diff_vs_gt_db:+.1f}dB  "
             f"noise_floor≈{noise_floor_db:+.1f}dB"),
        ]

        # ── Stampa tabella + scrivi WAV ────────────────────────────────────
        print(SEP)
        for track_name, audio, note in tracks:
            pk  = _pk_dbfs(audio)
            rms = _rms_dbfs(audio)
            flag = ""
            if track_name == "06_diff_residuals":
                if   diff_vs_gt_db < -12: flag = "[OK]   buona convergenza"
                elif diff_vs_gt_db <  -6: flag = "[~]    convergenza parziale"
                else:                     flag = "[WARN] diff elevato rispetto al GT"
            row = (f"  {item['file']:<{col_w}}  {track_name:<22}"
                   f"  {pk:>+10.2f}  {rms:>+9.2f}  {note}  {flag}")
            if _HAS_RICH:
                color = ("green"  if "[OK]"   in flag else
                         "yellow" if "[~]"    in flag else
                         "red"    if "[WARN]" in flag else "")
                _console.print(row.replace(flag, f"[{color or 'dim'}]{flag}[/]") if flag else row)
            else:
                print(row)
            _write_wav(out_dir / f"{stem}__{track_name}.wav", audio, sr)

        # ── Analisi spettrale per banda ────────────────────────────────────
        BANDS_SPEC = [
            ("Sub-bass ",   20,    80),
            ("Bass     ",   80,   250),
            ("Low-mid  ",  250,   800),
            ("High-mid ",  800,  4000),
            ("High <8k ",  4000, 8000),
            ("High >8k ",  8000, 20000),
        ]

        def band_energy(audio_2d, sr, f_lo, f_hi):
            mono  = audio_2d[:, 0] if audio_2d.ndim == 2 else audio_2d
            N     = len(mono)
            if N < 8: return -999.0
            nyq = sr / 2.0
            lo  = max(f_lo / nyq, 1e-4)
            hi  = min(f_hi / nyq, 0.9999)
            if lo >= hi: return -999.0
            if lo < 1e-3:
                b2, a2 = sig.butter(4, hi, btype="low")
            else:
                b2, a2 = sig.butter(4, [lo, hi], btype="band")
            filtered = sig.filtfilt(b2, a2, mono)
            return _rms_dbfs(filtered)

        print()
        band_hdr = (f"    {'banda':<12} {'GT_res RMS':>10}  {'iter rec RMS':>13}"
                    f"  {'diff':>6}  {'stato'}")
        print(f"  Analisi spettrale — {item['file']}  (LF/HF split @ {BAND_CROSSOVER_HZ:.0f} Hz)")
        print(f"  {'─'*76}")
        print(band_hdr)
        print(f"  {'─'*76}")
        for bname, f_lo, f_hi in BANDS_SPEC:
            gt_db   = band_energy(gt_res_raw,  sr, f_lo, f_hi)
            iter_db = band_energy(res_raw,      sr, f_lo, f_hi)
            is_hf   = f_lo >= BAND_CROSSOVER_HZ
            label   = "v11 HF →" if is_hf else "ML LF →"
            if gt_db < -60:
                rec_str = "  —    (silenzio)"
                status  = ""
            else:
                d = iter_db - gt_db
                status  = ("OK"         if d > -3 else
                           "~ parziale" if d > -9 else
                           "!! sotto")
                rec_str = f"{d:>+6.1f} dB  {status}"
            line = f"    {bname:<12} {gt_db:>+10.1f}  {iter_db:>+13.1f}  {rec_str}  [{label}]"
            if _HAS_RICH:
                color = ("green" if "OK" in rec_str else
                         "yellow" if "~" in rec_str else
                         "red" if "!!" in rec_str else "dim")
                _console.print(f"[{color}]{line}[/]")
            else:
                print(line)
        print()

    # ── Riepilogo complessivo ─────────────────────────────────────────────
    print(SEP)
    if diff_stats:
        vs_gt  = [d[0] for d in diff_stats]
        cosims = [d[1] for d in diff_stats]
        nf_db  = PINK_NOISE_LEVEL_DB + RESIDUAL_DBFS

        print(f"\n  RIEPILOGO  ({len(diff_stats)} file):")
        print(f"    diff/GT_rms   media   : {np.mean(vs_gt):>+7.2f} dB")
        print(f"    diff/GT_rms   migliore: {np.min(vs_gt):>+7.2f} dB")
        print(f"    diff/GT_rms   peggiore: {np.max(vs_gt):>+7.2f} dB")
        print(f"    cos_sim TD    media   : {np.mean(cosims):>8.4f}  (1.0 = identici)")
        print()
        print(f"  Floor fisico (rumore irrecuperabile): ≈ {nf_db:+.1f} dBFS")
        print(f"  Soglia 'buona convergenza':           diff/GT < −12 dB")
        verdict = ("OK     eccellente" if np.mean(vs_gt) < -12 else
                   "~      buona"      if np.mean(vs_gt) < -6  else
                   "INFO   compatibile con noise floor")
        print(f"  Verdetto: {verdict}")

    print(f"\n  WAV → {out_dir}/")
    print(f"  Formato: float32  (usa editor che supporta >0 dBFS)")
    print(f"  Nome: <stem>__<N>_<traccia>.wav")


# =============================================================================
# REPORT + CSV
# =============================================================================

def print_report(study: "optuna.Study", top_n: int = 20):
    trials = sorted(
        [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE],
        key=lambda t: t.value or 0, reverse=True,
    )
    if not trials:
        print("Nessun trial completato.")
        return

    if _HAS_RICH:
        _console.rule("[bold cyan]RISULTATI SWEEP BAYESIANO — HYBRID SPADE[/]")
        tbl = Table(show_header=True, header_style="bold cyan", show_lines=False)
        for col, w in [
            ("#",4),("score",9),
            ("HF_ddb",6),("HF_win",6),("HF_rel",6),("HF_gain",6),("HF_eps",5),("HF_iter",5),
            ("LF_ddb",6),("LF_gain",6),("LF_rel",6),
        ]:
            tbl.add_column(col, justify="right", width=w)
        for rank, t in enumerate(trials[:top_n], 1):
            p    = t.params
            win  = 2 ** p.get("hf_win_exp", 11)
            hop  = win // p.get("hf_hop_div", 4)
            sty  = "bold green" if rank == 1 else ("yellow" if rank <= 3 else "")
            tbl.add_row(
                str(rank), f"{t.value:.5f}",
                f"{p['hf_delta_db']:.2f}",  str(win),
                f"{p['hf_release_ms']:.0f}", f"{p['hf_max_gain_db']:.1f}",
                str(p['hf_eps']),            str(p['hf_max_iter']),
                f"{p['lf_delta_db']:.2f}",  f"{p['lf_max_gain_db']:.1f}",
                f"{p['lf_release_ms']:.0f}",
                style=sty,
            )
        _console.print(tbl)
    else:
        hdr = (f"{'#':>3}  {'score':>8}  {'HFddb':>5}  {'HFwin':>5}"
               f"  {'HFrel':>5}  {'HFgain':>6}  {'HFeps':>5}  {'HFiter':>5}"
               f"  {'LFddb':>5}  {'LFgain':>6}  {'LFrel':>5}")
        print(hdr); print("─" * len(hdr))
        for rank, t in enumerate(trials[:top_n], 1):
            p   = t.params
            win = 2 ** p.get("hf_win_exp", 11)
            print(f"{rank:>3}  {t.value:>8.5f}  {p['hf_delta_db']:>5.2f}"
                  f"  {win:>5}  {p['hf_release_ms']:>5.0f}"
                  f"  {p['hf_max_gain_db']:>6.1f}  {str(p['hf_eps']):>5}"
                  f"  {p['hf_max_iter']:>5}"
                  f"  {p['lf_delta_db']:>5.2f}  {p['lf_max_gain_db']:>6.1f}"
                  f"  {p['lf_release_ms']:>5.0f}")

    best = trials[0]
    p    = best.params
    win  = 2 ** p.get("hf_win_exp", 11)
    hop  = win // p.get("hf_hop_div", 4)
    print("\n" + "═" * 60)
    print("CONFIG OTTIMALE — HYBRID SPADE")
    print("═" * 60)
    print(f"""
hf_params = dict(
    hf_delta_db      = {p['hf_delta_db']:.2f},
    hf_window_length = {win},
    hf_hop_length    = {hop},
    hf_release_ms    = {p['hf_release_ms']:.1f},
    hf_max_gain_db   = {p['hf_max_gain_db']:.1f},
    hf_eps           = {p['hf_eps']},
    hf_max_iter      = {p['hf_max_iter']},
)
lf_params = dict(
    lf_delta_db      = {p['lf_delta_db']:.2f},
    lf_max_gain_db   = {p['lf_max_gain_db']:.1f},
    lf_release_ms    = {p['lf_release_ms']:.1f},
)
""")
    print(f"→ Best score : {best.value:.5f}")
    n_pruned = sum(1 for t in study.trials if t.state == optuna.trial.TrialState.PRUNED)
    print(f"   Completed : {len(trials)}   Pruned : {n_pruned}")


def save_csv(study: "optuna.Study"):
    import csv
    trials = sorted(
        [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE],
        key=lambda t: t.value or 0, reverse=True,
    )
    if not trials:
        return
    fieldnames = ["rank", "score"] + list(trials[0].params.keys())
    with open(OUT_CSV, "w", newline="") as f:
        w = csv.DictWriter(f, fieldnames=fieldnames)
        w.writeheader()
        for rank, t in enumerate(trials, 1):
            row = {"rank": rank, "score": f"{t.value:.6f}"}
            row.update({k: f"{v:.4f}" if isinstance(v, float) else v
                        for k, v in t.params.items()})
            w.writerow(row)
    print(f"\n  CSV salvato: {OUT_CSV}")


# =============================================================================
# MAIN
# =============================================================================

def main():
    p = argparse.ArgumentParser(
        description="Hybrid SPADE (v11 HF + Unrolled LF) — Bayesian sweep",
        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
    )
    p.add_argument("--base-dir",        type=Path,  default=Path("./Samples"),
                   help="Cartella radice contenente Kicks/, Snares/, ecc.")
    p.add_argument("--model",           type=Path,  default=None,
                   dest="model_ckpt",
                   help="Checkpoint SPADEUnrolled (.pt).  Ometti per baseline v11.")
    p.add_argument("--trials",          type=int,   default=200)
    p.add_argument("--resume",          action="store_true",
                   help="Riprende uno studio Optuna esistente")
    p.add_argument("--report",          action="store_true",
                   help="Stampa solo il report dal DB esistente")
    p.add_argument("--debug-export",    type=int,   default=0,
                   metavar="N",
                   help="Esporta le 6 tracce WAV per i primi N file del corpus")
    p.add_argument("--debug-out",       type=Path,  default=Path("debug_export"),
                   help="Directory di output per --debug-export")
    p.add_argument("--baseline-v11",    action="store_true",
                   help="Usa solo v11 broadband (nessun modello ML) come baseline")
    p.add_argument("--crossover-hz",    type=float, default=BAND_CROSSOVER_HZ,
                   help="Frequenza di crossover LF/HF in Hz")
    p.add_argument("--max-files",       type=int,   default=None,
                   help="Limita il corpus ai primi N file (test rapido)")
    p.add_argument("--top",             type=int,   default=20,
                   help="Numero di trial da mostrare nel report")
    p.add_argument("--db-path",         type=str,   default=f"sqlite:///{STUDY_NAME}.db",
                   help="SQLite URI per Optuna (default: sqlite:///hybrid_spade_v1.db)")
    args = p.parse_args()

    if not _HAS_V11:
        print("[ERRORE] spade_declip_v11.py non trovato — uscita.")
        sys.exit(1)

    # ── Carica corpus ─────────────────────────────────────────────────────
    print(f"\n  Caricamento corpus da: {args.base_dir}")
    corpus = build_corpus(args.base_dir, max_files=args.max_files)
    if not corpus:
        print("[ERRORE] Corpus vuoto — controlla --base-dir e le cartelle drum.")
        sys.exit(1)
    print(f"  Corpus: {len(corpus)} file\n")

    # ── Carica modello ML (opzionale) ─────────────────────────────────────
    lf_model = None
    if args.model_ckpt is not None and not args.baseline_v11:
        if not _HAS_UNROLLED:
            print("[ERRORE] spade_unrolled.py / PyTorch non trovati.")
            sys.exit(1)
        ckpt = torch.load(args.model_ckpt, map_location="cpu")
        cfg  = UnrolledConfig(**ckpt["cfg"])
        model = SPADEUnrolled(cfg)
        model.load_state_dict(ckpt["model"])
        model.eval()
        lf_model = HybridSPADEInference(
            model,
            crossover_hz   = args.crossover_hz,
            lf_delta_db    = DEBUG_LF["lf_delta_db"],
            lf_max_gain_db = DEBUG_LF["lf_max_gain_db"],
            device         = "auto",
        )
        print(f"  Modello caricato: {args.model_ckpt}")
        print(f"  Crossover:        {args.crossover_hz:.0f} Hz")
        print(f"  Parametri:        {model.parameter_count():,} trainable\n")
    else:
        print(f"  Modalità: {'baseline v11 broadband' if args.baseline_v11 else 'baseline v11 (nessun modello specificato)'}\n")

    # ── Optuna: report-only ────────────────────────────────────────────────
    if args.report:
        if not _HAS_OPTUNA:
            print("[ERRORE] optuna non trovato.")
            sys.exit(1)
        study = optuna.load_study(study_name=STUDY_NAME, storage=args.db_path)
        print_report(study, top_n=args.top)
        save_csv(study)
        return

    # ── Debug export ───────────────────────────────────────────────────────
    if args.debug_export > 0:
        # Se abbiamo un DB Optuna con trial completati → usa il best
        best_hf = dict(DEBUG_HF)
        best_lf = dict(DEBUG_LF)
        if _HAS_OPTUNA:
            try:
                study = optuna.load_study(study_name=STUDY_NAME, storage=args.db_path)
                complete = [t for t in study.trials
                            if t.state == optuna.trial.TrialState.COMPLETE]
                if complete:
                    bp = max(complete, key=lambda t: t.value or 0).params
                    win = 2 ** bp.get("hf_win_exp", 11)
                    hop = win // bp.get("hf_hop_div", 4)
                    best_hf = dict(
                        hf_delta_db      = bp.get("hf_delta_db",    1.5),
                        hf_window_length = win,
                        hf_hop_length    = hop,
                        hf_release_ms    = bp.get("hf_release_ms",  0.0),
                        hf_max_gain_db   = bp.get("hf_max_gain_db", 9.0),
                        hf_eps           = bp.get("hf_eps",         0.05),
                        hf_max_iter      = bp.get("hf_max_iter",    500),
                    )
                    best_lf = dict(
                        lf_delta_db    = bp.get("lf_delta_db",    1.5),
                        lf_max_gain_db = bp.get("lf_max_gain_db", 9.0),
                        lf_release_ms  = bp.get("lf_release_ms",  0.0),
                    )
                    print(f"  Best trial caricato dal DB ({len(complete)} completati)")
            except Exception:
                pass

        debug_export(corpus, args.base_dir, args.debug_out,
                     args.debug_export, best_hf, best_lf, lf_model)
        return

    # ── Bayesian sweep ─────────────────────────────────────────────────────
    if not _HAS_OPTUNA:
        print("[ERRORE] optuna non trovato — pip install optuna")
        sys.exit(1)

    sampler = TPESampler(multivariate=True, seed=42)
    pruner  = MedianPruner(n_startup_trials=10, n_warmup_steps=len(corpus)//2)

    if args.resume:
        study = optuna.load_study(
            study_name=STUDY_NAME, storage=args.db_path,
            sampler=sampler, pruner=pruner,
        )
        print(f"  Studio ripreso: {len(study.trials)} trial esistenti")
    else:
        study = optuna.create_study(
            study_name=STUDY_NAME, storage=args.db_path,
            direction="maximize",
            sampler=sampler, pruner=pruner,
            load_if_exists=True,
        )

    objective = make_objective(corpus, lf_model)

    # Progress bar (rich → tqdm → plain)
    _state = {
        "done": 0, "pruned": 0,
        "best": float("-inf"), "best_p": {}, "last": float("-inf"),
        "t0": time.time(),
    }

    try:
        from rich.progress import (
            Progress, BarColumn, TextColumn,
            TimeElapsedColumn, TimeRemainingColumn, MofNCompleteColumn,
        )
        _has_rich_p = True
    except ImportError:
        _has_rich_p = False

    try:
        import tqdm as _tqdm_mod
        _has_tqdm = True
    except ImportError:
        _has_tqdm = False

    def _on_trial_end(study, trial):
        fin = trial.state == optuna.trial.TrialState.COMPLETE
        prn = trial.state == optuna.trial.TrialState.PRUNED
        if fin:
            _state["done"]  += 1
            _state["last"]   = trial.value or 0.0
            if _state["last"] > _state["best"]:
                _state["best"]   = _state["last"]
                _state["best_p"] = dict(study.best_params)
        elif prn:
            _state["pruned"] += 1

    t0 = time.time()
    try:
        if _has_rich_p:
            progress = Progress(
                TextColumn("[bold cyan]Trial[/] [cyan]{task.completed}/{task.total}[/]"),
                BarColumn(bar_width=32),
                MofNCompleteColumn(),
                TextColumn("  score [green]{task.fields[last]:.5f}[/]"),
                TextColumn("  best [bold green]{task.fields[best]:.5f}[/]"),
                TextColumn("  [dim]pruned {task.fields[pruned]}[/]"),
                TimeElapsedColumn(), TextColumn("ETA"), TimeRemainingColumn(),
                refresh_per_second=4,
            )
            def _on_trial_rich(study, trial):
                _on_trial_end(study, trial)
                progress.update(task_id, advance=1,
                                last=_state["last"],
                                best=max(_state["best"], 0.0),
                                pruned=_state["pruned"])
            with progress:
                task_id = progress.add_task(
                    "sweep", total=args.trials,
                    last=0.0, best=0.0, pruned=0,
                )
                study.optimize(objective, n_trials=args.trials,
                               callbacks=[_on_trial_rich],
                               show_progress_bar=False)
        elif _has_tqdm:
            import tqdm
            pbar = tqdm.tqdm(total=args.trials, unit="trial")
            def _on_trial_tqdm(study, trial):
                _on_trial_end(study, trial)
                pbar.update(1)
                pbar.set_postfix(score=f"{_state['last']:.5f}",
                                 best=f"{_state['best']:.5f}",
                                 pruned=_state["pruned"])
            study.optimize(objective, n_trials=args.trials,
                           callbacks=[_on_trial_tqdm], show_progress_bar=False)
            pbar.close()
        else:
            study.optimize(objective, n_trials=args.trials,
                           callbacks=[_on_trial_end], show_progress_bar=False)
    except KeyboardInterrupt:
        print("\n[!] Interrotto — risultati parziali salvati.")

    elapsed = time.time() - t0
    n_done  = sum(1 for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE)
    n_prune = sum(1 for t in study.trials if t.state == optuna.trial.TrialState.PRUNED)
    print(f"\n  Completati: {n_done}  |  Pruned: {n_prune}"
          f"  |  Tempo: {elapsed/60:.1f} min"
          f"  |  Media: {elapsed/max(n_done+n_prune,1):.1f} s/trial")

    print_report(study, top_n=args.top)
    save_csv(study)
    print("\nDone.")


if __name__ == "__main__":
    main()