ChatApp/apps/desktop/src/lib/ringtone.ts

// Looping ringtones. Two patterns:
//   - outgoing: long calling tone, 3s cycle (oscillator only)
//   - incoming: classic "ring ring" double beep (oscillator), optionally
//     upgraded to a user-supplied audio file stored in ringtoneStorage
//
// The custom file plays immediately if we can load it; otherwise we fall
// back to the generated oscillator pattern so ringing never misses an
// incoming call due to an IO failure.

import { getIncomingRingtone } from './ringtoneStorage';

type Pattern = 'outgoing' | 'incoming';

class Ringtone {
  private ctx: AudioContext | null = null;
  private interval: number | null = null;
  private pattern: Pattern | null = null;

  // Custom-file playback path (incoming only).
  private audioEl: HTMLAudioElement | null = null;
  private customUrl: string | null = null;
  // Sequence token to ignore slow IO completing after user changed state.
  private startSeq = 0;

  start(pattern: Pattern): void {
    if (this.pattern === pattern) return; // already playing this pattern
    this.stop();
    this.pattern = pattern;
    const seq = ++this.startSeq;

    if (pattern === 'incoming') {
      // Kick off oscillator immediately so we never miss ringing feedback
      // while the custom file (if any) loads asynchronously. Once the blob
      // is ready we hand playback over to the <audio> element.
      this.startOscillator(pattern);
      void this.tryUpgradeToCustom(seq);
    } else {
      this.startOscillator(pattern);
    }
  }

  stop(): void {
    this.startSeq++;
    this.stopOscillator();
    this.stopCustom();
    this.pattern = null;
  }

  // --- Custom file path (incoming only) ----------------------------------

  private async tryUpgradeToCustom(seq: number): Promise<void> {
    let stored;
    try {
      stored = await getIncomingRingtone();
    } catch {
      return; // keep oscillator
    }
    // User stopped or switched patterns while we were loading.
    if (seq !== this.startSeq || this.pattern !== 'incoming' || !stored) return;

    const url = URL.createObjectURL(stored.blob);
    const el = new Audio(url);
    el.loop = true;
    el.volume = 0.85;
    // Chrome/WKWebView autoplay policy: muted playback is always allowed,
    // but ringtones must be audible, so play() may reject the first time
    // before the user interacted. If it rejects, we keep the oscillator.
    el.play().catch(() => {
      URL.revokeObjectURL(url);
    });

    this.audioEl = el;
    this.customUrl = url;
    // Only swap off the oscillator once the custom element is actually
    // wired — avoids a silent gap on transition.
    this.stopOscillator();
  }

  private stopCustom(): void {
    if (this.audioEl) {
      try {
        this.audioEl.pause();
      } catch {
        /* ignore */
      }
      this.audioEl.src = '';
      this.audioEl = null;
    }
    if (this.customUrl) {
      URL.revokeObjectURL(this.customUrl);
      this.customUrl = null;
    }
  }

  // --- Oscillator fallback ----------------------------------------------

  private startOscillator(pattern: Pattern): void {
    const AudioCtx =
      window.AudioContext ??
      (window as unknown as { webkitAudioContext?: typeof AudioContext }).webkitAudioContext;
    if (!AudioCtx) return;
    this.ctx = new AudioCtx();

    const play = pattern === 'outgoing' ? this.playOutgoing : this.playIncoming;
    play.call(this);
    this.interval = window.setInterval(
      () => play.call(this),
      pattern === 'outgoing' ? 3000 : 2000,
    );
  }

  private stopOscillator(): void {
    if (this.interval !== null) {
      window.clearInterval(this.interval);
      this.interval = null;
    }
    if (this.ctx) {
      void this.ctx.close().catch(() => {
        /* ignore */
      });
      this.ctx = null;
    }
  }

  private beep(freq: number, durationSec: number, delaySec: number, gain = 0.18): void {
    const ctx = this.ctx;
    if (!ctx) return;
    const osc = ctx.createOscillator();
    const g = ctx.createGain();
    osc.type = 'sine';
    osc.frequency.value = freq;
    osc.connect(g);
    g.connect(ctx.destination);
    const t0 = ctx.currentTime + delaySec;
    g.gain.setValueAtTime(0, t0);
    g.gain.linearRampToValueAtTime(gain, t0 + 0.02);
    g.gain.exponentialRampToValueAtTime(0.001, t0 + durationSec);
    osc.start(t0);
    osc.stop(t0 + durationSec + 0.02);
  }

  private playOutgoing(): void {
    // Soft calling tone — single warm note.
    this.beep(440, 0.4, 0, 0.14);
    this.beep(440, 0.4, 0.6, 0.14);
  }

  private playIncoming(): void {
    // Classic double-ring "ring ring".
    this.beep(880, 0.18, 0, 0.22);
    this.beep(660, 0.18, 0.22, 0.22);
    this.beep(880, 0.18, 0.6, 0.22);
    this.beep(660, 0.18, 0.82, 0.22);
  }
}

export const ringtone = new Ringtone();