// --- Lógica para búsqueda y gestión de familiar/apoderado y matrícula ---
document.addEventListener('DOMContentLoaded', function () {
    // --- Seleccionar elementos del DOM (debe ir antes de cualquier uso) ---
    const formNuevaMatricula = document.getElementById('formNuevaMatricula');
    const seccionNuevaMatricula = document.getElementById('seccionNuevaMatricula');
    const formularioMatricula = document.getElementById('formularioMatricula');
    const seccionBuscarApoderado = document.getElementById('seccionBuscarApoderado');
    const contenedorFormApoderadoMatricula = document.getElementById('contenedorFormApoderadoMatricula');
    const listaFamiliaresDiv = document.getElementById('listaFamiliaresAgregados');
    const resultadosBusqueda = document.getElementById('resultadosBusqueda');
    // Botones
    // const btnNuevaMatricula = document.getElementById('btnNuevaMatricula');
    const btnCancelarMatricula = document.getElementById('btnCancelarMatricula');
    const btnMostrarBuscarApoderado = document.getElementById('btnMostrarBuscarApoderado');
    const btnMostrarNuevoApoderado = document.getElementById('btnMostrarNuevoApoderado');
    const btnBuscarApoderado = document.getElementById('btnBuscarApoderado');
    const btnAnadirFamiliar = document.getElementById('btnAnadirFamiliar');
    // Filtros y campos de búsqueda
    const tipoEnsenanza = document.getElementById('tipo_ensenanza');
    const grado = document.getElementById('grado');
    const buscadorAlumno = document.getElementById('buscadorAlumno');
    const inputBuscarFamiliar = document.getElementById('apoderado_buscar');
    // Campos del formulario de matrícula (para acceso rápido)
    const matriculaTipoEnsenanza = document.getElementById('matricula_tipo_ensenanza');
    const matriculaGrado = document.getElementById('matricula_grado');

    // Debug: Verificar que los elementos existen
    console.log('🔧 GGEE Debug - DOMContentLoaded ejecutado');
    console.log('tipoEnsenanza:', tipoEnsenanza);
    console.log('grado:', grado);
    
    // Verificación adicional
    if (!tipoEnsenanza) {
        console.error('❌ Elemento tipo_ensenanza NO encontrado');
        const allSelects = document.querySelectorAll('select');
        console.log('Todos los selects disponibles:', allSelects);
    } else {
        console.log('✅ Elemento tipo_ensenanza encontrado');
        console.log('✅ tipoEnsenanza.id:', tipoEnsenanza.id);
        console.log('✅ tipoEnsenanza.value:', tipoEnsenanza.value);
    }
    
    if (!grado) {
        console.error('❌ Elemento grado NO encontrado');
    } else {
        console.log('✅ Elemento grado encontrado');
        console.log('✅ grado.id:', grado.id);
        console.log('✅ grado.value:', grado.value);
    }

    // --- NUEVO: Listar preinscritos al seleccionar grado ---
    function renderListaAlumnos(alumnos) {
        if (!resultadosBusqueda) return;
        if (!alumnos || alumnos.length === 0) {
            resultadosBusqueda.innerHTML = '<div class="alert alert-info">No hay alumnos preinscritos para este grado.</div>';
            resultadosBusqueda.style.display = '';
            return;
        }
        let html = '<div class="list-group">';
        alumnos.forEach(al => {
            html += `<button type="button" class="list-group-item list-group-item-action alumno-preinscrito-item" data-id="${al.id}">
                <strong>${al.ap_paterno} ${al.ap_materno}, ${al.nombre}</strong> <span class="text-muted">(${al.run})</span>
            </button>`;
        });
        html += '</div>';
        resultadosBusqueda.innerHTML = html;
        resultadosBusqueda.style.display = '';
    }

    function fetchAlumnosPreinscritos() {
        console.log('🔄 fetchAlumnosPreinscritos() llamada');
        if (!tipoEnsenanza || !grado) {
            console.log('❌ Elementos no encontrados:', {tipoEnsenanza: !!tipoEnsenanza, grado: !!grado});
            return;
        }
        const tipo_ensenanza_id = tipoEnsenanza.value;
        const grado_id = grado.value;
        console.log('📊 Valores actuales:', {tipo_ensenanza_id, grado_id});
        
        if (!tipo_ensenanza_id || !grado_id) {
            console.log('⚠️ Faltan valores, limpiando resultados');
            resultadosBusqueda.innerHTML = '';
            resultadosBusqueda.style.display = 'none';
            return;
        }
        // Solo listar si el input de búsqueda está vacío
        if (buscadorAlumno && buscadorAlumno.value.trim().length > 0) {
            console.log('⚠️ Campo de búsqueda no vacío, saltando fetchAlumnosPreinscritos');
            return;
        }
        
        const url = src(`buscar_alumnos.php?q=&grado_id=${grado_id}&tipo_ensenanza_id=${tipo_ensenanza_id}`);
        console.log('🌐 Cargando desde URL:', url);
        
        resultadosBusqueda.innerHTML = '<div class="text-center text-muted">Cargando preinscritos...</div>';
        resultadosBusqueda.style.display = '';
        
        fetch(url)
            .then(res => {
                console.log('📡 Response status:', res.status);
                return res.json();
            })
            .then(data => {
                console.log('📊 Datos recibidos:', data);
                // Manejar respuesta que puede ser array o objeto con debug
                let alumnos = Array.isArray(data) ? data : (data.alumnos || []);
                console.log('👥 Alumnos a renderizar:', alumnos.length);
                renderListaAlumnos(alumnos);
            })
            .catch(error => {
                console.error('❌ Error al cargar preinscritos:', error);
                resultadosBusqueda.innerHTML = '<div class="alert alert-danger">Error al cargar preinscritos.</div>';
            });
    }

    // Evento: al cambiar grado o tipo de enseñanza, listar preinscritos
    if (grado) {
        grado.addEventListener('change', function() {
            console.log('🔄 Event: grado changed to:', this.value);
            fetchAlumnosPreinscritos();
        });
    }
    if (tipoEnsenanza) {
        tipoEnsenanza.addEventListener('change', function() {
            console.log('🔄 Event: tipo_ensenanza changed to:', this.value);
            setTimeout(() => {
                console.log('🔄 Ejecutando fetchAlumnosPreinscritos después de timeout');
                fetchAlumnosPreinscritos();
            }, 300); // Esperar a que se cargue el select grado
        });
    }

    // Evento: si el input de búsqueda cambia, priorizar búsqueda manual
    if (buscadorAlumno) {
        buscadorAlumno.addEventListener('input', function() {
            const q = buscadorAlumno.value.trim();
            if (q.length > 0) {
                // Ejecutar búsqueda manual (ya implementada en tu código actual)
                // Aquí se asume que ya existe la lógica para buscar manualmente
                // Si borran el input, volver a listar preinscritos
                resultadosBusqueda.innerHTML = '';
                resultadosBusqueda.style.display = 'none';
            } else {
                fetchAlumnosPreinscritos();
            }
        });
    }

    // Evento: seleccionar alumno de la lista para abrir formulario
    if (resultadosBusqueda) {
        resultadosBusqueda.addEventListener('click', function(e) {
            const btn = e.target.closest('.alumno-preinscrito-item');
            if (btn) {
                const alumnoId = btn.getAttribute('data-id');
                if (alumnoId) {
                    cargarDatosAlumno(alumnoId);
                    if (formularioMatricula) formularioMatricula.style.display = '';
                }
            }
        });
    }
    // ...declaraciones movidas al inicio del bloque...

    // --- Constantes y estado de la aplicación ---
    const camposApoderado = [
        'run','nombre','ap_paterno','ap_materno','domicilio','parentesco','parentesco_especifico','telefono','telefono2','email','escolaridad','profesion','actividad_laboral'
    ]; // prettier-ignore

    function mostrarFormApoderado() {
        if (contenedorFormApoderadoMatricula) contenedorFormApoderadoMatricula.style.display = '';
    }
    function ocultarFormApoderado() {
        if (contenedorFormApoderadoMatricula) contenedorFormApoderadoMatricula.style.display = 'none';
    }
    function limpiarFormApoderado() {
        camposApoderado.forEach(c => {
            const input = document.getElementById('apoderado_' + c);
            if (input) input.value = '';
        });
        document.querySelectorAll('input[name="apoderado_rol[]"]').forEach(chk => chk.checked = false);
    }

    // Ocultar formulario y sección de búsqueda de apoderado al cargar
    ocultarFormApoderado();
    if (seccionBuscarApoderado) seccionBuscarApoderado.style.display = 'none';

    if (btnMostrarBuscarApoderado) {
        btnMostrarBuscarApoderado.addEventListener('click', function () {
            if (seccionBuscarApoderado) seccionBuscarApoderado.style.display = '';
            mostrarFormApoderado();
            limpiarFormApoderado();
        });
    }
    if (btnMostrarNuevoApoderado) {
        btnMostrarNuevoApoderado.addEventListener('click', function () {
            if (seccionBuscarApoderado) seccionBuscarApoderado.style.display = 'none';
            mostrarFormApoderado();
            limpiarFormApoderado();
        });
    }

    // Buscar apoderado existente
    if (btnBuscarApoderado && inputBuscarFamiliar) {
        btnBuscarApoderado.addEventListener('click', function () {
            const q = inputBuscarFamiliar.value.trim();
            if (!q || q.length < 2) return;
            fetch(src('buscar_familiar.php?q=') + encodeURIComponent(q))
                .then(res => res.json())
                .then(data => {
                    limpiarFormApoderado();
                    if (data.length > 0) {
                        const fam = data[0];
                        camposApoderado.forEach(c => {
                            const input = document.getElementById('apoderado_' + c);
                            if (input) {
                                input.value = fam[c] || '';
                            }
                        });
                        mostrarFormApoderado();
                    } else {
                        alert('No se encontró apoderado con ese dato.');
                        limpiarFormApoderado();
                    }
                })
                .catch(() => alert('Error al buscar apoderado.'));
        });
    }
    // Guardar el id del alumno seleccionado para usarlo al guardar
    window.ultimoAlumnoSeleccionadoId = null;
    // Array para almacenar los familiares que se van agregando
    let familiaresAgregados = [];


    const camposPrincipalesIds = [
        'matricula_run','matricula_nombre','matricula_ap_paterno','matricula_ap_materno',
        'matricula_fecha_nac','matricula_tipo_ensenanza','matricula_grado'
    ]; // prettier-ignore

    const camposSocialSaludIds = [
        'social_edad','social_repitente','social_grado_repitencia','social_colegio_procedencia',
        'social_alumno_pie','social_hermanos_escuela','social_grado_hermanos','social_nacionalidad',
        'social_integrantes_familia','social_orden_alejamiento','social_programa_social','social_etnia',
        'social_internet_hogar','social_smartphone','social_computador_hogar','social_opta_religion',
        'social_religion','social_transporte','social_sector','social_junaeb','social_uso_imagen','social_vive_con',
        'social_domicilio', 'social_observacion_alejamiento',
        'salud_sistema_salud','salud_alergias','salud_enfermedad_cuidado',
        'salud_medicamento_contraindicado','salud_medicamento_uso_diario','salud_observaciones'
    ]; // prettier-ignore

    function limpiarCampos(ids) {
        ids.forEach(id => {
            const el = document.getElementById(id);
            if (el) el.value = '';
        });
    }

    function limpiarCamposSocialSalud() {
        camposSocialSaludIds.forEach(id => {
        const el = document.getElementById(id);
        if (el) {
            if (el.tagName === 'SELECT') el.selectedIndex = 0;
            else el.value = '';
        }
    });
    // Restablecer elementos de la interfaz
    }

    // Función para limpiar y reiniciar el formulario
    function limpiarYReiniciarMatricula() {
        if (formNuevaMatricula) formNuevaMatricula.reset();
        limpiarCampos(camposPrincipalesIds);
        limpiarCamposSocialSalud();

        if (formularioMatricula) formularioMatricula.style.display = 'none';

        familiaresAgregados = [];
        renderizar();

    if (tipoEnsenanza) tipoEnsenanza.selectedIndex = 0;
    if (grado) {
        grado.innerHTML = '<option value="">Selecciona tipo de enseñanza primero</option>';
        grado.disabled = true;
    }
    if (buscadorAlumno) {
        buscadorAlumno.value = '';
        buscadorAlumno.disabled = true;
    }
    if (resultadosBusqueda) {
        resultadosBusqueda.innerHTML = '';
        resultadosBusqueda.style.display = 'none';
    }
    // if (btnNuevaMatricula && seccionNuevaMatricula) {
    //     btnNuevaMatricula.style.display = '';
    //     seccionNuevaMatricula.style.display = 'none';
    // }
    window.ultimoAlumnoSeleccionadoId = null;
    }

    // Función para cargar datos de un alumno
    function cargarDatosAlumno(alumnoId) {
        window.ultimoAlumnoSeleccionadoId = alumnoId;
        fetch(`${src("datos_alumno.php?id=${alumnoId}")}`)
            .then(res => {
                if (!res.ok) throw new Error('Error al cargar datos del alumno');
                return res.json();
            })
            .then(data => {
                if (data && data.id) {
                    // Datos básicos del alumno
                    document.getElementById('matricula_run').value = data.run || '';
                    document.getElementById('matricula_nombre').value = data.nombre || '';
                    document.getElementById('matricula_ap_paterno').value = data.ap_paterno || '';
                    document.getElementById('matricula_ap_materno').value = data.ap_materno || '';
                    document.getElementById('matricula_fecha_nac').value = data.fecha_nac || '';
                    document.getElementById('matricula_tipo_ensenanza').value = data.tipo_ensenanza || data.tipo_ensenanza_nombre || '';
                    document.getElementById('matricula_grado').value = data.grado_nombre || '';
                    // Calcular edad al 31 de marzo del año en curso
                    let edadCalculada = '';
                    if (data.fecha_nac) {
                        const fechaNac = new Date(data.fecha_nac);
                        const anioActual = new Date().getFullYear();
                        const fechaCorte = new Date(anioActual, 2, 31); // Mes 2 = marzo (0-index)
                        let edad = fechaCorte.getFullYear() - fechaNac.getFullYear();
                        if (
                            fechaCorte.getMonth() < fechaNac.getMonth() ||
                            (fechaCorte.getMonth() === fechaNac.getMonth() && fechaCorte.getDate() < fechaNac.getDate())
                        ) {
                            edad--;
                        }
                        edadCalculada = edad;
                    }
                    // Información social (con validación)
                    const socialData = data.social || {};
                    document.getElementById('social_edad').value = edadCalculada;
                    document.getElementById('social_repitente').value = socialData.repitente || '';
                    document.getElementById('social_grado_repitencia').value = socialData.grado_repitencia || '';
                    document.getElementById('social_colegio_procedencia').value = socialData.colegio_procedencia || '';
                    document.getElementById('social_alumno_pie').value = socialData.alumno_pie || '';
                    document.getElementById('social_hermanos_escuela').value = socialData.hermanos_escuela || '';
                    document.getElementById('social_grado_hermanos').value = socialData.grado_hermanos || '';
                    document.getElementById('social_nacionalidad').value = socialData.nacionalidad || '';
                    document.getElementById('social_integrantes_familia').value = socialData.integrantes_familia || '';
                    document.getElementById('social_orden_alejamiento').value = socialData.orden_alejamiento || '';
                    document.getElementById('social_programa_social').value = socialData.programa_social || '';
                    document.getElementById('social_etnia').value = socialData.etnia || '';
                    document.getElementById('social_internet_hogar').value = socialData.internet_hogar || '';
                    document.getElementById('social_smartphone').value = socialData.smartphone || '';
                    document.getElementById('social_computador_hogar').value = socialData.computador_hogar || '';
                    document.getElementById('social_opta_religion').value = socialData.opta_religion || '';
                    document.getElementById('social_religion').value = socialData.religion || '';
                    document.getElementById('social_transporte').value = socialData.transporte || '';
                    document.getElementById('social_sector').value = socialData.sector || '';
                    document.getElementById('social_junaeb').value = socialData.junaeb || '';
                    document.getElementById('social_uso_imagen').value = socialData.uso_imagen || '';
                    document.getElementById('social_vive_con').value = socialData.vive_con || '';
                    // Información de salud (con validación)
                    const saludData = data.salud || {};
                    document.getElementById('salud_sistema_salud').value = saludData.sistema_salud || '';
                    document.getElementById('salud_alergias').value = saludData.alergias || '';
                    document.getElementById('salud_enfermedad_cuidado').value = saludData.enfermedad_cuidado || '';
                    document.getElementById('salud_medicamento_contraindicado').value = saludData.medicamento_contraindicado || '';
                    document.getElementById('salud_medicamento_uso_diario').value = saludData.medicamento_uso_diario || '';
                    document.getElementById('salud_observaciones').value = saludData.observaciones || '';
                } else {
                    // Limpiar campos sociales y de salud si no hay datos
                    limpiarCamposSocialSalud();
                }
                // Mostrar formulario y ocultar resultados
                if (formularioMatricula) formularioMatricula.style.display = '';
                if (resultadosBusqueda) resultadosBusqueda.style.display = 'none';

            })
            .catch(error => {
                console.error('Error al cargar datos del alumno:', error);
                alert('Error al cargar datos del alumno: ' + error.message);
            });
    }

    // Guardar información social y de salud
    if (formNuevaMatricula) formNuevaMatricula.addEventListener('submit', async function (e) {
        e.preventDefault();
        const id = window.ultimoAlumnoSeleccionadoId || null;
        if (!id) {
            alert('Debes seleccionar un alumno antes de guardar.');
            return;
        }

        const fecha_matricula = document.getElementById('matricula_fecha_matricula').value;
        if (!fecha_matricula) {
            alert('La fecha de matrícula es obligatoria.');
            document.getElementById('matricula_fecha_matricula').focus();
            return;
        }

        if (familiaresAgregados.length === 0) {
            alert('Debes agregar al menos un apoderado a la lista antes de guardar.');
            return;
        }

        const gradoId = grado ? grado.value : null;
        if (!gradoId) {
            alert('Debe seleccionar un grado válido en los filtros de la parte superior.');
            return;
        }

        // Recolectar datos sociales
        const social = {
            edad: document.getElementById('social_edad').value,
            repitente: document.getElementById('social_repitente').value,
            grado_repitencia: document.getElementById('social_grado_repitencia').value,
            colegio_procedencia: document.getElementById('social_colegio_procedencia').value,
            alumno_pie: document.getElementById('social_alumno_pie').value,
            hermanos_escuela: document.getElementById('social_hermanos_escuela').value,
            grado_hermanos: document.getElementById('social_grado_hermanos').value,
            nacionalidad: document.getElementById('social_nacionalidad').value,
            domicilio: document.getElementById('social_domicilio').value,
            observacion_alejamiento: document.getElementById('social_observacion_alejamiento').value,
            integrantes_familia: document.getElementById('social_integrantes_familia').value,
            orden_alejamiento: document.getElementById('social_orden_alejamiento').value,
            programa_social: document.getElementById('social_programa_social').value,
            etnia: document.getElementById('social_etnia').value,
            internet_hogar: document.getElementById('social_internet_hogar').value,
            smartphone: document.getElementById('social_smartphone').value,
            computador_hogar: document.getElementById('social_computador_hogar').value,
            opta_religion: document.getElementById('social_opta_religion').value,
            religion: document.getElementById('social_religion').value,
            transporte: document.getElementById('social_transporte').value,
            sector: document.getElementById('social_sector').value,
            junaeb: document.getElementById('social_junaeb').value,
            uso_imagen: document.getElementById('social_uso_imagen').value,
            vive_con: document.getElementById('social_vive_con').value
        };
        // Recolectar datos de salud
        const salud = {
            sistema_salud: document.getElementById('salud_sistema_salud').value,
            alergias: document.getElementById('salud_alergias').value,
            enfermedad_cuidado: document.getElementById('salud_enfermedad_cuidado').value,
            medicamento_contraindicado: document.getElementById('salud_medicamento_contraindicado').value,
            medicamento_uso_diario: document.getElementById('salud_medicamento_uso_diario').value,
            observaciones: document.getElementById('salud_observaciones').value
        };

        try {
            // 1. Guardar todos los familiares y asociarlos en paralelo
            const promesasFamiliares = familiaresAgregados.map(async (familiar) => {
                // Guardar/Actualizar el familiar
                const resFamiliar = await fetch(src('guardar_familiar.php'), {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify(familiar)
                });

                if (!resFamiliar.ok) {
                    // Si el servidor devuelve un error (como 500), intenta leer el mensaje de error específico.
                    const errorData = await resFamiliar.json().catch(() => ({ error: `Error del servidor (${resFamiliar.status}) al guardar familiar ${familiar.run}` }));
                    throw new Error(errorData.error);
                }

                const respFamiliar = await resFamiliar.json();
                if (!respFamiliar.success) {
                    throw new Error(respFamiliar.error || `Error desconocido al guardar familiar ${familiar.run}.`);
                }
                const familiar_id = respFamiliar.familiar_id;
                if (!familiar_id) throw new Error('No se pudo obtener el ID del familiar guardado.');

                // Asociar el familiar con el alumno
                const resAsociar = await fetch(src('asociar_alumno_familiar.php'), {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({
                        alumno_id: id,
                        familiar_id: familiar_id, // Pasamos el ID directamente
                        tipo_relacion: familiar.rol || 'No especificado',
                        parentesco_especifico: familiar.parentesco_especifico || null
                    })
                });
                if (!resAsociar.ok) throw new Error(`Error al asociar familiar ${familiar.run}`);
                const respAsociar = await resAsociar.json();
                if (!respAsociar.success) throw new Error(respAsociar.error || `Error desconocido al asociar familiar ${familiar.run}.`);
            });

            await Promise.all(promesasFamiliares);

            // 2. Guardar información de matrícula, social y salud (después de que todos los familiares se guardaron)
            const resInfo = await fetch(src('guardar_info_alumno.php'), {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ alumno_id: id, fecha_matricula, grado_id: gradoId, social, salud })
            });
            if (!resInfo.ok) throw new Error(`Error del servidor al guardar: ${resInfo.statusText}`);
            const respInfo = await resInfo.json();
            if (!respInfo.success) throw new Error(respInfo.error || 'Error desconocido al guardar información.');

            // 3. Si todo fue exitoso
            alert('Información guardada correctamente.');
            limpiarYReiniciarMatricula();

        } catch (error) {
            console.error('Error de red al guardar:', error);
            alert('Error de red al guardar: ' + error.message);
        }
    });

    // --- Lógica para añadir y quitar familiares de la lista ---
    // Usa la función del helper para renderizar la lista
    function renderizar() {
        renderizarListaFamiliares(listaFamiliaresDiv, familiaresAgregados, false); // false = sin botón de editar
    }

    if (btnAnadirFamiliar) {
        btnAnadirFamiliar.addEventListener('click', () => {
            const apoderado = {};
            camposApoderado.forEach(c => {
                const input = document.getElementById('apoderado_' + c);
                const feedback = document.getElementById(`apoderado_${c}_feedback`);

                // Limpiar errores previos
                if (input && input.type !== 'checkbox') {
                    input.classList.remove('is-invalid');
                }
                if (feedback) {
                    feedback.textContent = '';
                }

                if (c === 'rol') {
                    // Esta lógica se movió fuera del bucle, ya que 'rol' no está en camposApoderado
                } else {
                    apoderado[c] = input ? input.value.trim() : '';
                }
            });

            // Recolectar roles por separado, fuera del bucle
            const selectedRoles = [];
            document.querySelectorAll('input[name="apoderado_rol[]"]:checked').forEach(chk => {
                selectedRoles.push(chk.value);
            });
            apoderado.rol = selectedRoles.join(', ');

            // --- Validaciones ---
            if (!apoderado.run) {
                mostrarError('run', 'El RUN del familiar es obligatorio.');
                return;
            }

            if (!validarRun(apoderado.run)) {
                mostrarError('run', 'El RUN del familiar es inválido. Por favor, verifícalo.');
                return;
            }

            if (!apoderado.nombre) {
                mostrarError('nombre', 'El Nombre del familiar es obligatorio.');
                return;
            }

            if (!apoderado.ap_paterno) {
                mostrarError('ap_paterno', 'El Apellido Paterno del familiar es obligatorio.');
                return;
            }

            if (familiaresAgregados.some(f => f.run === apoderado.run)) {
                alert('Este familiar ya ha sido agregado a la lista.');
                return;
            }

            familiaresAgregados.push(apoderado);
            renderizar();
            limpiarFormApoderado(camposApoderado);
            ocultarFormApoderado();
        });
    }

    if (listaFamiliaresDiv) listaFamiliaresDiv.addEventListener('click', (e) => {
        if (e.target.classList.contains('btn-quitar-familiar')) {
            const index = e.target.getAttribute('data-index');
            familiaresAgregados.splice(index, 1);
            renderizar();
        }
    });

    // Lógica para cargar grados según tipo de enseñanza (cabecera y formulario)
    function cargarGrados(tipoId, selectGrado) {
        console.log('🔄 cargarGrados llamado con tipoId:', tipoId, 'selectGrado:', selectGrado);
        selectGrado.innerHTML = '<option value="">Cargando grados...</option>';
        selectGrado.disabled = true;
        if (tipoId) {
            const url = src(`grados_por_ensenanza.php?tipo_ensenanza_id=${encodeURIComponent(tipoId)}`);
            console.log('🌐 Haciendo fetch a:', url);
            fetch(url)
                .then(res => {
                    console.log('📡 Response status:', res.status);
                    return res.json();
                })
                .then(data => {
                    console.log('📊 Datos recibidos:', data);
                    selectGrado.innerHTML = '<option value="">Selecciona grado</option>';
                    if (Array.isArray(data) && data.length > 0) {
                        data.forEach(gr => {
                            selectGrado.innerHTML += `<option value="${gr.id}">${gr.nombre}</option>`;
                        });
                        setTimeout(() => { selectGrado.disabled = false; }, 50); // Forzar habilitación tras renderizado
                        console.log('✅ Grados cargados exitosamente');
                    } else {
                        selectGrado.innerHTML = '<option value="">No hay grados disponibles</option>';
                        selectGrado.disabled = true;
                        console.log('⚠️ No hay grados disponibles');
                    }
                })
                .catch(error => {
                    console.error('❌ Error al cargar grados:', error);
                    selectGrado.innerHTML = '<option value="">Error al cargar grados</option>';
                    selectGrado.disabled = true;
                });
        } else {
            selectGrado.innerHTML = '<option value="">Selecciona tipo de enseñanza primero</option>';
            selectGrado.disabled = true;
            console.log('⚠️ No hay tipoId válido');
        }
    }

    // Listener para cabecera
    if (tipoEnsenanza && grado) {
        console.log('✅ Agregando event listeners para tipo y grado');
        console.log('🔧 Registrando listener para tipoEnsenanza.id:', tipoEnsenanza.id);
        
        tipoEnsenanza.addEventListener('change', function () {
            console.log('🔄 EVENT TRIGGERED - Cambio en tipo de enseñanza:', this.value);
            console.log('🔄 Event target:', this);
            console.log('🔄 Event target id:', this.id);
            cargarGrados(this.value, grado);
            // Limpiar y deshabilitar buscador al cambiar tipo
            if (buscadorAlumno) {
                buscadorAlumno.value = '';
                buscadorAlumno.disabled = true;
            }
            if (resultadosBusqueda) {
                resultadosBusqueda.innerHTML = '';
                resultadosBusqueda.style.display = 'none';
            }
        });
        
        console.log('✅ Event listener registrado exitosamente');
        
        // Remover auto-test que selecciona automáticamente
        console.log('🧪 Event listeners configurados correctamente - sin auto-selección');
        
    } else {
        console.error('❌ No se pueden agregar event listeners - elementos faltantes');
        console.log('tipoEnsenanza exists:', !!tipoEnsenanza);
        console.log('grado exists:', !!grado);
    }
    
    // Listener adicional para grado (solo si ambos elementos existen)
    if (tipoEnsenanza && grado) {
        grado.addEventListener('change', function () {
            console.log('🔄 Cambio en grado:', this.value);
            if (buscadorAlumno) {
                buscadorAlumno.disabled = !this.value;
                if (!this.value) {
                    buscadorAlumno.value = '';
                    if (resultadosBusqueda) {
                        resultadosBusqueda.innerHTML = '';
                        resultadosBusqueda.style.display = 'none';
                    }
                }
            }
        });
    }
    // Listener para formulario de matrícula
    if (matriculaTipoEnsenanza && matriculaGrado) {
        matriculaTipoEnsenanza.addEventListener('change', function () {
            cargarGrados(this.value, matriculaGrado);
        });
    }

    // Botón cancelar: oculta formulario, limpia campos y reinicia selección
    if (btnCancelarMatricula) {
        btnCancelarMatricula.addEventListener('click', limpiarYReiniciarMatricula);
    }

    // Botón Nueva Matrícula: muestra el formulario y oculta el botón
    // if (btnNuevaMatricula && seccionNuevaMatricula) {
    //     btnNuevaMatricula.addEventListener('click', function () {
    //         btnNuevaMatricula.style.display = 'none';
    //         seccionNuevaMatricula.style.display = '';
    //     });
    // }

    // Lógica de búsqueda y selección de alumno
    if (buscadorAlumno) {
        buscadorAlumno.addEventListener('input', function () {
            const q = buscadorAlumno.value.trim();
            if (q.length < 2) {
                if (resultadosBusqueda) {
                    resultadosBusqueda.style.display = 'none';
                    resultadosBusqueda.innerHTML = '';
                }
                if (formularioMatricula) formularioMatricula.style.display = 'none';
                return;
            }
            if (resultadosBusqueda) {
                resultadosBusqueda.style.display = '';
                resultadosBusqueda.innerHTML = '<div class="col-12 text-muted">Buscando...</div>';
            }
            fetch(`${src("buscar_alumnos.php?q=${encodeURIComponent(q)}&grado_id=${encodeURIComponent(grado ? grado.value : '')}&tipo_ensenanza_id=${encodeURIComponent(tipoEnsenanza ? tipoEnsenanza.value : '')}")}`)
                .then(res => {
                    if (!res.ok) throw new Error('Error en la búsqueda de alumnos');
                    return res.json();
                })
                .then(data => {
                    if (!resultadosBusqueda) return;
                    
                    // Manejar respuesta que puede ser array o objeto con debug
                    let alumnos = Array.isArray(data) ? data : (data.alumnos || []);
                    
                    if (alumnos.length === 0) {
                        let mensaje = '<div class="col-12 text-danger">No se encontraron alumnos.</div>';
                        if (data.debug_info) {
                            mensaje += '<div class="col-12 text-muted small">Debug: ' + data.debug_info.busqueda + ' - Total en BD: ' + data.debug_info.total_con_nombre + '</div>';
                        }
                        resultadosBusqueda.innerHTML = mensaje;
                        if (formularioMatricula) formularioMatricula.style.display = 'none';
                    } else {
                        resultadosBusqueda.innerHTML = alumnos.map(al =>
                            `<button type="button" class="list-group-item list-group-item-action w-100 mb-1" data-id="${al.id}" style="text-align:left;">${al.ap_paterno} ${al.ap_materno}, ${al.nombre} <span class='text-muted small'>(${al.run})</span></button>`
                        ).join('');
                        // Asignar evento a cada resultado
                        resultadosBusqueda.querySelectorAll('button[data-id]').forEach(btn => {
                            btn.addEventListener('click', function () {
                                const id = this.getAttribute('data-id');
                                cargarDatosAlumno(id);
                            });
                        });
                    }
                })
                .catch(error => {
                    console.error('Error en la búsqueda:', error);
                    if (resultadosBusqueda) {
                        resultadosBusqueda.innerHTML = `<div class=\"col-12 text-danger\">Error: ${error.message}</div>`;
                    }
                });
        });
    }
});

