/**
 * assets/js/sincronizacion.js
 * Sistema Global de Sincronización en Tiempo Real (SSE)
 * Se encarga de escuchar eventos del servidor y despacharlos a la interfaz.
 */

class SincronizacionTiempoReal {
    constructor() {
        this.eventSource = null;
        this.lastEventId = 0;
        this.reconnectTimeout = null;
        this.reconnectAttempts = 0;
        this.maxReconnectDelay = 30000; // Máximo 30 segundos
        
        // Iniciar conexión
        this.connect();
    }
    
    connect() {
        // Cerrar si ya existe
        if (this.eventSource) {
            this.eventSource.close();
        }
        
        console.log('🔄 Iniciando conexión de sincronización de datos...');
        
        // Usar EventSource nativo del navegador para SSE
        const url = `api/sync/escuchar_eventos.php?lastEventId=${this.lastEventId}`;
        this.eventSource = new EventSource(url);
        
        // Manejar conexión exitosa
        this.eventSource.onopen = () => {
            console.log('✅ Conectado al servidor de sincronización en tiempo real');
            this.reconnectAttempts = 0;
        };
        
        // === ESCUCHAR EVENTOS ESPECÍFICOS ===
        
        // 1. Stock Actualizado (Por Venta, Traslado, Ingreso)
        this.eventSource.addEventListener('STOCK_ACTUALIZADO', (e) => {
            try {
                const data = JSON.parse(e.data);
                console.log('📡 Evento STOCK_ACTUALIZADO recibido:', data);
                this.lastEventId = data.id;
                
                // Disparar evento personalizado en el DOM para que pos.js, ingresos.js, etc., lo escuchen
                document.dispatchEvent(new CustomEvent('sync:stock_actualizado', { 
                    detail: { productoId: data.producto_id } 
                }));
            } catch (err) {
                console.error('Error parseando evento de stock:', err);
            }
        });
        
        // 2. Nueva Venta (Para actualizar los totales del Header sin recargar)
        this.eventSource.addEventListener('NUEVA_VENTA', (e) => {
            try {
                const data = JSON.parse(e.data);
                console.log('📡 Evento NUEVA_VENTA recibido:', data);
                this.lastEventId = data.id;
                
                document.dispatchEvent(new CustomEvent('sync:nueva_venta'));
            } catch (err) {
                console.error('Error parseando evento de venta:', err);
            }
        });
        
        // 3. Nuevo Ingreso/Traslado
        this.eventSource.addEventListener('NUEVO_MOVIMIENTO', (e) => {
            try {
                const data = JSON.parse(e.data);
                this.lastEventId = data.id;
                
                document.dispatchEvent(new CustomEvent('sync:nuevo_movimiento', {
                    detail: { tipo: data.payload?.tipo }
                }));
            } catch (err) {
                console.error('Error parseando evento de movimiento:', err);
            }
        });
        
        // Manejo de errores y reconexión
        this.eventSource.onerror = (error) => {
            console.warn('⚠️ Desconectado del servidor de sincronización.');
            this.eventSource.close();
            this.scheduleReconnect();
        };
    }
    
    scheduleReconnect() {
        if (this.reconnectTimeout) {
            clearTimeout(this.reconnectTimeout);
        }
        
        this.reconnectAttempts++;
        // Retroceso exponencial (1s, 2s, 4s, 8s...) hasta el máximo
        let delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), this.maxReconnectDelay);
        
        console.log(`Intentando reconectar en ${delay/1000} segundos...`);
        this.reconnectTimeout = setTimeout(() => {
            this.connect();
        }, delay);
    }
}

// Inicializar globalmente cuando el DOM esté listo
document.addEventListener('DOMContentLoaded', () => {
    // Si el navegador soporta Server-Sent Events
    if (typeof(EventSource) !== "undefined") {
        window.sincronizador = new SincronizacionTiempoReal();
    } else {
        console.warn("Este navegador no soporta Server-Sent Events. El tiempo real no funcionará.");
    }

    // Iniciar intento de sincronización en background
    if (navigator.onLine) {
        setTimeout(triggerBackgroundSync, 5000);
    }
});

// === LÓGICA DE SINCRONIZACIÓN OFFLINE (Background Sync) ===
window.triggerBackgroundSync = async function() {
    if (!window.OfflineDB || !navigator.onLine) return;

    try {
        const pendientes = await window.OfflineDB.obtenerVentasPendientes();
        if (pendientes.length === 0) return;

        console.log(`📡 Sincronizando ${pendientes.length} ventas offline...`);
        if (typeof pos !== 'undefined' && pos.showToast) {
            pos.showToast(`↻ Sincronizando ${pendientes.length} ventas locales con el servidor...`, 'info');
        }

        for (const venta of pendientes) {
            try {
                const response = await fetch('api/ventas/crear.php', {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify(venta)
                });

                const result = await response.json();

                if (result.success) {
                    await window.OfflineDB.borrarVentaSincronizada(venta.id);
                    console.log(`✅ Venta offline #${venta.id} sincronizada al servidor.`);
                } else {
                    console.error(`❌ Falló la sincronización de la venta #${venta.id}:`, result.error);
                }
            } catch (err) {
                console.error(`❌ Error de red sincronizando venta #${venta.id}:`, err);
            }
        }
        
        const restantes = await window.OfflineDB.contarVentasPendientes();
        if (restantes === 0 && typeof pos !== 'undefined' && pos.showToast) {
            pos.showToast('✅ Todas las ventas offline fueron sincronizadas', 'success');
            if(pos.loadProducts) pos.loadProducts();
            if(pos.loadSalesSummary) pos.loadSalesSummary();
        }
    } catch (error) {
        console.error('Error en triggerBackgroundSync:', error);
    }
}

window.addEventListener('online', () => {
    console.log('🌐 Conexión restaurada. Intentando sincronizar...');
    if (typeof pos !== 'undefined' && pos.showToast) {
        pos.showToast('🌐 Conexión de Internet restaurada', 'success');
    }
    triggerBackgroundSync();
});

window.addEventListener('offline', () => {
    console.log('🚫 Conexión perdida. Cambiando a Modo Offline...');
    if (typeof pos !== 'undefined' && pos.showToast) {
        pos.showToast('🚫 Sin conexión. Usando modo Offline seguro', 'error');
    }
});
