// Browser TTS doesn't create voices - it orchestrates them
const synth = window.speechSynthesis;
const voices = synth.getVoices(); // Discovers available voices

// Voice sources hierarchy:
// 1. Operating System voices (Windows SAPI, macOS Speech)
// 2. Browser-embedded voices (Google voices in Chrome)
// 3. Cloud-based voices (when available)

// ✅ Browser-native - 0 bytes added to bundle
const utterance = new SpeechSynthesisUtterance(text);
window.speechSynthesis.speak(utterance);

// ❌ External library - adds KB/MB to bundle
import { TextToSpeechSDK } from 'heavy-tts-library';

class TTSController {
  constructor() {
    this.synth = window.speechSynthesis;
    this.voice = null;
    this.setupVoices();
  }
  
  setupVoices() {
    // Asynchronous voice discovery
    this.synth.addEventListener('voiceschanged', () => {
      const voices = this.synth.getVoices();
      this.voice = voices.find(v => v.lang.startsWith('en')) || voices[0];
    });
  }
  
  speak(text) {
    const utterance = new SpeechSynthesisUtterance(text);
    utterance.voice = this.voice;
    utterance.rate = 1.0;
    utterance.pitch = 1.0;
    this.synth.speak(utterance);
  }
}

const recognition = new (window.SpeechRecognition || window.webkitSpeechRecognition)();
recognition.continuous = true;
recognition.interimResults = true;
recognition.onresult = (event) => {
  // Process speech recognition results
};

// Advanced voice selection strategy prioritizing quality and compatibility
class OptimalTTSController {
  constructor() {
    this.synth = window.speechSynthesis;
    this.voice = null;
    this.isNeuralVoiceAvailable = false;
    this.setupVoices();
  }
  
  setupVoices() {
    this.synth.addEventListener('voiceschanged', () => {
      const voices = this.synth.getVoices();
      this.selectOptimalVoice(voices);
    });
    
    // Also call immediately in case voices are already loaded
    const voices = this.synth.getVoices();
    if (voices.length > 0) {
      this.selectOptimalVoice(voices);
    }
  }
  
  selectOptimalVoice(voices) {
    // Neural voice indicators (partial list)
    const neuralIndicators = [
      'neural', 'premium', 'enhanced', 'wavenet', 
      'natural', 'journey', 'alloy', 'echo', 'fable'
    ];
    
    // High-quality voice names to prioritize
    const highQualityVoices = [
      'Google US English', 'Google UK English', 'Microsoft Zira',
      'Microsoft David', 'Alex', 'Samantha', 'Karen', 'Daniel'
    ];
    
    // Selection priority hierarchy
    this.voice = 
      // 1. Neural/Premium voices (Chrome online)
      voices.find(v => 
        v.lang.startsWith('en') && 
        neuralIndicators.some(indicator => 
          v.name.toLowerCase().includes(indicator)
        )
      ) ||
      
      // 2. High-quality named voices
      voices.find(v => 
        v.lang.startsWith('en') && 
        highQualityVoices.some(name => v.name.includes(name))
      ) ||
      
      // 3. Google voices (Chrome)
      voices.find(v => 
        v.lang.startsWith('en') && 
        v.name.includes('Google')
      ) ||
      
      // 4. Microsoft voices (Windows/Edge)
      voices.find(v => 
        v.lang.startsWith('en') && 
        v.name.includes('Microsoft')
      ) ||
      
      // 5. System default English
      voices.find(v => v.lang.startsWith('en') && v.default) ||
      
      // 6. Any English voice
      voices.find(v => v.lang.startsWith('en')) ||
      
      // 7. Fallback to first available
      voices[0];
    
    // Check if we got a neural voice
    this.isNeuralVoiceAvailable = this.voice && 
      neuralIndicators.some(indicator => 
        this.voice.name.toLowerCase().includes(indicator)
      );
    
    console.log(`Selected voice: ${this.voice?.name}, Neural: ${this.isNeuralVoiceAvailable}`);
  }
  
  // Enhanced speak method with quality optimization
  speak(text, options = {}) {
    if (!this.voice) {
      console.warn('No voice available for TTS');
      return;
    }
    
    const utterance = new SpeechSynthesisUtterance(text);
    utterance.voice = this.voice;
    
    // Optimize settings based on voice quality
    if (this.isNeuralVoiceAvailable) {
      // Neural voices: use moderate settings for best quality
      utterance.rate = options.rate || 0.9;
      utterance.pitch = options.pitch || 1.0;
    } else {
      // System voices: slight adjustments for better clarity
      utterance.rate = options.rate || 0.85;
      utterance.pitch = options.pitch || 1.1;
    }
    
    utterance.volume = options.volume || 1.0;
    
    // Enhanced error handling
    utterance.onerror = (event) => {
      console.error('Speech synthesis error:', event.error);
      // Fallback to system default if current voice fails
      if (event.error === 'voice-unavailable') {
        this.fallbackToSystemVoice(text, options);
      }
    };
    
    this.synth.speak(utterance);
  }
  