// VERSIÓN FINAL - Debug de Cache
console.log('🚀 GGEE: JavaScript FINAL cargado - Timestamp:', new Date().toISOString());
console.log('🔧 Verificación de funcionalidad de grados activa');

// FUNCIÓN GLOBAL PARA DEBUG MANUAL
window.debugGGEE = function() {
    console.log('🔍 DEBUG MANUAL INICIADO');
    const tipoSelect = document.getElementById('tipo_ensenanza');
    const gradoSelect = document.getElementById('grado');
    
    console.log('tipoSelect:', tipoSelect);
    console.log('gradoSelect:', gradoSelect);
    
    if (tipoSelect && gradoSelect) {
        console.log('🧪 Ejecutando cargarGrados manualmente...');
        tipoSelect.value = '1'; // Educación Parvularia
        
        // Llamar directamente a cargarGrados
        fetch(window.src("grados_por_ensenanza.php?tipo_ensenanza_id=1"))
            .then(res => {
                console.log('📡 Response status manual:', res.status);
                return res.json();
            })
            .then(data => {
                console.log('📊 Datos manuales:', data);
                gradoSelect.innerHTML = '<option value="">Selecciona grado</option>';
                if (Array.isArray(data) && data.length > 0) {
                    data.forEach(gr => {
                        gradoSelect.innerHTML += `<option value="${gr.id}">${gr.nombre}</option>`;
                    });
                    gradoSelect.disabled = false;
                    console.log('✅ Grados cargados manualmente exitoso');
                } else {
                    console.log('⚠️ No hay grados en respuesta manual');
                }
            })
            .catch(error => {
                console.error('❌ Error en carga manual:', error);
            });
    } else {
        console.error('❌ Elementos no encontrados en debug manual');
    }
};

