"""Launch trailer score + timeline.

Reads renderer/public/launch-vo/durations.json, lays scenes out on bar lines at 120 bpm, writes
renderer/src/compositions/launchTimeline.ts and renderer/public/launch-vo/music.wav.

Shape: uncharted intro (pads, heartbeat) -> launch impact -> driving groove through the feature
galaxies (four on the floor, sidechained pads, plucked arp, bass) -> two bar build -> huge hit on
"Coming soon" and a long shimmering tail. Pure synthesis, no noise sources.
"""

import json
import math
import wave
from pathlib import Path

import numpy as np

ROOT = Path(__file__).resolve().parents[1]
DUR = json.loads((ROOT / "public/launch-vo/durations.json").read_text())

BPM = 120
BEAT = 60 / BPM
BAR = BEAT * 4
VO_START = {"intro": 1.0, "outro": 1.2}
MIN_BARS = {"intro": 4, "outro": 5}

order = ["intro", "launch", "sources", "research", "map", "voice", "audio", "video", "launchkit",
         "launchpad", "resurface", "montage", "outro"]
scenes = []
cursor = 0.0
for sid in order:
    if sid == "montage":
        bars, vo, vo_len = 2, None, None
    else:
        vo = VO_START.get(sid, 0.35)
        vo_len = DUR[sid]
        bars = max(MIN_BARS.get(sid, 2), math.ceil((vo + vo_len + 0.45) / BAR))
    scenes.append({"id": sid, "start": cursor, "len": bars * BAR, "vo": vo, "voLen": vo_len})
    cursor += bars * BAR
TOTAL = cursor
bar_of = {s["id"]: round(s["start"] / BAR) for s in scenes}
print("total", TOTAL, bar_of)

ts = ["// Generated by make_launch_music.py from public/launch-vo/durations.json. Do not edit by hand.",
      f"// {BPM} bpm; every scene starts on a bar line so cuts land on the beat.",
      f"export const LAUNCH_BPM = {BPM};",
      f"export const LAUNCH_SECONDS = {TOTAL};",
      "export const LAUNCH_SCENES = ["]
for s in scenes:
    vo = "null" if s["vo"] is None else s["vo"]
    vl = "null" if s["voLen"] is None else s["voLen"]
    ts.append(f'  {{ id: "{s["id"]}", start: {s["start"]}, len: {s["len"]}, vo: {vo}, voLen: {vl} }},')
ts.append("] as const;")
ts.append("export type LaunchSceneId = (typeof LAUNCH_SCENES)[number][\"id\"];")
(ROOT / "src/compositions/launchTimeline.ts").write_text("\n".join(ts) + "\n")

# ---------------------------------------------------------------- synthesis

SR = 44100
n = int(SR * (TOTAL + 0.2))
t = np.arange(n) / SR
L = {k: np.zeros(n) for k in ("pad", "bass", "arp", "drums", "fx", "bell")}
R = {k: np.zeros(n) for k in L}
rng = np.random.default_rng(11)


def hz(m: float) -> float:
    return 440.0 * 2 ** ((m - 69) / 12)


def add(bus: str, i0: int, sig: np.ndarray, pan: float = 0.0) -> None:
    if i0 >= n:
        return
    sig = sig[: n - i0]
    L[bus][i0:i0 + len(sig)] += sig * (1 - pan)
    R[bus][i0:i0 + len(sig)] += sig * (1 + pan)


def at(seconds: float) -> int:
    return int(seconds * SR)


def bar_t(b: float) -> float:
    return b * BAR


INTRO_END = bar_of["launch"]
GROOVE_START = bar_of["sources"]
BUILD = bar_of["montage"]
OUTRO = bar_of["outro"]
END_BAR = TOTAL / BAR

# I vi IV V in D, two bars each; outro resolves on a wide Dadd9.
PROG = [[50, 57, 62, 66, 69], [47, 54, 59, 62, 66], [43, 50, 55, 59, 62], [45, 52, 57, 61, 64]]
INTRO_PROG = [[50, 57, 64, 66, 69], [47, 54, 61, 62, 66]]
OUTRO_CHORD = [38, 50, 57, 62, 64, 66, 69, 74]


