PTT-Live/server/bridge/AudioBridge.js

/**
 * AudioBridge.js
 * Classe principale du bridge audio serveur
 *
 * Orchestre :
 * - Détection et initialisation du backend audio (CoreAudio/JACK/etc.)
 * - Routing : CoreAudio → Opus → LiveKit
 * - Routing : LiveKit → Opus → CoreAudio
 * - Jitter buffer pour flux entrants
 * - Logs détaillés et statistiques
 */

import { EventEmitter } from 'events';
import { platform } from 'os';
import CoreAudioBackend from './backends/CoreAudioBackend.js';
import JACKBackend from './backends/JACKBackend.js';
import PipeWireBackend from './backends/PipeWireBackend.js';
import OpusCodec, { OpusPresets } from './OpusCodec.js';
import JitterBuffer, { JitterBufferPresets } from './JitterBuffer.js';
import LiveKitClient from './LiveKitClient.js';
import GroupAudioRouter from './GroupAudioRouter.js';

export class AudioBridge extends EventEmitter {
  constructor(options = {}) {
    super();

    this.options = {
      // Configuration audio
      sampleRate: options.sampleRate || 48000,
      channels: options.channels || 1,
      frameSize: options.frameSize || 960, // 20ms à 48kHz

      // Configuration Opus
      opusPreset: options.opusPreset || 'VOICE_STANDARD',
      customOpusBitrate: options.customOpusBitrate || null,

      // Configuration JitterBuffer
      jitterBufferPreset: options.jitterBufferPreset || 'LOW_LATENCY',

      // Configuration LiveKit
      liveKitUrl: options.liveKitUrl || 'ws://localhost:7880',
      liveKitToken: options.liveKitToken || null,
      roomName: options.roomName || 'main',

      // Configuration backend
      inputDeviceId: options.inputDeviceId || null,
      outputDeviceId: options.outputDeviceId || null,

      ...options
    };

    // Composants
    this.audioBackend = null;
    this.opusEncoder = null;
    this.opusDecoder = null;
    this.jitterBuffer = null;
    this.liveKitClient = null;
    this.groupAudioRouter = null;

    // État
    this.isRunning = false;
    this.backendType = null;

    // Buffers pour routing multi-canaux
    this.inputChannelBuffers = new Map(); // Map<channelId, Float32Array>
    this.groupBuffersFromLiveKit = new Map(); // Map<groupName, Float32Array>

    // Statistiques
    this.stats = {
      startTime: null,
      framesCapture: 0,
      framesPlayback: 0,
      bytesEncoded: 0,
      bytesDecoded: 0,
      errors: {
        capture: 0,
        playback: 0,
        encode: 0,
        decode: 0,
        network: 0
      }
    };
  }

  /**
   * Initialise et démarre le bridge audio
   * @returns {Promise<void>}
   */
  async start() {
    if (this.isRunning) {
      console.warn('Bridge audio déjà démarré');
      return;
    }

    console.log('🚀 Démarrage AudioBridge...');

    try {
      // 1. Détection et initialisation du backend audio
      await this._initAudioBackend();

      // 2. Initialisation des codecs Opus
      this._initOpusCodecs();

      // 3. Initialisation du jitter buffer
      this._initJitterBuffer();

      // 4. Initialisation du GroupAudioRouter
      this._initGroupAudioRouter();

      // 5. Connexion à LiveKit
      await this._initLiveKit();

      // 6. Démarrage du routing audio
      await this._startAudioRouting();

      this.isRunning = true;
      this.stats.startTime = Date.now();

      console.log('✅ AudioBridge démarré avec succès');
      this.emit('started');

      // Logs périodiques
      this._startStatsLogger();
    } catch (error) {
      console.error('❌ Erreur démarrage AudioBridge:', error);
      await this.stop();
      throw error;
    }
  }