// FUNCIÓN PARA VERIFICAR DATOS DE BASE DE DATOS
window.verificarDatos = function() {
    console.log('🔍 VERIFICANDO DATOS DE BASE DE DATOS');
    
    // Verificar grados por tipo (esto ya funciona)
    [1, 2].forEach(tipo => {
        fetch(window.src(`grados_por_ensenanza.php?tipo_ensenanza_id=${tipo}`))
            .then(res => res.json())
            .then(data => {
                console.log(`🎓 Grados para tipo ${tipo}:`, data);
            })
            .catch(error => {
                console.error(`❌ Error obteniendo grados para tipo ${tipo}:`, error);
            });
    });
    
    // Verificar alumnos directamente
    fetch(window.src("buscar_alumnos.php?q="))
        .then(res => res.json())
        .then(data => {
            console.log('👥 TODOS los alumnos en la base de datos:', data);
            console.log('📊 Total de alumnos encontrados:', data.length);
        })
        .catch(error => {
            console.error('❌ Error obteniendo TODOS los alumnos:', error);
        });
    
    // Verificar si buscar_alumnos.php funciona con parámetros
    fetch(window.src("buscar_alumnos.php?q=&tipo_ensenanza_id=2&debug=1"))
        .then(res => res.json())
        .then(data => {
            console.log('� Alumnos con debug para Básica:', data);
        })
        .catch(error => {
            console.error('❌ Error en búsqueda con debug:', error);
        });
};

