// ========================================
// VOZ-BACKGROUND-MEJORADO.JS
// Lectura de voz con pantalla apagada
// ========================================

let voces = [];
let isSpeaking = false;
let audioBackground = false;
let currentUtterance = null;
let audioContext = null;
let silentNode = null;
let keepAliveTimer = null;
let textoActual = '';
let callbackActual = null;
let mediaSession = null;
let utteranceEndedNaturally = false;

// 🔹 CARGAR CONFIGURACIÓN
function cargarConfiguracionAudioBackground() {
  const configuracion = localStorage.getItem('lecturaConPantallaApagada');
  audioBackground = configuracion === 'true' || configuracion === true;
  console.log('📱 Audio en segundo plano:', audioBackground ? 'HABILITADO' : 'DESHABILITADO');
}

// 🔹 CARGAR VOCES
function cargarVoces() {
  const vocesDisponibles = speechSynthesis.getVoices();
  voces = vocesDisponibles.filter(v => v.lang.startsWith('es'));
  
  console.log('🔊 Voces disponibles:', vocesDisponibles.length);
  console.log('🇪🇸 Voces en español:', voces.length);
  
  if (voces.length === 0 && vocesDisponibles.length > 0) {
    voces = [vocesDisponibles[0]];
    console.warn('⚠️ Usando voz predeterminada');
  }
}

// 🔹 CREAR AUDIO SILENCIOSO PARA MANTENER CONTEXTO ACTIVO
function crearAudioSilencioso() {
  if (!audioBackground || audioContext) return;
  
  try {
    audioContext = new (window.AudioContext || window.webkitAudioContext)();
    
    // Crear oscilador ultrasónico (inaudible)
    const oscillator = audioContext.createOscillator();
    const gainNode = audioContext.createGain();
    
    oscillator.connect(gainNode);
    gainNode.connect(audioContext.destination);
    
    // Frecuencia ultrasónica (inaudible para humanos)
    oscillator.frequency.setValueAtTime(22000, audioContext.currentTime);
    // Volumen extremadamente bajo
    gainNode.gain.setValueAtTime(0.0001, audioContext.currentTime);
    
    oscillator.start();
    silentNode = oscillator;
    
    console.log('🎵 Audio silencioso creado para mantener contexto activo');
  } catch (e) {
    console.warn('⚠️ No se pudo crear audio silencioso:', e);
  }
}

// 🔹 DESTRUIR AUDIO SILENCIOSO
function destruirAudioSilencioso() {
  if (silentNode) {
    try {
      silentNode.stop();
      silentNode.disconnect();
      silentNode = null;
    } catch (e) {
      console.warn('⚠️ Error al detener audio silencioso:', e);
    }
  }
  
  if (audioContext) {
    try {
      audioContext.close();
      audioContext = null;
    } catch (e) {
      console.warn('⚠️ Error al cerrar contexto de audio:', e);
    }
  }
}

// 🔹 CONFIGURAR MEDIA SESSION API (para controles de bloqueo de pantalla)
function configurarMediaSession(textoActual) {
  if (!audioBackground || !('mediaSession' in navigator)) {
    console.log('⚠️ Media Session API no disponible');
    return;
  }
  
  try {
    // Configurar metadata para que aparezca en los controles de bloqueo
    navigator.mediaSession.metadata = new MediaMetadata({
      title: 'Simulador AscensoFacil',
      artist: 'Lectura de Preguntas',
      album: 'Material de Estudio',
      artwork: [
        { src: 'iconos/audio.png', sizes: '96x96', type: 'image/png' },
        { src: 'iconos/audio.png', sizes: '128x128', type: 'image/png' },
        { src: 'iconos/audio.png', sizes: '256x256', type: 'image/png' }
      ]
    });
    
    // Configurar handlers para controles de reproducción
    navigator.mediaSession.setActionHandler('play', () => {
      if (window.speechSynthesis.paused) {
        window.speechSynthesis.resume();
        console.log('▶️ Reproducción reanudada desde controles');
      }
    });
    
    navigator.mediaSession.setActionHandler('pause', () => {
      if (window.speechSynthesis.speaking) {
        window.speechSynthesis.pause();
        console.log('⏸️ Reproducción pausada desde controles');
      }
    });
    
    navigator.mediaSession.setActionHandler('stop', () => {
      detenerLectura();
      console.log('⏹️ Reproducción detenida desde controles');
    });
    
    // Estado de reproducción
    navigator.mediaSession.playbackState = 'playing';
    
    console.log('🎮 Media Session configurado');
    mediaSession = true;
  } catch (e) {
    console.warn('⚠️ Error al configurar Media Session:', e);
  }
}

