"""Gera os 9 efeitos sonoros do Rusty's Mini Golf (substituem os do autor, sem credito de origem).

Sintese propria, deterministica (PRNG com semente fixa), dedicada ao dominio publico (CC0). Escreve WAV estereo de
16 bits a 44,1 kHz e, se passado um codificador, converte em .ogg com o wav2ogg do projeto (Builds/pygame-music/wav2ogg.c,
Ogg Vorbis com numero de serie fixo: mesma entrada, mesmos bytes).

  python3 -I sounds.py <pasta-de-saida> [caminho-do-wav2ogg]
"""
import math, os, random, struct, subprocess, sys

SR = 44100


def buf(seconds):
    return [0.0] * int(SR * seconds)


def add(dst, src, at=0.0, gain=1.0):
    o = int(at * SR)
    for i, v in enumerate(src):
        if o + i < len(dst):
            dst[o + i] += v * gain


def env(t, attack, decay):
    return min(1.0, t / attack) * math.exp(-t / decay) if attack else math.exp(-t / decay)


def tone(freq, dur, decay, attack=0.004, shape='sine', f_end=None):
    out, ph = [], 0.0
    n = int(SR * dur)
    for i in range(n):
        t = i / SR
        f = freq if f_end is None else freq + (f_end - freq) * (t / dur)
        ph += 2 * math.pi * f / SR
        s = math.sin(ph)
        if shape == 'tri':
            s = 2 / math.pi * math.asin(s)
        elif shape == 'soft':  # seno com um pouco de harmonicos
            s = s + 0.25 * math.sin(2 * ph) + 0.1 * math.sin(3 * ph)
        out.append(s * env(t, attack, decay))
    return out


def noise(dur, decay, rng, lp=1.0, attack=0.0005):
    out, y = [], 0.0
    for i in range(int(SR * dur)):
        t = i / SR
        y += lp * (rng.uniform(-1, 1) - y)
        out.append(y * env(t, attack, decay))
    return out


def sweep_noise(dur, rng, f0, f1, decay):
    out, y = [], 0.0
    n = int(SR * dur)
    for i in range(n):
        t = i / SR
        a = 1 - math.exp(-2 * math.pi * (f0 + (f1 - f0) * t / dur) / SR)
        y += a * (rng.uniform(-1, 1) - y)
        out.append(y * env(t, 0.003, decay))
    return out


def clap(rng, gain=1.0):
    n = noise(0.09, 0.018, rng, lp=0.55, attack=0.0008)
    # passa-altas simples para tirar o grave
    out, prev = [], 0.0
    for v in n:
        out.append((v - prev * 0.6) * gain)
        prev = v
    return out


def finish(mono, path, pan=None):
    peak = max(1e-9, max(abs(v) for v in mono))
    scale = 0.85 / peak
    n = len(mono)
    fade = int(0.005 * SR)
    data = bytearray()
    for i, v in enumerate(mono):
        if i > n - fade:
            v *= (n - i) / fade
        s = max(-32767, min(32767, int(v * scale * 32767)))
        data += struct.pack('<hh', s, s)
    with open(path, 'wb') as f:
        f.write(b'RIFF' + struct.pack('<I', 36 + len(data)) + b'WAVEfmt ' + struct.pack('<IHHIIHH', 16, 1, 2, SR, SR * 4, 4, 16)
                + b'data' + struct.pack('<I', len(data)) + bytes(data))