// FUNCIÓN PARA PROBAR CARGA DE GRADOS MANUALMENTE
window.probarGrados = function(tipo) {
    const gradoSelect = document.getElementById('grado');
    fetch(window.src(`grados_por_ensenanza.php?tipo_ensenanza_id=${tipo}`))
        .then(res => res.json())
        .then(data => {
            console.log(`📚 Cargando grados para tipo ${tipo}:`, data);
            gradoSelect.innerHTML = '<option value="">Selecciona grado</option>';
            if (Array.isArray(data) && data.length > 0) {
                data.forEach(gr => {
                    gradoSelect.innerHTML += `<option value="${gr.id}">${gr.nombre}</option>`;
                });
                gradoSelect.disabled = false;
                console.log('✅ Grados cargados en el select');
            }
        })
        .catch(error => {
            console.error('❌ Error cargando grados:', error);
        });
};

console.log('💡 Ejecuta window.debugGGEE() en la consola para debug manual');
console.log('💡 Ejecuta window.verificarDatos() para verificar datos de BD');
console.log('💡 Ejecuta window.diagnosticarBD() para diagnóstico completo');
console.log('💡 Ejecuta window.probarAlgunosGrados() para probar solo algunos grados (evita errores de espacio)');
console.log('💡 Ejecuta window.actualizarInterfaz() para forzar actualización de la lista de alumnos');

