#!/usr/bin/env python3
"""Vanta Tones: synthesise the ROM's entire sound set from nothing.

No samples, no recordings, no borrowed audio: every file is numpy maths.
One identity throughout: glassy FM bells and soft sine plucks, all tuned to
D major pentatonic (D E F# A B), short attacks, clean exponential tails, one
small shared room. Output is .ogg (Vorbis q6) under vendor/vanta/tones/.

    python3 tools/gen_tones.py            # render everything
    python3 tools/gen_tones.py --check    # ffprobe every file against its target length
"""
import os
import subprocess
import sys
import tempfile
import wave

import numpy as np

SR = 48000
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
OUT = os.path.join(ROOT, "vendor/vanta/tones")

# D major pentatonic, named by scale degree + octave. A4 = 440.
_SEMI = {"D": -7, "E": -5, "F#": -3, "A": 0, "B": 2}


def hz(note):
    name, octave = note[:-1], int(note[-1])
    return 440.0 * 2 ** ((_SEMI[name] + 12 * (octave - 4)) / 12)


def t_axis(dur):
    return np.arange(int(dur * SR)) / SR


def env(dur, attack=0.004, decay=0.6):
    """Near-instant attack, exponential fall; decay is the time to -60 dB."""
    t = t_axis(dur)
    a = np.clip(t / attack, 0, 1)
    return a * np.exp(-6.9 * t / decay)


def bell(note, dur=1.6, decay=1.2, ratio=3.5, index=2.4, bright=1.0):
    """FM glass bell. The non-integer ratio gives the glassy inharmonic shimmer;
    the index decays faster than the body so the tail settles into a pure tone."""
    f = hz(note) if isinstance(note, str) else note
    t = t_axis(dur)
    mod_env = index * bright * np.exp(-6.9 * t / (decay * 0.35))
    mod = mod_env * np.sin(2 * np.pi * f * ratio * t)
    body = np.sin(2 * np.pi * f * t + mod)
    # a faint octave partial keeps it "struck glass" rather than "FM organ"
    body += 0.18 * np.sin(2 * np.pi * f * 2.0 * t) * np.exp(-6.9 * t / (decay * 0.5))
    return body * env(dur, 0.002, decay)


def pluck(note, dur=0.8, decay=0.55, warmth=0.25):
    """Soft sine pluck: fundamental plus a quickly-fading 2nd/3rd harmonic."""
    f = hz(note) if isinstance(note, str) else note
    t = t_axis(dur)
    h = np.exp(-6.9 * t / (decay * 0.3))
    s = np.sin(2 * np.pi * f * t) + warmth * h * np.sin(4 * np.pi * f * t) + 0.5 * warmth * h * np.sin(6 * np.pi * f * t)
    return s * env(dur, 0.006, decay)


def click(dur=0.03, freq=2400.0, decay=0.012, noise=0.15, seed=7):
    """UI tick: a very short damped sine with a breath of filtered noise."""
    t = t_axis(dur)
    rng = np.random.default_rng(seed)
    n = np.convolve(rng.standard_normal(len(t)), np.ones(6) / 6, mode="same")
    return (np.sin(2 * np.pi * freq * t) + noise * n) * env(dur, 0.0005, decay)


def room(x, mix=0.16, size=1.0):
    """Tiny Schroeder room shared by every sound, so they sit in one space."""
    out = np.zeros(len(x))
    for d_ms, g in ((29.7, 0.77), (37.1, 0.74), (41.1, 0.71), (43.7, 0.69)):
        d = int(d_ms * size * SR / 1000)
        y = np.copy(x)
        for i in range(d, len(y), d):
            y[i:i + d] += g * y[i - d:i][: len(y[i:i + d])]
        out += y
    out /= 4
    for d_ms, g in ((5.0, 0.7), (1.7, 0.7)):
        # y[n] = -g x[n] + x[n-d] + g y[n-d], computed a block of d at a time
        d = int(d_ms * SR / 1000)
        xp = np.concatenate([np.zeros(d), out])
        yp = np.zeros(len(xp))
        for i in range(d, len(xp), d):
            j = min(len(xp), i + d)
            yp[i:j] = -g * xp[i:j] + xp[i - d:j - d] + g * yp[i - d:j - d]
        out = yp[d:]
    return (1 - mix) * x + mix * out


