// All sound: WebAudio context, synthesized SFX, recorded umpire lines, speech fallback.

let AC = null;
export const audio = () => {
  if (!AC) AC = new (window.AudioContext || window.webkitAudioContext)();
  if (AC.state === 'suspended') AC.resume();
  return AC;
};

// Umpire lines are pre-recorded files (assets/audio/*.m4a) played via WebAudio —
// works on mobile where speechSynthesis is unreliable. say() remains the fallback.
const VOICE = {};
let reverbNode = null;
function reverb(ac) { // stadium PA tail: exponentially decaying noise as impulse response
  if (reverbNode) return reverbNode;
  const len = ac.sampleRate * 1.3, ir = ac.createBuffer(2, len, ac.sampleRate);
  for (let c = 0; c < 2; c++) {
    const d = ir.getChannelData(c);
    for (let i = 0; i < len; i++) d[i] = (Math.random() * 2 - 1) * Math.pow(1 - i / len, 2.8);
  }
  reverbNode = ac.createConvolver(); reverbNode.buffer = ir;
  const wet = ac.createGain(); wet.gain.value = 0.35;
  reverbNode.connect(wet).connect(ac.destination);
  return reverbNode;
}

export function voice(name, delay = 0) {
  const ac = audio();
  const play = buf => {
    const src = ac.createBufferSource(); src.buffer = buf;
    src.connect(ac.destination); src.connect(reverb(ac)); // dry + center-court echo
    src.start(ac.currentTime + delay);
  };
  if (VOICE[name]) return play(VOICE[name]);
  fetch('assets/audio/' + name + '.m4a')
    .then(r => { if (!r.ok) throw 0; return r.arrayBuffer(); })
    .then(ab => ac.decodeAudioData(ab))
    .then(buf => { VOICE[name] = buf; play(buf); })
    .catch(() => say(name.replace(/_/g, ' '), delay));
}

let sysVoice = null;
export function say(text, delay = 0) { // fallback when a recorded umpire line is missing
  try {
    if (!sysVoice) sysVoice = speechSynthesis.getVoices().find(v => v.lang.startsWith('en-GB')) || null;
    const u = new SpeechSynthesisUtterance(text);
    if (sysVoice) u.voice = sysVoice; u.rate = 0.88; u.pitch = 0.75; u.volume = 0.9;
    setTimeout(() => speechSynthesis.speak(u), delay * 1000);
  } catch (e) {}
}

function noiseBuf(ac, len) {
  const b = ac.createBuffer(1, ac.sampleRate * len, ac.sampleRate), d = b.getChannelData(0);
  for (let i = 0; i < d.length; i++) d[i] = Math.random() * 2 - 1;
  return b;
}

export function swish(vol = 0.3) { // racket cutting air — the sound of a whiff
  try {
    const ac = audio(), t = ac.currentTime;
    const src = ac.createBufferSource(); src.buffer = noiseBuf(ac, 0.16);
    const bp = ac.createBiquadFilter(); bp.type = 'bandpass'; bp.frequency.setValueAtTime(1600, t);
    bp.frequency.exponentialRampToValueAtTime(3200, t + 0.12); bp.Q.value = 1.5;
    const g = ac.createGain();
    g.gain.setValueAtTime(0.001, t); g.gain.exponentialRampToValueAtTime(vol, t + 0.05);
    g.gain.exponentialRampToValueAtTime(0.001, t + 0.16);
    src.connect(bp).connect(g).connect(ac.destination); src.start();
  } catch (e) {}
}

export function pock(vol = 0.8, freq = 900) { // racket contact / bounce thock
  try {
    const ac = audio(), t = ac.currentTime;
    const src = ac.createBufferSource(); src.buffer = noiseBuf(ac, 0.06);
    const bp = ac.createBiquadFilter(); bp.type = 'bandpass'; bp.frequency.value = freq; bp.Q.value = 1.2;
    const g = ac.createGain();
    g.gain.setValueAtTime(vol, t); g.gain.exponentialRampToValueAtTime(0.001, t + 0.07);
    src.connect(bp).connect(g).connect(ac.destination); src.start();
    const o = ac.createOscillator(), og = ac.createGain(); // low thump body
    o.frequency.setValueAtTime(180, t); o.frequency.exponentialRampToValueAtTime(70, t + 0.08);
    og.gain.setValueAtTime(vol * 0.5, t); og.gain.exponentialRampToValueAtTime(0.001, t + 0.09);
    o.connect(og).connect(ac.destination); o.start(t); o.stop(t + 0.1);
  } catch (e) {}
}

export function applause(seconds = 2.4, vol = 0.5) { // ponytail: synthesized claps; swap for a sample if it reads flat
  try {
    const ac = audio(), t0 = ac.currentTime, n = 90 * seconds;
    for (let i = 0; i < n; i++) {
      const t = t0 + Math.random() * seconds;
      const env = Math.min(1, 4 * (1 - Math.abs(2 * (t - t0) / seconds - 1))); // fade in/out
      const src = ac.createBufferSource(); src.buffer = noiseBuf(ac, 0.025);
      const bp = ac.createBiquadFilter(); bp.type = 'bandpass';
      bp.frequency.value = 1000 + Math.random() * 1600; bp.Q.value = 2.5;
      const g = ac.createGain();
      g.gain.setValueAtTime(vol * env * (0.3 + Math.random() * 0.7), t);
      g.gain.exponentialRampToValueAtTime(0.001, t + 0.03);
      src.connect(bp).connect(g).connect(ac.destination); src.start(t);
    }
  } catch (e) {}
}