# -*- coding: utf-8 -*-
"""
genera_suoni.py  ELX Client, suoni dell'interfaccia, SECONDA SERIE «dopo» (lane MOCKUP-LIVELLO-SUONI, 30/10). Mockup, non codice.
Owner 30/10 dopo l'ascolto della prima serie: «il suono un po' meno impattante, non è molto adattato allo stile, forse un po' più elegante».
La prima serie resta in prima/ (genera_suoni_prima.py) per il confronto prima/dopo in ascolta.html.

Cosa cambia rispetto alla prima serie:
- attacchi lenti (5-15 ms) a mezzo coseno, nessun rumore secco né «clic», niente tonfi bassi (passa alto 180-220 Hz);
- una sola famiglia: tutte le note sono di RE maggiore con la settima (D E F# A B C#), come un set pentatonico/maj7;
- timbro «martelletto di feltro»: seno con un filo di FM che si spegne in pochi ms (il colpo morbido), poi seno puro;
- aria filtrata morbida (rumore con attacco lento, mai a scatto), larghezza stereo leggera data dal riverbero diverso a sinistra e a destra
  (il suono asciutto resta al centro: in mono non si perde niente), code corte;
- livello di tutti -24 LUFS (prima -20), picco vero <= -3 dBFS.
Tutto sintetizzato qui da zero (numpy): nessun campione, nessun suono copiato da Sony o da altri prodotti. Seme fisso = stessi file.
Uscita: <nome>.wav (48 kHz, 16 bit, stereo) e <nome>.ogg (Vorbis q4), misure.json.
Uso: python genera_suoni.py   (numpy; ffmpeg nel PATH per gli .ogg)
"""
import json, os, subprocess, wave
import numpy as np

SR = 48000
OUT = os.path.dirname(os.path.abspath(__file__))
rng = np.random.default_rng(3110)

# RE maggiore con la settima: le sole note usate
N = {'D4': 293.66, 'A4': 440.0, 'B4': 493.88, 'D5': 587.33, 'E5': 659.26, 'F#5': 739.99, 'A5': 880.0, 'B5': 987.77,
     'C#6': 1108.73, 'D6': 1174.66, 'E6': 1318.51, 'F#6': 1479.98, 'A6': 1760.0, 'C#7': 2217.46}


# ---------------------------------------------------------------- mattoni
def env(n, attack, tau, hold=0.0):
    t = np.arange(n) / SR
    a = np.clip(t / max(attack, 1e-4), 0, 1)
    e = 0.5 - 0.5 * np.cos(np.pi * a)
    return e * np.exp(-np.clip(t - attack - hold, 0, None) / tau)


def mallet(f, dur, attack=0.008, tau=0.05, fm=0.5, fm_tau=0.012, h2=0.06, ratio=1.0):
    """martelletto di feltro: seno con FM (rapporto ratio) che si spegne in fm_tau secondi, un filo di seconda armonica"""
    n = int(round(dur * SR))
    t = np.arange(n) / SR
    idx = fm * np.exp(-t / fm_tau)
    y = np.sin(2 * np.pi * f * t + idx * np.sin(2 * np.pi * f * ratio * t)) + h2 * np.sin(4 * np.pi * f * t) * np.exp(-t / (tau * .5))
    return y * env(n, attack, tau)


def biquad(x, b, a):
    b0, b1, b2 = b
    _, a1, a2 = a
    y = np.zeros_like(x)
    x1 = x2 = y1 = y2 = 0.0
    for i in range(len(x)):
        xi = x[i]
        yi = b0 * xi + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2
        x2, x1, y2, y1 = x1, xi, y1, yi
        y[i] = yi
    return y


def rbj(kind, f, q=0.707):
    w = 2 * np.pi * f / SR
    c, s = np.cos(w), np.sin(w)
    al = s / (2 * q)
    if kind == 'lp':
        b = [(1 - c) / 2, 1 - c, (1 - c) / 2]
    elif kind == 'hp':
        b = [(1 + c) / 2, -(1 + c), (1 + c) / 2]
    else:
        b = [al, 0.0, -al]
    a = [1 + al, -2 * c, 1 - al]
    return [v / a[0] for v in b], [1.0, a[1] / a[0], a[2] / a[0]]


def filt(x, kind, f, q=0.707):
    b, a = rbj(kind, f, q)
    return biquad(x, b, a)


def sweep_bp(x, path, q):
    """passa banda che segue path(t) -> frequenza; coefficienti aggiornati ogni 32 campioni"""
    y = np.zeros_like(x)
    x1 = x2 = y1 = y2 = 0.0
    for start in range(0, len(x), 32):
        (b0, b1, b2), (_, a1, a2) = rbj('bp', path(start / SR), q)
        for i in range(start, min(start + 32, len(x))):
            xi = x[i]
            yi = b0 * xi + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2
            x2, x1, y2, y1 = x1, xi, y1, yi
            y[i] = yi
    return y