// FUNCIÓN DE DIAGNÓSTICO COMPLETO
window.diagnosticarBD = function() {
    console.log('🏥 DIAGNÓSTICO COMPLETO DE BASE DE DATOS');
    
    // 1. Verificar que tenemos acceso a los archivos de verificación
    console.log('🔗 URLs para verificar manualmente:');
    console.log(`${window.location.origin}/src/verificar_importacion.php`);
    console.log(`${window.location.origin}/export_database_FINAL.php`);
    
    // 2. Verificar estructura con verificar_importacion.php
    fetch(window.src("verificar_importacion.php"))
        .then(res => {
            console.log('📋 Status verificar_importacion.php:', res.status);
            return res.text();
        })
        .then(html => {
            console.log('📋 Contenido verificar_importacion.php:', html.substring(0, 800));
            if (html.includes('estudiantes')) {
                console.log('✅ El archivo contiene información sobre estudiantes');
            } else {
                console.log('⚠️ El archivo NO parece contener información sobre estudiantes');
            }
        })
        .catch(error => {
            console.error('❌ Error accediendo verificar_importacion.php:', error);
        });
    
    // 3. Intentar múltiples métodos de búsqueda
    const metodos = ['', 'a', 'juan', 'maria'];
    metodos.forEach(busqueda => {
        fetch(window.src(`buscar_alumnos.php?q=${busqueda}`))
            .then(res => res.json())
            .then(data => {
                // Manejar respuesta que puede ser array o objeto con debug
                let alumnos = Array.isArray(data) ? data : (data.alumnos || []);
                console.log(`🔍 Búsqueda "${busqueda}": ${alumnos.length} resultados`);
                if (alumnos.length > 0) {
                    console.log('📝 Primer resultado:', alumnos[0]);
                }
                // Si hay debug_info, mostrarla
                if (data.debug_info) {
                    console.log('🔧 Debug info para búsqueda "' + busqueda + '":', data.debug_info);
                }
            })
            .catch(error => {
                console.error(`❌ Error en búsqueda "${busqueda}":`, error);
            });
    });
};