def chord_at(b: float) -> list[int]:
    if b < INTRO_END:
        return INTRO_PROG[int(b // 2) % 2]
    if b >= OUTRO:
        return OUTRO_CHORD[1:6]
    return PROG[int((b - INTRO_END) // 2) % 4]


# Pads: detuned soft saws per two bar chord, slow attack.
def pad(notes, start, dur, gain, bright):
    i0 = at(start)
    length = at(dur + 2.5)
    tt = np.arange(length) / SR
    a = np.clip(tt / 1.2, 0, 1)
    r = np.clip((dur + 2.5 - tt) / 2.5, 0, 1)
    e = (0.5 - 0.5 * np.cos(np.pi * a)) * (0.5 - 0.5 * np.cos(np.pi * r))
    for k, m in enumerate(notes):
        tone = np.zeros(length)
        for cents, ph in ((-8, 0.0), (8, 1.7)):
            f = hz(m) * 2 ** (cents / 1200)
            for h in range(1, 8):
                tone += np.sin(2 * np.pi * f * h * tt + ph * h) * bright ** (h - 1) / h ** 1.3
        add("pad", i0, tone * e * gain, pan=(k - 2) * 0.25)


b = 0.0
while b < END_BAR:
    notes = chord_at(b)
    if b >= OUTRO:
        pad(OUTRO_CHORD, bar_t(b), END_BAR * BAR - bar_t(b) - 3.0, 0.05, 0.5)
        break
    bright = 0.3 if b < INTRO_END else 0.42 + 0.1 * (b - GROOVE_START) / max(1, BUILD - GROOVE_START)
    pad(notes, bar_t(b), BAR * 2, 0.05 if b < INTRO_END else 0.042, bright)
    b += 2


# Kick: pitched sine sweep + tiny click.
def kick(start, gain=1.0):
    length = at(0.45)
    tt = np.arange(length) / SR
    f = 44 + 90 * np.exp(-tt * 28)
    body = np.sin(2 * np.pi * np.cumsum(f) / SR) * np.exp(-tt * 7.5)
    click = np.sin(2 * np.pi * 1800 * tt) * np.exp(-tt * 400) * 0.25
    add("drums", at(start), (body + click) * 0.5 * gain)


# Hat: inharmonic metallic partials, very short.
def hat(start, gain=1.0, pan=0.25):
    length = at(0.07)
    tt = np.arange(length) / SR
    sig = sum(np.sin(2 * np.pi * f * tt + p) for f, p in ((6230, 0.1), (7310, 1.2), (8420, 2.3), (9870, 0.7), (11200, 1.9)))
    add("drums", at(start), sig * np.exp(-tt * 70) * 0.018 * gain, pan)


# Snare/tom tick for the build: short tone burst with a pitch drop.
def tom(start, pitch, gain):
    length = at(0.16)
    tt = np.arange(length) / SR
    f = pitch * (1 + 0.6 * np.exp(-tt * 40))
    sig = np.sin(2 * np.pi * np.cumsum(f) / SR) + 0.4 * np.sin(2 * np.pi * np.cumsum(f * 2.3) / SR)
    add("drums", at(start), sig * np.exp(-tt * 22) * gain * 0.2, pan=rng.uniform(-0.3, 0.3))


kicks: list[float] = []
# Heartbeat in the intro's second half.
for bb in range(2, INTRO_END):
    for off in (0, BEAT * 0.75):
        kick(bar_t(bb) + off, 0.35 if off else 0.5)
        kicks.append(bar_t(bb) + off)
# Launch: kick on beat one of bar 1, quarters on bar 2.
kick(bar_t(INTRO_END), 1.2)
kicks.append(bar_t(INTRO_END))
for q in range(4):
    kick(bar_t(INTRO_END + 1) + q * BEAT, 0.7)
    kicks.append(bar_t(INTRO_END + 1) + q * BEAT)
# Groove: four on the floor with offbeat hats and 16th ghost hats.
for bb in range(GROOVE_START, BUILD):
    for q in range(4):
        s = bar_t(bb) + q * BEAT
        kick(s, 0.85)
        kicks.append(s)
        hat(s + BEAT / 2, 1.0)
        hat(s + BEAT / 4, 0.35, -0.25)
        hat(s + BEAT * 3 / 4, 0.35, -0.25)
# Build: toms accelerating and rising, no kick.
bs = bar_t(BUILD)
steps = [(0, 8, 8), (1, 16, 16)]
for bar_i, per_bar, _ in steps:
    for k in range(per_bar):
        s = bs + bar_i * BAR + k * BAR / per_bar
        prog = (s - bs) / (2 * BAR)
        tom(s, 140 + 160 * prog, 0.4 + 0.8 * prog)
# Outro hit.
kick(bar_t(OUTRO), 1.5)
kicks.append(bar_t(OUTRO))

# Sidechain envelope: pads, bass and arp duck briefly after each kick.
side = np.ones(n)
for k in kicks:
    i0 = at(k)
    length = min(n - i0, at(0.4))
    if length <= 0:
        continue
    tt = np.arange(length) / SR
    side[i0:i0 + length] = np.minimum(side[i0:i0 + length], 1 - 0.55 * np.exp(-tt * 9))

# Bass: offbeat 8ths on the chord root through the groove, long root in the launch bars.
def bass_note(m, start, dur, gain):
    length = at(dur + 0.05)
    tt = np.arange(length) / SR
    f = hz(m)
    sig = np.sin(2 * np.pi * f * tt) + 0.35 * np.sin(2 * np.pi * 2 * f * tt) + 0.12 * np.sin(2 * np.pi * 3 * f * tt)
    e = np.clip(tt / 0.008, 0, 1) * np.clip((dur + 0.05 - tt) / 0.05, 0, 1) * np.exp(-tt * 1.5)
    add("bass", at(start), sig * e * gain)


bass_note(chord_at(INTRO_END)[0] - 12, bar_t(INTRO_END), BAR * 2 - 0.1, 0.22)
for bb in range(GROOVE_START, BUILD):
    root = chord_at(bb)[0] - 12
    for e8 in range(8):
        if e8 % 2 == 1 or e8 == 0:
            bass_note(root + (12 if e8 == 7 else 0), bar_t(bb) + e8 * BEAT / 2, BEAT / 2 - 0.03, 0.2)
# Build: sustained root, rising an octave by sliding in steps.
for k in range(8):
    bass_note(chord_at(BUILD)[0] - 12 + k, bs + k * BAR / 4, BAR / 4 - 0.02, 0.12 + 0.02 * k)
# Outro: deep sustained sub.
bass_note(38 - 12, bar_t(OUTRO), 6.0, 0.3)


# Plucked arp: 16ths from the launch on, pattern up the chord, brightness grows.
def pluck(m, start, gain, bright, pan):
    length = at(0.6)
    tt = np.arange(length) / SR
    f = hz(m)
    sig = np.zeros(length)
    for h in range(1, 7):
        sig += np.sin(2 * np.pi * f * h * tt) * np.exp(-tt * (6 + h * h * 2.5 / bright)) / h
    sig *= np.clip(tt / 0.003, 0, 1)
    add("arp", at(start), sig * gain, pan)


k = 0
s = bar_t(INTRO_END)
end_arp = bar_t(OUTRO) + BAR * 2
while s < end_arp:
    b_now = s / BAR
    notes = chord_at(b_now)
    pattern = [notes[1], notes[2], notes[3], notes[4], notes[3] + 12, notes[4], notes[2] + 12, notes[3]]
    m = pattern[k % len(pattern)] + 12
    if b_now < GROOVE_START:
        gain, bright, every = 0.05, 0.7, 2
    elif b_now < BUILD:
        gain, bright, every = 0.06, 0.8 + 0.6 * (b_now - GROOVE_START) / max(1, BUILD - GROOVE_START), 1
    elif b_now < OUTRO:
        gain, bright, every = 0.07, 1.6 + (b_now - BUILD), 1
    else:
        gain, bright, every = 0.05 * max(0, 1 - (b_now - OUTRO) / 2), 1.4, 2
    if k % every == 0:
        pluck(m, s, gain * (1.0 if k % 4 == 0 else 0.75), bright, 0.45 * math.sin(k * 0.8))
    s += BEAT / 4
    k += 1


# Bells: sparse in the intro, a cascade on the outro hit.
def bell(m, start, gain, pan=0.0, decay=1.6):
    length = at(3.0)
    tt = np.arange(length) / SR
    f = hz(m)
    sig = np.sin(2 * np.pi * f * tt) + 0.35 * np.sin(2 * np.pi * f * 2.76 * tt) * np.exp(-tt * 4)
    sig += 0.12 * np.sin(2 * np.pi * f * 5.4 * tt) * np.exp(-tt * 8)
    add("bell", at(start), sig * np.exp(-tt * decay) * np.clip(tt / 0.004, 0, 1) * gain, pan)


for i, m in enumerate([81, 76, 78, 74, 81, 83]):
    bell(m, 0.8 + i * 1.2, 0.05, 0.4 * math.sin(i * 1.3))
for i, m in enumerate([74, 78, 81, 86, 90, 93, 98]):
    bell(m, bar_t(OUTRO) + i * BEAT / 2, 0.06, 0.5 * math.sin(i), decay=1.1)


# FX: risers into the launch and the outro, soft swells into each feature scene, impacts.
def riser(end, dur, gain, top=2400):
    length = at(dur)
    tt = np.arange(length) / SR
    p = tt / dur
    f = 180 * (top / 180) ** p
    sig = np.zeros(length)
    for d in (-5, 0, 7):
        sig += np.sin(2 * np.pi * np.cumsum(f * 2 ** (d / 1200)) / SR)
    sig *= p ** 2 * gain
    add("fx", at(end - dur), sig)


def impact(start, gain):
    length = at(3.5)
    tt = np.arange(length) / SR
    boom = np.sin(2 * np.pi * np.cumsum(30 + 60 * np.exp(-tt * 6)) / SR) * np.exp(-tt * 1.4)
    shimmer = sum(np.sin(2 * np.pi * f * tt) * np.exp(-tt * 2.2) for f in (1174.7, 1480, 1760, 2349)) * 0.05
    add("fx", at(start), (boom * 0.6 + shimmer) * gain)


riser(bar_t(INTRO_END), BAR * 1.5, 0.06)
impact(bar_t(INTRO_END), 0.9)
for sc in scenes:
    sb = round(sc["start"] / BAR)
    if GROOVE_START < sb < BUILD:
        riser(sc["start"], BEAT * 2, 0.025, top=1600)
riser(bar_t(OUTRO), BAR * 2, 0.09, top=3200)
impact(bar_t(OUTRO), 1.3)

# ---------------------------------------------------------------- mix

for bus in ("pad", "bass", "arp"):
    L[bus] *= side
    R[bus] *= side

# Ping pong delay on the arp and bells (dotted eighth).
delay = at(BEAT * 0.75)
for bus in ("arp", "bell"):
    dl, dr = np.zeros(n), np.zeros(n)
    for i in range(4):
        shift = delay * (i + 1)
        g = 0.35 ** (i + 1)
        src_l, src_r = (R[bus], L[bus]) if i % 2 == 0 else (L[bus], R[bus])
        dl[shift:] += src_l[:-shift] * g
        dr[shift:] += src_r[:-shift] * g
    L[bus] += dl * 0.6
    R[bus] += dr * 0.6

# Reverb (smooth partial-based IR, no noise).
ir_len = at(3.4)
it = np.arange(ir_len) / SR
irl, irr = np.zeros(ir_len), np.zeros(ir_len)
for f in rng.uniform(200, 2600, 100):
    ph = rng.uniform(0, 2 * np.pi, 2)
    d = np.exp(-it * rng.uniform(1.0, 2.0))
    irl += np.sin(2 * np.pi * f * it + ph[0]) * d
    irr += np.sin(2 * np.pi * f * it + ph[1]) * d
irl /= np.max(np.abs(irl))
irr /= np.max(np.abs(irr))


def convolve(x, ir):
    size = 1 << int(np.ceil(np.log2(len(x) + len(ir))))
    return np.fft.irfft(np.fft.rfft(x, size) * np.fft.rfft(ir, size), size)[: len(x)]


def norm(x):
    return x / (np.max(np.abs(x)) + 1e-9)


LEVEL = {"pad": 0.55, "bass": 0.7, "arp": 0.55, "drums": 0.8, "fx": 0.6, "bell": 0.5}
SEND = {"pad": 0.5, "arp": 0.35, "bell": 0.7, "fx": 0.5, "drums": 0.05, "bass": 0.0}
ml, mr = np.zeros(n), np.zeros(n)
send_l, send_r = np.zeros(n), np.zeros(n)
peak = max(np.max(np.abs(L[b])) + np.max(np.abs(R[b])) for b in L) / 2
for bus in L:
    gl, gr = L[bus] / peak * LEVEL[bus], R[bus] / peak * LEVEL[bus]
    ml += gl
    mr += gr
    send_l += gl * SEND[bus]
    send_r += gr * SEND[bus]
wet_l = norm(convolve(send_l, irl)) * np.max(np.abs(send_l)) * 0.9
wet_r = norm(convolve(send_r, irr)) * np.max(np.abs(send_r)) * 0.9
ml += wet_l
mr += wet_r

master = np.minimum(1, t / 1.5) * np.clip((TOTAL + 0.2 - t) / 3.5, 0, 1)
ml *= master
mr *= master
pk = max(np.max(np.abs(ml)), np.max(np.abs(mr)))
ml = np.tanh(ml / pk * 1.4) * 0.85
mr = np.tanh(mr / pk * 1.4) * 0.85
out = ROOT / "public/launch-vo/music.wav"
with wave.open(str(out), "wb") as w:
    w.setnchannels(2)
    w.setsampwidth(2)
    w.setframerate(SR)
    w.writeframes((np.stack([ml, mr], axis=1) * 32767).astype("<i2").tobytes())
print("music ok", out, round(TOTAL, 2), "s")