  /**
   * Détecte et initialise le backend audio approprié
   * @private
   */
  async _initAudioBackend() {
    const os = platform();
    let BackendClass = null;
    let devices = [];

    // macOS : CoreAudio prioritaire
    if (os === 'darwin') {
      if (CoreAudioBackend.isAvailable()) {
        this.backendType = 'CoreAudio';
        BackendClass = CoreAudioBackend;
        console.log('✓ Backend audio : CoreAudio (macOS natif)');
      } else {
        throw new Error('CoreAudio non disponible sur ce système');
      }
    }
    // Linux : PipeWire > JACK (ordre de préférence)
    else if (os === 'linux') {
      // Détection automatique : préfère PipeWire (moderne) puis JACK (pro)
      if (PipeWireBackend.isAvailable() && PipeWireBackend.isServerRunning()) {
        this.backendType = 'PipeWire';
        BackendClass = PipeWireBackend;
        console.log('✓ Backend audio : PipeWire (Linux moderne)');
      } else if (JACKBackend.isAvailable() && JACKBackend.isServerRunning()) {
        this.backendType = 'JACK';
        BackendClass = JACKBackend;
        console.log('✓ Backend audio : JACK (Linux professionnel)');
      } else {
        // Aucun backend disponible
        const pipewireInstalled = PipeWireBackend.isAvailable();
        const jackInstalled = JACKBackend.isAvailable();

        let errorMsg = 'Aucun backend audio disponible sur Linux.\n';

        if (!pipewireInstalled && !jackInstalled) {
          errorMsg += 'Installez PipeWire (recommandé) ou JACK :\n';
          errorMsg += '  Ubuntu/Debian : sudo apt install pipewire pipewire-pulse\n';
          errorMsg += '  Arch Linux : sudo pacman -S pipewire pipewire-pulse\n';
          errorMsg += '  JACK : sudo apt install jackd2 jack-tools';
        } else if (pipewireInstalled && !PipeWireBackend.isServerRunning()) {
          errorMsg += 'PipeWire installé mais non démarré.\n';
          errorMsg += 'Démarrez-le : systemctl --user start pipewire pipewire-pulse';
        } else if (jackInstalled && !JACKBackend.isServerRunning()) {
          errorMsg += 'JACK installé mais serveur non démarré.\n';
          errorMsg += 'Démarrez-le : jackd -d alsa -r 48000';
        }

        throw new Error(errorMsg);
      }
    }
    // Windows : WASAPI (futur)
    else if (os === 'win32') {
      throw new Error('Support Windows non encore implémenté');
    }
    else {
      throw new Error(`Plateforme non supportée : ${os}`);
    }

    // Initialisation du backend sélectionné
    this.audioBackend = new BackendClass({
      sampleRate: this.options.sampleRate,
      channels: this.options.channels,
      framesPerBuffer: this.options.frameSize,
      inputDeviceId: this.options.inputDeviceId,
      outputDeviceId: this.options.outputDeviceId,
      // Options spécifiques PipeWire
      latency: this.options.latency || 20
    });

    // Liste des devices disponibles
    devices = BackendClass.getDevices();
    console.log(`📻 Devices audio détectés : ${devices.length}`);
    devices.forEach(d => {
      console.log(`  - ${d.name} (in:${d.maxInputChannels}, out:${d.maxOutputChannels})`);
    });
  }

  /**
   * Initialise les codecs Opus (encoder et decoder)
   * @private
   */
  _initOpusCodecs() {
    // Configuration Opus depuis preset ou custom
    let opusConfig = OpusPresets[this.options.opusPreset] || OpusPresets.VOICE_STANDARD;

    if (this.options.customOpusBitrate) {
      opusConfig = { ...opusConfig, bitrate: this.options.customOpusBitrate };
    }

    const codecOptions = {
      sampleRate: this.options.sampleRate,
      channels: this.options.channels,
      frameSize: this.options.frameSize,
      ...opusConfig
    };

    // Encoder pour capture (CoreAudio → Opus → LiveKit)
    this.opusEncoder = new OpusCodec(codecOptions);

    // Decoder pour lecture (LiveKit → Opus → CoreAudio)
    this.opusDecoder = new OpusCodec(codecOptions);

    console.log(`✓ Codecs Opus : ${opusConfig.bitrate / 1000}kbps, ${this.options.sampleRate}Hz`);
  }