def make_all():
    S = {}
    r = random.Random(20231001)

    # Taco batendo na bola: estalo seco e um "tok" grave.
    b = buf(0.5)
    add(b, noise(0.02, 0.004, r, lp=0.8), 0, 0.9)
    add(b, tone(210, 0.3, 0.05, f_end=95), 0, 1.0)
    add(b, tone(1500, 0.15, 0.03), 0, 0.18)
    S['BallHit'] = b

    # Bola quicando na parede: estalinho curto.
    b = buf(0.12)
    add(b, noise(0.012, 0.003, r, lp=0.9), 0, 0.8)
    add(b, tone(640, 0.1, 0.02, f_end=520), 0, 0.7)
    S['BallBounce'] = b

    # Bola no buraco: cai, bate no fundo e toca tres notas de acerto.
    b = buf(1.5)
    for k, at in enumerate((0.0, 0.11, 0.19, 0.24)):
        add(b, noise(0.015, 0.004, r, lp=0.6), at, 0.7 - 0.12 * k)
        add(b, tone(300 - 25 * k, 0.07, 0.015), at, 0.5)
    for f, at in ((523.25, 0.45), (659.25, 0.62), (783.99, 0.79)):
        add(b, tone(f, 0.7, 0.16, shape='soft'), at, 0.55)
    S['BallEnterHole'] = b

    # Splash: jato de agua, que escurece, com algumas bolhas.
    b = buf(0.9)
    add(b, sweep_noise(0.8, r, 5200, 700, 0.22), 0, 1.0)
    for at, f in ((0.08, 420), (0.2, 520), (0.33, 360), (0.46, 470)):
        add(b, tone(f, 0.1, 0.03, f_end=f * 1.9), at, 0.35)
    S['Splash'] = b

    # Clique da interface.
    b = buf(0.18)
    add(b, noise(0.008, 0.002, r, lp=0.9), 0, 0.5)
    add(b, tone(880, 0.12, 0.022, f_end=740, shape='soft'), 0, 0.8)
    S['ClickSound'] = b

    # Estrela estourando: "pop" que sobe e um brilho.
    b = buf(0.5)
    add(b, tone(380, 0.09, 0.03, f_end=1150), 0, 1.0)
    add(b, tone(1760, 0.3, 0.07, shape='tri'), 0.07, 0.35)
    add(b, tone(2349, 0.25, 0.05, shape='tri'), 0.11, 0.25)
    S['StarPop'] = b

    # Vitoria com 1, 2 e 3 estrelas: fanfarra curta + palmas, cada vez mais cheia.
    def win(notes, claps_from, density, seed, length=3.5):
        rr = random.Random(seed)
        b = buf(length)
        for f, at, dur in notes:
            add(b, tone(f, dur, dur * 0.45, shape='soft'), at, 0.45)
            add(b, tone(f * 2, dur, dur * 0.3, shape='tri'), at, 0.12)
        t = claps_from
        while t < length - 0.25:
            add(b, clap(rr), t + rr.uniform(-0.01, 0.01), rr.uniform(0.35, 0.8) * math.exp(-max(0, t - 2.4) * 1.2))
            t += rr.uniform(0.5, 1.0) / density
        return b

    C5, D5, E5, F5, G5, A5, C6 = 523.25, 587.33, 659.25, 698.46, 783.99, 880.0, 1046.5
    S['Win1Star'] = win([(C5, 0.0, 0.5), (E5, 0.25, 0.5), (G5, 0.5, 0.9)], 0.9, 1.6, 11)
    S['Win2Stars'] = win([(C5, 0.0, 0.4), (E5, 0.2, 0.4), (G5, 0.4, 0.4), (C6, 0.6, 1.1), (G5, 0.6, 1.1)], 0.7, 3.0, 22)
    S['Win3Stars'] = win([(C5, 0.0, 0.35), (E5, 0.15, 0.35), (G5, 0.3, 0.35), (C6, 0.45, 0.5), (G5, 0.8, 0.3),
                          (C6, 1.0, 1.8), (E5, 1.0, 1.8), (G5, 1.0, 1.8)], 0.5, 6.0, 33)
    return S


# nome -> pasta dentro do projeto do jogo (Src/)
DEST = {'BallHit': 'GameObjects/Ball', 'BallBounce': 'GameObjects/Ball', 'BallEnterHole': 'GameObjects/Ball',
        'Splash': 'GameObjects/Ball', 'ClickSound': 'UI/Sounds', 'StarPop': 'UI/Sounds', 'Win1Star': 'UI/Sounds',
        'Win2Stars': 'UI/Sounds', 'Win3Stars': 'UI/Sounds'}

if __name__ == '__main__':
    out = sys.argv[1]
    enc = sys.argv[2] if len(sys.argv) > 2 else None
    for name, mono in make_all().items():
        d = os.path.join(out, DEST[name])
        os.makedirs(d, exist_ok=True)
        wav = os.path.join(d, name + '.wav')
        finish(mono, wav)
        if enc:
            subprocess.run([enc, wav, os.path.join(d, name + '.ogg'), '0.4'], check=True)
            os.remove(wav)