def track(dur):
    return np.zeros(int(dur * SR))


def put(buf, sig, at, gain=1.0, wrap=False):
    i = int(at * SR)
    n = len(sig)
    if wrap:
        idx = (np.arange(n) + i) % len(buf)
        np.add.at(buf, idx, gain * sig)
    else:
        end = min(len(buf), i + n)
        buf[i:end] += gain * sig[: end - i]
    return buf


def finish(x, peak_db=-1.0, fade_ms=8.0, loop=False):
    x = x - np.mean(x)
    x *= 10 ** (peak_db / 20) / (np.max(np.abs(x)) + 1e-12)
    if not loop:
        f = min(len(x) // 4, int(fade_ms * SR / 1000))
        if f > 0:
            x[-f:] *= np.linspace(1, 0, f) ** 2
        s = min(len(x) // 8, int(0.001 * SR))
        if s > 0:
            x[:s] *= np.linspace(0, 1, s)
    return x


# ---------------------------------------------------------------------------
# Ringtones: 12 s, loopable. Tails that run past the end wrap onto the start,
# and the room is applied to a doubled copy, so the seam is continuous.

def loop_render(dur, events, mix=0.18):
    buf = track(dur)
    for sig, at, gain in events:
        put(buf, sig, at, gain, wrap=True)
    wet = room(np.concatenate([buf, buf]), mix=mix)
    return finish(wet[len(buf):], loop=True)


def ring_vanta():
    beat = 0.375  # 160 bpm, eighth-note feel
    phrase = ["D5", "F#5", "A5", "B5", "A5", "F#5", "E5", "A5"]
    ev = []
    for p in range(4):  # 4 phrases x 8 beats x 0.375 = 12 s
        base = p * 8 * beat
        notes = phrase if p % 2 == 0 else ["D5", "F#5", "A5", "D6", "B5", "A5", "F#5", "E5"]
        for k, n in enumerate(notes):
            ev.append((bell(n, 1.6, 1.1, bright=0.9), base + k * beat, 0.55 if k % 2 else 0.7))
        ev.append((pluck("D3" if p % 2 == 0 else "A2", 2.8, 2.2, 0.35), base, 0.8))
        ev.append((pluck("A3" if p % 2 == 0 else "E3", 1.6, 1.2), base + 4 * beat, 0.45))
    return loop_render(12.0, ev)


def ring_halo():
    beat = 0.25
    arp = ["D5", "A5", "D6", "F#6", "E6", "A5", "B5", "F#5"]
    ev = []
    for bar in range(6):  # 6 x 8 x 0.25 = 12 s
        for k, n in enumerate(arp):
            n2 = n if bar % 3 != 2 else {"F#6": "E6", "E6": "D6"}.get(n, n)
            ev.append((pluck(n2, 1.0, 0.7, 0.2), bar * 2 + k * beat, 0.6))
        ev.append((bell("D4" if bar % 2 == 0 else "B3", 2.5, 2.0, ratio=1.4, index=1.2), bar * 2, 0.5))
    return loop_render(12.0, ev, mix=0.22)


def ring_pulse():
    ev = []
    pairs = [("A5", "D6"), ("F#5", "A5"), ("B5", "E6"), ("A5", "D6")]
    for i in range(8):  # a double-tap every 1.5 s
        a, b = pairs[i % 4]
        at = i * 1.5
        ev.append((bell(a, 1.0, 0.7, index=2.0), at, 0.75))
        ev.append((bell(b, 1.2, 0.9, index=2.0), at + 0.16, 0.8))
        if i % 2 == 0:
            ev.append((pluck("D3", 1.5, 1.2, 0.3), at, 0.55))
    return loop_render(12.0, ev, mix=0.15)


# ---------------------------------------------------------------------------
# One-shots

def seq(dur, events, mix=0.16, size=1.0):
    buf = track(dur)
    for sig, at, gain in events:
        put(buf, sig, at, gain)
    return finish(room(buf, mix=mix, size=size))


def ping():
    return seq(1.3, [(bell("A5", 1.3, 0.9), 0.0, 0.8), (bell("D6", 1.2, 1.0), 0.11, 1.0)])


def glint():
    return seq(1.1, [(pluck(n, 0.9, 0.6), i * 0.07, 0.8 + 0.1 * i) for i, n in enumerate(["F#5", "A5", "D6"])])


def drop():
    return seq(1.3, [(bell("D6", 1.2, 0.9), 0.0, 0.9), (bell("A5", 1.2, 1.0), 0.13, 0.85)])


def orbit():
    notes = ["D5", "A5", "F#5", "D6"]
    return seq(1.6, [(bell(n, 1.4, 0.9, index=1.8), i * 0.09, 0.7 + 0.1 * i) for i, n in enumerate(notes)])


def dawn():
    """20 s alarm: starts as one quiet bell, gains a pluck bed, then the full
    phrase; the gain curve rises ~24 dB so it wakes you without a jolt."""
    dur = 20.0
    buf = track(dur + 2.0)
    beat = 0.5
    motif = ["D5", "F#5", "A5", "E5", "D5", "A5", "B5", "A5"]
    for k in range(int(dur / beat)):
        at = k * beat
        g = 0.06 + 0.94 * (at / dur) ** 1.6
        put(buf, bell(motif[k % 8], 1.8, 1.4, bright=0.6 + 0.4 * at / dur), at, g)
        if at >= 4.0 and k % 4 == 0:
            put(buf, pluck("D3" if (k // 8) % 2 == 0 else "A2", 2.2, 1.8, 0.3), at, 0.7 * g)
        if at >= 10.0 and k % 2 == 1:
            put(buf, pluck(motif[(k + 3) % 8].replace("5", "6"), 0.8, 0.5), at + 0.25, 0.5 * g)
    x = room(buf, mix=0.2)[: int(dur * SR)]
    return finish(x, fade_ms=400)


def lock():
    return seq(0.32, [(pluck("A5", 0.3, 0.18, 0.3), 0.0, 0.8), (pluck("D5", 0.3, 0.2, 0.3), 0.06, 1.0)], mix=0.1)


def unlock():
    return seq(0.32, [(pluck("D5", 0.3, 0.18, 0.3), 0.0, 0.8), (pluck("A5", 0.3, 0.2, 0.3), 0.06, 1.0)], mix=0.1)


def charging():
    return seq(0.75, [(bell(n, 0.7, 0.5, index=1.6), i * 0.08, 0.7 + 0.1 * i) for i, n in enumerate(["D5", "F#5", "A5"])])


def wireless_charging():
    notes = ["D5", "A5", "D6", "F#6"]
    ev = [(pluck(n, 0.8, 0.55, 0.15), i * 0.06, 0.55 + 0.12 * i) for i, n in enumerate(notes)]
    ev.append((bell("A6", 0.9, 0.7, ratio=1.4, index=1.0), 0.24, 0.5))
    return seq(1.0, ev, mix=0.22)


def low_battery():
    return seq(0.75, [(bell("A5", 0.6, 0.45, index=1.4), 0.0, 0.9), (bell("E5", 0.6, 0.5, index=1.4), 0.2, 0.9)])


def trusted():
    ev = [(pluck(n, 0.6, 0.45, 0.2), 0.0, 0.7) for n in ("D5", "F#5", "A5")]
    ev.append((bell("D6", 0.6, 0.4, index=1.2), 0.03, 0.5))
    return seq(0.6, ev, mix=0.12)


def tick():
    return finish(click(0.03, 2600, 0.01, 0.1), fade_ms=3)


def key(note, dur=0.07, decay=0.045):
    x = pluck(note, dur, decay, 0.4) + 0.25 * click(dur, 3000, 0.006, 0.2)
    return finish(x, peak_db=-3.0, fade_ms=5)


TONES = {
    "ringtones/Vanta_Ring.ogg": (ring_vanta, 12.0),
    "ringtones/Vanta_Halo.ogg": (ring_halo, 12.0),
    "ringtones/Vanta_Pulse.ogg": (ring_pulse, 12.0),
    "notifications/Vanta_Ping.ogg": (ping, 1.3),
    "notifications/Vanta_Glint.ogg": (glint, 1.1),
    "notifications/Vanta_Drop.ogg": (drop, 1.3),
    "notifications/Vanta_Orbit.ogg": (orbit, 1.6),
    "alarms/Vanta_Dawn.ogg": (dawn, 20.0),
    "ui/Vanta_Lock.ogg": (lock, 0.32),
    "ui/Vanta_Unlock.ogg": (unlock, 0.32),
    "ui/Vanta_ChargingStarted.ogg": (charging, 0.75),
    "ui/Vanta_WirelessChargingStarted.ogg": (wireless_charging, 1.0),
    "ui/Vanta_LowBattery.ogg": (low_battery, 0.75),
    "ui/Vanta_Trusted.ogg": (trusted, 0.6),
    "ui/Vanta_Effect_Tick.ogg": (tick, 0.03),
    "ui/Vanta_KeypressStandard.ogg": (lambda: key("A6"), 0.07),
    "ui/Vanta_KeypressSpacebar.ogg": (lambda: key("D6", 0.08, 0.05), 0.08),
    "ui/Vanta_KeypressDelete.ogg": (lambda: key("E6"), 0.07),
    "ui/Vanta_KeypressReturn.ogg": (lambda: key("A5", 0.09, 0.06), 0.09),
}


def write_wav(path, x):
    pcm = (np.clip(x, -1, 1) * 32767).astype("<i2")
    with wave.open(path, "wb") as w:
        w.setnchannels(1)
        w.setsampwidth(2)
        w.setframerate(SR)
        w.writeframes(pcm.tobytes())


def render():
    with tempfile.TemporaryDirectory() as tmp:
        for rel, (fn, expect) in TONES.items():
            x = fn()
            assert abs(len(x) / SR - expect) < 0.01, (rel, len(x) / SR, expect)
            wav = os.path.join(tmp, "x.wav")
            write_wav(wav, x)
            dst = os.path.join(OUT, rel)
            os.makedirs(os.path.dirname(dst), exist_ok=True)
            subprocess.run(["ffmpeg", "-y", "-v", "error", "-i", wav, "-c:a", "libvorbis", "-q:a", "6", dst], check=True)
            print(f"  {rel:40s} {expect:6.2f}s")


def probe(path):
    r = subprocess.run(["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", path],
                       capture_output=True, text=True)
    dec = subprocess.run(["ffmpeg", "-v", "error", "-i", path, "-f", "null", "-"], capture_output=True, text=True)
    ok = r.returncode == 0 and dec.returncode == 0 and not dec.stderr.strip()
    return (float(r.stdout.strip()) if ok and r.stdout.strip() else None), ok


def check():
    bad = 0
    for rel, (_, expect) in TONES.items():
        dur, ok = probe(os.path.join(OUT, rel))
        good = ok and dur is not None and abs(dur - expect) <= 0.02
        bad += not good
        print(f"  {'ok ' if good else 'BAD'} {rel:40s} want {expect:6.3f}s  got {dur if dur is not None else 'n/a'}")
    print(f"tones: {len(TONES) - bad}/{len(TONES)} ok")
    return bad == 0


if __name__ == "__main__":
    if "--check" not in sys.argv:
        render()
    sys.exit(0 if check() else 1)