  /**
   * Initialise le jitter buffer
   * @private
   */
  _initJitterBuffer() {
    const bufferConfig = JitterBufferPresets[this.options.jitterBufferPreset] || JitterBufferPresets.LOW_LATENCY;

    this.jitterBuffer = new JitterBuffer(bufferConfig);

    // Events du jitter buffer
    this.jitterBuffer.on('underrun', () => {
      console.warn('⚠️  Jitter buffer underrun');
    });

    this.jitterBuffer.on('overrun', () => {
      console.warn('⚠️  Jitter buffer overrun');
    });

    this.jitterBuffer.on('adapted', ({ newTargetSize, reason }) => {
      console.log(`🔧 Jitter buffer adapté : ${newTargetSize} frames (raison: ${reason})`);
    });

    console.log(`✓ Jitter buffer : cible ${bufferConfig.targetSize} frames`);
  }

  /**
   * Initialise le GroupAudioRouter pour le routing multi-canaux
   * @private
   */
  _initGroupAudioRouter() {
    this.groupAudioRouter = new GroupAudioRouter({
      sampleRate: this.options.sampleRate,
      frameSize: this.options.frameSize,
      maxInputChannels: this.options.maxInputChannels || 32,
      maxOutputChannels: this.options.maxOutputChannels || 32,
      groups: this.options.groups || []
    });

    // Charger la configuration de routing depuis les options
    if (this.options.routing) {
      this.groupAudioRouter.configure(this.options.routing);
    }

    // Events du router
    this.groupAudioRouter.on('configured', (stats) => {
      console.log(`✓ GroupAudioRouter configuré : ${stats.routesActive} routes`);
    });

    console.log('✓ GroupAudioRouter initialisé');
  }

  /**
   * Initialise la connexion LiveKit
   * @private
   */
  async _initLiveKit() {
    if (!this.options.liveKitToken) {
      throw new Error('Token LiveKit requis');
    }

    this.liveKitClient = new LiveKitClient({
      url: this.options.liveKitUrl,
      token: this.options.liveKitToken,
      roomName: this.options.roomName,
      participantName: 'AudioBridge',
      audioBitrate: this.opusEncoder.options.bitrate
    });

    // Events LiveKit
    this.liveKitClient.on('connected', () => {
      console.log('✓ LiveKit connecté');
    });

    this.liveKitClient.on('disconnected', ({ reason }) => {
      console.warn('⚠️  LiveKit déconnecté:', reason);
      this.stats.errors.network++;
    });

    this.liveKitClient.on('reconnecting', () => {
      console.log('🔄 LiveKit reconnexion...');
    });

    this.liveKitClient.on('audioTrackSubscribed', ({ track, participant }) => {
      console.log(`🎵 Nouveau track audio : ${participant.identity}`);
      this._handleRemoteAudioTrack(track);
    });

    await this.liveKitClient.connect();
  }