// FUNCIÓN ESPECÍFICA PARA PROBAR FILTROS DE GRADO
window.probarFiltros = function() {
    console.log('🧪 PROBANDO FILTROS DE GRADO Y TIPO');
    
    const tipoSelect = document.getElementById('tipo_ensenanza');
    const gradoSelect = document.getElementById('grado');
    
    console.log('📊 Valores actuales:');
    console.log('Tipo enseñanza:', tipoSelect ? tipoSelect.value : 'NO ENCONTRADO');
    console.log('Grado:', gradoSelect ? gradoSelect.value : 'NO ENCONTRADO');
    
    if (tipoSelect && gradoSelect && tipoSelect.value && gradoSelect.value) {
        // Primera consulta: Debug SQL
        const debugUrl = window.src(`buscar_alumnos.php?q=&grado_id=${gradoSelect.value}&tipo_ensenanza_id=${tipoSelect.value}&debug=1`);
        console.log('🌐 URL de debug:', debugUrl);
        
        fetch(debugUrl)
            .then(res => res.json())
            .then(debugData => {
                console.log('🔧 Debug de filtros:', debugData);
                
                // Segunda consulta: Resultados reales
                const realUrl = window.src(`buscar_alumnos.php?q=&grado_id=${gradoSelect.value}&tipo_ensenanza_id=${tipoSelect.value}`);
                console.log('🌐 URL de resultados reales:', realUrl);
                
                return fetch(realUrl);
            })
            .then(res => res.json())
            .then(realData => {
                console.log('📊 RESULTADOS REALES:');
                console.log('Total de alumnos encontrados:', realData.length);
                if (realData.length > 0) {
                    console.log('Primeros 3 alumnos:', realData.slice(0, 3));
                    
                    // Verificar que todos los alumnos pertenecen al grado correcto
                    const gradosEncontrados = [...new Set(realData.map(a => a.grado))];
                    console.log('Grados encontrados en resultados:', gradosEncontrados);
                } else {
                    console.log('⚠️ No se encontraron alumnos para este filtro');
                }
            })
            .catch(error => {
                console.error('❌ Error en prueba de filtros:', error);
            });
    } else {
        console.log('⚠️ Faltan valores de tipo o grado');
    }
};

