/* HypnoMusic -- the shared background-music engine (game + session + antechamber).
 *
 * WHY THIS EXISTS: the old beds were two hardcoded patterns. strokegame.js played a fixed
 * 124 BPM kick/hat/bass loop with no harmony and no variation -- byte-identical every
 * session -- and bed.js played brown noise plus a 6 Hz theta tone, which is masking, not
 * music. Neither had any notion of "this session should sound different from the last one".
 *
 * This module replaces both music layers with ONE hybrid engine:
 *
 *   1. BANK layer   -- pre-rendered AI clips (audiogen/build_musicbank.py -> /musicbank.json),
 *                      shuffled and equal-power crossfaded. Real instruments, real production;
 *                      variety comes from having many clips per mood and never repeating an
 *                      order. Crossfading BETWEEN different clips also sidesteps seamless-loop
 *                      hunting entirely -- the transition is the feature.
 *   2. PROCEDURAL   -- a seeded generative synth: key, mode, tempo and chord progression are
 *      layer           rolled per session, and the arrangement moves through sections
 *                      (intro / rise / peak / breakdown) so it never settles into a loop.
 *
 * They are not alternatives, they compose. With a bank present the procedural engine drops to
 * "texture" (pads and swells only, no drums) and sits UNDER the clips, so the rendered audio
 * is the music and the synth is the glue that makes clip changes feel arranged rather than
 * shuffled. With no bank rendered it runs "full" and is the whole bed on its own -- so a fresh
 * checkout with an empty musicbank still sounds better than what it replaced, and nothing here
 * depends on a GPU render having happened.
 *
 * Everything else that made the old beds work is preserved:
 *   - the binaural/isochronic entrainment tone stays in bed.js, phase-locked and untouched;
 *     this module deliberately owns no entrainment (mixing a beat frequency into evolving
 *     harmony would smear it).
 *   - the bed must sit FAR under the voice. That is enforced two ways: a low absolute level,
 *     and DUCKING -- duck()/attachVoice() pull the whole music bus down whenever the Dom is
 *     actually speaking. Ducking is what lets the music be more present than the old flat
 *     MUSIC_VOL = 0.10 without ever competing with the TTS.
 *
 * Signal graph:
 *
 *   bank clips  --> bankBus  ---\
 *   drums/bass/pad/arp -> dryBus +--> musicBus -> duckGain -> masterFade -> destination
 *                       \-> reverb -/
 *
 *   duckGain   -- voice ducking ONLY (1 = nobody speaking).
 *   masterFade -- start/pause/stop envelope ONLY (0..1).
 *   musicBus   -- the user-facing volume (setVolume).
 * Keeping those three separate is what stops a pause from being undone by a duck release, or
 * a volume slider from cancelling a fade -- the old bed collapsed all of this onto one gain
 * and every automation fought the others.
 *
 * API:
 *   HypnoMusic.start(opts)      -- opts: {ctx, destination, mood, seed, volume, bank, proc, fadeIn}
 *                                  fadeIn (seconds) lengthens the start envelope; it always
 *                                  rises from 0, never from the current level.
 *                                  Call from a user gesture. Idempotent; a second call with a
 *                                  different mood just re-moods.
 *   HypnoMusic.stop()           -- fade out and tear down.
 *   HypnoMusic.pause() / resume()
 *   HypnoMusic.setVolume(0..1)  -- perceived-loudness curve applied internally.
 *   HypnoMusic.getVolume()
 *   HypnoMusic.setMood(name)    -- crossfades key/tempo/arrangement AND the bank selection.
 *   HypnoMusic.getMood()
 *   HypnoMusic.duck(depth, ms)  -- depth 0..1 (1 = untouched, 0.25 = well out of the way).
 *   HypnoMusic.unduck(ms)
 *   HypnoMusic.attachVoice(el)  -- auto-duck for the lifetime of an <audio> element.
 *   HypnoMusic.duckFor(ms)      -- one-shot duck (for clips whose element we do not own).
 *   HypnoMusic.state()          -- {state, mood, bank, clips, bpm, key} for UI/debug.
 *   HypnoMusic.moods()          -- [{id, label}] for building pickers.
 *
 * Graceful everywhere: no Web Audio, no bank, a blocked AudioContext or a decode failure all
 * degrade to something quieter rather than throwing. The caller never has to guard.
 */