  fallbackToSystemVoice(text, options) {
    const voices = this.synth.getVoices();
    const systemVoice = voices.find(v => v.default) || voices[0];
    
    if (systemVoice) {
      const utterance = new SpeechSynthesisUtterance(text);
      utterance.voice = systemVoice;
      utterance.rate = options.rate || 0.8;
      utterance.pitch = options.pitch || 1.0;
      utterance.volume = options.volume || 1.0;
      
      this.synth.speak(utterance);
    }
  }
  
  // Voice quality assessment
  getVoiceQuality() {
    if (!this.voice) return 'unavailable';
    
    if (this.isNeuralVoiceAvailable) return 'neural';
    if (this.voice.name.includes('Google')) return 'cloud';
    if (this.voice.name.includes('Microsoft')) return 'system-premium';
    if (this.voice.name.includes('Alex') || this.voice.name.includes('Samantha')) return 'system-high';
    
    return 'system-basic';
  }
  
  // Browser-specific optimizations
  getBrowserOptimizations() {
    const userAgent = navigator.userAgent;
    
    if (userAgent.includes('Chrome')) {
      return {
        preferGoogleVoices: true,
        requiresUserGesture: true,
        supportsBackgroundPlayback: true
      };
    } else if (userAgent.includes('Firefox')) {
      return {
        preferSystemVoices: true,
        requiresUserGesture: false,
        supportsBackgroundPlayback: false
      };
    } else if (userAgent.includes('Safari')) {
      return {
        preferSystemVoices: true,
        requiresUserGesture: true,
        supportsBackgroundPlayback: false,
        limitedPitchControl: true
      };
    }
    
    return {
      preferSystemVoices: true,
      requiresUserGesture: true,
      supportsBackgroundPlayback: false
    };
  }
}

// Usage example with quality prioritization
const tts = new OptimalTTSController();

// Wait for voices to load, then assess quality
setTimeout(() => {
  const quality = tts.getVoiceQuality();
  console.log(`Voice quality level: ${quality}`);
  
  if (quality === 'neural' || quality === 'cloud') {
    console.log('High-quality voice available');
  } else {
    console.log('Using system voice - consider cloud TTS for premium quality');
  }
}, 1000);

const utterance = new SpeechSynthesisUtterance(text);
utterance.voice = selectedVoice;
speechSynthesis.speak(utterance);

