/**
 * Maneja la validación de formularios para TRAUMA 2025
 * Este script proporciona validación genérica de campos
 */

document.addEventListener('DOMContentLoaded', function() {
    // Función para validar un campo específico
    function validateField(field) {
        const fieldType = field.type;
        const fieldValue = field.value.trim();
        const isRequired = field.hasAttribute('required');
        const fieldId = field.id;
        const errorElement = document.getElementById(`${fieldId}-error`);
        
        // Verificar si el campo es obligatorio y está vacío
        if (isRequired && fieldValue === '') {
            setFieldError(field, errorElement, 'Este campo es obligatorio');
            return false;
        }
        
        // Validar según el tipo de campo
        switch (fieldType) {
            case 'email':
                if (fieldValue !== '' && !isValidEmail(fieldValue)) {
                    setFieldError(field, errorElement, 'Por favor, ingrese un email válido');
                    return false;
                }
                break;
                
            case 'tel':
                if (fieldValue !== '' && !isValidPhone(fieldValue)) {
                    setFieldError(field, errorElement, 'Por favor, ingrese un número de teléfono válido');
                    return false;
                }
                break;
                
            case 'number':
                if (fieldValue !== '') {
                    const min = parseFloat(field.getAttribute('min'));
                    const max = parseFloat(field.getAttribute('max'));
                    
                    if (!isNaN(min) && parseFloat(fieldValue) < min) {
                        setFieldError(field, errorElement, `El valor mínimo es ${min}`);
                        return false;
                    }
                    
                    if (!isNaN(max) && parseFloat(fieldValue) > max) {
                        setFieldError(field, errorElement, `El valor máximo es ${max}`);
                        return false;
                    }
                }
                break;
                
            case 'password':
                if (fieldValue !== '' && field.getAttribute('data-min-length')) {
                    const minLength = parseInt(field.getAttribute('data-min-length'));
                    
                    if (fieldValue.length < minLength) {
                        setFieldError(field, errorElement, `La contraseña debe tener al menos ${minLength} caracteres`);
                        return false;
                    }
                }
                break;
                
            case 'file':
                if (isRequired && field.files.length === 0) {
                    setFieldError(field, errorElement, 'Por favor, seleccione un archivo');
                    return false;
                }
                
                if (field.files.length > 0) {
                    const fileValidation = window.fileUploader ? 
                                         window.fileUploader.validateFile(field.files[0]) : 
                                         { valid: true };
                    
                    if (!fileValidation.valid) {
                        setFieldError(field, errorElement, fileValidation.errorMessage);
                        return false;
                    }
                }
                break;
                
            default:
                // Para textarea, validar límites de palabras si está configurado
                if (field.tagName.toLowerCase() === 'textarea' && window.wordCounter) {
                    if (!window.wordCounter.validateWordCount(fieldId)) {
                        // El mensaje de error lo maneja el word counter
                        return false;
                    }
                }
                break;
        }
        
        // Si pasó todas las validaciones, limpiar errores
        clearFieldError(field, errorElement);
        return true;
    }
    
    // Establecer error en un campo
    function setFieldError(field, errorElement, message) {
        field.classList.add('error');
        
        if (errorElement) {
            errorElement.textContent = message;
            errorElement.style.display = 'block';
        }
    }
    
    // Limpiar error de un campo
    function clearFieldError(field, errorElement) {
        field.classList.remove('error');
        
        if (errorElement) {
            errorElement.style.display = 'none';
        }
    }
    
    // Validar formato de email
    function isValidEmail(email) {
        const re = /^(([^<>()\[\]\\.,;:\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,}))$/;
        return re.test(String(email).toLowerCase());
    }
    
    // Validar formato de teléfono (básico)
    function isValidPhone(phone) {
        // Permitir números, espacios, paréntesis, guiones y el signo +
        const re = /^[0-9()+\- ]+$/;
        return re.test(phone) && phone.replace(/[^0-9]/g, '').length >= 7;
    }
    
    // Validar formulario completo
    function validateForm(form) {
        const fields = form.querySelectorAll('input, select, textarea');
        let isValid = true;
        
        fields.forEach(field => {
            if (!validateField(field)) {
                isValid = false;
            }
        });
        
        return isValid;
    }
    
    // Adjuntar eventos de validación en tiempo real a todos los campos
    function initValidation() {
        const fields = document.querySelectorAll('input, select, textarea');
        
        fields.forEach(field => {
            // Validar en tiempo real según el tipo de campo
            if (field.type === 'text' || field.type === 'email' || field.type === 'tel' || 
                field.type === 'number' || field.type === 'password' || field.tagName.toLowerCase() === 'textarea') {
                
                field.addEventListener('blur', function() {
                    validateField(this);
                });
                
                field.addEventListener('input', function() {
                    // Si ya estaba marcado como error, validar en tiempo real
                    if (this.classList.contains('error')) {
                        validateField(this);
                    }
                });
            } else if (field.type === 'radio' || field.type === 'checkbox' || field.tagName.toLowerCase() === 'select') {
                field.addEventListener('change', function() {
                    validateField(this);
                });
            } else if (field.type === 'file') {
                field.addEventListener('change', function() {
                    validateField(this);
                });
            }
        });
        
        // Validación de campos que deben coincidir (como contraseñas)
        const confirmFields = document.querySelectorAll('[data-match]');
        
        confirmFields.forEach(field => {
            const targetId = field.getAttribute('data-match');
            const targetField = document.getElementById(targetId);
            
            if (targetField) {
                field.addEventListener('blur', function() {
                    const errorElement = document.getElementById(`${field.id}-error`);
                    
                    if (field.value !== targetField.value) {
                        setFieldError(field, errorElement, 'Los campos no coinciden');
                    } else {
                        clearFieldError(field, errorElement);
                    }
                });
            }
        });
    }
    
    // Inicializar validación
    initValidation();
    
    // Exponer funciones para uso en otros scripts
    window.formValidator = {
        validateField,
        validateForm,
        setFieldError,
        clearFieldError
    };
});