// FUNCIÓN PARA COMPARAR RESULTADOS ENTRE DIFERENTES GRADOS
window.compararGrados = function() {
    console.log('🔍 COMPARANDO RESULTADOS ENTRE GRADOS');
    
    const tipoSelect = document.getElementById('tipo_ensenanza');
    const gradoSelect = document.getElementById('grado');
    
    if (!tipoSelect || !tipoSelect.value) {
        console.log('⚠️ Primero selecciona un tipo de enseñanza');
        return;
    }
    
    const tipoEnsenanza = tipoSelect.value;
    console.log(`📊 Comparando grados para tipo de enseñanza: ${tipoEnsenanza}`);
    
    // Obtener todas las opciones de grado disponibles
    const gradoOptions = Array.from(gradoSelect.options)
        .filter(opt => opt.value && opt.value !== '')
        .map(opt => ({ id: opt.value, nombre: opt.text }));
    
    console.log('Grados disponibles:', gradoOptions);
    
    // Consultar cada grado
    const promesas = gradoOptions.map(grado => {
        const url = window.src(`buscar_alumnos.php?q=&grado_id=${grado.id}&tipo_ensenanza_id=${tipoEnsenanza}`);
        return fetch(url)
            .then(res => {
                if (!res.ok) {
                    console.warn(`⚠️ Error ${res.status} para grado ${grado.nombre} (ID: ${grado.id})`);
                    return {
                        grado: grado.nombre,
                        gradoId: grado.id,
                        cantidad: 0,
                        primeros3: [],
                        error: `Error ${res.status}: ${res.statusText}`
                    };
                }
                return res.json();
            })
            .then(alumnos => {
                if (alumnos.error) {
                    return {
                        grado: grado.nombre,
                        gradoId: grado.id,
                        cantidad: 0,
                        primeros3: [],
                        error: alumnos.error
                    };
                }
                return {
                    grado: grado.nombre,
                    gradoId: grado.id,
                    cantidad: alumnos.length,
                    primeros3: alumnos.slice(0, 3).map(a => `${a.nombre} ${a.ap_paterno}`),
                    error: null
                };
            })
            .catch(error => {
                console.warn(`⚠️ Error de red para grado ${grado.nombre}:`, error);
                return {
                    grado: grado.nombre,
                    gradoId: grado.id,
                    cantidad: 0,
                    primeros3: [],
                    error: error.message
                };
            });
    });
    
    Promise.all(promesas)
        .then(resultados => {
            console.log('📊 COMPARACIÓN DE RESULTADOS POR GRADO:');
            resultados.forEach(resultado => {
                if (resultado.error) {
                    console.log(`❌ Grado ${resultado.grado} (ID: ${resultado.gradoId}): ERROR - ${resultado.error}`);
                } else {
                    console.log(`✅ Grado ${resultado.grado} (ID: ${resultado.gradoId}): ${resultado.cantidad} alumnos`);
                    if (resultado.primeros3.length > 0) {
                        console.log('  Primeros alumnos:', resultado.primeros3);
                    }
                }
            });
            
            // Filtrar solo resultados exitosos para el análisis
            const resultadosExitosos = resultados.filter(r => !r.error && r.cantidad > 0);
            
            if (resultadosExitosos.length === 0) {
                console.log('⚠️ No hay resultados exitosos para analizar');
                return;
            }
            
            // Verificar si hay resultados duplicados
            const totalAlumnos = resultadosExitosos.reduce((sum, r) => sum + r.cantidad, 0);
            console.log(`Total de alumnos encontrados: ${totalAlumnos}`);
            
            // Verificar si los primeros alumnos son diferentes entre grados
            const primerosAlumnos = resultadosExitosos.map(r => r.primeros3[0]).filter(Boolean);
            const alumnosUnicos = [...new Set(primerosAlumnos)];
            
            if (primerosAlumnos.length > 1 && alumnosUnicos.length === 1) {
                console.log('⚠️ PROBLEMA DETECTADO: Todos los grados están devolviendo los mismos alumnos');
            } else if (primerosAlumnos.length > 1) {
                console.log('✅ Los grados están devolviendo alumnos diferentes');
            } else {
                console.log('ℹ️ Solo hay datos de un grado para comparar');
            }
        })
        .catch(error => {
            console.error('❌ Error comparando grados:', error);
        });
};

