/* Ambient masking bed -- under-voice texture to smooth TTS artifacts.
 *
 * Distinct from the antechamber wait-loop (loop.js): that bed is her SPOKEN voice
 * during the synth wait, and it FADES OUT at handoff so two voices never overlap.
 * THIS bed is non-vocal texture (generated brown noise + an optional theta tone) that
 * deliberately KEEPS PLAYING UNDER the real session voice. A continuous, low,
 * spectrally-warm bed reduces how critically the ear parses the voice, masking the
 * slight timbre error and -- crucially -- filling the bare silences at the `...`
 * long-pause seams (TTS_PROSODY_CONTRACT.md), where TTS artifacts are most exposed.
 *
 * It must sit FAR under the voice -- a wash you barely notice, not a second instrument.
 *
 * Everything is synthesized in-browser via the Web Audio API: zero audio assets, fully
 * runtime-tunable, and the binaural/isochronic generator needs no files at all.
 *
 * Signal graph -- the noise bed and the tone are INDEPENDENT, each with its own volume
 * bus, so they can be balanced separately (each has its own slider):
 *
 *     noiseSrc -> lowpass --------> busBed (bed slider) ----\
 *     ent oscillators -> entSum --> busEnt (tone slider) ---+--> masterFade -> output
 *
 * masterFade is ONLY the start/pause/stop envelope (0..1); it never sets a layer's level.
 *
 * Four layers:
 *   1. brown-noise bed   -- looped buffer through a lowpass that slowly "breathes"
 *                           (an LFO sweeps the cutoff) so the wash is never static.
 *   2. binaural beat     -- two detuned sines panned hard L/R; the brain hears the
 *                           difference frequency (theta ~6 Hz). HEADPHONES ONLY.
 *   3. isochronic tone   -- one sine gated on/off at the beat rate; works on SPEAKERS.
 *   4. MUSIC             -- HypnoMusic (musicbed.js), sharing THIS AudioContext. Added
 *                           because layers 1-3 are masking, not music: they smooth the TTS
 *                           but they are the same wash in every session forever. The music
 *                           layer is what actually varies -- AI-rendered beds when a bank has
 *                           been built, a seeded generative synth when it has not -- and it
 *                           DUCKS under her voice, which the noise bed deliberately does not
 *                           (the noise has to keep filling the `...` pause seams; music
 *                           sitting at full level through a pause would draw the ear instead).
 *                           It has its own slider and starts at a low default: on for the
 *                           variety, quiet enough that nothing about layers 1-3 changes.
 * The theta tone is ON by default (binaural), and eases in VERY slowly so its arrival is
 * never noticed -- it plays under both the antechamber loop and the session voice.
 *
 * Volume model: each slider is 0..1; perceived loudness is ~quadratic, so a bus gain is
 * v*v*MAX. That gives fine control down at the low, subtle end where these live.
 *
 * Transition cue: HypnoBed.cue() plays a soft synthesized bell-swell -- fired at the
 * antechamber->session handoff to gently pull attention to the session beginning.
 *
 * Lifecycle:
 *   HypnoBed.start({fadeIn})      -- from the "Voice my session" click (the gesture that
 *                                    unblocks audio). Builds the graph, eases in over a
 *                                    long fade, reveals the control bar. Idempotent. The
 *                                    rise ALWAYS begins at 0 (never at the current level),
 *                                    on a quadratic curve, and only once the context runs.
 *   HypnoBed.toggle()             -- pause/resume the whole bed from the bar button.
 *   HypnoBed.setEntrainment(mode) -- "off" | "binaural" | "isochronic" (slow fade either way).
 *   HypnoBed.setVolume(0..1)      -- bed (noise) level. Ramped fast; click-free.
 *   HypnoBed.setEntVolume(0..1)   -- tone level, INDEPENDENT of the bed.
 *   HypnoBed.setMusicVolume(0..1) -- music level, INDEPENDENT of both. 0 = no music at all.
 *   HypnoBed.setMusicMood(id)     -- crossfade the music to another mood.
 *   HypnoBed.duckFor(el)          -- duck the music under an <audio> element (her voice).
 *   HypnoBed.getVolume() / getEntVolume() / getMusicVolume() -- slider values (to seed the UI).
 *   HypnoBed.cue()                -- play the one-shot transition swell.
 *   HypnoBed.stop()               -- ease out and tear down (e.g. on leaving the page).
 *
 * Graceful: if Web Audio is unavailable or the context can't resume, it stays silent and
 * the control bar simply never appears -- the session audio is unaffected.
 */