const response = await fetch('https://tts-api.com/synthesize', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${apiKey}` },
  body: JSON.stringify({ text, voice: 'neural-en-US' })
});
const audioBlob = await response.blob();

import { speak } from 'speech-synthesis-library';
speak(text, { voice: 'premium', rate: 1.2 });

class HybridTTS {
  async speak(text) {
    if (this.hasHighQualityNativeVoice()) {
      return this.speakNative(text);
    } else if (navigator.onLine) {
      return this.speakCloud(text);
    } else {
      return this.speakNative(text); // Fallback
    }
  }
}

// Priority-based voice selection
1. Neural/Premium voices (Chrome online)
2. High-quality named voices (Google, Microsoft, Alex, Samantha)
3. Google voices (Chrome-specific)
4. Microsoft voices (Windows/Edge)
5. System default English voices
6. Any available English voice
7. Fallback to first available voice

// Real-time voice availability checking
- Validate voice existence before speaking
- Re-select optimal voice if current becomes unavailable
- Multiple fallback voice selection strategies
- Safe parameter validation (rate, pitch, volume)

// Comprehensive error recovery
- synthesis-failed → Automatic fallback voice
- voice-unavailable → Re-selection and retry
- interrupted → User-initiated, continue normally
- Other errors → Skip sentence, continue reading

// Browser-specific timing and resource management
- Chrome: 50ms delays, synthesis queue management
- Firefox: Standard timing, system voice optimization
- Safari: Pitch control limitations, gesture requirements
- Universal: Memory cleanup, background handling

// Automatic voice quality detection
- Neural: Best quality, premium features
- Cloud: High quality, internet-dependent
- System-premium: Good quality, always available
- System-high: Better than basic, reliable
- System-basic: Functional, universal compatibility

// Old Chrome versions - voices loaded synchronously
const voices = speechSynthesis.getVoices(); // Returned populated array immediately
console.log(voices.length); // > 0 on page load

// Modern Chrome - asynchronous voice loading with restrictions
const voices = speechSynthesis.getVoices(); // Returns empty array initially
console.log(voices.length); // 0 until user interaction or async loading completes

// Required pattern for modern Chrome
speechSynthesis.addEventListener('voiceschanged', () => {
  const voices = speechSynthesis.getVoices(); // Now populated
});

// The fundamental Chrome problem
class ChromeVoiceIssue {
  constructor() {
    // ❌ This pattern fails in modern Chrome
    this.voices = speechSynthesis.getVoices(); // Empty array
    this.selectedVoice = this.voices[0]; // undefined
  }
  
  // ✅ Correct Chrome-compatible pattern
  async setupVoices() {
    return new Promise((resolve) => {
      // Strategy 1: Check if already loaded
      let voices = speechSynthesis.getVoices();
      if (voices.length > 0) {
        this.processVoices(voices);
        resolve();
        return;
      }
      
      // Strategy 2: Wait for voiceschanged event
      const handler = () => {
        voices = speechSynthesis.getVoices();
        if (voices.length > 0) {
          speechSynthesis.removeEventListener('voiceschanged', handler);
          this.processVoices(voices);
          resolve();
        }
      };
      speechSynthesis.addEventListener('voiceschanged', handler);
      
      // Strategy 3: Force trigger with user gesture
      if (!this.userGestureTriggered) {
        this.triggerVoiceLoading();
      }
    });
  }
  
  triggerVoiceLoading() {
    // Chrome-specific: empty utterance triggers voice engine initialization
    const utterance = new SpeechSynthesisUtterance('');
    speechSynthesis.speak(utterance);
    speechSynthesis.cancel();
    this.userGestureTriggered = true;
  }
}

// Chrome's voice lifecycle management
class ChromeVoiceLifecycle {
  // Phase 1: Page Load - Voices not loaded
  onPageLoad() {
    console.log(speechSynthesis.getVoices().length); // 0
  }
  
  // Phase 2: User Interaction - Triggers voice loading
  onUserGesture() {
    speechSynthesis.speak(new SpeechSynthesisUtterance('test'));
    // Voices may now begin loading asynchronously
  }
  
  // Phase 3: Voice Discovery - Async population
  onVoicesChanged() {
    const voices = speechSynthesis.getVoices();
    console.log(voices.length); // > 0, voices now available
    
    // ⚠️ Chrome may unload voices during:
    // - Tab backgrounding
    // - Memory pressure
    // - Network disconnection
    // - Extended idle periods
  }
  
  // Phase 4: Voice Validation - Continuous monitoring required
  validateVoice(voice) {
    const currentVoices = speechSynthesis.getVoices();
    return currentVoices.find(v => v.name === voice.name && v.lang === voice.lang);
  }
}

// Simplified Chrome/Blink implementation concept
class SpeechSynthesisController {
  // Voices loaded asynchronously in background thread
  void LoadVoicesAsync() {
    // 1. Query OS speech services (SAPI on Windows, Speech Framework on macOS)
    // 2. Connect to Google TTS services (if authenticated and online)
    // 3. Populate JavaScript-accessible voice array
    // 4. Fire 'voiceschanged' event
  }
  
  // User gesture requirement enforced at engine level
  bool RequiresUserGesture() {
    return !user_activation_state_.HasBeenActive();
  }
}

// Feature policy impacts on speech synthesis
const checkFeaturePolicy = () => {
  // Autoplay policy affects speech synthesis
  const autoplayAllowed = document.featurePolicy?.allowsFeature('autoplay');
  
  // User activation required for speech
  const userActivated = navigator.userActivation?.hasBeenActive;
  
  // Secure context requirement
  const secureContext = window.isSecureContext;
  
  console.log({
    autoplayAllowed,    // May block automatic speech
    userActivated,      // Required for voice loading
    secureContext       // HTTPS required for some voices
  });
};

// Network voice loading flow
class ChromeNetworkVoices {
  async loadNetworkVoices() {
    // 1. Check network connectivity
    if (!navigator.onLine) {
      return this.fallbackToLocalVoices();
    }
    
    // 2. Authenticate with Google services (if signed in)
    const authState = await this.checkGoogleAuth();
    
    // 3. Query available voices from Google TTS API
    const networkVoices = await this.queryGoogleVoices(authState);
    
    // 4. Merge with local system voices
    return [...this.getLocalVoices(), ...networkVoices];
  }
  
  // Network voices have different characteristics
  analyzeVoiceSource(voice) {
    return {
      isLocal: voice.localService === true,
      isNetworkDependent: voice.localService === false,
      quality: this.assessVoiceQuality(voice),
      availability: voice.localService ? 'always' : 'network-dependent'
    };
  }
}

// Voice streaming performance characteristics
const voicePerformanceMetrics = {
  localVoices: {
    latency: '<50ms',           // Immediate processing
    bandwidth: '0KB',           // No network usage
    reliability: '99.9%',       // Always available
    quality: 'basic-to-good'    // Depends on OS
  },
  
  googleVoices: {
    latency: '200-800ms',       // Network + processing time
    bandwidth: '~50KB/sentence', // Streaming audio data
    reliability: '95-98%',      // Network dependent
    quality: 'excellent'        // Neural synthesis
  }
};

class RobustChromeVoiceLoader {
  constructor() {
    this.loadingStrategies = [
      this.immediateCheck.bind(this),
      this.eventListenerStrategy.bind(this),
      this.userGestureTrigger.bind(this),
      this.periodicPolling.bind(this),
      this.fallbackVoice.bind(this)
    ];
  }
  
  async loadVoices() {
    for (const strategy of this.loadingStrategies) {
      try {
        const voices = await strategy();
        if (voices.length > 0) {
          console.log(`Voice loading succeeded with strategy: ${strategy.name}`);
          return voices;
        }
      } catch (error) {
        console.warn(`Strategy ${strategy.name} failed:`, error);
        continue;
      }
    }
    
    throw new Error('All voice loading strategies exhausted');
  }
  
  // Strategy 1: Direct synchronous check
  async immediateCheck() {
    const voices = speechSynthesis.getVoices();
    return voices.length > 0 ? voices : [];
  }
  
  // Strategy 2: Event-driven loading
  async eventListenerStrategy() {
    return new Promise((resolve, reject) => {
      const timeout = setTimeout(() => reject(new Error('Event timeout')), 3000);
      
      const handler = () => {
        clearTimeout(timeout);
        speechSynthesis.removeEventListener('voiceschanged', handler);
        resolve(speechSynthesis.getVoices());
      };
      
      speechSynthesis.addEventListener('voiceschanged', handler);
    });
  }
  
  // Strategy 3: Force trigger with user gesture
  async userGestureTrigger() {
    // Only effective during user interaction
    if (!navigator.userActivation?.hasBeenActive) {
      throw new Error('No user activation available');
    }
    
    const utterance = new SpeechSynthesisUtterance(' ');
    utterance.volume = 0;
    speechSynthesis.speak(utterance);
    speechSynthesis.cancel();
    
    // Wait for voice loading to complete
    await new Promise(resolve => setTimeout(resolve, 500));
    return speechSynthesis.getVoices();
  }
  
  // Strategy 4: Periodic polling with exponential backoff
  async periodicPolling() {
    let attempts = 0;
    const maxAttempts = 10;
    
    while (attempts < maxAttempts) {
      const voices = speechSynthesis.getVoices();
      if (voices.length > 0) return voices;
      
      attempts++;
      const delay = Math.min(100 * Math.pow(2, attempts), 2000);
      await new Promise(resolve => setTimeout(resolve, delay));
    }
    
    throw new Error('Polling timeout exceeded');
  }
  
  // Strategy 5: Fallback to basic synthesis without voice specification
  async fallbackVoice() {
    // Chrome always supports basic synthesis even without voice enumeration
    return [{
      name: 'Chrome Default',
      lang: 'en-US',
      localService: true,
      default: true,
      isFallback: true
    }];
  }
}

class ProductionTTSImplementation {
  async initializeTTS() {
    try {
      // Attempt robust voice loading
      this.voices = await new RobustChromeVoiceLoader().loadVoices();
      this.selectedVoice = this.selectOptimalVoice(this.voices);
      
    } catch (error) {
      // Graceful degradation strategy
      console.error('Voice loading failed, using fallback approach:', error);
      this.enableFallbackMode();
    }
  }
  
  enableFallbackMode() {
    // TTS without voice specification - Chrome always supports this
    this.useFallbackSynthesis = true;
    console.warn('Operating in fallback mode - basic TTS functionality only');
  }
  
  speak(text) {
    const utterance = new SpeechSynthesisUtterance(text);
    
    if (this.useFallbackSynthesis) {
      // Don't specify voice - let Chrome use internal default
      utterance.rate = 0.85;
      utterance.pitch = 0.8;
    } else {
      // Full voice configuration
      utterance.voice = this.selectedVoice;
      this.applyAdvancedSettings(utterance);
    }
    
    speechSynthesis.speak(utterance);
  }
}

// Potential future implementation
class WASMNeuralTTS {
  async initialize() {
    // Load neural TTS model as WebAssembly module
    this.wasmModule = await WebAssembly.instantiateStreaming(
      fetch('/models/neural-tts.wasm')
    );
    
    // High-quality synthesis without network dependency
    this.synthesizer = new this.wasmModule.NeuralSynthesizer();
  }
  
  synthesize(text) {
    // Direct neural synthesis in browser - no voice loading required
    return this.synthesizer.process(text);
  }
}