  /**
   * Démarre le routing audio bidirectionnel complet
   * @private
   */
  async _startAudioRouting() {
    console.log('🔄 Démarrage routing audio bidirectionnel...');

    // ===== FLUX 1 : CAPTURE (Carte Son → Groupes → LiveKit → Clients) =====
    this.audioBackend.on('audioData', (pcmData) => {
      try {
        // Convertir PCM Buffer → Float32Array (pour GroupAudioRouter)
        const float32Data = this._bufferToFloat32(pcmData);

        // Pour l'instant, on assume que l'audio vient du canal 0
        // TODO: Supporter multi-canaux depuis la carte son
        const channelId = this.options.inputDeviceChannel || 0;
        this.inputChannelBuffers.set(channelId, float32Data);

        // ÉTAPE 1 : Inputs physiques → Groupes (via GroupAudioRouter)
        const groupBuffers = this.groupAudioRouter.processInputsToGroups(
          this.inputChannelBuffers
        );

        // ÉTAPE 2 : Pour chaque groupe, envoyer vers LiveKit
        groupBuffers.forEach((groupBuffer, groupName) => {
          // Convertir Float32Array → PCM Buffer
          const pcmBuffer = this._float32ToBuffer(groupBuffer);

          // Encoder en Opus
          const opusData = this.opusEncoder.encode(pcmBuffer);

          if (opusData) {
            this.stats.framesCapture++;
            this.stats.bytesEncoded += opusData.length;

            // TODO: Envoyer opusData à LiveKit pour ce groupe spécifique
            // this.liveKitClient.sendAudioToGroup(groupName, opusData);

            // Pour Phase 3, on émet un événement que le système d'intégration LiveKit écoutera
            this.emit('groupAudioOut', { groupName, opusData, pcmBuffer });
          }
        });

        this.stats.framesCapture++;
      } catch (error) {
        console.error('Erreur routing capture:', error);
        this.stats.errors.capture++;
      }
    });

    // ===== FLUX 2 : LECTURE (Clients → LiveKit → Groupes → Carte Son) =====

    // Écouter l'audio entrant de LiveKit (sera connecté par LiveKitServerBridge)
    this.on('groupAudioIn', ({ groupName, pcmBuffer }) => {
      try {
        // Stocker le buffer du groupe pour le routing
        const float32Data = this._bufferToFloat32(pcmBuffer);
        this.groupBuffersFromLiveKit.set(groupName, float32Data);

        // ÉTAPE 3 : Groupes → Outputs physiques (via GroupAudioRouter)
        const outputBuffers = this.groupAudioRouter.processGroupsToOutputs(
          this.groupBuffersFromLiveKit
        );

        // ÉTAPE 4 : Envoyer chaque output à la carte son
        outputBuffers.forEach((outputBuffer, channelId) => {
          const pcmBuffer = this._float32ToBuffer(outputBuffer);

          // Envoyer à la carte son
          this.audioBackend.queueAudio(pcmBuffer);
        });

        this.stats.framesPlayback++;
      } catch (error) {
        console.error('Erreur routing lecture:', error);
        this.stats.errors.playback++;
      }
    });

    // Démarrage des streams audio
    await this.audioBackend.startCapture();
    await this.audioBackend.startPlayback();

    console.log('✓ Routing audio bidirectionnel actif');
    console.log('  → Carte Son → GroupRouter → LiveKit → Clients');
    console.log('  ← Carte Son ← GroupRouter ← LiveKit ← Clients');
  }

  /**
   * Gère l'arrivée d'un track audio distant
   * @param {RemoteAudioTrack} track - Track LiveKit
   * @private
   */
  _handleRemoteAudioTrack(track) {
    // Récupération du MediaStream du track
    const mediaStream = new MediaStream([track.mediaStreamTrack]);

    // Note: Pour décoder Opus côté serveur, on aurait besoin d'accéder
    // aux données brutes via DataChannel ou API bas niveau
    // LiveKit gère nativement le décodage WebRTC → PCM dans le navigateur

    // Pour un vrai bridge serveur, il faudrait :
    // 1. Recevoir les paquets Opus via DataChannel ou API custom
    // 2. Décoder avec opusDecoder
    // 3. Envoyer au jitterBuffer
    // 4. Lire depuis jitterBuffer vers CoreAudio

    // TODO: Implémenter réception bas niveau Opus depuis LiveKit
    console.warn('Réception track distant : implémentation complète en cours');
  }

  /**
   * Convertit Buffer PCM 16-bit → Float32Array [-1.0, 1.0]
   * @param {Buffer} buffer - Buffer PCM 16-bit signed
   * @returns {Float32Array}
   * @private
   */
  _bufferToFloat32(buffer) {
    const samples = buffer.length / 2; // 2 bytes per sample (16-bit)
    const float32 = new Float32Array(samples);

    for (let i = 0; i < samples; i++) {
      // Lire 16-bit signed little-endian
      const int16 = buffer.readInt16LE(i * 2);
      // Normaliser vers [-1.0, 1.0]
      float32[i] = int16 / 32768.0;
    }

    return float32;
  }