// FUNCIÓN PARA PROBAR SOLO ALGUNOS GRADOS (EVITAR PROBLEMAS DE ESPACIO)
window.probarAlgunosGrados = function() {
    console.log('🔍 PROBANDO ALGUNOS GRADOS ESPECÍFICOS');
    
    const tipoSelect = document.getElementById('tipo_ensenanza');
    const gradoSelect = document.getElementById('grado');
    
    if (!tipoSelect || !tipoSelect.value) {
        console.log('⚠️ Primero selecciona un tipo de enseñanza');
        return;
    }
    
    const tipoEnsenanza = tipoSelect.value;
    console.log(`📊 Probando primeros 3 grados para tipo de enseñanza: ${tipoEnsenanza}`);
    
    // Obtener solo los primeros 3 grados para evitar problemas de espacio
    const gradoOptions = Array.from(gradoSelect.options)
        .filter(opt => opt.value && opt.value !== '')
        .slice(0, 3) // Solo primeros 3 grados
        .map(opt => ({ id: opt.value, nombre: opt.text }));
    
    console.log('Grados a probar:', gradoOptions);
    
    // Consultar cada grado seleccionado
    gradoOptions.forEach((grado, index) => {
        setTimeout(() => {
            const url = window.src(`buscar_alumnos.php?q=&grado_id=${grado.id}&tipo_ensenanza_id=${tipoEnsenanza}`);
            console.log(`🔍 Probando grado ${grado.nombre} (${index + 1}/3)...`);
            
            fetch(url)
                .then(res => {
                    if (!res.ok) {
                        console.warn(`❌ Error ${res.status} para grado ${grado.nombre}`);
                        return [];
                    }
                    return res.json();
                })
                .then(alumnos => {
                    console.log(`✅ ${grado.nombre}: ${alumnos.length} alumnos`);
                    if (alumnos.length > 0) {
                        console.log(`  Primer alumno: ${alumnos[0].nombre} ${alumnos[0].ap_paterno}`);
                    }
                })
                .catch(error => {
                    console.error(`❌ Error en grado ${grado.nombre}:`, error);
                });
        }, index * 500); // Esperar 500ms entre cada consulta
    });
};

// FUNCIÓN PARA FORZAR ACTUALIZACIÓN DE LA INTERFAZ
window.actualizarInterfaz = function() {
    console.log('🔄 FORZANDO ACTUALIZACIÓN DE INTERFAZ');
    
    const tipoSelect = document.getElementById('tipo_ensenanza');
    const gradoSelect = document.getElementById('grado');
    const buscadorAlumno = document.getElementById('buscadorAlumno');
    const resultadosBusqueda = document.getElementById('resultadosBusqueda');
    
    console.log('📊 Estado actual:');
    console.log('Tipo:', tipoSelect ? tipoSelect.value : 'NO ENCONTRADO');
    console.log('Grado:', gradoSelect ? gradoSelect.value : 'NO ENCONTRADO');
    console.log('Buscador:', buscadorAlumno ? buscadorAlumno.value : 'NO ENCONTRADO');
    
    if (tipoSelect && gradoSelect && tipoSelect.value && gradoSelect.value) {
        // Limpiar buscador si tiene contenido
        if (buscadorAlumno && buscadorAlumno.value.trim().length > 0) {
            console.log('🧹 Limpiando buscador para permitir lista automática');
            buscadorAlumno.value = '';
        }
        
        const url = window.src(`buscar_alumnos.php?q=&grado_id=${gradoSelect.value}&tipo_ensenanza_id=${tipoSelect.value}`);
        console.log('🌐 Actualizando desde URL:', url);
        
        if (resultadosBusqueda) {
            resultadosBusqueda.innerHTML = '<div class="text-center text-muted">Actualizando lista...</div>';
            resultadosBusqueda.style.display = '';
        }
        
        fetch(url)
            .then(res => res.json())
            .then(data => {
                console.log('📊 Datos recibidos para interfaz:', data.length, 'alumnos');
                
                if (!resultadosBusqueda) {
                    console.error('❌ resultadosBusqueda no encontrado');
                    return;
                }
                
                if (!data || data.length === 0) {
                    resultadosBusqueda.innerHTML = '<div class="alert alert-info">No hay alumnos preinscritos para este grado.</div>';
                    return;
                }
                
                let html = '<div class="list-group">';
                data.forEach(al => {
                    html += `<button type="button" class="list-group-item list-group-item-action alumno-preinscrito-item" data-id="${al.id}">
                        <strong>${al.ap_paterno} ${al.ap_materno}, ${al.nombre}</strong> <span class="text-muted">(${al.run})</span>
                    </button>`;
                });
                html += '</div>';
                resultadosBusqueda.innerHTML = html;
                
                console.log('✅ Interfaz actualizada con', data.length, 'alumnos');
            })
            .catch(error => {
                console.error('❌ Error actualizando interfaz:', error);
                if (resultadosBusqueda) {
                    resultadosBusqueda.innerHTML = '<div class="alert alert-danger">Error al actualizar lista.</div>';
                }
            });
    } else {
        console.log('⚠️ Faltan valores para actualizar interfaz');
    }
};

window.probarBusquedaTexto = function(texto = 'a') {
    console.log(`🔍 PROBANDO BÚSQUEDA DE TEXTO: "${texto}"`);
    
    // 1. Búsqueda normal
    fetch(window.src(`buscar_alumnos.php?q=${texto}`))
        .then(res => res.json())
        .then(data => {
            // Manejar respuesta que puede ser array o objeto con debug
            let alumnos = Array.isArray(data) ? data : (data.alumnos || []);
            console.log(`📊 Resultados para "${texto}":`, alumnos.length);
            if (data.debug_info) {
                console.log('🔧 Información de debug:', data.debug_info);
            }
            if (alumnos.length > 0) {
                console.log('📝 Primeros 3 resultados:', alumnos.slice(0, 3));
            }
        })
        .catch(error => {
            console.error(`❌ Error en búsqueda de "${texto}":`, error);
        });
    
    // 2. Búsqueda con debug activado
    fetch(window.src(`buscar_alumnos.php?q=${texto}&debug=1`))
        .then(res => res.json())
        .then(data => {
            console.log(`🔧 DEBUG para búsqueda "${texto}":`, data);
        })
        .catch(error => {
            console.error(`❌ Error en debug de "${texto}":`, error);
        });
};