(function () {
  "use strict";

  var BED_MAX = 0.13;       // noise-bus gain at bed slider = 1.0
  var ENT_MAX = 0.10;       // tone-bus gain at tone slider = 1.0
  var VOL_DEFAULT = 0.22;   // bed slider start -- tuned by ear to a faint, present wash
  var ENT_DEFAULT = 0.30;   // tone slider start
  var MUS_DEFAULT = 0.30;   // music slider start -- deliberately below the noise bed: in a
                            // SESSION the music is colour, not the point. The game runs it far
                            // higher (see strokegame.js MUSIC_VOL); same engine, different job.
  var BEAT_HZ = 6.0;        // theta band -- conventional meditative/hypnotic target
  var CARRIER_HZ = 196;     // base tone for binaural/isochronic (low, unobtrusive)
  var FADE_IN_S = 4.0;      // gentle ease-in of the noise bed on start
  var FADE_OUT_S = 2.0;     // ease-out on stop
  var TONE_FADE_IN_S = 14;  // the theta tone eases in VERY slowly (unnoticed arrival)
  var TONE_FADE_OUT_S = 3;  // ease-out when a tone is switched off
  var SLEW_S = 0.18;        // fast (but click-free) ramp when a slider moves
  var NOISE_SECS = 4;       // length of the looped brown-noise buffer

  var CUE_PEAK = 0.05;      // transition swell level (soft -- a nudge, not an alarm)
  var CUE_ATTACK_S = 1.4;   // slow attack draws attention without startling
  var CUE_LEN_S = 5.5;      // full length incl. the long dissolving tail

  // The listener's own levels, remembered across pages (localStorage). Without this every
  // page reopened the bed at the defaults, so a tone the listener had turned down came back
  // up on the next round -- "loud unless the user set it" has to survive navigation.
  var PREFS_KEY = "hypnobed.prefs.v1";
  function loadPrefs() {
    try { return JSON.parse(window.localStorage.getItem(PREFS_KEY) || "{}") || {}; }
    catch (e) { return {}; }
  }
  function savePrefs() {
    try {
      window.localStorage.setItem(PREFS_KEY, JSON.stringify(
        { vol: vol, entVol: entVol, musVol: musVol, entMode: entMode }));
    } catch (e) {}
  }
  function num(v, dflt) {
    var n = Number(v);
    return (v != null && isFinite(n)) ? Math.min(1, Math.max(0, n)) : dflt;
  }

  var ctx = null;
  var masterFade = null;    // 0..1 start/pause/stop envelope ONLY
  var busBed = null;        // noise level (bed slider)
  var busEnt = null;        // tone level (tone slider)
  var entSum = null;        // sums the entrainment oscillators into busEnt
  var lowpass = null;       // the "breathing" filter on the noise
  var sweepOsc = null;      // LFO sweeping the lowpass cutoff
  var noiseSrc = null;
  var entNodes = [];        // current entrainment oscillators/gains (torn down on change)
  var prefs = loadPrefs();
  var entMode = (["off", "binaural", "isochronic"].indexOf(prefs.entMode) >= 0)
    ? prefs.entMode : "binaural";   // ON by default; eased in slowly
  var state = "idle";       // idle | playing | paused | stopped
  var vol = num(prefs.vol, VOL_DEFAULT);       // bed slider 0..1
  var entVol = num(prefs.entVol, ENT_DEFAULT); // tone slider 0..1
  var musVol = num(prefs.musVol, MUS_DEFAULT); // music slider 0..1 (handed straight to HypnoMusic)
  var musicUp = false;      // HypnoMusic has been started on our context
  var armed = false;

  function now() { return ctx ? ctx.currentTime : 0; }
  function gainFor(v, max) { return v * v * max; }   // ~quadratic loudness curve

  // AudioContext may start suspended if start() wasn't inside a real gesture (e.g. the
  // already-voiced revisit page autoplays with no click). Arm a one-shot listener that
  // resumes on the first pointer/key event; harmless when it's already running.
  function armResume() {
    if (armed || !ctx) return;
    armed = true;
    var h = function () {
      document.removeEventListener("pointerdown", h, true);
      document.removeEventListener("keydown", h, true);
      armed = false;
      if (ctx && ctx.state === "suspended") { try { ctx.resume(); } catch (e) {} }
    };
    document.addEventListener("pointerdown", h, true);
    document.addEventListener("keydown", h, true);
  }

  function makeBrownNoise() {
    var len = Math.floor(ctx.sampleRate * NOISE_SECS);
    var buf = ctx.createBuffer(1, len, ctx.sampleRate);
    var d = buf.getChannelData(0);
    var last = 0;
    for (var i = 0; i < len; i++) {
      var white = Math.random() * 2 - 1;
      last = (last + 0.02 * white) / 1.02;   // integrate white -> brown (warm, low-tilt)
      d[i] = last * 3.5;                       // compensate the level lost to integration
    }
    return buf;
  }

  function buildBed() {
    masterFade = ctx.createGain();
    masterFade.gain.value = 0;                 // eased up in start()
    masterFade.connect(ctx.destination);

    // --- noise wash --> its own bus ----------------------------------------------
    busBed = ctx.createGain();
    busBed.gain.value = gainFor(vol, BED_MAX);
    busBed.connect(masterFade);

    lowpass = ctx.createBiquadFilter();
    lowpass.type = "lowpass";
    lowpass.frequency.value = 1700;            // soft; keeps energy where TTS sounds "off"
    lowpass.Q.value = 0.4;
    lowpass.connect(busBed);

    // slow cutoff sweep so the wash breathes (1200..2200 Hz @ ~0.06 Hz)
    sweepOsc = ctx.createOscillator();
    sweepOsc.frequency.value = 0.06;
    var sweepDepth = ctx.createGain();
    sweepDepth.gain.value = 500;
    sweepOsc.connect(sweepDepth);
    sweepDepth.connect(lowpass.frequency);
    sweepOsc.start();

    noiseSrc = ctx.createBufferSource();
    noiseSrc.buffer = makeBrownNoise();
    noiseSrc.loop = true;
    noiseSrc.connect(lowpass);
    noiseSrc.start();

    // --- entrainment tone --> its own bus ----------------------------------------
    busEnt = ctx.createGain();
    busEnt.gain.value = 0;                      // eased in slowly in start()/setEntrainment
    busEnt.connect(masterFade);
    entSum = ctx.createGain();
    entSum.gain.value = 1.0;
    entSum.connect(busEnt);
    if (entMode !== "off") buildEnt(entMode);   // create the default tone's oscillators
  }

  function teardownEnt() {
    entNodes.forEach(function (n) {
      try { n.stop && n.stop(); } catch (e) {}
      try { n.disconnect(); } catch (e) {}
    });
    entNodes = [];
  }

  function buildEnt(mode) {
    teardownEnt();
    if (mode === "binaural") {
      // Two sines, detuned by the beat, panned hard L/R. The beat exists only in the
      // listener's head -- REQUIRES headphones; collapses to a faint drone on speakers.
      ["L", "R"].forEach(function (side) {
        var osc = ctx.createOscillator();
        osc.type = "sine";
        osc.frequency.value = CARRIER_HZ + (side === "R" ? BEAT_HZ : 0);
        var pan = ctx.createStereoPanner ? ctx.createStereoPanner() : null;
        if (pan) { pan.pan.value = side === "L" ? -1 : 1; osc.connect(pan); pan.connect(entSum); entNodes.push(pan); }
        else { osc.connect(entSum); }     // very old browsers: mono fallback (no real beat)
        osc.start();
        entNodes.push(osc);
      });
    } else if (mode === "isochronic") {
      // One sine, amplitude-gated at the beat rate -- the pulse is audible on speakers,
      // no headphones needed.
      var osc = ctx.createOscillator();
      osc.type = "sine";
      osc.frequency.value = CARRIER_HZ;
      var gate = ctx.createGain();
      gate.gain.value = 0.5;
      var lfo = ctx.createOscillator();      // drives the gate 0..1 at BEAT_HZ
      lfo.type = "sine";
      lfo.frequency.value = BEAT_HZ;
      var depth = ctx.createGain();
      depth.gain.value = 0.5;
      lfo.connect(depth);
      depth.connect(gate.gain);
      osc.connect(gate);
      gate.connect(entSum);
      osc.start();
      lfo.start();
      entNodes.push(osc, lfo, gate, depth);
    }
    entMode = mode;
  }

  function ramp(param, target, dur) {
    if (!param) return;
    param.cancelScheduledValues(now());
    param.setValueAtTime(param.value, now());
    param.linearRampToValueAtTime(target, now() + dur);
  }

  // A START envelope: always from an explicit 0, never from "wherever the gain happens to
  // be", and on a quadratic curve rather than a straight line. A linear amplitude ramp is
  // front-loaded to the ear (half the loudness arrives in the first fifth of the fade), so
  // even a 12 s linear rise reads as the bed "hitting". Squared, the first half of the fade
  // stays genuinely faint and the level arrives across the whole window.
  // Built from short linear segments rather than setValueCurveAtTime: every segment is an
  // ordinary event that cancelScheduledValues() removes cleanly, so a pause or stop during
  // the rise cannot leave a curve still driving the gain up underneath the fade-out.
  var RISE_SEGS = 32;
  function riseFrom0(param, target, dur) {
    if (!param) return;
    var t = now();
    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 + dur * x);
    }
  }

  // Automation is scheduled on the context's clock, and a context the browser is holding
  // suspended (no gesture yet) has a clock that is not moving. Scheduling the rise against
  // that clock and resuming later risks the whole ramp landing in the past -- which the
  // engine resolves by jumping straight to the end value: the bed at full level, instantly.
  // So a start envelope is only scheduled once the context is genuinely running.
  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();                   // not if the bed was torn down meanwhile
    };
    c.addEventListener("statechange", h);
  }

  function bar(show) {
    var b = document.getElementById("ambient-bar");
    if (b) b.style.display = show ? "flex" : "none";
  }

  function syncUI() {
    var t = document.getElementById("bed-toggle");
    if (t) t.textContent = (state === "paused") ? "▶ Resume bed" : "❚❚ Pause bed";
    var sel = document.getElementById("bed-ent");
    if (sel && sel.value !== entMode) sel.value = entMode;
    var sl = document.getElementById("bed-vol");
    if (sl && Math.abs(Number(sl.value) - vol) > 0.001) sl.value = String(vol);
    var es = document.getElementById("bed-ent-vol");
    if (es && Math.abs(Number(es.value) - entVol) > 0.001) es.value = String(entVol);
    var ms = document.getElementById("bed-mus-vol");
    if (ms && Math.abs(Number(ms.value) - musVol) > 0.001) ms.value = String(musVol);
    var mm = document.getElementById("bed-mus-mood");
    if (mm && window.HypnoMusic && mm.value !== HypnoMusic.getMood()) mm.value = HypnoMusic.getMood();
  }

  window.HypnoBed = {
    // opts.fadeIn (seconds) lengthens the arrival: the between space starts the bed only
    // AFTER her recording ends, into silence, so it wants a far longer rise than a bed
    // that comes up under a click.
    start: function (opts) {
      opts = opts || {};
      var fadeIn = Math.max(FADE_IN_S, Number(opts.fadeIn) || 0);
      if (state === "playing") { if (ctx && ctx.state === "suspended") armResume(); return; }
      if (!ctx) {
        var AC = window.AudioContext || window.webkitAudioContext;
        if (!AC) return;                       // no Web Audio -> stay silent
        try { ctx = new AC(); } catch (e) { ctx = null; return; }
        buildBed();
      }
      if (ctx.state === "suspended") { try { ctx.resume(); } catch (e) {} armResume(); }
      state = "playing";
      // Silence NOW, whatever the envelope was doing (a resume from pause, a start that
      // overlapped a stop's fade-out) -- the rise itself is scheduled once the clock runs.
      masterFade.gain.cancelScheduledValues(now());
      masterFade.gain.setValueAtTime(0, now());
      if (busEnt) { busEnt.gain.cancelScheduledValues(now()); busEnt.gain.setValueAtTime(0, now()); }
      whenRunning(function () {
        if (state !== "playing") return;
        riseFrom0(masterFade.gain, 1, fadeIn);               // from 0, on the slow curve
        if (busEnt && entMode !== "off")                     // the tone arrives even later
          riseFrom0(busEnt.gain, gainFor(entVol, ENT_MAX), Math.max(TONE_FADE_IN_S, fadeIn * 1.5));
      });
      // Music shares this context (one clock, one suspend/resume) but NOT masterFade: it owns
      // its own envelope so its long fade-in and this bed's can differ, and so a music level of
      // 0 costs nothing rather than being a silent graph hanging off ours.
      if (window.HypnoMusic && musVol > 0) {
        musicUp = true;
        HypnoMusic.start({
          ctx: ctx,
          mood: window.BED_MUSIC_MOOD || "trance",
          seed: window.BED_MUSIC_SEED || String(Date.now()),
          volume: musVol,
          fadeIn: fadeIn                       // rise with the bed, on its own envelope
        });
        // start() ignores `volume` when the engine is ALREADY running -- which it is whenever
        // loop.js got there first in the same click (antechamber then bed). Set it explicitly
        // so this slider is authoritative from the moment the bed exists.
        HypnoMusic.setVolume(musVol);
      }
      bar(true);
      syncUI();
    },

    toggle: function () {
      if (state === "playing") {
        state = "paused";
        ramp(masterFade.gain, 0, SLEW_S);
        if (musicUp && window.HypnoMusic) HypnoMusic.pause();
      } else if (state === "paused") {
        state = "playing";
        if (ctx && ctx.state === "suspended") { try { ctx.resume(); } catch (e) {} }
        ramp(masterFade.gain, 1, 0.6);
        if (musicUp && window.HypnoMusic) HypnoMusic.resume();
      }
      syncUI();
    },

    setEntrainment: function (mode) {
      if (!ctx) { entMode = mode; return; }   // remembered; applied when start() builds
      if (mode === entMode) return;
      if (mode === "off") {
        entMode = "off";
        ramp(busEnt.gain, 0, TONE_FADE_OUT_S); // ease out, THEN drop the oscillators
        setTimeout(teardownEnt, (TONE_FADE_OUT_S * 1000) + 50);
      } else {
        buildEnt(mode);                        // (re)create oscillators; sets entMode
        riseFrom0(busEnt.gain, gainFor(entVol, ENT_MAX), TONE_FADE_IN_S);  // from 0, slowly
      }
      savePrefs();
      syncUI();
    },

    setVolume: function (v) {
      vol = Math.min(1, Math.max(0, Number(v) || 0));
      if (busBed) ramp(busBed.gain, gainFor(vol, BED_MAX), SLEW_S);
      savePrefs();
      syncUI();
    },

    setEntVolume: function (v) {
      entVol = Math.min(1, Math.max(0, Number(v) || 0));
      if (busEnt && entMode !== "off") ramp(busEnt.gain, gainFor(entVol, ENT_MAX), SLEW_S);
      savePrefs();
      syncUI();
    },

    // The music layer is started lazily: at 0 it was never built, so raising the slider from
    // zero mid-session has to start it rather than just set a gain.
    setMusicVolume: function (v) {
      musVol = Math.min(1, Math.max(0, Number(v) || 0));
      if (!window.HypnoMusic) return;
      if (musVol > 0 && !musicUp && state === "playing") {
        musicUp = true;
        HypnoMusic.start({ ctx: ctx, mood: window.BED_MUSIC_MOOD || "trance", volume: musVol });
      } else {
        HypnoMusic.setVolume(musVol);
      }
      savePrefs();
      syncUI();
    },

    setMusicMood: function (id) {
      if (window.HypnoMusic && id) HypnoMusic.setMood(id);
    },

    // Duck the music (not the noise bed -- that has to keep filling the pause seams) for as
    // long as an element is sounding. Called by the page with the session player.
    duckFor: function (el) {
      if (window.HypnoMusic && el) HypnoMusic.attachVoice(el);
    },

    getVolume: function () { return vol; },
    // The live start/pause/stop envelope (0..1) -- for probing a fade from the console.
    getEnvelope: function () { return masterFade ? masterFade.gain.value : 0; },
    getEntrainment: function () { return entMode; },
    getEntVolume: function () { return entVol; },
    getMusicVolume: function () { return musVol; },

    cue: function () {
      if (!ctx) return;
      var t = now();
      var out = ctx.createGain();
      out.gain.setValueAtTime(0.0001, t);
      out.connect(ctx.destination);
      out.gain.linearRampToValueAtTime(CUE_PEAK, t + CUE_ATTACK_S);   // slow attention swell
      out.gain.exponentialRampToValueAtTime(0.0001, t + CUE_LEN_S);   // long dissolving tail
      // detuned partials -> a warm, calm bell rather than a hard chime
      [[220, 0.6], [330, 0.3], [528, 0.18]].forEach(function (p) {
        var o = ctx.createOscillator(); o.type = "sine"; o.frequency.value = p[0];
        var g = ctx.createGain(); g.gain.value = p[1];
        o.connect(g); g.connect(out); o.start(t); o.stop(t + CUE_LEN_S + 0.1);
      });
      setTimeout(function () { try { out.disconnect(); } catch (e) {} }, (CUE_LEN_S + 0.3) * 1000);
    },

    stop: function () {
      if (state === "idle" || state === "stopped") { bar(false); return; }
      state = "stopped";
      ramp(masterFade.gain, 0, FADE_OUT_S);
      // Stop the music FIRST, and give the teardown its longer fade before closing the shared
      // context -- HypnoMusic fades out over more seconds than this bed does, and closing the
      // context on OUR schedule would cut its tail rather than fade it.
      var teardownMs = FADE_OUT_S * 1000 + 50;
      if (musicUp && window.HypnoMusic) {
        HypnoMusic.stop();
        musicUp = false;
        teardownMs = Math.max(teardownMs, 4000);
      }
      setTimeout(function () {
        teardownEnt();
        try { noiseSrc && noiseSrc.stop(); } catch (e) {}
        try { sweepOsc && sweepOsc.stop(); } catch (e) {}
        try { ctx && ctx.close(); } catch (e) {}
        ctx = masterFade = busBed = busEnt = entSum = lowpass = sweepOsc = noiseSrc = null;
        bar(false);
      }, teardownMs);
    }
  };
})();