  /**
   * Convertit Float32Array [-1.0, 1.0] → Buffer PCM 16-bit
   * @param {Float32Array} float32 - Données audio normalisées
   * @returns {Buffer}
   * @private
   */
  _float32ToBuffer(float32) {
    const buffer = Buffer.alloc(float32.length * 2); // 2 bytes per sample

    for (let i = 0; i < float32.length; i++) {
      // Clamping [-1.0, 1.0]
      const clamped = Math.max(-1.0, Math.min(1.0, float32[i]));
      // Convertir vers 16-bit signed
      const int16 = Math.round(clamped * 32767);
      buffer.writeInt16LE(int16, i * 2);
    }

    return buffer;
  }

  /**
   * Arrête le bridge audio
   */
  async stop() {
    if (!this.isRunning) {
      return;
    }

    console.log('🛑 Arrêt AudioBridge...');

    // Arrêt des composants
    if (this.audioBackend) {
      this.audioBackend.destroy();
      this.audioBackend = null;
    }

    if (this.liveKitClient) {
      await this.liveKitClient.destroy();
      this.liveKitClient = null;
    }

    if (this.groupAudioRouter) {
      this.groupAudioRouter.destroy();
      this.groupAudioRouter = null;
    }

    if (this.jitterBuffer) {
      this.jitterBuffer.destroy();
      this.jitterBuffer = null;
    }

    if (this.opusEncoder) {
      this.opusEncoder.destroy();
      this.opusEncoder = null;
    }

    if (this.opusDecoder) {
      this.opusDecoder.destroy();
      this.opusDecoder = null;
    }

    // Nettoyer les buffers
    this.inputChannelBuffers.clear();
    this.groupBuffersFromLiveKit.clear();

    this.isRunning = false;

    console.log('✓ AudioBridge arrêté');
    this.emit('stopped');
  }

  /**
   * Logger de statistiques périodiques
   * @private
   */
  _startStatsLogger() {
    const logInterval = 10000; // 10s

    const logger = setInterval(() => {
      if (!this.isRunning) {
        clearInterval(logger);
        return;
      }

      const stats = this.getStats();
      console.log('📊 Statistiques AudioBridge:');
      console.log(`  Uptime: ${Math.floor(stats.uptimeSeconds)}s`);
      console.log(`  Capture: ${stats.framesCapture} frames (${stats.errors.capture} erreurs)`);
      console.log(`  Playback: ${stats.framesPlayback} frames (${stats.errors.playback} erreurs)`);
      console.log(`  Jitter buffer: ${stats.jitterBuffer.currentBufferSize}/${stats.jitterBuffer.maxSize} (santé: ${stats.jitterBuffer.health.toFixed(1)}%)`);
      console.log(`  Codec: enc=${stats.codec.encoded}, dec=${stats.codec.decoded}`);
    }, logInterval);
  }

  /**
   * Récupère les statistiques complètes
   * @returns {Object}
   */
  getStats() {
    const uptime = this.stats.startTime ? (Date.now() - this.stats.startTime) / 1000 : 0;

    return {
      running: this.isRunning,
      backendType: this.backendType,
      uptimeSeconds: uptime,
      framesCapture: this.stats.framesCapture,
      framesPlayback: this.stats.framesPlayback,
      bytesEncoded: this.stats.bytesEncoded,
      bytesDecoded: this.stats.bytesDecoded,
      errors: { ...this.stats.errors },
      audioBackend: this.audioBackend ? this.audioBackend.getStats() : null,
      codec: this.opusEncoder ? this.opusEncoder.getStats() : null,
      jitterBuffer: this.jitterBuffer ? this.jitterBuffer.getStats() : null,
      liveKit: this.liveKitClient ? this.liveKitClient.getStats() : null
    };
  }

  /**
   * Détruit le bridge et libère toutes les ressources
   */
  async destroy() {
    await this.stop();
    this.removeAllListeners();
    console.log('✓ AudioBridge détruit');
  }
}

export default AudioBridge;