// Made by DNMjustME

// Validar los inputs
function validarInputNumerico(idInput) {
    var input = $('#' + idInput);
    var mensajeError = $('<div/>', {
        'text': 'Por favor ingrese solo caracteres numéricos',
        'class': 'text-danger',
        'id': 'error_numerico'
    });

    // Expresión regular para permitir solo caracteres numéricos
    var regex = /^[0-9]*$/;

    if (!regex.test(input.val().trim())) {
        if (!input.parent().find('#error_numerico').length) {
            // El input contiene caracteres no numéricos, mostramos el mensaje de error
            input.parent().append(mensajeError);
        }
        // Actualizar el estado del campo a inválido (false)
        return false;
    } else {
        // El input contiene solo caracteres numéricos, ocultamos cualquier mensaje de error previo
        input.parent().find('#error_numerico').remove();
        // Actualizar el estado del campo a válido (true)
        return true;
    }
}

function validarInputEmail(idInput) {
    var input = $('#' + idInput);
    var mensajeError = $('<div/>', {
        'text': 'Por favor ingrese un correo electrónico válido',
        'class': 'text-danger',
        'id': 'error_email'
    });

    // Expresión regular para validar correos electrónicos
    var regex = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;

    if (!regex.test(input.val().trim())) {
        if (!input.parent().find('#error_email').length) {
            // El input no contiene un correo electrónico válido, mostramos el mensaje de error
            input.parent().append(mensajeError);
        }
        // Actualizar el estado del campo a inválido (false)
        return false;
    } else {
        // El input contiene un correo electrónico válido, ocultamos cualquier mensaje de error previo
        input.parent().find('#error_email').remove();
        // Actualizar el estado del campo a válido (true)
        return true;
    }
}

function validarInputNotEmpty(idInput) {
    var input = $('#' + idInput);
    var mensajeError = $('<div/>', {
        'text': 'Este campo es obligatorio',
        'class': 'text-danger',
        'id': 'error_notempty'
    });

    var parent;
    if (idInput.includes('fecha')) {
        parent = input.parent();
    } else {
        parent = input;
    }

    if (input.val().trim() === '') {
        if (!parent.parent().find('#error_notempty').length) {
            // El input está vacío, mostramos el mensaje de error
            parent.parent().append(mensajeError);
        }
        // Actualizar el estado del campo a vacío (false)
        return false;
    } else {
        // El input no está vacío, ocultamos cualquier mensaje de error previo
        parent.parent().find('#error_notempty').remove();
        // Actualizar el estado del campo a no vacío (true)
        return true;
    }
}

function validarInputMinMaxCaracteres(idInput, min, max) {
    var input = $('#' + idInput);
    var mensajeError = $('<div/>', {
        'class': 'text-danger',
        'id': 'error_minmaxcaracteres'
    });

    if (input.val().length < min) {
        mensajeError.text('El mínimo de caracteres permitido es ' + min);
        if (!input.parent().find('#error_minmaxcaracteres').length) {
            // El input tiene menos caracteres que el mínimo permitido, mostramos el mensaje de error
            input.parent().append(mensajeError);
        }
        // Actualizar el estado del campo a no válido (false)
        return false;
    } else if (input.val().length > max) {
        mensajeError.text('El máximo de caracteres permitido es ' + max);
        if (!input.parent().find('#error_minmaxcaracteres').length) {
            // El input tiene más caracteres que el máximo permitido, mostramos el mensaje de error
            input.parent().append(mensajeError);
        }
        // Actualizar el estado del campo a no válido (false)
        return false;
    } else {
        // El número de caracteres es válido, eliminamos cualquier mensaje de error previo
        input.parent().find('#error_minmaxcaracteres').remove();
        // Actualizar el estado del campo a válido (true)
        return true;
    }
}

function validarInputMinMaxExactosCaracteres(idInput, min, max) {
    var input = $('#' + idInput);
    var mensajeError = $('<div/>', {
        'class': 'text-danger',
        'id': 'error_minmaxexactoscaracteres'
    });

    if (input.val().length === min || input.val().length === max) {
        // El número de caracteres es válido, eliminamos cualquier mensaje de error previo
        input.parent().find('#error_minmaxexactoscaracteres').remove();
        // Actualizar el estado del campo a válido (true)
        return true;
    } else {
        mensajeError.text('El campo debe tener exactamente ' + min + ' o ' + max + ' caracteres');
        if (!input.parent().find('#error_minmaxexactoscaracteres').length) {
            // El input tiene menos o más caracteres que los permitidos exactos, mostramos el mensaje de error
            input.parent().append(mensajeError);
        }
        // Actualizar el estado del campo a no válido (false)
        return false;
    }
}

function validarInputDatalist(idInput) {
    var input = $('#' + idInput);
    var inputValue = input.val();

    var mensajeError = $('<div/>', {
        'class': 'text-danger',
        'id': 'error_datalist',
        'text': 'Seleccione una opción válida.' // Mensaje de error por defecto
    });

    if (inputValue === null || inputValue === undefined || inputValue.trim() === '') {
        mostrarOcultarError(input.parent(), mensajeError, true);
        return false;
    } else {
        mostrarOcultarError(input.parent(), mensajeError, false);
        return true;
    }
}