def air(dur, path, q, attack, tau, hold=0.0):
    """aria filtrata morbida: rumore in un passa banda che scorre, attacco lento (mai a scatto), scurita"""
    n = int(round(dur * SR))
    x = sweep_bp(rng.standard_normal(n), path, q)
    return filt(x, 'lp', 4200) * env(n, attack, tau, hold)


def place(buf, sig, at, amp=1.0):
    i = int(round(at * SR))
    end = min(len(buf), i + len(sig))
    buf[i:end] += amp * sig[:end - i]
    return buf


def room(x, wet, tau, lp=4500):
    """riverbero stereo piccolo: due risposte all'impulso diverse (sinistra e destra) = larghezza leggera; l'asciutto resta al centro"""
    L = int(SR * min(tau * 5, 0.8))
    t = np.arange(L) / SR
    out = []
    dry = np.concatenate([x, np.zeros(L)])
    n = len(x) + L
    nfft = 1 << (n - 1).bit_length()
    X = np.fft.rfft(x, nfft)
    for _ in range(2):
        ir = filt(rng.standard_normal(L) * np.exp(-t / tau), 'lp', lp)
        ramp = int(0.008 * SR)
        ir[:ramp] *= np.linspace(0, 1, ramp)
        ir /= np.sqrt(np.sum(ir ** 2)) + 1e-12
        y = np.fft.irfft(X * np.fft.rfft(ir, nfft), nfft)[:n]
        y *= np.sqrt(np.sum(x ** 2)) / (np.sqrt(np.sum(y ** 2)) + 1e-12)
        out.append(dry + wet * y)
    return np.stack(out)   # 2 x n


# ---------------------------------------------------------------- misure (BS.1770, K-pesatura 48 kHz; stereo = somma dei canali)
K1 = ([1.53512485958697, -2.69169618940638, 1.19839281085285], [1.0, -1.69065929318241, 0.73248077421585])
K2 = ([1.0, -2.0, 1.0], [1.0, -1.99004745483398, 0.99007225036621])


def lufs(st):
    return -0.691 + 10 * np.log10(sum(np.mean(biquad(biquad(c, *K1), *K2) ** 2) for c in st) + 1e-20)


def true_peak_db(st):
    pk = 0.0
    for c in st:
        up = np.fft.irfft(np.fft.rfft(c), len(c) * 4) * 4
        pk = max(pk, np.max(np.abs(up)))
    return 20 * np.log10(pk + 1e-12)