// 🔹 LIMPIAR MEDIA SESSION
function limpiarMediaSession() {
  if (!mediaSession || !('mediaSession' in navigator)) return;
  
  try {
    navigator.mediaSession.playbackState = 'none';
    navigator.mediaSession.metadata = null;
    mediaSession = false;
    console.log('🎮 Media Session limpiado');
  } catch (e) {
    console.warn('⚠️ Error al limpiar Media Session:', e);
  }
}

// 🔹 KEEP-ALIVE MEJORADO: Solo actúa cuando la síntesis se detiene inesperadamente
function iniciarKeepAlive() {
  if (!audioBackground || keepAliveTimer) return;
  
  keepAliveTimer = setInterval(() => {
    // Solo actuar si hay un utterance activo
    if (!currentUtterance) return;
    
    // Verificar si el speechSynthesis se detuvo inesperadamente
    if (!window.speechSynthesis.speaking && !window.speechSynthesis.pending && !utteranceEndedNaturally) {
      console.log('⚠️ Síntesis se detuvo inesperadamente, reiniciando...');
      reiniciarLectura();
    }
    // Si está pausado, intentar reanudar (solo en modo background)
    else if (window.speechSynthesis.paused && document.visibilityState === 'hidden') {
      console.log('▶️ Reanudando síntesis pausada en background');
      window.speechSynthesis.resume();
    }
  }, 15000); // Cada 15 segundos (menos agresivo para evitar interrupciones)
  
  console.log('⏰ Keep-alive iniciado (cada 15 segundos)');
}

// 🔹 DETENER KEEP-ALIVE
function detenerKeepAlive() {
  if (keepAliveTimer) {
    clearInterval(keepAliveTimer);
    keepAliveTimer = null;
    console.log('⏰ Keep-alive detenido');
  }
}

// 🔹 MANEJAR VISIBILIDAD DE LA PÁGINA (cuando pantalla se apaga/bloquea)
function configurarManejadorVisibilidad() {
  if (!audioBackground) return;
  
  document.addEventListener('visibilitychange', () => {
    if (document.visibilityState === 'hidden') {
      console.log('📴 Página oculta/Pantalla apagada - manteniendo audio activo');
      
      // Crear audio silencioso si no existe (mantiene contexto activo)
      if (currentUtterance && !audioContext) {
        crearAudioSilencioso();
      }
    } else if (document.visibilityState === 'visible') {
      console.log('📱 Página visible/Pantalla encendida');
      
      // Verificar si la síntesis se detuvo mientras estaba oculta
      if (currentUtterance && !window.speechSynthesis.speaking && !window.speechSynthesis.paused && !utteranceEndedNaturally) {
        console.log('⚠️ Síntesis se detuvo mientras pantalla estaba apagada, reiniciando...');
        reiniciarLectura();
      }
    }
  });
  
  console.log('👁️ Manejador de visibilidad configurado');
}

// 🔹 REINICIAR LECTURA (cuando se detecta que se detuvo)
function reiniciarLectura() {
  if (!textoActual || !currentUtterance || utteranceEndedNaturally) return;
  
  console.log('🔄 Reiniciando lectura...');
  
  // Cancelar utterance anterior
  window.speechSynthesis.cancel();
  
  // Pequeño delay antes de reiniciar
  setTimeout(() => {
    if (textoActual && !utteranceEndedNaturally) {
      leerTexto(textoActual, callbackActual);
    }
  }, 500);
}

// 🔹 FUNCIÓN PRINCIPAL: LEER TEXTO
function leerTexto(texto, callback = null) {
  if (!voces.length) cargarVoces();

  if (voces.length === 0) {
    console.error('❌ No hay voces disponibles');
    if (typeof callback === 'function') callback();
    return;
  }

  // Guardar para posible reinicio
  textoActual = texto;
  callbackActual = callback;
  utteranceEndedNaturally = false;

  // Cancelar lectura anterior
  if (currentUtterance) {
    window.speechSynthesis.cancel();
    currentUtterance = null;
  }

  currentUtterance = new SpeechSynthesisUtterance(texto);

  // Seleccionar voz preferida
  const vozPreferida = localStorage.getItem('vozPreferida');
  const vozSeleccionada = voces.find(v => v.name === vozPreferida) || voces[0];
  currentUtterance.voice = vozSeleccionada;

  // Configuración optimizada
  currentUtterance.rate = 1.0;
  currentUtterance.pitch = 1.0;
  currentUtterance.volume = 1.0;

  console.log('🎤 Voz seleccionada:', vozSeleccionada?.name || 'Predeterminada');

  currentUtterance.onstart = () => {
    console.log('▶️ Lectura iniciada');
    isSpeaking = true;
    utteranceEndedNaturally = false;
    
    if (audioBackground) {
      crearAudioSilencioso();
      iniciarKeepAlive();
      configurarMediaSession(texto);
    }
  };

  currentUtterance.onend = () => {
    console.log('⏹️ Lectura finalizada normalmente');
    utteranceEndedNaturally = true;
    isSpeaking = false;
    currentUtterance = null;
    textoActual = '';
    callbackActual = null;
    
    if (audioBackground) {
      destruirAudioSilencioso();
      detenerKeepAlive();
      limpiarMediaSession();
    }
    
    if (typeof callback === 'function') callback();
  };

  currentUtterance.onerror = (e) => {
    console.error('❌ Error en síntesis de voz:', e.error);
    
    // Solo reintentar si NO fue cancelado manualmente y está en modo background
    if (audioBackground && e.error !== 'interrupted' && e.error !== 'canceled' && !utteranceEndedNaturally) {
      console.log('🔄 Error recuperable, reintentando en 1 segundo...');
      utteranceEndedNaturally = false;
      setTimeout(() => {
        if (textoActual && !utteranceEndedNaturally) {
          reiniciarLectura();
        }
      }, 1000);
      return;
    }
    
    // Limpiar estado
    utteranceEndedNaturally = true;
    isSpeaking = false;
    currentUtterance = null;
    textoActual = '';
    callbackActual = null;
    
    if (audioBackground) {
      destruirAudioSilencioso();
      detenerKeepAlive();
      limpiarMediaSession();
    }
    
    if (typeof callback === 'function') callback();
  };

  // Cancelar cualquier síntesis pendiente
  window.speechSynthesis.cancel();
  
  // Delay más corto para mejor respuesta
  setTimeout(() => {
    if (currentUtterance) {
      window.speechSynthesis.speak(currentUtterance);
    }
  }, 50);
}