function mostrarOcultarError(contenedor, mensajeError, mostrar) {
    if (mostrar) {
        if (!contenedor.find('#error_datalist').length) {
            contenedor.append(mensajeError);
        }
    } else {
        contenedor.find('#error_datalist').remove();
    }
}

// Evento para ll


//Funcion que valida el input por cada una de sus validaciones
function validarCampo(idInput, validaciones) {
    var estadoCampos = JSON.parse(localStorage.getItem("estadoCampos")) || {};
    var campoValido = true; // Suponemos que el campo es válido hasta que se demuestre lo contrario

    // Iterar sobre todas las validaciones
    validaciones.forEach(function (validacion) {
        var tipo = validacion.tipo;
        var parametros = validacion.parametros || {};

        switch (tipo) {
            case "notEmpty":
                if (!validarInputNotEmpty(idInput)) {
                    campoValido = false;
                }
                break;
            case "minMaxCaracteres":
                var min = parametros.min;
                var max = parametros.max;
                if (!validarInputMinMaxCaracteres(idInput, min, max)) {
                    campoValido = false;
                }
                break;
            case "minMaxExactosCaracteres":
                var min = parametros.min;
                var max = parametros.max;
                if (!validarInputMinMaxExactosCaracteres(idInput, min, max)) {
                    campoValido = false;
                }
                break;
            case "numerico":
                if (!validarInputNumerico(idInput)) {
                    campoValido = false;
                }
                break;
            case "datalist":
                if (!validarInputDatalist(idInput)) {
                    campoValido = false;
                }
                break;
            case "email":
                if (!validarInputEmail(idInput)) {
                    campoValido = false;
                }
                break;
            // Agregar más casos según las validaciones que necesites
            default:
                console.error('Validación no reconocida: ' + tipo);
        }
    });

    // Actualizar el estado del campo en el objeto estadoCampos
    estadoCampos[idInput] = campoValido;
    localStorage.setItem("estadoCampos", JSON.stringify(estadoCampos));

    // Devolver true si el campo es válido, false si no lo es
    return campoValido;
}


// Función para adjuntar eventos de validación a un campo
function eventAttacher(idInput, validaciones) {
    var input = $('#' + idInput);

    // Asignar la función validarCampo a los eventos de input, blur y change
    input.on('input blur change', function () {
        validarCampo(idInput, validaciones);
    });
}

// Función para manejar la visualización del asterisco rojo para campos requeridos
function manejarAsteriscoRojo(input, validaciones) {
    var label;
    var redSpan;

    // Buscar el label adecuado dependiendo del tipo de input
    if (input.attr('id').includes('fecha')) {
        label = input.closest('.fv-row').find('label');
    } else {
        label = input.closest('.fv-row').find('label');
    }

    // Encontrar el span de error (si existe)
    redSpan = label.find('span.error-span');

    // Verificar si hay validaciones de tipo notEmpty
    var contieneNotEmpty = validaciones.some(function (validation) {
        return validation.tipo === "notEmpty" || validation.tipo === "datalist";
    });

    // Manejo de la lógica para agregar o quitar el asterisco rojo
    if (!contieneNotEmpty && validaciones.length > 0) {
        // No hay validaciones notEmpty, remover el asterisco si existe
        if (redSpan.length) {
            redSpan.remove();
        }
    } else if (contieneNotEmpty && validaciones.length > 0) {
        // Hay validaciones notEmpty, agregar el asterisco si no existe
        if (!redSpan.length) {
            label.append('<span class="error-span" style="color: red;">*</span>');
        }
    }
}




localStorage.setItem("estadoCampos", JSON.stringify({}));

// Inicializar el formulario
function inicializarFormulario(campos) {
    // Objeto para almacenar el estado de cada campo
    var estadoCampos = JSON.parse(localStorage.getItem("estadoCampos")) || {};

    localStorage.setItem("campos", JSON.stringify(campos));

    // Recorrer los campos
    campos.forEach(function (campo) {
        // Obtener el input por su id
        var input = $('#' + campo.campo);
        var validaciones = campo.validaciones;

        // Verificar si el campo ya existe en estadoCampos
        if (!(campo.campo in estadoCampos)) {
            // Si no existe, inicializar el estado del campo como false
            estadoCampos[campo.campo] = false;
        }

        // Verificar si hay validaciones
        if (validaciones && validaciones.length > 0) {
            // Aplicar cada validación al input
            eventAttacher(campo.campo, validaciones);
        }

        // Manejar la visualización del asterisco rojo para campos requeridos
        if (validaciones.some(function (validation) { return validation.tipo === "notEmpty" || validation.tipo === "datalist" })) {
            manejarAsteriscoRojo(input, validaciones)
        }
    });

    // Eliminar campos en estadoCampos que no están presentes en la lista de campos proporcionada
    for (var campo in estadoCampos) {
        if (estadoCampos.hasOwnProperty(campo) && !campos.some(function (c) { return c.campo === campo; })) {
            delete estadoCampos[campo];
        }
    }

    // Guardar el objeto actualizado en localStorage
    localStorage.setItem("estadoCampos", JSON.stringify(estadoCampos));
}