def finish(st, max_dur, hp=200, lp=6000, fade=0.03):
    st = np.stack([filt(filt(filt(c, 'hp', hp), 'lp', lp), 'lp', lp * 1.2) for c in st])
    a = np.max(np.abs(st), axis=0)
    last = np.nonzero(a > a.max() * 10 ** (-60 / 20))[0][-1] + 1
    st = st[:, : min(last, int(max_dur * SR))].copy()
    fo = min(int(fade * SR), st.shape[1] // 3)
    st[:, -fo:] *= np.linspace(1, 0, fo) ** 2
    return st


def master(st, target=-24.0, ceiling=-3.0):
    st = st * 10 ** ((target - lufs(st)) / 20)
    tp = true_peak_db(st)
    if tp > ceiling:
        st = st * 10 ** ((ceiling - tp - 0.05) / 20)
    return st


def buf(d):
    return np.zeros(int(round(d * SR)))


# ---------------------------------------------------------------- i suoni (tutti in RE maggiore 7)
def s_focus():
    # fuoco che si sposta: un tocco di feltro su F#6, appena accennato
    b = buf(0.08)
    place(b, mallet(N['F#6'], 0.08, attack=0.005, tau=0.016, fm=0.4, fm_tau=0.006, h2=0.0), 0)
    return finish(room(b, 0.08, 0.06), 0.075, hp=400, fade=0.02)


def s_seleziona():
    # conferma: RE6 con il LA6 che lo segue piano (quinta), feltro morbido
    b = buf(0.2)
    place(b, mallet(N['D6'], 0.2, attack=0.006, tau=0.045, fm=0.5, fm_tau=0.01), 0)
    place(b, mallet(N['A6'], 0.18, attack=0.008, tau=0.045, fm=0.3, fm_tau=0.01, h2=0.0), 0.022, 0.42)
    return finish(room(b, 0.16, 0.08), 0.16)


def s_indietro():
    # indietro o chiudi: LA5 che scende a FA#5 (terza), più scuro
    b = buf(0.2)
    place(b, mallet(N['A5'], 0.18, attack=0.007, tau=0.04, fm=0.35, fm_tau=0.01), 0, 0.8)
    place(b, mallet(N['F#5'], 0.18, attack=0.009, tau=0.05, fm=0.3, fm_tau=0.01), 0.035)
    return finish(room(b, 0.14, 0.08), 0.16, lp=4800)


def s_apri():
    # apre un pannello: un respiro d'aria che sale e due note che salgono (FA#5, RE6)
    b = buf(0.3)
    place(b, air(0.26, lambda t: 900 * (2200 / 900) ** min(t / 0.2, 1), 1.6, 0.06, 0.05, 0.03), 0, 0.3)
    place(b, mallet(N['F#5'], 0.22, attack=0.012, tau=0.06, fm=0.3), 0.01, 0.7)
    place(b, mallet(N['D6'], 0.22, attack=0.012, tau=0.07, fm=0.3), 0.05, 0.6)
    return finish(room(b, 0.2, 0.1), 0.26)


def s_pagina():
    # cambio pagina: un soffio laterale corto e una nota sola (MI6), leggera
    b = buf(0.26)
    place(b, air(0.2, lambda t: 1900 * (1300 / 1900) ** min(t / 0.15, 1), 1.2, 0.04, 0.05, 0.02), 0, 0.35)
    place(b, mallet(N['E6'], 0.18, attack=0.01, tau=0.05, fm=0.3), 0.035, 0.55)
    return finish(room(b, 0.18, 0.09), 0.22)


def s_notifica():
    # notifica: due tocchi di campanella morbida, RE6 poi FA#6 (terza maggiore), FM leggera da vetro
    b = buf(0.5)
    place(b, mallet(N['D6'], 0.42, attack=0.008, tau=0.11, fm=0.35, fm_tau=0.03, ratio=2.0), 0)
    place(b, mallet(N['F#6'], 0.42, attack=0.008, tau=0.13, fm=0.3, fm_tau=0.03, ratio=2.0), 0.085, 0.85)
    return finish(room(b, 0.22, 0.16), 0.42)


def s_errore():
    # rifiuto: SI4 che scende a LA4, ovattato, con pochissimi armonici; un «no» gentile
    b = buf(0.26)
    place(b, mallet(N['B4'], 0.16, attack=0.01, tau=0.045, fm=0.25, fm_tau=0.008, h2=0.03), 0)
    place(b, mallet(N['A4'], 0.2, attack=0.012, tau=0.06, fm=0.2, fm_tau=0.008, h2=0.03), 0.09)
    return finish(room(b, 0.12, 0.08), 0.22, hp=220, lp=2600)


def s_ritira():
    # Ritira: piccola campanella in tre note (RE6, FA#6, LA6) con un velo d'aria; mai una fanfara
    b = buf(0.65)
    for k, (nn, a, tau) in enumerate([('D6', 1.0, .12), ('F#6', .85, .14), ('A6', .75, .17)]):
        place(b, mallet(N[nn], 0.55, attack=0.008, tau=tau, fm=0.3, fm_tau=0.03, ratio=2.0), k * 0.05, a)
    place(b, air(0.4, lambda t: 3000, 2.5, 0.12, 0.12), 0.06, 0.06)
    return finish(room(b, 0.24, 0.17), 0.6, fade=0.08)


def s_drone():
    # arriva il drone: un soffio d'aria leggero che passa da destra al centro, con un tremolio morbido delle eliche; niente ronzio
    d = 0.8
    n = int(d * SR)
    t = np.arange(n) / SR
    path = lambda tt: 650 * (1500 / 650) ** min(tt / 0.4, 1) if tt < 0.4 else 1500 * (950 / 1500) ** min((tt - 0.4) / 0.4, 1)
    w = sweep_bp(rng.standard_normal(n), path, 1.3)
    w = filt(w, 'lp', 3800)
    flutter = 1 - 0.28 * (0.5 + 0.5 * np.sin(2 * np.pi * 21 * t))
    e = np.clip(t / 0.32, 0, 1) ** 1.5 * np.exp(-np.clip(t - 0.4, 0, None) / 0.16)
    mono = w * flutter * e
    pan = np.clip(1 - t / 0.45, 0, 1) * 0.55        # da destra verso il centro
    L = mono * np.cos((0.5 + pan * 0.5) * np.pi / 2) * np.sqrt(2)
    R = mono * np.sin((0.5 + pan * 0.5) * np.pi / 2) * np.sqrt(2)
    rv = room(mono, 0.18, 0.12)
    st = np.stack([np.concatenate([L, np.zeros(rv.shape[1] - n)]), np.concatenate([R, np.zeros(rv.shape[1] - n)])]) + (rv - np.concatenate([mono, np.zeros(rv.shape[1] - n)]))
    return finish(st, 0.8, hp=220, fade=0.08)


def s_pacco():
    # il pacco tocca terra: un tocco morbido (RE5 con FA#5 sopra) e un piccolo sbuffo d'aria; niente tonfo basso
    b = buf(0.3)
    place(b, air(0.12, lambda t: 1000, 0.9, 0.01, 0.03), 0, 0.18)
    place(b, mallet(N['D5'], 0.22, attack=0.008, tau=0.05, fm=0.5, fm_tau=0.012), 0.004, 0.9)
    place(b, mallet(N['F#5'], 0.2, attack=0.01, tau=0.045, fm=0.3, fm_tau=0.012), 0.012, 0.45)
    return finish(room(b, 0.14, 0.08), 0.26)


def s_livello():
    # salita di livello: campanella in quattro note dell'accordo RE maggiore 7 (RE6 FA#6 LA6 DO#7) sopra un velo RE5+LA5 che si gonfia piano
    d = 0.85
    b = buf(d)
    t = np.arange(len(b)) / SR
    pad = (np.sin(2 * np.pi * N['D5'] * t) + 0.7 * np.sin(2 * np.pi * N['A5'] * t) + 0.35 * np.sin(2 * np.pi * N['F#5'] * t))
    b += 0.16 * pad * (0.5 - 0.5 * np.cos(np.pi * np.clip(t / 0.16, 0, 1))) * np.exp(-np.clip(t - 0.22, 0, None) / 0.2)
    for k, (nn, a, tau) in enumerate([('D6', 1.0, .14), ('F#6', .9, .16), ('A6', .8, .19), ('C#7', .55, .22)]):
        place(b, mallet(N[nn], 0.7, attack=0.008, tau=tau, fm=0.3, fm_tau=0.03, ratio=2.0), k * 0.06, a)
    place(b, air(0.5, lambda tt: 600 * (2600 / 600) ** min(tt / 0.3, 1), 1.8, 0.14, 0.12), 0, 0.12)
    return finish(room(b, 0.26, 0.2), 0.82, fade=0.14)


SOUNDS = [
    ('focus', s_focus, 'Fuoco che si sposta (tastiera o controller)'),
    ('seleziona', s_seleziona, 'Conferma o scelta'),
    ('indietro', s_indietro, 'Indietro o chiudi'),
    ('apri', s_apri, 'Apre un pannello o una finestra'),
    ('pagina', s_pagina, 'Cambio pagina dalla striscia'),
    ('notifica', s_notifica, 'Notifica nuova'),
    ('errore', s_errore, 'Errore o rifiuto'),
    ('ritira', s_ritira, 'Ritira un premio'),
    ('drone', s_drone, 'Arriva il drone'),
    ('pacco', s_pacco, 'Il pacco tocca terra'),
    ('livello', s_livello, 'Salita di livello'),
]


def write_wav(path, st):
    pcm = np.clip(np.round(st.T * 32767), -32768, 32767).astype('<i2')
    with wave.open(path, 'wb') as w:
        w.setnchannels(2)
        w.setsampwidth(2)
        w.setframerate(SR)
        w.writeframes(pcm.tobytes())


def main():
    rows = []
    for name, fn, use in SOUNDS:
        st = master(fn())
        wav, ogg = os.path.join(OUT, name + '.wav'), os.path.join(OUT, name + '.ogg')
        write_wav(wav, st)
        subprocess.run(['ffmpeg', '-v', 'error', '-y', '-i', wav, '-c:a', 'libvorbis', '-q:a', '4', ogg], check=True)
        r = {'nome': name, 'uso': use, 'ms': round(st.shape[1] / SR * 1000), 'lufs': round(lufs(st), 1),
             'picco_vero_dbfs': round(true_peak_db(st), 1), 'kb_ogg': round(os.path.getsize(ogg) / 1024, 1), 'kb_wav': round(os.path.getsize(wav) / 1024, 1)}
        rows.append(r)
        print(f"{name:10s} {r['ms']:4d} ms  {r['lufs']:6.1f} LUFS  picco {r['picco_vero_dbfs']:5.1f} dBFS  ogg {r['kb_ogg']:5.1f} KB  wav {r['kb_wav']:5.1f} KB")
    with open(os.path.join(OUT, 'misure.json'), 'w', encoding='utf-8') as f:
        json.dump(rows, f, ensure_ascii=False, indent=1)


if __name__ == '__main__':
    main()