// 🔹 DETENER LECTURA COMPLETAMENTE
function detenerLectura() {
  console.log('🛑 Deteniendo lectura completa');
  
  utteranceEndedNaturally = true;
  textoActual = '';
  callbackActual = null;
  
  if (currentUtterance) {
    currentUtterance.onend = null;
    currentUtterance.onerror = null;
    currentUtterance = null;
  }
  
  window.speechSynthesis.cancel();
  isSpeaking = false;
  
  destruirAudioSilencioso();
  detenerKeepAlive();
  limpiarMediaSession();
}

// 🔹 VERIFICAR ESTADO DE SÍNTESIS (para debugging)
function verificarEstadoSintesis() {
  console.log('📊 Estado de síntesis:');
  console.log('- Speaking:', window.speechSynthesis.speaking);
  console.log('- Pending:', window.speechSynthesis.pending);
  console.log('- Paused:', window.speechSynthesis.paused);
  console.log('- isSpeaking:', isSpeaking);
  console.log('- Audio background:', audioBackground);
  console.log('- CurrentUtterance:', currentUtterance ? 'Existe' : 'null');
  console.log('- AudioContext:', audioContext ? 'Activo' : 'null');
  console.log('- Media Session:', mediaSession ? 'Configurado' : 'null');
  console.log('- Utterance ended naturally:', utteranceEndedNaturally);
}

// 🔹 INICIALIZACIÓN
function inicializarVoz() {
  cargarConfiguracionAudioBackground();
  
  if (audioBackground) {
    configurarManejadorVisibilidad();
    
    console.log('🔋 Modo ahorro de energía: La pantalla puede apagarse');
    console.log('🔊 El audio continuará reproduciéndose en segundo plano');
  }
  
  // Escuchar cambios desde otras pestañas
  window.addEventListener('storage', (e) => {
    if (e.key === 'lecturaConPantallaApagada') {
      const anteriorEstado = audioBackground;
      cargarConfiguracionAudioBackground();
      
      if (anteriorEstado !== audioBackground) {
        console.log('🔄 Configuración actualizada desde otra pestaña');
        
        if (audioBackground && isSpeaking) {
          configurarManejadorVisibilidad();
          crearAudioSilencioso();
          iniciarKeepAlive();
          configurarMediaSession(textoActual);
        } else if (!audioBackground) {
          destruirAudioSilencioso();
          detenerKeepAlive();
          limpiarMediaSession();
        }
      }
    }
  });
  
  // Limpiar al cerrar/salir
  window.addEventListener('beforeunload', () => {
    detenerLectura();
  });
  
  window.addEventListener('pagehide', () => {
    if (!audioBackground) {
      detenerLectura();
    }
  });
}

// 🔹 CARGAR VOCES AL INICIO
if (window.speechSynthesis.onvoiceschanged !== undefined) {
  window.speechSynthesis.onvoiceschanged = cargarVoces;
}

cargarVoces();
setTimeout(cargarVoces, 500);
inicializarVoz();

// Exponer función de verificación en consola
window.verificarEstadoSintesis = verificarEstadoSintesis;

console.log('✅ voz-background-mejorado.js cargado correctamente');
console.log('🔋 Pantalla puede apagarse - Audio continúa en segundo plano');
console.log('💡 Usa verificarEstadoSintesis() en consola para debugging');