(function () {
  "use strict";

  // ---- tunables ---------------------------------------------------------------
  var VOL_DEFAULT   = 0.35;   // slider position, not gain -- see gainFor()
  var BUS_MAX       = 0.34;   // musicBus gain at slider 1.0 (headroom for the voice)
  var FADE_IN_S     = 6.0;    // music arrives slowly; a bed that starts abruptly announces itself
  var FADE_OUT_S    = 3.0;
  var MOOD_FADE_S   = 8.0;    // crossfade when the mood changes mid-session
  var DUCK_DOWN_S   = 0.22;   // duck attack -- fast enough to clear the first syllable
  var DUCK_UP_S     = 4.00;   // duck release -- slow, so the music swells back in unnoticed.
                              // 1.1s read as a hit when a recording ENDED (the between space:
                              // silence, then the full bed arriving in one breath); 4s lets it
                              // rise under the listener's attention instead of in front of it.
  var DUCK_DEPTH    = 0.32;   // default depth: how far down the bed goes under the voice
  var XFADE_S       = 6.0;    // bank clip-to-clip equal-power crossfade
  var LOOKAHEAD_MS  = 25;     // scheduler tick
  var SCHED_WIN_S   = 0.20;   // how far ahead notes are scheduled on the audio clock
  var SECTION_MIN   = 8;      // bars per arrangement section (rolled between these)
  var SECTION_MAX   = 16;
  var BANK_URL      = "/musicbank.json";

  // ---- seeded PRNG ------------------------------------------------------------
  // Everything generative draws from ONE seeded stream, so a session's music is reproducible
  // from its seed (useful when a subject reports "that one was good") while differing from
  // every other session. Math.random() is used only where reproducibility has no value.
  function mulberry32(a) {
    return function () {
      a |= 0; a = (a + 0x6D2B79F5) | 0;
      var t = Math.imul(a ^ (a >>> 15), 1 | a);
      t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
      return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
    };
  }
  function hashSeed(s) {
    var h = 2166136261, str = String(s);
    for (var i = 0; i < str.length; i++) { h ^= str.charCodeAt(i); h = Math.imul(h, 16777619); }
    return h >>> 0;
  }

  var rnd = mulberry32(1);                       // replaced on start()
  function rf(lo, hi) { return lo + rnd() * (hi - lo); }
  function ri(lo, hi) { return Math.floor(rf(lo, hi + 1)); }
  function pick(a) { return a[Math.floor(rnd() * a.length)]; }
  function chance(p) { return rnd() < p; }

  // ---- music theory -----------------------------------------------------------
  // Minor-family modes only. This material wants unresolved, circular harmony -- a major key
  // reads as cheerful and breaks the tone instantly, so no major mode is offered anywhere.
  var MODES = {
    aeolian:  [0, 2, 3, 5, 7, 8, 10],   // natural minor -- the default sadness
    dorian:   [0, 2, 3, 5, 7, 9, 10],   // minor with a raised 6th: warmer, less resolved
    phrygian: [0, 1, 3, 5, 7, 8, 10],   // flat 2nd -- tense, faintly menacing
    lydianmin:[0, 2, 3, 6, 7, 8, 10]    // minor with a raised 4th: alien, hard to place
  };
  function mtof(n) { return 440 * Math.pow(2, (n - 69) / 12); }

  // Degrees the chord walk is allowed to visit, as scale-degree indices. Kept off the leading
  // tone so the progression never implies a resolution it is not going to deliver.
  var DEGREES = [0, 2, 3, 5, 6];

  // ---- moods ------------------------------------------------------------------
  // A mood is the WHOLE sonic decision: tempo, register, which layers exist, how bright, how
  // wet, and how hard the arrangement swings between sections. The same ids are used by the
  // offline renderer (audiogen/moods.py) so a bank clip and the procedural layer that plays
  // under it agree about what "deep" means.
  //
  //   roots   MIDI note numbers the bass root is drawn from (low -- these are sub registers)
  //   bpm     tempo range; ambient moods still have one, it drives LFOs and note spacing
  //   layers  which generators exist at all in this mood
  //   cutoff  [floor, ceiling] Hz that the section energy sweeps the pad filter between
  var MOODS = {
    trance: {
      label: "Trance · slow, weightless",
      roots: [33, 35, 36, 38], modes: ["aeolian", "dorian"],
      bpm: [58, 68], chordBars: 4,
      layers: { drums: false, bass: true, pad: true, arp: 0.10, texture: 0.5 },
      cutoff: [420, 1500], revMix: 0.55, padGain: 0.55, bassGain: 0.22, energy: [0.15, 0.55]
    },
    deep: {
      label: "Deep · dark, minimal",
      roots: [29, 31, 33, 34], modes: ["aeolian", "phrygian"],
      bpm: [62, 72], chordBars: 4,
      layers: { drums: false, bass: true, pad: true, arp: 0.05, texture: 0.35 },
      cutoff: [260, 900], revMix: 0.45, padGain: 0.50, bassGain: 0.30, energy: [0.10, 0.45]
    },
    warm: {
      label: "Warm · soft, enveloping",
      roots: [36, 38, 40, 41], modes: ["dorian", "aeolian"],
      bpm: [64, 74], chordBars: 2,
      layers: { drums: false, bass: true, pad: true, arp: 0.22, texture: 0.6 },
      cutoff: [500, 2000], revMix: 0.60, padGain: 0.60, bassGain: 0.18, energy: [0.20, 0.60]
    },
    sharp: {
      label: "Sharp · cold, tense",
      roots: [31, 33, 34, 36], modes: ["phrygian", "lydianmin"],
      bpm: [70, 80], chordBars: 2,
      layers: { drums: false, bass: true, pad: true, arp: 0.30, texture: 0.7 },
      cutoff: [700, 3200], revMix: 0.40, padGain: 0.42, bassGain: 0.24, energy: [0.25, 0.75]
    },
    pulse: {
      label: "Pulse · steady techno",
      roots: [33, 34, 36, 38], modes: ["aeolian", "phrygian"],
      bpm: [118, 126], chordBars: 4,
      layers: { drums: true, bass: true, pad: true, arp: 0.25, texture: 0.35 },
      cutoff: [500, 2600], revMix: 0.30, padGain: 0.32, bassGain: 0.30, energy: [0.30, 0.95]
    },
    drive: {
      label: "Drive · harder, relentless",
      roots: [31, 33, 36], modes: ["phrygian", "aeolian"],
      bpm: [128, 138], chordBars: 4,
      layers: { drums: true, bass: true, pad: true, arp: 0.35, texture: 0.30 },
      cutoff: [600, 3400], revMix: 0.24, padGain: 0.26, bassGain: 0.34, energy: [0.45, 1.0]
    }
  };
  var DEFAULT_MOOD = "trance";

  // ---- state ------------------------------------------------------------------
  var ctx = null, ownCtx = false, dest = null;
  var masterFade = null, duckGain = null, musicBus = null;
  var dryBus = null, revBus = null, bankBus = null, convolver = null;
  var padBus = null, bassBus = null, drumBus = null, arpBus = null;
  var padFilter = null;

  var state = "idle";              // idle | playing | paused | stopped
  var vol = VOL_DEFAULT;
  var moodId = DEFAULT_MOOD;
  var procMode = "full";           // full | texture | off
  var wantBank = true;

  var timer = null;                // lookahead scheduler
  var nextTime = 0;                // next 16th on the audio clock
  var step16 = 0;                  // global 16th counter since start
  var bpm = 120, spb = 0.5;
  var root = 36, mode = "aeolian", scale = MODES.aeolian;
  var prog = [];                   // chord walk (scale-degree indices)
  var section = null;              // {barsLeft, energy, drums, arp, name}
  var duckDepth = 1;               // current duck target (1 = open)
  var duckHolds = 0;               // nested attachVoice/duckFor holders
  // Bumped on every start(). stop()'s deferred teardown captures it and bails if it no longer
  // matches -- otherwise a restart inside the fade-out window (stop then start again, which the
  // game does between rounds) would have the OLD teardown null out the NEW graph seconds later.
  var gen = 0;

  // bank playback
  var bankClips = [];              // manifest entries for the current mood
  var bankQueue = [];
  var bankSrc = null;              // {src, gain, endsAt}
  var bankTimer = null;
  var bankFetched = false;

  function now() { return ctx ? ctx.currentTime : 0; }
  function gainFor(v) { return v * v * BUS_MAX; }   // ~quadratic: fine control down low

  function ramp(param, target, dur) {
    if (!param || !ctx) return;
    var t = now();
    try {
      param.cancelScheduledValues(t);
      param.setValueAtTime(param.value, t);
      param.linearRampToValueAtTime(target, t + Math.max(0.01, dur));
    } catch (e) {}
  }

  // The START envelope (mirrors bed.js): pinned to 0 first, then a quadratic rise -- a linear
  // amplitude ramp is front-loaded to the ear and reads as the music "hitting" even when it
  // is technically fading. Only scheduled once the context clock is actually running: a ramp
  // scheduled against a suspended clock can land in the past on resume and snap to the end.
  // Short linear segments, not setValueCurveAtTime, so a pause/stop mid-rise cancels cleanly.
  var RISE_SEGS = 32;
  function riseFrom0(param, target, dur) {
    if (!param || !ctx) return;
    var t = now();
    try {
      param.cancelScheduledValues(t);
      param.setValueAtTime(0, t);
      for (var i = 1; i <= RISE_SEGS; i++) {
        var x = i / RISE_SEGS;
        param.linearRampToValueAtTime(target * x * x, t + Math.max(0.01, dur) * x);
      }
    } catch (e) {}
  }
  function whenRunning(fn) {
    if (!ctx) return;
    if (ctx.state === "running") { fn(); return; }
    var c = ctx;
    var h = function () {
      if (c.state !== "running") return;
      c.removeEventListener("statechange", h);
      if (ctx === c) fn();
    };
    c.addEventListener("statechange", h);
  }

  // ---- graph ------------------------------------------------------------------
  // A procedurally-built impulse response: noise shaped by an exponential decay, with the tail
  // progressively darkened. Cheap to make, and a real convolution reverb is what separates
  // "synth notes" from "a space" -- without it the pad reads as a test tone.
  function makeIR(seconds, decay) {
    var len = Math.max(1, Math.floor(ctx.sampleRate * seconds));
    var buf = ctx.createBuffer(2, len, ctx.sampleRate);
    for (var c = 0; c < 2; c++) {
      var d = buf.getChannelData(c), lp = 0;
      for (var i = 0; i < len; i++) {
        var env = Math.pow(1 - i / len, decay);
        var white = Math.random() * 2 - 1;
        lp = lp * 0.72 + white * 0.28;            // darken as the tail decays
        d[i] = (white * 0.35 + lp * 0.65) * env;
      }
    }
    return buf;
  }

  function buildGraph() {
    masterFade = ctx.createGain(); masterFade.gain.value = 0;
    masterFade.connect(dest);

    duckGain = ctx.createGain(); duckGain.gain.value = 1;
    duckGain.connect(masterFade);

    musicBus = ctx.createGain(); musicBus.gain.value = gainFor(vol);
    musicBus.connect(duckGain);

    dryBus = ctx.createGain(); dryBus.gain.value = 1;
    dryBus.connect(musicBus);

    convolver = ctx.createConvolver();
    convolver.buffer = makeIR(2.8, 2.4);
    revBus = ctx.createGain(); revBus.gain.value = MOODS[moodId].revMix;
    convolver.connect(revBus); revBus.connect(musicBus);

    bankBus = ctx.createGain(); bankBus.gain.value = 1;
    bankBus.connect(dryBus);
    // Bank clips get a light send too -- rendered music already has its own space, but a touch
    // of the SAME room is what makes the procedural pad sound like it is in the mix rather than
    // stapled on top of it.
    var bankSend = ctx.createGain(); bankSend.gain.value = 0.12;
    bankBus.connect(bankSend); bankSend.connect(convolver);

    // Per-layer buses so a section can mute drums without touching the pad's tail.
    padFilter = ctx.createBiquadFilter();
    padFilter.type = "lowpass"; padFilter.frequency.value = 800; padFilter.Q.value = 0.7;
    padBus = ctx.createGain(); padBus.gain.value = 1;
    padFilter.connect(padBus); padBus.connect(dryBus);
    var padSend = ctx.createGain(); padSend.gain.value = 0.85;
    padBus.connect(padSend); padSend.connect(convolver);

    bassBus = ctx.createGain(); bassBus.gain.value = 1; bassBus.connect(dryBus);
    drumBus = ctx.createGain(); drumBus.gain.value = 1; drumBus.connect(dryBus);
    arpBus  = ctx.createGain(); arpBus.gain.value = 1;  arpBus.connect(dryBus);
    var arpSend = ctx.createGain(); arpSend.gain.value = 0.6;
    arpBus.connect(arpSend); arpSend.connect(convolver);
  }

  // ---- arrangement ------------------------------------------------------------
  function rollMusic(m) {
    bpm = rf(m.bpm[0], m.bpm[1]);
    spb = 60 / bpm;
    root = pick(m.roots);
    mode = pick(m.modes);
    scale = MODES[mode] || MODES.aeolian;
    // A 4- or 8-chord walk over the allowed degrees, never repeating the same chord twice in a
    // row. Starting on the tonic and refusing to end there keeps it circular.
    var n = chance(0.5) ? 4 : 8, last = 0;
    prog = [0];
    for (var i = 1; i < n; i++) {
      var d = pick(DEGREES);
      var guard = 0;
      while (d === last && guard++ < 8) d = pick(DEGREES);
      prog.push(d); last = d;
    }
    if (revBus) ramp(revBus.gain, m.revMix, 2.0);
  }

  // Sections are what stop this being a loop. Each one re-rolls how much is playing and how
  // bright it is; a "breakdown" strips to pad and a "peak" runs everything. The energy value
  // drives the pad filter, drum density, arp probability and note velocities together, so the
  // whole arrangement moves as one thing rather than four independent randomisers.
  var SECTION_NAMES = ["rise", "peak", "hold", "breakdown"];
  function nextSection(m) {
    var name;
    if (!section) name = "rise";
    else if (section.name === "breakdown") name = "rise";
    else if (section.name === "peak") name = chance(0.45) ? "breakdown" : "hold";
    else name = pick(SECTION_NAMES);
    var lo = m.energy[0], hi = m.energy[1];
    var e = name === "breakdown" ? rf(lo, lo + (hi - lo) * 0.25)
          : name === "rise"      ? rf(lo + (hi - lo) * 0.25, lo + (hi - lo) * 0.6)
          : name === "peak"      ? rf(lo + (hi - lo) * 0.75, hi)
          :                        rf(lo + (hi - lo) * 0.4, lo + (hi - lo) * 0.8);
    section = {
      name: name,
      barsLeft: ri(SECTION_MIN, SECTION_MAX),
      energy: e,
      drums: !!m.layers.drums && name !== "breakdown",
      arp: chance(m.layers.arp + e * 0.25),
      openHats: chance(0.6),
      // A per-section rhythm choice, so consecutive peaks are not the same peak.
      bassPat: ri(0, 3),
      kickPat: chance(0.8) ? 0 : 1
    };
  }

  // ---- voices -----------------------------------------------------------------
  function env(g, t, a, d, peak) {
    g.gain.setValueAtTime(0.0001, t);
    g.gain.exponentialRampToValueAtTime(Math.max(0.0002, peak), t + a);
    g.gain.exponentialRampToValueAtTime(0.0001, t + a + d);
  }

  function padChord(t, degIdx, bars) {
    var m = MOODS[moodId];
    var dur = bars * 4 * spb;
    var deg = prog[degIdx % prog.length];
    // Root, third and fifth OF THE MODE (scale-degree stacking, not fixed intervals) -- this is
    // what keeps the chord inside the mode instead of importing a major triad into phrygian.
    var tones = [0, 2, 4].map(function (o) {
      var idx = deg + o;
      return root + 24 + scale[idx % 7] + 12 * Math.floor(idx / 7);
    });
    if (chance(0.4)) tones.push(tones[0] + 12);          // occasional octave doubling
    var peak = m.padGain * (0.5 + section.energy * 0.5) / tones.length;
    tones.forEach(function (n) {
      // Two slightly detuned oscillators per tone: the beating between them is the entire
      // reason a synth pad sounds wide rather than like an organ.
      [-1, 1].forEach(function (side) {
        var o = ctx.createOscillator();
        o.type = chance(0.5) ? "sawtooth" : "triangle";
        o.frequency.value = mtof(n);
        o.detune.value = side * rf(4, 11);
        var g = ctx.createGain(); g.gain.value = 0.0001;
        var pan = ctx.createStereoPanner ? ctx.createStereoPanner() : null;
        o.connect(g);
        if (pan) { pan.pan.value = side * rf(0.25, 0.7); g.connect(pan); pan.connect(padFilter); }
        else g.connect(padFilter);
        // Long attack and release -- a pad should arrive and leave without an edge.
        var a = dur * 0.35, r = dur * 0.5;
        g.gain.setValueAtTime(0.0001, t);
        g.gain.linearRampToValueAtTime(peak / 2, t + a);
        g.gain.setValueAtTime(peak / 2, t + dur - r);
        g.gain.linearRampToValueAtTime(0.0001, t + dur + 0.1);
        o.start(t); o.stop(t + dur + 0.2);
      });
    });
    // Sweep the pad filter with the section energy so brightness tracks the arrangement.
    var m2 = MOODS[moodId];
    var target = m2.cutoff[0] + (m2.cutoff[1] - m2.cutoff[0]) * section.energy;
    ramp(padFilter.frequency, target, dur * 0.6);
  }

  function bassNote(t, degIdx, len) {
    var m = MOODS[moodId];
    var deg = prog[degIdx % prog.length];
    var n = root + scale[deg % 7] + 12 * Math.floor(deg / 7);
    var o = ctx.createOscillator(); o.type = "sawtooth"; o.frequency.value = mtof(n);
    var sub = ctx.createOscillator(); sub.type = "sine"; sub.frequency.value = mtof(n - 12);
    var lp = ctx.createBiquadFilter(); lp.type = "lowpass";
    lp.frequency.value = 180 + section.energy * 420; lp.Q.value = 3;
    var g = ctx.createGain(); g.gain.value = 0.0001;
    o.connect(lp); sub.connect(lp); lp.connect(g); g.connect(bassBus);
    var peak = m.bassGain * (0.55 + section.energy * 0.45);
    env(g, t, 0.02, len, peak);
    o.start(t); o.stop(t + len + 0.1);
    sub.start(t); sub.stop(t + len + 0.1);
  }

  function arpNote(t) {
    var deg = prog[Math.floor(step16 / (16 * MOODS[moodId].chordBars)) % prog.length];
    var idx = deg + pick([0, 2, 4, 6]);
    var n = root + 36 + scale[idx % 7] + 12 * Math.floor(idx / 7);
    var o = ctx.createOscillator(); o.type = "triangle"; o.frequency.value = mtof(n);
    var g = ctx.createGain(); g.gain.value = 0.0001;
    o.connect(g); g.connect(arpBus);
    env(g, t, 0.005, rf(0.25, 0.7), rf(0.05, 0.11) * (0.5 + section.energy * 0.5));
    o.start(t); o.stop(t + 1.0);
  }

  var _noiseBuf = null;
  function noiseBuf() {
    if (_noiseBuf) return _noiseBuf;
    var len = Math.floor(ctx.sampleRate * 0.5);
    _noiseBuf = ctx.createBuffer(1, len, ctx.sampleRate);
    var d = _noiseBuf.getChannelData(0);
    for (var i = 0; i < len; i++) d[i] = Math.random() * 2 - 1;
    return _noiseBuf;
  }

  function kick(t, vel) {
    var o = ctx.createOscillator(); o.type = "sine";
    var g = ctx.createGain();
    o.frequency.setValueAtTime(160, t);
    o.frequency.exponentialRampToValueAtTime(48, t + 0.11);
    g.gain.setValueAtTime(0.0001, t);
    g.gain.exponentialRampToValueAtTime(0.85 * vel, t + 0.005);
    g.gain.exponentialRampToValueAtTime(0.0001, t + 0.18);
    o.connect(g); g.connect(drumBus);
    o.start(t); o.stop(t + 0.22);
  }

  function hat(t, open, vel) {
    var src = ctx.createBufferSource(); src.buffer = noiseBuf();
    src.playbackRate.value = rf(0.9, 1.1);              // tiny variation: no two hats identical
    var hp = ctx.createBiquadFilter(); hp.type = "highpass";
    hp.frequency.value = open ? 6200 : 7600;
    var g = ctx.createGain();
    var dur = open ? rf(0.06, 0.10) : rf(0.02, 0.04);
    g.gain.setValueAtTime((open ? 0.15 : 0.10) * vel, t);
    g.gain.exponentialRampToValueAtTime(0.0001, t + dur);
    var pan = ctx.createStereoPanner ? ctx.createStereoPanner() : null;
    src.connect(hp); hp.connect(g);
    if (pan) { pan.pan.value = rf(-0.35, 0.35); g.connect(pan); pan.connect(drumBus); }
    else g.connect(drumBus);
    src.start(t); src.stop(t + dur + 0.02);
  }

  // A slow filtered noise swell -- fired at section boundaries. This is the single cheapest
  // trick that makes a generative bed sound arranged: the ear hears a transition coming.
  function swell(t, up) {
    var src = ctx.createBufferSource(); src.buffer = noiseBuf(); src.loop = true;
    var bp = ctx.createBiquadFilter(); bp.type = "bandpass"; bp.Q.value = 1.2;
    var g = ctx.createGain(); g.gain.value = 0.0001;
    var dur = rf(2.5, 4.5);
    bp.frequency.setValueAtTime(up ? 400 : 3000, t);
    bp.frequency.exponentialRampToValueAtTime(up ? 3600 : 350, t + dur);
    g.gain.linearRampToValueAtTime(0.05, t + dur * (up ? 0.85 : 0.2));
    g.gain.linearRampToValueAtTime(0.0001, t + dur);
    src.connect(bp); bp.connect(g); g.connect(convolver);   // straight to the room: no dry edge
    src.start(t); src.stop(t + dur + 0.1);
  }

  // ---- scheduler --------------------------------------------------------------
  // Standard Web Audio lookahead: a coarse JS timer decides WHAT plays, the audio clock decides
  // WHEN. A setInterval that triggered notes directly would jitter audibly at this tempo.
  function schedule() {
    if (!ctx || state !== "playing") return;
    var m = MOODS[moodId];
    var s16 = spb / 4;
    while (nextTime < now() + SCHED_WIN_S) {
      var inBar = step16 % 16;
      var barNo = Math.floor(step16 / 16);

      if (inBar === 0) {
        if (!section || section.barsLeft <= 0) {
          var wasEnergy = section ? section.energy : 0;
          nextSection(m);
          if (m.layers.texture && chance(0.7)) swell(nextTime, section.energy > wasEnergy);
        }
        section.barsLeft--;
        if (barNo % m.chordBars === 0 && procMode !== "off") {
          padChord(nextTime, Math.floor(barNo / m.chordBars), m.chordBars);
        }
      }

      // "texture" mode is what runs under a bank clip: harmony and space only. Drums, bass and
      // arps would fight the rendered track's own rhythm section and turn the mix to mud.
      if (procMode === "full") {
        var chordIdx = Math.floor(barNo / m.chordBars);
        if (section.drums) {
          var kickOn = section.kickPat === 0 ? (inBar % 4 === 0)
                                             : (inBar % 4 === 0 || inBar === 14);
          if (kickOn) kick(nextTime, 0.8 + section.energy * 0.2);
          if (inBar % 2 === 0 && chance(0.35 + section.energy * 0.5)) {
            hat(nextTime, section.openHats && inBar % 4 === 2, 0.6 + section.energy * 0.4);
          } else if (chance(section.energy * 0.28)) {
            hat(nextTime, false, 0.4);                    // ghost 16ths at high energy only
          }
        }
        if (m.layers.bass) {
          var bassOn =
            section.bassPat === 0 ? inBar === 0 || inBar === 8 :
            section.bassPat === 1 ? inBar % 4 === 0 :
            section.bassPat === 2 ? inBar === 0 || inBar === 6 || inBar === 10 :
                                    inBar === 0;
          if (bassOn) bassNote(nextTime, chordIdx, section.drums ? s16 * 3 : s16 * 8);
        }
        if (section.arp && chance(0.18 + section.energy * 0.22) && inBar % 2 === 1) {
          arpNote(nextTime);
        }
      } else if (procMode === "texture") {
        // Very sparse: an occasional single note so the pad is not the only moving thing.
        if (inBar === 0 && chance(0.12)) arpNote(nextTime);
      }

      nextTime += s16;
      step16++;
    }
  }

  // ---- bank layer -------------------------------------------------------------
  function shuffle(a) {
    a = a.slice();
    for (var i = a.length - 1; i > 0; i--) {
      var j = Math.floor(rnd() * (i + 1));
      var t = a[i]; a[i] = a[j]; a[j] = t;
    }
    return a;
  }

  function loadBank() {
    if (!wantBank || bankFetched) return Promise.resolve();
    bankFetched = true;
    return fetch(BANK_URL, { cache: "no-store" })
      .then(function (r) { return r.json(); })
      .then(function (data) { window.__musicbank = Array.isArray(data) ? data : []; })
      .catch(function () { window.__musicbank = []; });
  }

  function selectClips() {
    var all = window.__musicbank || [];
    // Prefer clips rendered FOR this mood; fall back to anything tagged compatible so a
    // half-rendered bank still plays rather than silently dropping to procedural.
    var exact = all.filter(function (c) { return c.mood === moodId; });
    if (exact.length) return exact;
    var m = MOODS[moodId];
    return all.filter(function (c) {
      var cm = MOODS[c.mood];
      return cm && !!cm.layers.drums === !!m.layers.drums;
    });
  }

  function nextClip() {
    if (!bankQueue.length) bankQueue = shuffle(bankClips);
    return bankQueue.shift();
  }

  function playClip(entry, fadeIn) {
    if (!entry || !ctx) return;
    fetch(entry.url, { cache: "force-cache" })
      .then(function (r) { return r.arrayBuffer(); })
      .then(function (b) {
        return new Promise(function (res, rej) {
          // Callback form: Safari still does not return a promise from decodeAudioData.
          try { ctx.decodeAudioData(b, res, rej); } catch (e) { rej(e); }
        });
      })
      .then(function (buf) {
        if (state === "idle" || state === "stopped" || !bankBus) return;
        var src = ctx.createBufferSource();
        src.buffer = buf;
        var g = ctx.createGain(); g.gain.value = 0.0001;
        src.connect(g); g.connect(bankBus);
        var t = now() + 0.05;
        // Equal-power-ish: a linear ramp on each side of a crossfade dips in the middle, so
        // both clips ramp over the SAME window and the sum stays roughly constant.
        var fi = fadeIn ? XFADE_S : 1.0;
        var lvl = entry.gain != null ? entry.gain : 1.0;
        g.gain.setValueAtTime(0.0001, t);
        g.gain.linearRampToValueAtTime(lvl, t + fi);
        var dur = buf.duration;
        g.gain.setValueAtTime(lvl, t + Math.max(fi, dur - XFADE_S));
        g.gain.linearRampToValueAtTime(0.0001, t + dur);
        src.start(t);
        if (bankSrc) { try { bankSrc.src.stop(t + dur + 0.2); } catch (e) {} }
        bankSrc = { src: src, gain: g };
        // Queue the next clip so its fade-in overlaps this one's fade-out.
        if (bankTimer) clearTimeout(bankTimer);
        bankTimer = setTimeout(function () {
          if (state === "playing") playClip(nextClip(), true);
        }, Math.max(1000, (dur - XFADE_S) * 1000));
      })
      .catch(function () {
        // A bad clip must not end the bed. Skip to the next after a beat; if the whole bank is
        // broken this settles into procedural-only, which is exactly the right failure.
        if (bankTimer) clearTimeout(bankTimer);
        bankTimer = setTimeout(function () {
          if (state === "playing" && bankClips.length > 1) playClip(nextClip(), true);
        }, 3000);
      });
  }

  function startBank() {
    bankClips = selectClips();
    // An explicit {proc: false} means bank-only and stays that way even with no bank -- the
    // caller asked for silence over a generated bed, and quietly substituting one would be a
    // surprise. Every other case picks its own level.
    if (procMode === "off") {
      if (bankClips.length) {
        bankQueue = shuffle(bankClips);
        playClip(nextClip(), true);
      }
      return;
    }
    if (!bankClips.length) { procMode = "full"; return; }
    procMode = "texture";
    bankQueue = shuffle(bankClips);
    playClip(nextClip(), true);
  }

  function stopBank() {
    if (bankTimer) { clearTimeout(bankTimer); bankTimer = null; }
    if (bankSrc) { try { bankSrc.src.stop(); } catch (e) {} bankSrc = null; }
    bankQueue = [];
  }

  // ---- ducking ----------------------------------------------------------------
  function applyDuck(ms) {
    if (!duckGain) return;
    var target = duckHolds > 0 ? duckDepth : 1;
    ramp(duckGain.gain, target, (ms != null ? ms / 1000 : (duckHolds > 0 ? DUCK_DOWN_S : DUCK_UP_S)));
  }

  // ---- public API -------------------------------------------------------------
  window.HypnoMusic = {
    moods: function () {
      return Object.keys(MOODS).map(function (k) { return { id: k, label: MOODS[k].label }; });
    },

    start: function (opts) {
      opts = opts || {};
      if (opts.mood && MOODS[opts.mood]) moodId = opts.mood;
      if (opts.volume != null) vol = Math.min(1, Math.max(0, Number(opts.volume)));
      if (opts.bank === false) wantBank = false;
      if (opts.proc === false) procMode = "off";

      if (state === "playing") {                       // already running: just re-mood
        if (opts.mood) this.setMood(opts.mood);
        return;
      }
      if (state === "paused") { this.resume(); return; }

      if (!ctx) {
        if (opts.ctx) { ctx = opts.ctx; ownCtx = false; }
        else {
          var AC = window.AudioContext || window.webkitAudioContext;
          if (!AC) return;                              // no Web Audio -> stay silent
          try { ctx = new AC(); ownCtx = true; } catch (e) { ctx = null; return; }
        }
        dest = opts.destination || ctx.destination;
        rnd = mulberry32(hashSeed(opts.seed != null ? opts.seed : Math.random()));
        buildGraph();
        rollMusic(MOODS[moodId]);
      }
      if (ctx.state === "suspended") { try { ctx.resume(); } catch (e) {} }

      state = "playing";
      gen++;
      section = null;
      step16 = 0;
      nextTime = now() + 0.15;
      // Always from silence, whatever the envelope was doing (a restart inside a stop's
      // fade-out, a borrowed context that is still suspended). opts.fadeIn lengthens the
      // arrival for a caller that starts the music into silence rather than under a click.
      var fadeIn = Math.max(FADE_IN_S, Number(opts.fadeIn) || 0);
      var myGen = gen;
      try { masterFade.gain.cancelScheduledValues(now()); masterFade.gain.setValueAtTime(0, now()); } catch (e) {}
      whenRunning(function () {
        if (myGen !== gen || state !== "playing") return;
        riseFrom0(masterFade.gain, 1, fadeIn);
      });
      // A voice may already have been attached (and be sounding) before the engine existed --
      // attachVoice works whether or not we are running. Take the current duck state now, or
      // the bed would come up at full level over her and stay there until she next stops.
      applyDuck(50);
      if (timer) clearInterval(timer);
      timer = setInterval(schedule, LOOKAHEAD_MS);

      var self = this;
      loadBank().then(function () { if (state === "playing") startBank(); });
      return self;
    },

    setMood: function (id, fadeS) {
      if (!MOODS[id] || id === moodId) return;
      moodId = id;
      rollMusic(MOODS[id]);
      section = null;                                   // next bar rolls a fresh arrangement
      if (state !== "playing") return;
      // Duck the whole bus through the change so the tempo/key jump lands under a dip rather
      // than as an audible cut, then bring the new bank in on the other side.
      var f = (fadeS != null ? fadeS : MOOD_FADE_S) / 2;
      ramp(musicBus.gain, gainFor(vol) * 0.25, f);
      stopBank();
      setTimeout(function () {
        if (state !== "playing") return;
        startBank();
        ramp(musicBus.gain, gainFor(vol), f);
      }, f * 1000);
    },

    getMood: function () { return moodId; },

    setVolume: function (v) {
      vol = Math.min(1, Math.max(0, Number(v) || 0));
      if (musicBus) ramp(musicBus.gain, gainFor(vol), 0.25);
    },
    getVolume: function () { return vol; },

    duck: function (depth, ms) {
      duckDepth = depth != null ? Math.min(1, Math.max(0, depth)) : DUCK_DEPTH;
      duckHolds++;
      applyDuck(ms);
    },
    unduck: function (ms) {
      duckHolds = Math.max(0, duckHolds - 1);
      applyDuck(ms);
    },
    duckFor: function (ms, depth) {
      var self = this;
      self.duck(depth);
      setTimeout(function () { self.unduck(); }, Math.max(200, ms || 2000));
    },

    // Duck for exactly as long as an <audio> element is sounding. Used for the Dom's voice on
    // every surface -- the element is the only thing that reliably knows when she stops.
    attachVoice: function (el, depth) {
      if (!el || el.__hmDucked) return;
      el.__hmDucked = true;
      var held = false;
      var self = this;
      var down = function () { if (!held) { held = true; self.duck(depth); } };
      var up   = function () { if (held) { held = false; self.unduck(); } };
      el.addEventListener("play", down);
      el.addEventListener("playing", down);
      el.addEventListener("pause", up);
      el.addEventListener("ended", up);
      el.addEventListener("emptied", up);
      if (!el.paused && !el.ended) down();
    },

    pause: function () {
      if (state !== "playing") return;
      state = "paused";
      if (timer) { clearInterval(timer); timer = null; }
      ramp(masterFade.gain, 0, 0.4);
    },

    resume: function () {
      if (state !== "paused") return;
      state = "playing";
      if (ctx && ctx.state === "suspended") { try { ctx.resume(); } catch (e) {} }
      nextTime = now() + 0.15;
      if (!timer) timer = setInterval(schedule, LOOKAHEAD_MS);
      ramp(masterFade.gain, 1, 1.2);
      if (!bankSrc && bankClips.length) playClip(nextClip(), true);
    },

    toggle: function () {
      if (state === "playing") this.pause();
      else if (state === "paused") this.resume();
    },

    // Ride the bed down over an arbitrary window WITHOUT tearing it down -- for a fade that has
    // to match something else on screen (the game's blackout, a skipped ending). stop() has its
    // own fixed fade and destroys the graph, which is wrong when the caller is timing the fade
    // to a visual and will tear down separately a moment later.
    fadeOut: function (seconds) {
      if (state !== "playing" && state !== "paused") return;
      ramp(masterFade.gain, 0, seconds != null ? seconds : FADE_OUT_S);
    },

    stop: function () {
      if (state === "idle" || state === "stopped") return;
      state = "stopped";
      if (timer) { clearInterval(timer); timer = null; }
      stopBank();
      ramp(masterFade.gain, 0, FADE_OUT_S);
      var myGen = gen;
      setTimeout(function () {
        if (myGen !== gen) return;              // restarted during the fade -- leave it alone
        try { if (ownCtx && ctx) ctx.close(); } catch (e) {}
        // `ctx` is dropped even when it is BORROWED (the game's, the bed's). start() treats a
        // null ctx as "build the graph", and every node below has just been discarded -- a
        // second game on the same page would otherwise start against a torn-down graph and
        // play nothing. The borrowed context itself is untouched and gets handed back in.
        ctx = null; dest = null; ownCtx = false;
        masterFade = duckGain = musicBus = dryBus = revBus = bankBus = null;
        padBus = bassBus = drumBus = arpBus = padFilter = convolver = null;
        _noiseBuf = null;                       // belongs to the context we just let go of
        bankClips = []; duckHolds = 0; duckDepth = 1;
        // Back to first-run defaults: procMode is decided by startBank() from what the NEXT
        // run's bank turns out to hold, not inherited from the last one's.
        procMode = "full"; wantBank = true; bankFetched = false;
        state = "idle";
      }, FADE_OUT_S * 1000 + 100);
    },

    state: function () {
      return {
        state: state, mood: moodId, proc: procMode,
        envelope: masterFade ? masterFade.gain.value : 0,   // live start/stop fade (0..1)
        bank: bankClips.length > 0, clips: bankClips.length,
        bpm: Math.round(bpm), key: root + " " + mode,
        section: section ? section.name : null
      };
    }
  };
})();