<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Portal del Consolidador - Ríos de Agua Viva</title>
    <!-- Tailwind CSS para diseño moderno -->
    <script src="https://cdn.tailwindcss.com"></script>
    <!-- Iconos Lucide -->
    <script src="https://unpkg.com/lucide@latest"></script>
    <!-- Firebase Compat SDK (Compatible con Divi/WordPress) -->
    <script src="https://www.gstatic.com/firebasejs/10.8.0/firebase-app-compat.js"></script>
    <script src="https://www.gstatic.com/firebasejs/10.8.0/firebase-firestore-compat.js"></script>
    <style>
        @import url('https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@300;400;500;600;700&display=swap');
        body { font-family: 'Plus Jakarta Sans', sans-serif; }
    </style>
</head>
<body class="bg-slate-50 text-slate-800 min-h-screen">

    <!-- BARRA DE RED SUPERIOR -->
    <div id="conn-bar" class="bg-slate-900 text-white text-[11px] font-semibold py-1.5 px-4 flex justify-between items-center">
        <span class="flex items-center gap-1.5">
            <span class="w-1.5 h-1.5 rounded-full bg-amber-400 animate-ping"></span>
            <span>Estableciendo conexión segura...</span>
        </span>
        <span class="opacity-60">RÍOS DE AGUA VIVA</span>
    </div>

    <!-- PANTALLA 1: ACCESO POR PIN -->
    <div id="login-container" class="max-w-md mx-auto px-4 py-16 flex flex-col justify-center min-h-[80vh]">
        <div class="bg-white p-8 rounded-3xl shadow-xl border border-slate-100 text-center space-y-6">
            <div class="w-16 h-16 bg-indigo-50 text-indigo-600 rounded-2xl flex items-center justify-center mx-auto">
                <i data-lucide="key-round" class="w-8 h-8"></i>
            </div>
            <div>
                <h2 class="font-bold text-2xl text-slate-900">Acceso Líder</h2>
                <p class="text-sm text-slate-500 mt-1">Escribe tu PIN de 4 dígitos para acceder a tus asignaciones</p>
            </div>

            <form id="form-login" onsubmit="window.intentarLogin(event)" class="space-y-4">
                <input type="password" id="input-pin" required maxlength="4" pattern="[0-9]{4}" placeholder="0000" class="w-full text-center tracking-[1.5em] text-2xl font-bold py-3 border border-slate-200 rounded-2xl focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500 bg-slate-50">
                <button type="submit" class="w-full py-3.5 bg-indigo-600 hover:bg-indigo-700 text-white font-semibold rounded-2xl shadow-lg shadow-indigo-100 transition">
                    Ver mis creyentes
                </button>
            </form>
            <p id="error-login" class="text-xs text-rose-600 font-bold hidden">PIN Incorrecto. Por favor verifica con el administrador.</p>
        </div>
    </div>

    <!-- PANTALLA 2: DASHBOARD -->
    <div id="dashboard-container" class="max-w-4xl mx-auto px-4 py-8 hidden space-y-6">
        <header class="bg-white p-6 rounded-3xl shadow-sm border border-slate-100 flex justify-between items-center">
            <div class="flex items-center gap-3">
                <div class="p-2.5 bg-indigo-50 text-indigo-600 rounded-2xl"><i data-lucide="heart" class="w-6 h-6"></i></div>
                <div>
                    <h2 class="font-bold text-lg text-slate-900" id="lider-nombre">Cargando líder...</h2>
                    <span class="text-xs text-emerald-600 font-bold tracking-wider uppercase flex items-center gap-1">
                        <span class="w-2 h-2 rounded-full bg-emerald-500"></span> Consolidador Ríos de Agua Viva
                    </span>
                </div>
            </div>
            <button onclick="window.logout()" class="p-2 text-slate-400 hover:text-slate-600 hover:bg-slate-50 rounded-xl transition"><i data-lucide="log-out" class="w-5 h-5"></i></button>
        </header>

        <!-- Indicador rápido -->
        <div class="bg-indigo-900 text-white p-6 rounded-3xl shadow-lg relative overflow-hidden">
            <div class="absolute right-0 top-0 bottom-0 opacity-10 flex items-center justify-center p-8"><i data-lucide="sparkles" class="w-48 h-48"></i></div>
            <div class="relative z-10 space-y-1">
                <p class="text-xs text-indigo-200 uppercase tracking-widest font-bold">Resumen de Cuidado</p>
                <h3 class="text-3xl font-black" id="count-asignados">0</h3>
                <p class="text-xs text-indigo-100">Personas asignadas bajo tu tutoría espiritual</p>
            </div>
        </div>

        <div class="space-y-4">
            <h3 class="font-bold text-lg text-slate-800 flex items-center gap-1.5"><i data-lucide="user-check" class="text-indigo-600 w-5 h-5"></i> Personas Asignadas</h3>
            <div id="grid-creyentes" class="grid grid-cols-1 md:grid-cols-2 gap-6"></div>
        </div>
    </div>

    <!-- MODAL: REPORTAR PROGRESO -->
    <div id="modal-reportar" class="fixed inset-0 bg-slate-900/40 backdrop-blur-sm z-50 flex items-center justify-center hidden p-4">
        <div class="bg-white rounded-3xl shadow-xl border border-slate-100 max-w-lg w-full overflow-hidden">
            <div class="p-6 border-b border-slate-100 flex justify-between items-center bg-slate-50/50">
                <div>
                    <h3 class="font-bold text-lg text-slate-900" id="modal-title-persona">Reportar Avance</h3>
                    <p class="text-xs text-slate-500">Registra el día exacto en que avanzó la persona</p>
                </div>
                <button onclick="window.cerrarModalReportar()" class="text-slate-400 hover:text-slate-600"><i data-lucide="x" class="w-5 h-5"></i></button>
            </div>
            <div class="p-6 space-y-6 max-h-[60vh] overflow-y-auto">
                <div class="space-y-6">
                    <div class="space-y-2">
                        <p class="text-xs font-black uppercase tracking-wider text-indigo-600 flex items-center gap-1">🕊️ Semana 1: NPT (Días 1-3) y LBS (Días 4-7)</p>
                        <div class="grid grid-cols-1 gap-2" id="grid-semana1"></div>
                    </div>
                    <div class="space-y-2">
                        <p class="text-xs font-black uppercase tracking-wider text-emerald-600 flex items-center gap-1">🙌 Semana 2: LBS (Días 8-14)</p>
                        <div class="grid grid-cols-1 gap-2" id="grid-semana2"></div>
                    </div>
                    <div class="space-y-2">
                        <p class="text-xs font-black uppercase tracking-wider text-amber-600 flex items-center gap-1">💖 Semana 3: LBS (Días 15-21)</p>
                        <div class="grid grid-cols-1 gap-2" id="grid-semana3"></div>
                    </div>
                </div>

                <div class="border-t border-slate-100 pt-4 space-y-2">
                    <label class="block text-xs font-bold text-slate-500 uppercase">Observación / Nota sobre este avance</label>
                    <textarea id="modal-nota" rows="2" placeholder="Escribe detalles del avance de hoy..." class="w-full px-4 py-2.5 text-sm border border-slate-200 rounded-2xl focus:outline-none focus:ring-2 focus:ring-indigo-500 bg-slate-50"></textarea>
                </div>
            </div>
            <div class="p-6 border-t border-slate-100 flex justify-end gap-2 bg-slate-50/50">
                <button onclick="window.cerrarModalReportar()" class="px-4 py-2.5 text-slate-500 hover:text-slate-700 text-sm font-semibold">Cancelar</button>
                <button onclick="window.procesarReporte()" class="px-5 py-2.5 bg-indigo-600 hover:bg-indigo-700 text-white rounded-2xl text-sm font-semibold shadow-lg shadow-indigo-100 transition">Guardar Avance</button>
            </div>
        </div>
    </div>

    <!-- MODAL NOTIFICACIONES -->
    <div id="modal-notif" class="fixed inset-0 bg-slate-900/30 backdrop-blur-xs z-[100] flex items-center justify-center hidden p-4">
        <div class="bg-white rounded-3xl shadow-xl border border-slate-100 max-w-sm w-full p-6 text-center space-y-4">
            <div id="notif-icon" class="w-12 h-12 bg-indigo-50 text-indigo-600 rounded-full flex items-center justify-center mx-auto"></div>
            <div>
                <h3 id="notif-title" class="font-bold text-lg text-slate-900">Mensaje</h3>
                <p id="notif-text" class="text-sm text-slate-500 mt-1">Detalles...</p>
            </div>
            <button onclick="window.cerrarNotif()" class="w-full py-2.5 bg-slate-900 hover:bg-slate-800 text-white rounded-2xl text-sm font-semibold transition">Entendido</button>
        </div>
    </div>

    <!-- ==================== LÓGICA DE PROGRAMACIÓN ==================== -->
    <script>
        var firebaseConfig = {
            apiKey: "AIzaSyBhHWcL0FbUwA1RVbHsvSy93u0VbajFerc",
            authDomain: "consolidacion-1183d.firebaseapp.com",
            projectId: "consolidacion-1183d",
            storageBucket: "consolidacion-1183d.firebasestorage.app",
            messagingSenderId: "595918754239",
            appId: "1:595918754239:web:372c5ba166abd8190c510a",
            measurementId: "G-N2S9N78ELE"
        };

        var DEVOCIONAL_DIAS = [
            { dia: 1, semana: 1, titulo: "Quebrantando la Maldición de la Tierra" },
            { dia: 2, semana: 1, titulo: "Rompiendo Pactos de Oscuridad" },
            { dia: 3, semana: 1, titulo: "Quebrantando la Maldición de la Parentela" },
            { dia: 4, semana: 1, titulo: "Sanando las Heridas del Rechazo" },
            { dia: 5, semana: 1, titulo: "Libertad de Vicios y Ataduras" },
            { dia: 6, semana: 1, titulo: "Renunciando al Espíritu de Orfandad" },
            { dia: 7, semana: 1, titulo: "Estableciendo Altares de Adoración" },
            { dia: 8, semana: 2, titulo: "Abriendo las Puertas de los Cielos" },
            { dia: 9, semana: 2, titulo: "El Poder de la Semilla y la Honra" },
            { dia: 10, semana: 2, titulo: "Desatando la Doble Porción" },
            { dia: 11, semana: 2, titulo: "La Identidad de un Hijo Bendito" },
            { dia: 12, semana: 2, titulo: "Conquistando tus Promesas" },
            { dia: 13, semana: 2, titulo: "La Gracia Divina sobre tu Familia" },
            { dia: 14, semana: 2, titulo: "Poseyendo las Puertas de tus Enemigos" },
            { dia: 15, semana: 3, titulo: "Sanando el Corazón Quebrantado" },
            { dia: 16, semana: 3, titulo: "El Poder del Perdón y la Reconciliación" },
            { dia: 17, semana: 3, titulo: "Arrancando Raíces de Amargura" },
            { dia: 18, semana: 3, titulo: "Restaurando la Autoestima en Dios" },
            { dia: 19, semana: 3, titulo: "Sanando las Emociones Dañadas" },
            { dia: 20, semana: 3, titulo: "La Paz que Sobrepasa todo Entendimiento" },
            { dia: 21, semana: 3, titulo: "Coronados de Misericordia y Favor" }
        ];

        firebase.initializeApp(firebaseConfig);
        var db = firebase.firestore();

        var consolidadorActivo = null;
        var misAsignados = [];
        var idPersonaReportar = null;
        var diaSeleccionado = null;
        var desvincularEscuchadorLider = null;

        window.showAlert = function(title, text, type) {
            var modal = document.getElementById('modal-notif');
            var icon = document.getElementById('notif-icon');
            document.getElementById('notif-title').innerText = title;
            document.getElementById('notif-text').innerText = text;

            if (type === 'success') {
                icon.className = "w-12 h-12 bg-emerald-50 text-emerald-600 rounded-full flex items-center justify-center mx-auto";
                icon.innerHTML = '<i data-lucide="check" class="w-6 h-6"></i>';
            } else if (type === 'error') {
                icon.className = "w-12 h-12 bg-rose-50 text-rose-600 rounded-full flex items-center justify-center mx-auto";
                icon.innerHTML = '<i data-lucide="alert-triangle" class="w-6 h-6"></i>';
            } else {
                icon.className = "w-12 h-12 bg-indigo-50 text-indigo-600 rounded-full flex items-center justify-center mx-auto";
                icon.innerHTML = '<i data-lucide="info" class="w-6 h-6"></i>';
            }
            modal.classList.remove('hidden');
            lucide.createIcons();
        };

        window.cerrarNotif = function() { document.getElementById('modal-notif').classList.add('hidden'); };

        // VALIDAR PIN Y ESCUCHAR LIDER
        window.intentarLogin = function(e) {
            e.preventDefault();
            var pin = document.getElementById('input-pin').value.trim();
            if (pin.length !== 4) return;

            db.collection('consolidadores').where('pin', '==', pin).get().then(function(snapshot) {
                if (snapshot.empty) {
                    document.getElementById('error-login').classList.remove('hidden');
                } else {
                    var idEncontrado = "";
                    snapshot.forEach(function(doc) { idEncontrado = doc.id; });
                    document.getElementById('error-login').classList.add('hidden');
                    
                    if (desvincularEscuchadorLider) desvincularEscuchadorLider();
                    desvincularEscuchadorLider = db.collection('consolidadores').doc(idEncontrado).onSnapshot(function(docSnap) {
                        if (!docSnap.exists) {
                            window.logout();
                            window.showAlert("Sesión Cerrada", "Tu cuenta de consolidador ha sido desvinculada por administración.", "error");
                            return;
                        }
                        consolidadorActivo = docSnap.data();
                        consolidadorActivo.id = docSnap.id;
                        document.getElementById('lider-nombre').innerText = "Hola, " + consolidadorActivo.nombre;
                    });

                    document.getElementById('login-container').classList.add('hidden');
                    document.getElementById('dashboard-container').classList.remove('hidden');
                    conectarCreyentes(idEncontrado);
                }
            }).catch(function(err) {
                window.showAlert("Error de conexión", "Firestore denegó la consulta.", "error");
            });
        };

        function conectarCreyentes(liderId) {
            db.collection('nuevos_creyentes')
              .where('consolidador_id', '==', liderId)
              .onSnapshot(function(snapshot) {
                  misAsignados = [];
                  snapshot.forEach(function(doc) {
                      var data = doc.data(); data.id = doc.id; misAsignados.push(data);
                  });
                  document.getElementById('count-asignados').innerText = misAsignados.length;
                  renderTarjetasCreyentes();
              });
        }

        function renderTarjetasCreyentes() {
            var container = document.getElementById('grid-creyentes');
            container.innerHTML = '';

            if (misAsignados.length === 0) {
                container.innerHTML = '<div class="col-span-full py-8 text-center text-slate-400 font-medium">Aún no tienes nuevos creyentes asignados.</div>';
                return;
            }

            misAsignados.forEach(function(c) {
                var card = document.createElement('div');
                card.className = "bg-white p-6 rounded-3xl shadow-sm border border-slate-100 space-y-4 flex flex-col justify-between";

                var progreso = c.dia_devocional || 0;
                var infoDia = "Por iniciar";
                if (progreso > 0 && progreso <= 21) {
                    var objDia = DEVOCIONAL_DIAS.find(function(d) { return d.dia === progreso; });
                    if (objDia) {
                        var tipoLabel = progreso <= 3 ? "NPT - " : "LBS - ";
                        infoDia = tipoLabel + "Día " + progreso + " - " + objDia.titulo;
                    }
                }

                var fTel = (c.telefono || '').replace(/\D/g, '');
                var linkWaContacto = "https://wa.me/" + fTel + "?text=" + encodeURIComponent("¡Hola " + c.nombre + "! Te saludo de parte del ministerio Ríos de Agua Viva...");

                var proximoDia = progreso + 1;
                if (proximoDia > 21) proximoDia = 21;

                var tipoProximo = proximoDia <= 3 ? "NPT" : "LBS";

                card.innerHTML = [
                    '<div><div class="flex justify-between items-start"><div><h4 class="font-bold text-base text-slate-900">' + c.nombre + '</h4><p class="text-xs text-slate-400">Edad: ' + (c.edad || 'N/R') + ' | Género: ' + (c.sexo || 'N/R') + '</p></div><a href="' + linkWaContacto + '" target="_blank" class="p-2 bg-emerald-50 text-emerald-600 rounded-full hover:bg-emerald-100 transition"><i data-lucide="message-circle" class="w-5 h-5"></i></a></div><p class="text-xs text-slate-500 mt-2 bg-slate-50 p-2 rounded-xl border border-slate-100 truncate">Nota inicial: ' + (c.observaciones_adicionales || 'Ninguna') + '</p></div>',
                    '<div class="space-y-1.5 pt-2"><div class="flex justify-between text-xs font-bold text-indigo-600"><span>Progreso Devocional</span><span>' + progreso + '/21 Días</span></div><p class="text-[10px] text-slate-400 font-medium truncate" title="' + infoDia + '">' + infoDia + '</p><div class="w-full bg-slate-100 rounded-full h-2"><div class="bg-indigo-600 h-2 rounded-full" style="width: ' + ((progreso/21)*100) + '%"></div></div></div>',
                    '<div class="pt-4 border-t border-slate-50 flex flex-col gap-2">',
                    '  <button onclick="window.abrirModalReportar(\'' + c.id + '\', \'' + c.nombre + '\')" class="w-full py-2.5 bg-indigo-50 text-indigo-600 hover:bg-indigo-100 rounded-2xl text-xs font-bold transition flex items-center justify-center gap-1.5"><i data-lucide="check-square" class="w-4 h-4"></i> Marcar Avance de Hoy</button>',
                    '  <button onclick="window.enviarDevocionalWhatsApp(\'' + c.id + '\', ' + proximoDia + ')" class="w-full py-2.5 bg-emerald-50 text-emerald-700 hover:bg-emerald-100 rounded-2xl text-xs font-bold transition flex items-center justify-center gap-1.5"><i data-lucide="book-open" class="w-4 h-4"></i> Enviar Devocional ' + tipoProximo + ' Día ' + proximoDia + '</button>',
                    '</div>'
                ].join('');
                container.appendChild(card);
            });
            lucide.createIcons();
        }

        // ==================== OPERACIÓN EN VIVO WHATSAPP (CON CONSULTA FIREBASE DIRECTA) ====================
        window.enviarDevocionalWhatsApp = function(personaId, dia) {
            var c = misAsignados.find(function(item) { return item.id === personaId; });
            if (!c) return;

            var fTel = (c.telefono || '').replace(/\D/g, '');
            if (!fTel) {
                window.showAlert("Falta Teléfono", "Esta persona no posee un número de teléfono válido para enviarle WhatsApp.", "error");
                return;
            }

            var objDia = DEVOCIONAL_DIAS.find(function(d) { return d.dia === dia; });
            var tipoNombre = dia <= 3 ? "NPT - Nací Para Triunfar" : "LBS - Libreta de Bienvenida al Señor";
            var tituloLeccion = objDia ? "Día " + dia + ": " + objDia.titulo : "Día " + dia;

            // CONSULTAR FIREBASE EN VIVO EN EL SEGUNDO EXACTO DEL CLIC
            db.collection('devocionales').doc('dia_' + dia).get().then(function(docSnap) {
                var config = docSnap.exists ? docSnap.data() : {};
                
                // Si el link de Firebase está vacío, generamos la sugerencia por defecto apuntando a tu hosting
                var pdfUrl = config.pdf_url || "https://riosenmi.org/wp-content/uploads/dia" + dia + ".pdf";
                var template = config.mensaje_template || "";

                var mensajeFinal = "";

                if (template) {
                    mensajeFinal = template;
                    mensajeFinal = mensajeFinal.replace(/{nombre}/gi, c.nombre || '');
                    mensajeFinal = mensajeFinal.replace(/{link}/gi, pdfUrl);
                } else {
                    // Mensaje elegante por defecto con la nueva identidad de Ríos de Agua Viva
                    mensajeFinal = [
                        "¡Hola, " + (c.nombre || '') + "! Bendiciones de parte de Ríos de Agua Viva. 🕊️",
                        "Te comparto el devocional del día de hoy para tu crecimiento espiritual:",
                        "📖 *" + tipoNombre + "*\n*" + tituloLeccion + "*",
                        "Puedes leerlo o descargarlo directamente en formato PDF en este enlace:\n" + pdfUrl,
                        "¡Que la gracia del Señor te acompañe en esta hermosa lectura! 🙌"
                    ].join('\n\n');
                }

                var linkFinal = "https://wa.me/" + fTel + "?text=" + encodeURIComponent(mensajeFinal);
                window.open(linkFinal, '_blank');
            }).catch(function(e) {
                // Fallback en caso de error de red
                var fallbackPdfUrl = "https://riosenmi.org/wp-content/uploads/dia" + dia + ".pdf";
                var defaultMsg = "¡Hola, " + (c.nombre || '') + "! Bendiciones de parte de Ríos de Agua Viva. Te comparto la lectura de hoy (" + tituloLeccion + "): " + fallbackPdfUrl;
                window.open("https://wa.me/" + fTel + "?text=" + encodeURIComponent(defaultMsg), '_blank');
            });
        };

        window.abrirModalReportar = function(id, nombre) {
            idPersonaReportar = id; diaSeleccionado = null;
            document.getElementById('modal-title-persona').innerText = "Reportar para " + nombre;
            document.getElementById('modal-nota').value = '';

            var c = misAsignados.find(function(item) { return item.id === id; });
            var diaActual = c ? c.dia_devocional || 0 : 0;

            var s1 = document.getElementById('grid-semana1');
            var s2 = document.getElementById('grid-semana2');
            var s3 = document.getElementById('grid-semana3');
            s1.innerHTML = ''; s2.innerHTML = ''; s3.innerHTML = '';

            DEVOCIONAL_DIAS.forEach(function(d) {
                var btn = document.createElement('button'); btn.type = "button";
                btn.onclick = function() { window.seleccionarDia(d.dia); };
                btn.id = "btn-dia-" + d.dia;
                
                var btnStyle = "w-full text-left px-3 py-2.5 text-xs font-semibold border rounded-xl transition flex justify-between items-center ";
                if (d.dia <= diaActual) { btnStyle += "bg-indigo-50 border-indigo-200 text-indigo-700 hover:bg-indigo-100"; }
                else { btnStyle += "bg-white border-slate-200 text-slate-600 hover:bg-slate-50"; }

                btn.className = btnStyle;

                var subPrefijo = d.dia <= 3 ? "NPT - " : "LBS - ";
                btn.innerHTML = '<span>' + subPrefijo + 'Día ' + d.dia + ': ' + d.titulo + '</span><i data-lucide="circle" class="w-4 h-4 text-slate-300"></i>';

                if (d.semana === 1) s1.appendChild(btn);
                else if (d.semana === 2) s2.appendChild(btn);
                else s3.appendChild(btn);
            });

            document.getElementById('modal-reportar').classList.remove('hidden');
            lucide.createIcons();
        };

        window.seleccionarDia = function(dia) {
            diaSeleccionado = dia;
            DEVOCIONAL_DIAS.forEach(function(d) {
                var btn = document.getElementById('btn-dia-' + d.dia);
                if (btn) btn.classList.remove('ring-4', 'ring-indigo-300', 'border-indigo-600', 'bg-indigo-600', 'text-white');
            });
            var act = document.getElementById('btn-dia-' + dia);
            if (act) {
                act.className = "w-full text-left px-3 py-2.5 text-xs font-semibold border rounded-xl transition flex justify-between items-center bg-indigo-600 text-white border-indigo-600 ring-4 ring-indigo-100";
                act.querySelector('i').outerHTML = '<i data-lucide="check-circle-2" class="w-4 h-4 text-white"></i>';
                lucide.createIcons();
            }
        };

        window.cerrarModalReportar = function() { document.getElementById('modal-reportar').classList.add('hidden'); };

        window.procesarReporte = function() {
            if (!idPersonaReportar || !diaSeleccionado) {
                window.showAlert("Falta Información", "Por favor selecciona un día del devocional para reportar.", "error"); return;
            }
            var textoNota = document.getElementById('modal-nota').value.trim();
            if (!textoNota) {
                var leccion = DEVOCIONAL_DIAS.find(function(d) { return d.dia === diaSeleccionado; });
                textoNota = "Avanzó con éxito a la lección del " + (leccion ? "Día " + diaSeleccionado + " (" + leccion.titulo + ")" : "Día " + diaSeleccionado);
            }

            var nuevaNotaObj = {
                fecha: new Date().toISOString(),
                texto: textoNota,
                consolidador: consolidadorActivo.nombre
            };

            db.collection('nuevos_creyentes').doc(idPersonaReportar).update({
                dia_devocional: diaSeleccionado,
                observaciones: firebase.firestore.FieldValue.arrayUnion(nuevaNotaObj)
            }).then(function() {
                window.showAlert("¡Perfecto!", "Avance reportado y sincronizado con éxito.", "success");
                window.cerrarModalReportar();
            }).catch(function(err) {
                window.showAlert("Error", "No se guardó el avance: " + err.message, "error");
            });
        };

        window.logout = function() {
            if (desvincularEscuchadorLider) desvincularEscuchadorLider();
            consolidadorActivo = null; misAsignados = [];
            document.getElementById('input-pin').value = '';
            document.getElementById('dashboard-container').classList.add('hidden');
            document.getElementById('login-container').classList.remove('hidden');
        };

        window.onload = function() {
            lucide.createIcons();
            document.getElementById('conn-bar').className = "bg-emerald-600 text-white text-[11px] font-semibold py-1.5 px-4 flex justify-between items-center";
            document.getElementById('conn-bar').innerHTML = '<span><i data-lucide="wifi" class="inline w-3 h-3 mr-1"></i> Base de Datos Ríos de Agua Viva Conectada</span><span class="opacity-80">PRODUCCIÓN</span>';
            lucide.createIcons();
        };
    </script>
</body>
</html>