useAudio.ts

'use client';

import { useEffect, useRef, useCallback } from 'react';
import { useScrollProgress, useExperiencePhase } from './useScrollProgress';
import { SCENE_RANGES, inRange } from '@/lib/sceneConfig';

export function useAudio(enabled: boolean) {
  const progress = useScrollProgress();
  const { phase } = useExperiencePhase();

  // Web Audio Context & Nodes refs
  const ctxRef = useRef<AudioContext | null>(null);
  
  // Ambient drone nodes
  const droneGainRef = useRef<GainNode | null>(null);
  const droneOsc1Ref = useRef<OscillatorNode | null>(null);
  const droneOsc2Ref = useRef<OscillatorNode | null>(null);
  const droneFilterRef = useRef<BiquadFilterNode | null>(null);
  
  // Heartbeat loop state & nodes
  const heartbeatGainRef = useRef<GainNode | null>(null);
  const heartbeatTimerRef = useRef<number | null>(null);
  const heartbeatIntervalRef = useRef<number>(1500); // ms
  
  // Black hole rumble nodes
  const rumbleGainRef = useRef<GainNode | null>(null);
  const rumbleOscRef = useRef<OscillatorNode | null>(null);
  const rumbleFilterRef = useRef<BiquadFilterNode | null>(null);
  
  const started = useRef(false);

  // Helper to trigger a single heartbeat double thump
  const triggerThump = useCallback((time: number, freq = 55, duration = 0.22) => {
    const ctx = ctxRef.current;
    const dest = heartbeatGainRef.current;
    if (!ctx || !dest || ctx.state === 'suspended') return;

    // First thump of the heartbeat
    const osc1 = ctx.createOscillator();
    const gain1 = ctx.createGain();
    
    osc1.frequency.setValueAtTime(freq, time);
    osc1.frequency.exponentialRampToValueAtTime(0.01, time + duration);
    
    gain1.gain.setValueAtTime(0, time);
    gain1.gain.linearRampToValueAtTime(0.8, time + 0.02);
    gain1.gain.exponentialRampToValueAtTime(0.001, time + duration);
    
    osc1.connect(gain1);
    gain1.connect(dest);
    osc1.start(time);
    osc1.stop(time + duration);

    // Second thump (0.25 seconds later)
    const t2 = time + 0.25;
    const osc2 = ctx.createOscillator();
    const gain2 = ctx.createGain();
    
    osc2.frequency.setValueAtTime(freq * 0.85, t2);
    osc2.frequency.exponentialRampToValueAtTime(0.01, t2 + duration);
    
    gain2.gain.setValueAtTime(0, t2);
    gain2.gain.linearRampToValueAtTime(0.55, t2 + 0.02);
    gain2.gain.exponentialRampToValueAtTime(0.001, t2 + duration);
    
    osc2.connect(gain2);
    gain2.connect(dest);
    osc2.start(t2);
    osc2.stop(t2 + duration);
  }, []);

  // Warp Whoosh sound effect
  const playWarpWhoosh = useCallback(() => {
    const ctx = ctxRef.current;
    if (!ctx) return;
    
    const now = ctx.currentTime;
    
    // Create random white noise buffer
    const bufferSize = ctx.sampleRate * 1.5; // 1.5 seconds
    const buffer = ctx.createBuffer(1, bufferSize, ctx.sampleRate);
    const data = buffer.getChannelData(0);
    for (let i = 0; i < bufferSize; i++) {
      data[i] = Math.random() * 2 - 1;
    }
    
    const noiseSource = ctx.createBufferSource();
    noiseSource.buffer = buffer;
    
    const filter = ctx.createBiquadFilter();
    filter.type = 'bandpass';
    filter.Q.value = 3.5;
    filter.frequency.setValueAtTime(80, now);
    filter.frequency.exponentialRampToValueAtTime(2800, now + 0.7);
    filter.frequency.exponentialRampToValueAtTime(100, now + 1.4);
    
    const gain = ctx.createGain();
    gain.gain.setValueAtTime(0, now);
    gain.gain.linearRampToValueAtTime(0.5, now + 0.25);
    gain.gain.exponentialRampToValueAtTime(0.001, now + 1.4);
    
    noiseSource.connect(filter);
    filter.connect(gain);
    gain.connect(ctx.destination);
    
    // Sweeping sine oscillator for a powerful sub-whoosh
    const subOsc = ctx.createOscillator();
    const subGain = ctx.createGain();
    subOsc.frequency.setValueAtTime(45, now);
    subOsc.frequency.exponentialRampToValueAtTime(550, now + 0.7);
    subOsc.frequency.exponentialRampToValueAtTime(25, now + 1.4);
    
    subGain.gain.setValueAtTime(0, now);
    subGain.gain.linearRampToValueAtTime(0.35, now + 0.35);
    subGain.gain.exponentialRampToValueAtTime(0.001, now + 1.4);
    
    subOsc.connect(subGain);
    subGain.connect(ctx.destination);
    
    noiseSource.start(now);
    subOsc.start(now);
    
    noiseSource.stop(now + 1.4);
    subOsc.stop(now + 1.4);
  }, []);

  const start = useCallback(() => {
    if (started.current) return;
    started.current = true;

    // Create browser AudioContext safely
    const AudioContextClass = window.AudioContext || (window as any).webkitAudioContext;
    const ctx = new AudioContextClass();
    ctxRef.current = ctx;

    if (ctx.state === 'suspended') {
      ctx.resume();
    }

    const now = ctx.currentTime;

    // 1. Ambient Space Drone setup
    const osc1 = ctx.createOscillator();
    const osc2 = ctx.createOscillator();
    const filter = ctx.createBiquadFilter();
    const droneGain = ctx.createGain();

    osc1.type = 'triangle';
    osc1.frequency.setValueAtTime(55, now); // A1 note
    osc1.detune.setValueAtTime(-5, now);

    osc2.type = 'sawtooth';
    osc2.frequency.setValueAtTime(110, now); // A2 note
    osc2.detune.setValueAtTime(5, now);

    filter.type = 'lowpass';
    filter.frequency.setValueAtTime(180, now);
    filter.Q.value = 1.0;

    droneGain.gain.setValueAtTime(0, now);
    droneGain.gain.linearRampToValueAtTime(0.25, now + 1.5);

    osc1.connect(filter);
    osc2.connect(filter);
    filter.connect(droneGain);
    droneGain.connect(ctx.destination);

    osc1.start(now);
    osc2.start(now);

    droneOsc1Ref.current = osc1;
    droneOsc2Ref.current = osc2;
    droneFilterRef.current = filter;
    droneGainRef.current = droneGain;

    // 2. Heartbeat Gain setup
    const heartbeatGain = ctx.createGain();
    heartbeatGain.gain.setValueAtTime(0, now);
    heartbeatGain.connect(ctx.destination);
    heartbeatGainRef.current = heartbeatGain;

    // Start scheduled heartbeat loop
    const runHeartbeat = () => {
      if (!ctxRef.current) return;
      triggerThump(ctxRef.current.currentTime);
      heartbeatTimerRef.current = window.setTimeout(runHeartbeat, heartbeatIntervalRef.current);
    };
    runHeartbeat();

    // 3. Black Hole Rumble setup
    const rumbleOsc = ctx.createOscillator();
    const rumbleFilter = ctx.createBiquadFilter();
    const rumbleGain = ctx.createGain();

    rumbleOsc.type = 'sawtooth';
    rumbleOsc.frequency.setValueAtTime(32, now); // Very low sub frequency

    rumbleFilter.type = 'lowpass';
    rumbleFilter.frequency.setValueAtTime(65, now);
    rumbleFilter.Q.value = 7.0; // High resonance for hum/rumble

    rumbleGain.gain.setValueAtTime(0, now);

    rumbleOsc.connect(rumbleFilter);
    rumbleFilter.connect(rumbleGain);
    rumbleGain.connect(ctx.destination);

    rumbleOsc.start(now);

    rumbleOscRef.current = rumbleOsc;
    rumbleFilterRef.current = rumbleFilter;
    rumbleGainRef.current = rumbleGain;

    // Play warp whoosh to start experience
    playWarpWhoosh();
  }, [triggerThump, playWarpWhoosh]);

  // Play whoosh when phase transitions to entering
  useEffect(() => {
    if (phase === 'entering' && started.current) {
      playWarpWhoosh();
    }
  }, [phase, playWarpWhoosh]);

  // Adjust volumes and parameters based on scroll progress
  useEffect(() => {
    if (!enabled || !started.current || !ctxRef.current) return;

    const ctx = ctxRef.current;
    const now = ctx.currentTime;

    // Black Hole Rumble volume control
    const inBH = inRange(progress, SCENE_RANGES.blackHole) || inRange(progress, SCENE_RANGES.eventHorizon);
    const targetRumbleVolume = inBH ? 0.35 : 0.0;
    rumbleGainRef.current?.gain.setTargetAtTime(targetRumbleVolume, now, 0.2);
    
    if (inBH) {
      const factor = (progress - SCENE_RANGES.blackHole[0]) / (SCENE_RANGES.eventHorizon[1] - SCENE_RANGES.blackHole[0]);
      const pitch = 32 - factor * 6; // rumble pitch sweeps downward as you fall in
      rumbleOscRef.current?.frequency.setTargetAtTime(pitch, now, 0.25);
    }

    // Heartbeat volume and tempo control
    const inHeartbeatZone =
      inRange(progress, SCENE_RANGES.eventHorizon) ||
      inRange(progress, SCENE_RANGES.singularity);

    const targetHBVolume = inHeartbeatZone ? 0.45 : 0.0;
    heartbeatGainRef.current?.gain.setTargetAtTime(targetHBVolume, now, 0.3);

    if (inHeartbeatZone) {
      const horizonT = (progress - SCENE_RANGES.eventHorizon[0]) / (SCENE_RANGES.singularity[1] - SCENE_RANGES.eventHorizon[0]);
      // Speed up heartbeat rate from 1400ms down to 600ms
      heartbeatIntervalRef.current = 1400 - horizonT * 800;
    } else {
      heartbeatIntervalRef.current = 1500;
    }

    // Modulate space drone filter cutoff slightly based on scroll to feel interactive
    const targetCutoff = 170 + Math.sin(progress * Math.PI * 6) * 60;
    droneFilterRef.current?.frequency.setTargetAtTime(targetCutoff, now, 0.4);

  }, [progress, enabled]);

  // Cleanup Web Audio Context
  useEffect(() => {
    return () => {
      if (heartbeatTimerRef.current) {
        clearTimeout(heartbeatTimerRef.current);
      }
      if (ctxRef.current) {
        ctxRef.current.close();
      }
    };
  }, []);

  return { start };
}