wagtail-enap-designsystem 1.2.1.127__py3-none-any.whl → 1.2.1.128__py3-none-any.whl

enap_designsystem/templates/enap_designsystem/form_templates/formulario_page.html

@@ -1419,7 +1419,7 @@
 </div>
 
 <script>
-    // 🎯 CONFIGURAÇÕES GLOBAIS CORRIGIDAS
+    // VARIÁVEIS GLOBAIS
     let currentStep = 0;
     let currentActiveWizardIndex = 0;
     let isScrolling = false;
@@ -1427,242 +1427,85 @@
     const totalSteps = formSteps + 2;
     const successStepIndex = formSteps + 1;
     let wizardSteps = [];
-
-    console.log(`📊 Config: formSteps=${formSteps}, totalSteps=${totalSteps}`);
-
-    // 📍 INICIALIZAÇÃO DOS STEPS DO WIZARD BASEADO EM DIVISORES (COMO ORIGINAL)
-    function initializeWizard() {
-        // Encontrar todos os elementos .divider-title em TODOS os steps do formulário
-        const allDividers = [];
-        
-        for (let i = 1; i <= formSteps; i++) {
-            const stepElement = document.getElementById(`step${i}`);
-            if (stepElement) {
-                const dividers = stepElement.querySelectorAll('.divider-title');
-                dividers.forEach(divider => {
-                    allDividers.push({
-                        title: divider.textContent.trim(),
-                        element: divider,
-                        stepNumber: i
-                    });
-                });
-            }
-        }
-        
-        // Se não encontrou divisores, criar steps padrão baseado nos form steps
-        if (allDividers.length === 0) {
-            console.log('⚠️ Nenhum divisor encontrado, usando steps do formulário');
-            for (let i = 1; i <= formSteps; i++) {
-                allDividers.push({
-                    title: `Etapa ${i}`,
-                    element: null,
-                    stepNumber: i
-                });
-            }
-        }
-        
-        wizardSteps = allDividers;
-        
-        console.log(`📍 Wizard inicializado com ${wizardSteps.length} divisores:`, wizardSteps.map(s => s.title));
-        
-        // Criar visual do wizard
-        createWizardSteps();
+    
+    // DADOS DO DJANGO COM VALIDAÇÃO
+    let sectionMapData = {};
+    let navigationDataRaw = {};
+    
+    try {
+        {% if section_map_json %}
+            sectionMapData = {{ section_map_json|safe }};
+        {% endif %}
+    } catch(e) {
+        console.log('Section map não disponível');
+        sectionMapData = {};
     }
-
-    // 🎨 CRIAR ELEMENTOS VISUAIS DO WIZARD - VERSÃO MELHORADA
-    function createWizardSteps() {
-        const wizardContainer = document.getElementById('wizardSteps');
-        if (!wizardContainer) return;
-        
-        wizardContainer.innerHTML = '';
-        
-        wizardSteps.forEach((step, index) => {
-            const stepDiv = document.createElement('div');
-            stepDiv.className = 'wizard-step';
-            stepDiv.style.cursor = 'pointer';
-            stepDiv.setAttribute('data-index', index);
-            stepDiv.setAttribute('data-step-number', step.stepNumber);
-            
-            stepDiv.innerHTML = `
-                <div class="step-circle">
-                    <span>${index + 1}</span>
-                </div>
-                <div class="step-label">${step.title}</div>
-            `;
-            
-            // 🎯 CLIQUE PARA NAVEGAR
-            stepDiv.addEventListener('click', () => {
-                scrollToWizardStep(index);
-            });
-            
-            wizardContainer.appendChild(stepDiv);
-        });
-        
-        console.log(`✅ ${wizardSteps.length} steps visuais criados com eventos de clique`);
+    
+    try {
+        {% if navigation_data_json %}
+            navigationDataRaw = {{ navigation_data_json|safe }};
+        {% endif %}
+    } catch(e) {
+        console.log('Navigation data não disponível');
+        navigationDataRaw = {};
     }
-
-    // 📡 CONFIGURAR DETECÇÃO DE SCROLL - COM PRIMEIRO STEP ATIVO POR PADRÃO
-    function setupScrollDetection() {
-        const formContent = document.getElementById('formContent');
-        if (!formContent) {
-            console.error('❌ #formContent não encontrado');
+    
+    // SISTEMA DE NAVEGAÇÃO INTELIGENTE
+    let sectionMap = sectionMapData || {};
+    let navigationData = navigationDataRaw || {};
+    let hiddenSections = new Set();
+    
+    console.log('Config: formSteps=' + formSteps + ', totalSteps=' + totalSteps);
+    
+    // FUNÇÕES PRINCIPAIS - ESCOPO GLOBAL
+    function nextStep() {
+        console.log('nextStep: currentStep=' + currentStep);
+        
+        if (currentStep === 0) {
+            currentStep = 1;
+            showStep(currentStep);
             return;
         }
         
-        let scrollTimeout;
-        
-        function handleScroll() {
-            if (isScrolling) return; // Evitar conflito durante scroll programático
-            
-            const scrollTop = formContent.scrollTop;
-            const containerHeight = formContent.clientHeight;
-            const viewportCenter = scrollTop + (containerHeight / 3); // 1/3 da tela como referência
-            
-            console.log(`📜 Scroll: ${scrollTop}px, ViewportCenter: ${viewportCenter}px`);
-            
-            // COMEÇAR COM O PRIMEIRO STEP ATIVO
-            let newActiveIndex = 0;
-            let closestDistance = Infinity;
-            
-            wizardSteps.forEach((step, index) => {
-                if (!step.element) return;
-                
-                // Calcular posição absoluta do divisor
-                const elementRect = step.element.getBoundingClientRect();
-                const containerRect = formContent.getBoundingClientRect();
-                const elementTop = elementRect.top - containerRect.top + scrollTop;
-                
-                // Log para debug
-                console.log(`  ${index + 1}: "${step.title}" - Top: ${elementTop}px`);
-                
-                // Se passou deste divisor, ele vira ativo (mantém o último que passou)
-                if (elementTop <= viewportCenter + 50) { // Margem menor para mais precisão
-                    newActiveIndex = index;
-                    console.log(`    ✅ Step ${index + 1} passou pelo viewportCenter`);
-                }
-            });
-            
-            // Atualizar visual se mudou
-            if (newActiveIndex !== currentActiveWizardIndex) {
-                const previousIndex = currentActiveWizardIndex;
-                currentActiveWizardIndex = newActiveIndex;
-                
-                updateWizardVisual();
-                updateDividerVisual();
-                
-                console.log(`🎯 MUDANÇA! De ${previousIndex + 1} para ${newActiveIndex + 1} - "${wizardSteps[newActiveIndex]?.title}"`);
+        if (currentStep >= 1 && currentStep <= formSteps) {
+            if (!validateCurrentStep()) {
+                console.log('Validação falhou');
+                return;
             }
         }
         
-        // DEFINIR PRIMEIRO STEP COMO ATIVO INICIALMENTE
-        currentActiveWizardIndex = 0;
-        updateWizardVisual();
-        updateDividerVisual();
-        console.log('🎯 Primeiro step definido como ativo inicialmente');
-        
-        // Adicionar listener com debounce menor para mais responsividade
-        formContent.addEventListener('scroll', () => {
-            clearTimeout(scrollTimeout);
-            scrollTimeout = setTimeout(handleScroll, 30); // Mais rápido
-        });
-        
-        // Detecção inicial após um delay
-        setTimeout(handleScroll, 300);
-        
-        console.log('📡 Scroll detection configurado - Primeiro step ativo por padrão');
-    }
-
-    // 🎨 ATUALIZAR VISUAL DO WIZARD - VERSÃO MELHORADA COM LOG
-    function updateWizardVisual() {
-        const allSteps = document.querySelectorAll('.wizard-step');
-        
-        allSteps.forEach((stepElement, index) => {
-            // Remover todas as classes de status
-            stepElement.classList.remove('active', 'completed');
-            
-            // Aplicar classes baseado no índice atual
-            if (index < currentActiveWizardIndex) {
-                stepElement.classList.add('completed');
-            } else if (index === currentActiveWizardIndex) {
-                stepElement.classList.add('active');
-            }
-        });
-        
-        console.log(`🎨 Wizard atualizado - Step ${currentActiveWizardIndex + 1}/${wizardSteps.length} ativo: "${wizardSteps[currentActiveWizardIndex]?.title}"`);
-        
-        // Log das classes aplicadas
-        allSteps.forEach((el, i) => {
-            const classes = Array.from(el.classList).filter(c => ['active', 'completed'].includes(c)).join(', ');
-            if (classes) {
-                console.log(`  Step ${i + 1}: ${classes}`);
+        if (currentStep === formSteps) {
+            const form = document.getElementById('wagtailForm');
+            if (form) {
+                form.submit();
             }
-        });
-    }
-
-    // 🎯 ATUALIZAR VISUAL DOS DIVISORES
-    function updateDividerVisual() {
-        // Remover classe active de todos os divisores
-        document.querySelectorAll('.divider-title').forEach(divider => {
-            divider.classList.remove('active');
-        });
+            return;
+        }
         
-        // Adicionar classe active ao divisor atual
-        const activeStep = wizardSteps[currentActiveWizardIndex];
-        if (activeStep && activeStep.element) {
-            activeStep.element.classList.add('active');
+        if (currentStep < totalSteps - 1) {
+            currentStep++;
+            showStep(currentStep);
         }
     }
-
-    // 🎯 SCROLL PARA DIVISOR ESPECÍFICO
-    function scrollToWizardStep(stepIndex) {
-        if (stepIndex < 0 || stepIndex >= wizardSteps.length) return;
-        
-        const step = wizardSteps[stepIndex];
-        const formContent = document.getElementById('formContent');
-        
-        if (!step.element || !formContent) {
-            console.log(`❌ Divisor ${stepIndex} não tem elemento ou formContent não encontrado`);
-            return;
+    
+    function prevStep() {
+        if (currentStep > 1) {
+            currentStep--;
+            showStep(currentStep);
         }
-        
-        isScrolling = true; // Flag para evitar conflito
-        
-        // Calcular posição alvo do divisor
-        const elementRect = step.element.getBoundingClientRect();
-        const containerRect = formContent.getBoundingClientRect();
-        const relativeTop = elementRect.top - containerRect.top + formContent.scrollTop;
-        const targetScrollTop = relativeTop - 100; // 100px de offset
-        
-        console.log(`🎯 Scrolling para divisor ${stepIndex}: "${step.title}" - targetScrollTop: ${targetScrollTop}px`);
-        
-        // Scroll suave
-        formContent.scrollTo({
-            top: targetScrollTop,
-            behavior: 'smooth'
-        });
-        
-        // Atualizar estado imediatamente
-        currentActiveWizardIndex = stepIndex;
-        updateWizardVisual();
-        updateDividerVisual();
-        
-        // Liberar flag após scroll
-        setTimeout(() => {
-            isScrolling = false;
-        }, 1000);
     }
-
-    // 🎨 MOSTRAR STEP PRINCIPAL
+    
     function showStep(step) {
-        console.log(`🎯 Mostrando step: ${step}`);
+        console.log('Mostrando step: ' + step);
         
         // Ocultar todos os steps
-        document.querySelectorAll('.step-content').forEach(content => {
-            content.classList.remove('active');
-        });
+        const allSteps = document.querySelectorAll('.step-content');
+        for (let i = 0; i < allSteps.length; i++) {
+            allSteps[i].classList.remove('active');
+        }
         
         // Mostrar step atual
-        const stepElement = document.getElementById(`step${step}`);
+        const stepElement = document.getElementById('step' + step);
         if (stepElement) {
             stepElement.classList.add('active');
         }
@@ -1697,9 +1540,8 @@
             }
             
             // Configurar scroll listener
-            setTimeout(() => {
+            setTimeout(function() {
                 setupScrollDetection();
-                // Garantir que o primeiro step está ativo após setup
                 if (currentActiveWizardIndex === 0) {
                     updateWizardVisual();
                     updateDividerVisual();
@@ -1713,69 +1555,30 @@
             formContent.scrollTop = 0;
         }
     }
-
-    // 🚀 NAVEGAÇÃO ENTRE STEPS PRINCIPAIS
-    function nextStep() {
-        console.log(`🚀 nextStep: currentStep=${currentStep}`);
-        
-        if (currentStep === 0) {
-            currentStep = 1;
-            showStep(currentStep);
-            return;
-        }
-        
-        if (currentStep >= 1 && currentStep <= formSteps) {
-            if (!validateCurrentStep()) {
-                console.log('❌ Validação falhou');
-                return;
-            }
-        }
-        
-        if (currentStep === formSteps) {
-            const form = document.getElementById('wagtailForm');
-            if (form) {
-                form.submit();
-            }
-            return;
-        }
-        
-        if (currentStep < totalSteps - 1) {
-            currentStep++;
-            showStep(currentStep);
-        }
-    }
-
-    function prevStep() {
-        if (currentStep > 1) {
-            currentStep--;
-            showStep(currentStep);
-        }
-    }
-
-    // ⬅️➡️ NAVEGAÇÃO SEQUENCIAL DO WIZARD
-    function scrollToNext() {
-        const nextIndex = Math.min(currentActiveWizardIndex + 1, wizardSteps.length - 1);
-        scrollToWizardStep(nextIndex);
-    }
-
-    function scrollToPrevious() {
-        const prevIndex = Math.max(currentActiveWizardIndex - 1, 0);
-        scrollToWizardStep(prevIndex);
-    }
-
-    // 🔍 VALIDAÇÃO DO STEP ATUAL
+    
     function validateCurrentStep() {
-        const currentStepElement = document.getElementById(`step${currentStep}`);
+        const currentStepElement = document.getElementById('step' + currentStep);
         if (!currentStepElement) return true;
         
         let isValid = true;
         const requiredInputs = currentStepElement.querySelectorAll('input[required], select[required], textarea[required]');
         
-        requiredInputs.forEach(input => {
+        for (let i = 0; i < requiredInputs.length; i++) {
+            const input = requiredInputs[i];
+            
             // Pular campos que estão dentro de conditional-fields ocultos
             const conditionalParent = input.closest('.conditional-fields');
             if (conditionalParent && conditionalParent.style.display === 'none') {
-                return;
+                continue;
+            }
+            
+            // Pular campos em seções ocultas
+            const sectionElement = input.closest('[data-section-name]');
+            if (sectionElement) {
+                const sectionName = sectionElement.dataset.sectionName;
+                if (hiddenSections.has(sectionName)) {
+                    continue;
+                }
             }
             
             // Limpar erros anteriores
@@ -1789,8 +1592,13 @@
             if (input.type === 'checkbox') {
                 hasValue = input.checked;
             } else if (input.type === 'radio') {
-                const radioGroup = currentStepElement.querySelectorAll(`input[name="${input.name}"]`);
-                hasValue = Array.from(radioGroup).some(radio => radio.checked);
+                const radioGroup = currentStepElement.querySelectorAll('input[name="' + input.name + '"]');
+                for (let j = 0; j < radioGroup.length; j++) {
+                    if (radioGroup[j].checked) {
+                        hasValue = true;
+                        break;
+                    }
+                }
             } else {
                 hasValue = input.value.trim() !== '';
             }
@@ -1798,34 +1606,12 @@
             if (!hasValue) {
                 showFieldError(input, 'Este campo é obrigatório');
                 isValid = false;
-            } else {
-                // Validações específicas
-                if (input.type === 'email' && input.value) {
-                    if (!validateEmail(input.value)) {
-                        showFieldError(input, 'Email inválido');
-                        isValid = false;
-                    }
-                }
-                
-                if (input.classList.contains('cpf-field') && input.value) {
-                    if (!validateCPF(input.value)) {
-                        showFieldError(input, 'CPF deve ter 9 dígitos');
-                        isValid = false;
-                    }
-                }
-                
-                if (input.classList.contains('phone-field') && input.value) {
-                    if (!validatePhone(input.value)) {
-                        showFieldError(input, 'Telefone inválido');
-                        isValid = false;
-                    }
-                }
             }
-        });
+        }
         
         return isValid;
     }
-
+    
     function showFieldError(input, message) {
         let errorDiv = input.parentNode.querySelector('.error-message');
         if (!errorDiv) {
@@ -1836,49 +1622,352 @@
         errorDiv.textContent = message;
         errorDiv.style.display = 'block';
         
-        // Scroll para o campo com erro
         input.scrollIntoView({ behavior: 'smooth', block: 'center' });
         input.focus();
     }
-
-    function validateEmail(email) {
-        const re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-        return re.test(email);
-    }
-
-    function validateCPF(cpf) {
-        const digits = cpf.replace(/[^0-9]/g, '');
-        return digits.length === 11;
-    }
-
-    function validatePhone(phone) {
-        const digits = phone.replace(/[^0-9]/g, '');
-        return digits.length >= 10 && digits.length <= 11;
-    }
-
-    // 🔍 VERIFICAR SUCCESS NA URL
-    function checkForSuccess() {
-        const urlParams = new URLSearchParams(window.location.search);
-        const hasSuccess = urlParams.get('success') === '1';
+    
+    // SISTEMA DE NAVEGAÇÃO INTELIGENTE
+    function initializeSmartNavigation() {
+        console.log('Inicializando Smart Navigation');
         
-        if (hasSuccess) {
-            console.log(`✅ Success detectado! Indo para step ${successStepIndex}`);
-            currentStep = successStepIndex;
-            showStep(currentStep);
-            return true;
+        // Verificar se temos dados
+        if (Object.keys(sectionMap).length === 0 && Object.keys(navigationData).length === 0) {
+            console.log('Dados de navegação não disponíveis');
+            return;
         }
-        return false;
+        
+        // Adicionar listeners
+        document.addEventListener('change', function(e) {
+            const smartField = e.target.closest('[data-field-type="smart_navigation_field"]');
+            if (smartField) {
+                handleSmartNavigation(e.target);
+            }
+        });
+        
+        hideDefaultHiddenSections();
+        console.log('Sistema de Navegação Inteligente carregado');
     }
-
-    // 🎉 CONFETTI PARA SUCESSO
-    function createConfetti() {
-        console.log('🎊 Iniciando confetti...');
-        const colors = ['#2d5530', '#4CAF50', '#ffd700', '#ff6b6b', '#e74c3c', '#3498db'];
+    
+    function handleSmartNavigation(element) {
+        const fieldContainer = element.closest('[data-field-type="smart_navigation_field"]');
+        if (!fieldContainer) return;
         
-        for (let i = 0; i < 50; i++) {
-            setTimeout(() => {
-                const confetti = document.createElement('div');
-                confetti.className = 'confetti';
+        const fieldId = fieldContainer.dataset.fieldId;
+        const selectedValue = getSelectedValue(element);
+        
+        if (!navigationData[fieldId] || !selectedValue) {
+            return;
+        }
+        
+        const actionData = navigationData[fieldId][selectedValue];
+        if (!actionData) {
+            return;
+        }
+        
+        console.log('Navegação ativada: ' + fieldId + ' -> ' + selectedValue);
+        
+        // Executar ação baseada no tipo
+        switch (actionData.action_type) {
+            case 'continue':
+                console.log('Continuando navegação normal');
+                break;
+                
+            case 'jump_to_section':
+                handleJumpToSection(actionData.target_section);
+                break;
+                
+            case 'finish_form':
+                handleFinishForm();
+                break;
+                
+            case 'show_message_and_finish':
+                handleShowMessageAndFinish(actionData);
+                break;
+        }
+    }
+    
+    function getSelectedValue(element) {
+        if (element.type === 'radio') {
+            const radioGroup = document.querySelectorAll('input[name="' + element.name + '"]');
+            for (let i = 0; i < radioGroup.length; i++) {
+                if (radioGroup[i].checked) {
+                    return radioGroup[i].value;
+                }
+            }
+            return null;
+        } else if (element.type === 'checkbox') {
+            return element.checked ? element.value : null;
+        } else if (element.tagName === 'SELECT') {
+            return element.value;
+        }
+        return element.value;
+    }
+    
+    function handleJumpToSection(targetSectionName) {
+        if (!targetSectionName || !sectionMap[targetSectionName]) {
+            console.log('Seção não encontrada: ' + targetSectionName);
+            return;
+        }
+        
+        const targetSection = sectionMap[targetSectionName];
+        showSection(targetSectionName);
+        
+        currentStep = targetSection.step;
+        showStep(currentStep);
+        
+        setTimeout(function() {
+            scrollToSection(targetSection.block_id);
+        }, 100);
+        
+        console.log('Pulando para seção: ' + targetSectionName);
+    }
+    
+    function handleFinishForm() {
+        currentStep = totalSteps - 1;
+        showStep(currentStep);
+        console.log('Formulário finalizado antecipadamente');
+    }
+    
+    function hideDefaultHiddenSections() {
+        const sections = Object.keys(sectionMap);
+        for (let i = 0; i < sections.length; i++) {
+            const sectionName = sections[i];
+            const sectionData = sectionMap[sectionName];
+            if (sectionData.hidden_by_default) {
+                hideSection(sectionName);
+            }
+        }
+    }
+    
+    function hideSection(sectionName) {
+        const sectionData = sectionMap[sectionName];
+        if (!sectionData) return;
+        
+        hiddenSections.add(sectionName);
+        
+        const sectionElement = document.querySelector('[data-section-name="' + sectionName + '"]');
+        if (sectionElement) {
+            sectionElement.style.display = 'none';
+            disableFieldsInSection(sectionElement);
+        }
+        
+        console.log('Seção oculta: ' + sectionName);
+    }
+    
+    function showSection(sectionName) {
+        const sectionData = sectionMap[sectionName];
+        if (!sectionData) return;
+        
+        hiddenSections.delete(sectionName);
+        
+        const sectionElement = document.querySelector('[data-section-name="' + sectionName + '"]');
+        if (sectionElement) {
+            sectionElement.style.display = 'block';
+            enableFieldsInSection(sectionElement);
+        }
+        
+        console.log('Seção mostrada: ' + sectionName);
+    }
+    
+    function disableFieldsInSection(sectionElement) {
+        const fields = sectionElement.querySelectorAll('input, select, textarea');
+        for (let i = 0; i < fields.length; i++) {
+            const field = fields[i];
+            field.dataset.wasRequired = field.required ? 'true' : 'false';
+            field.required = false;
+            field.disabled = true;
+        }
+    }
+    
+    function enableFieldsInSection(sectionElement) {
+        const fields = sectionElement.querySelectorAll('input, select, textarea');
+        for (let i = 0; i < fields.length; i++) {
+            const field = fields[i];
+            field.disabled = false;
+            if (field.dataset.wasRequired === 'true') {
+                field.required = true;
+            }
+        }
+    }
+    
+    // WIZARD FUNCTIONS
+    function initializeWizard() {
+        const allDividers = [];
+        
+        for (let i = 1; i <= formSteps; i++) {
+            const stepElement = document.getElementById('step' + i);
+            if (stepElement) {
+                const dividers = stepElement.querySelectorAll('.divider-title');
+                for (let j = 0; j < dividers.length; j++) {
+                    allDividers.push({
+                        title: dividers[j].textContent.trim(),
+                        element: dividers[j],
+                        stepNumber: i
+                    });
+                }
+            }
+        }
+        
+        if (allDividers.length === 0) {
+            for (let i = 1; i <= formSteps; i++) {
+                allDividers.push({
+                    title: 'Etapa ' + i,
+                    element: null,
+                    stepNumber: i
+                });
+            }
+        }
+        
+        wizardSteps = allDividers;
+        createWizardSteps();
+    }
+    
+    function createWizardSteps() {
+        const wizardContainer = document.getElementById('wizardSteps');
+        if (!wizardContainer) return;
+        
+        wizardContainer.innerHTML = '';
+        
+        for (let i = 0; i < wizardSteps.length; i++) {
+            const step = wizardSteps[i];
+            const stepDiv = document.createElement('div');
+            stepDiv.className = 'wizard-step';
+            stepDiv.style.cursor = 'pointer';
+            stepDiv.setAttribute('data-index', i);
+            stepDiv.setAttribute('data-step-number', step.stepNumber);
+            
+            stepDiv.innerHTML = '<div class="step-circle"><span>' + (i + 1) + '</span></div><div class="step-label">' + step.title + '</div>';
+            
+            stepDiv.addEventListener('click', function() {
+                scrollToWizardStep(i);
+            });
+            
+            wizardContainer.appendChild(stepDiv);
+        }
+    }
+    
+    function scrollToWizardStep(stepIndex) {
+        if (stepIndex < 0 || stepIndex >= wizardSteps.length) return;
+        
+        const step = wizardSteps[stepIndex];
+        const formContent = document.getElementById('formContent');
+        
+        if (!step.element || !formContent) return;
+        
+        isScrolling = true;
+        
+        const elementRect = step.element.getBoundingClientRect();
+        const containerRect = formContent.getBoundingClientRect();
+        const relativeTop = elementRect.top - containerRect.top + formContent.scrollTop;
+        const targetScrollTop = relativeTop - 100;
+        
+        formContent.scrollTo({
+            top: targetScrollTop,
+            behavior: 'smooth'
+        });
+        
+        currentActiveWizardIndex = stepIndex;
+        updateWizardVisual();
+        updateDividerVisual();
+        
+        setTimeout(function() {
+            isScrolling = false;
+        }, 1000);
+    }
+    
+    function setupScrollDetection() {
+        const formContent = document.getElementById('formContent');
+        if (!formContent) return;
+        
+        let scrollTimeout;
+        
+        function handleScroll() {
+            if (isScrolling) return;
+            
+            const scrollTop = formContent.scrollTop;
+            const containerHeight = formContent.clientHeight;
+            const viewportCenter = scrollTop + (containerHeight / 3);
+            
+            let newActiveIndex = 0;
+            
+            for (let i = 0; i < wizardSteps.length; i++) {
+                const step = wizardSteps[i];
+                if (!step.element) continue;
+                
+                const elementRect = step.element.getBoundingClientRect();
+                const containerRect = formContent.getBoundingClientRect();
+                const elementTop = elementRect.top - containerRect.top + scrollTop;
+                
+                if (elementTop <= viewportCenter + 50) {
+                    newActiveIndex = i;
+                }
+            }
+            
+            if (newActiveIndex !== currentActiveWizardIndex) {
+                currentActiveWizardIndex = newActiveIndex;
+                updateWizardVisual();
+                updateDividerVisual();
+            }
+        }
+        
+        currentActiveWizardIndex = 0;
+        updateWizardVisual();
+        updateDividerVisual();
+        
+        formContent.addEventListener('scroll', function() {
+            clearTimeout(scrollTimeout);
+            scrollTimeout = setTimeout(handleScroll, 30);
+        });
+        
+        setTimeout(handleScroll, 300);
+    }
+    
+    function updateWizardVisual() {
+        const allSteps = document.querySelectorAll('.wizard-step');
+        
+        for (let i = 0; i < allSteps.length; i++) {
+            const stepElement = allSteps[i];
+            stepElement.classList.remove('active', 'completed');
+            
+            if (i < currentActiveWizardIndex) {
+                stepElement.classList.add('completed');
+            } else if (i === currentActiveWizardIndex) {
+                stepElement.classList.add('active');
+            }
+        }
+    }
+    
+    function updateDividerVisual() {
+        const dividers = document.querySelectorAll('.divider-title');
+        for (let i = 0; i < dividers.length; i++) {
+            dividers[i].classList.remove('active');
+        }
+        
+        const activeStep = wizardSteps[currentActiveWizardIndex];
+        if (activeStep && activeStep.element) {
+            activeStep.element.classList.add('active');
+        }
+    }
+    
+    function checkForSuccess() {
+        const urlParams = new URLSearchParams(window.location.search);
+        const hasSuccess = urlParams.get('success') === '1';
+        
+        if (hasSuccess) {
+            currentStep = successStepIndex;
+            showStep(currentStep);
+            return true;
+        }
+        return false;
+    }
+    
+    function createConfetti() {
+        const colors = ['#2d5530', '#4CAF50', '#ffd700', '#ff6b6b', '#e74c3c', '#3498db'];
+        
+        for (let i = 0; i < 50; i++) {
+            setTimeout(function() {
+                const confetti = document.createElement('div');
+                confetti.className = 'confetti';
                 confetti.style.position = 'fixed';
                 confetti.style.left = Math.random() * 100 + 'vw';
                 confetti.style.top = '-10px';
@@ -1888,12 +1977,12 @@
                 confetti.style.borderRadius = Math.random() > 0.5 ? '50%' : '0';
                 confetti.style.zIndex = '1001';
                 confetti.style.pointerEvents = 'none';
-                confetti.style.animation = `confetti-fall ${Math.random() * 3 + 2}s linear infinite`;
+                confetti.style.animation = 'confetti-fall ' + (Math.random() * 3 + 2) + 's linear infinite';
                 confetti.style.animationDelay = Math.random() * 2 + 's';
                 
                 document.body.appendChild(confetti);
                 
-                setTimeout(() => {
+                setTimeout(function() {
                     if (confetti.parentNode) {
                         confetti.remove();
                     }
@@ -1901,58 +1990,39 @@
             }, i * 50);
         }
     }
-
-    // Adicionar após a função validateCPF
-function validateCNPJ(cnpj) {
-    const digits = cnpj.replace(/[^0-9]/g, '');
-    return digits.length === 14;
-}
-
-// Adicionar na validação do validateCurrentStep
-if (input.classList.contains('cnpj-field') && input.value) {
-    if (!validateCNPJ(input.value)) {
-        showFieldError(input, 'CNPJ deve ter 14 dígitos');
-        isValid = false;
-    }
-}
-
-    // Adicionar formatação automática no listener 'input'
-    // CNPJ - 14 dígitos
-    if (e.target.classList.contains('cnpj-field')) {
-        let value = e.target.value.replace(/[^\d]/g, '');
-        if (value.length > 14) value = value.slice(0, 14);
+    
+    // EVENT LISTENERS E INICIALIZAÇÃO
+    document.addEventListener('DOMContentLoaded', function() {
+        console.log('DOM carregado');
         
-        if (value.length > 12) {
-            value = value.replace(/(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})/, '$1.$2.$3/$4-$5');
-        } else if (value.length > 8) {
-            value = value.replace(/(\d{2})(\d{3})(\d{3})(\d{4})/, '$1.$2.$3/$4');
-        } else if (value.length > 5) {
-            value = value.replace(/(\d{2})(\d{3})(\d{3})/, '$1.$2.$3');
-        } else if (value.length > 2) {
-            value = value.replace(/(\d{2})(\d{3})/, '$1.$2');
+        // Inicializar sistemas
+        initializeSmartNavigation();
+        
+        // Verificar success na URL primeiro
+        if (!checkForSuccess()) {
+            showStep(0);
         }
-        e.target.value = value;
-    }
-
-    // 🎨 FORMATAÇÃO DE CAMPOS
-    document.addEventListener('input', function(e) {
-        // CPF - 9 dígitos
-        // CPF - 11 dígitos
-    if (e.target.classList.contains('cpf-field')) {
-        let value = e.target.value.replace(/[^\d]/g, '');
-        if (value.length > 11) value = value.slice(0, 11);
         
-        if (value.length > 9) {
-            value = value.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, '$1.$2.$3-$4');
-        } else if (value.length > 6) {
-            value = value.replace(/(\d{3})(\d{3})(\d{3})/, '$1.$2.$3');
-        } else if (value.length > 3) {
-            value = value.replace(/(\d{3})(\d{3})/, '$1.$2');
+        // Scroll inicial para o topo
+        window.scrollTo({ top: 0, behavior: 'smooth' });
+    });
+    
+    // FORMATAÇÃO DE CAMPOS
+    document.addEventListener('input', function(e) {
+        if (e.target.classList.contains('cpf-field')) {
+            let value = e.target.value.replace(/[^\d]/g, '');
+            if (value.length > 11) value = value.slice(0, 11);
+            
+            if (value.length > 9) {
+                value = value.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, '$1.$2.$3-$4');
+            } else if (value.length > 6) {
+                value = value.replace(/(\d{3})(\d{3})(\d{3})/, '$1.$2.$3');
+            } else if (value.length > 3) {
+                value = value.replace(/(\d{3})(\d{3})/, '$1.$2');
+            }
+            e.target.value = value;
         }
-        e.target.value = value;
-    }
         
-        // Telefone
         if (e.target.classList.contains('phone-field')) {
             let value = e.target.value.replace(/[^\d]/g, '');
             if (value.length <= 10) {
@@ -1965,8 +2035,8 @@ if (input.classList.contains('cnpj-field') && input.value) {
             e.target.value = value;
         }
     });
-
-    // 🌟 RATING COM ESTRELAS
+    
+    // RATING COM ESTRELAS
     document.addEventListener('click', function(e) {
         if (e.target.classList.contains('star')) {
             const ratingGroup = e.target.parentNode;
@@ -1977,600 +2047,227 @@ if (input.classList.contains('cnpj-field') && input.value) {
                 hiddenInput.value = value;
                 
                 const stars = ratingGroup.querySelectorAll('.star');
-                stars.forEach((star, index) => {
-                    if (index < value) {
-                        star.classList.add('active');
+                for (let i = 0; i < stars.length; i++) {
+                    if (i < value) {
+                        stars[i].classList.add('active');
                     } else {
-                        star.classList.remove('active');
+                        stars[i].classList.remove('active');
                     }
-                });
+                }
                 
                 const ratingText = ratingGroup.querySelector('.rating-text');
                 if (ratingText) {
                     const maxRating = stars.length;
-                    ratingText.textContent = `${value} de ${maxRating} estrelas`;
+                    ratingText.textContent = value + ' de ' + maxRating + ' estrelas';
                 }
             }
         }
     });
+    
+    console.log('Formulário carregado com sucesso!');
 
-    // ⌨️ NAVEGAÇÃO POR TECLADO
-    document.addEventListener('keydown', function(e) {
-        if (e.key === 'Enter' && e.target.tagName !== 'TEXTAREA') {
-            e.preventDefault();
-            nextStep();
-        }
-        
-        if (e.key === 'Escape' && currentStep > 1 && currentStep < successStepIndex) {
-            prevStep();
-        }
-        
-        // Navegação do wizard por teclado
-        if (currentStep >= 1 && currentStep <= formSteps) {
-            if (e.key === 'ArrowDown' || e.key === 'PageDown') {
-                e.preventDefault();
-                scrollToNext();
-            } else if (e.key === 'ArrowUp' || e.key === 'PageUp') {
-                e.preventDefault();
-                scrollToPrevious();
-            }
-        }
-    });
-
-    // 🚀 INICIALIZAÇÃO PRINCIPAL
-    document.addEventListener('DOMContentLoaded', function() {
-        console.log('📄 DOM carregado - Wizard com scroll detection corrigido');
+    // Adicione esta função no seu script principal
+function handleChildrenNavigation(selectedValue, targetSection) {
+    console.log(`Resposta sobre filhos: ${selectedValue}`);
+    
+    if (selectedValue === 'SIM') {
+        // Mostrar perguntas 2-5 sobre filhos
+        showChildrenQuestions();
+        console.log('Mostrando perguntas sobre filhos');
         
-        // Verificar success na URL primeiro
-        if (!checkForSuccess()) {
-            showStep(0);
-        }
+    } else if (selectedValue === 'NÃO') {
+        // Ocultar perguntas 2-5 e pular para próxima seção
+        hideChildrenQuestions();
         
-        // Scroll inicial para o topo
-        window.scrollTo({ top: 0, behavior: 'smooth' });
-    });
-
-    // 🔧 FUNÇÕES DE DEBUG GLOBAIS
-    window.debugFormulario = {
-        currentStep: () => currentStep,
-        currentWizardIndex: () => currentActiveWizardIndex,
-        wizardSteps: () => wizardSteps,
-        goToStep: (step) => {
-            currentStep = step;
-            showStep(step);
-        },
-        goToWizardStep: (index) => scrollToWizardStep(index),
-        updateWizardVisual: () => updateWizardVisual(),
-        logPositions: () => {
-            const formContent = document.getElementById('formContent');
-            const scrollTop = formContent.scrollTop;
-            
-            console.log(`📍 Debug das posições dos divisores:`);
-            console.log(`ScrollTop atual: ${scrollTop}px`);
-            console.log(`Wizard ativo: ${currentActiveWizardIndex + 1}/${wizardSteps.length} - "${wizardSteps[currentActiveWizardIndex]?.title}"`);
-            console.log(`ViewportCenter: ${scrollTop + (formContent.clientHeight / 3)}px`);
-            
-            wizardSteps.forEach((step, index) => {
-                if (step.element) {
-                    const rect = step.element.getBoundingClientRect();
-                    const containerRect = formContent.getBoundingClientRect();
-                    const elementTop = rect.top - containerRect.top + scrollTop;
-                    const viewportCenter = scrollTop + (formContent.clientHeight / 3);
-                    const distance = Math.abs(elementTop - viewportCenter);
-                    const isInView = elementTop <= viewportCenter + 100;
-                    
-                    console.log(`${index + 1}: "${step.title}"`);
-                    console.log(`  - ElementTop: ${elementTop}px`);
-                    console.log(`  - Distance: ${distance}px`);
-                    console.log(`  - InView: ${isInView}`);
-                    console.log(`  - IsActive: ${index === currentActiveWizardIndex}`);
-                    console.log(`  ---`);
-                }
-            });
-        },
-        forceUpdate: (index) => {
-            currentActiveWizardIndex = index;
-            updateWizardVisual();
-            updateDividerVisual();
-            console.log(`🔧 Forçado update para index ${index}`);
+        // Pular para "DADOS PESSOAIS E PROFISSIONAIS"
+        if (targetSection) {
+            setTimeout(() => {
+                redirectToSpecificSection(targetSection);
+            }, 500);
         }
-    };
-
-    console.log('🚀 Wizard com detecção de scroll CORRIGIDO carregado!');
-    console.log('🔧 Para debug: window.debugFormulario');
-    </script>
-
-    {% if form_success %}
-    <script>
-    console.log('🎉 Form success detectado via template');
-    document.addEventListener('DOMContentLoaded', function() {
-        setTimeout(() => {
-            currentStep = successStepIndex;
-            showStep(currentStep);
-        }, 100);
-    });
-
-
-    // ========================================
-    // SISTEMA AVANÇADO DE MULTI-REDIRECIONAMENTO
-    // ========================================
-
-    // Variáveis para controle avançado
-    let multiRedirectFields = new Map();
-    let pendingActions = new Map();
-    let conditionalFieldsVisible = new Set();
-
-    // INICIALIZAÇÃO DOS CAMPOS MULTI-REDIRECT
-    function initializeMultiRedirectFields() {
-        console.log('🔀 Inicializando sistema multi-redirecionamento...');
         
-        const multiRedirectGroups = document.querySelectorAll('.checkbox-multi-redirect-group');
-        
-        multiRedirectGroups.forEach(group => {
-            try {
-                const configData = group.getAttribute('data-field-config');
-                const config = JSON.parse(configData);
-                
-                multiRedirectFields.set(config.fieldId, config);
-                
-                // Configurar listeners baseado no tipo de campo
-                if (config.fieldType === 'checkbox') {
-                    setupCheckboxListeners(group, config);
-                } else if (config.fieldType === 'radio') {
-                    setupRadioListeners(group, config);
-                } else if (config.fieldType === 'dropdown') {
-                    setupDropdownListeners(group, config);
-                }
-                
-                console.log(`✅ Multi-redirect configurado: ${config.fieldId} (${config.fieldType})`);
-                
-            } catch (error) {
-                console.error('❌ Erro configuração multi-redirect:', error);
-            }
-        });
-        
-        console.log(`🔀 ${multiRedirectFields.size} campos multi-redirect ativos`);
+        console.log('Ocultando perguntas sobre filhos e pulando para próxima seção');
     }
+}
 
-    // CONFIGURAR LISTENERS PARA CHECKBOX
-    function setupCheckboxListeners(group, config) {
-        const checkbox = group.querySelector('.multi-redirect-input');
-        const item = group.querySelector('.multi-redirect-item');
-        
-        if (checkbox && item) {
-            checkbox.addEventListener('change', function(e) {
-                const isChecked = e.target.checked;
-                
-                if (isChecked) {
-                    item.classList.add('selected');
-                    handleOptionSelected(config, 0, config.options[0]); // Primeira opção
-                } else {
-                    item.classList.remove('selected');
-                    handleOptionDeselected(config);
+function showChildrenQuestions() {
+    // IDs ou seletores das perguntas 2-5 sobre filhos
+    const childrenQuestionIds = [
+        '#question-2-children',  // Substitua pelos IDs reais
+        '#question-3-children', 
+        '#question-4-children',
+        '#question-5-children'
+    ];
+    
+    childrenQuestionIds.forEach(questionId => {
+        const questionElement = document.querySelector(questionId);
+        if (questionElement) {
+            questionElement.style.display = 'block';
+            questionElement.style.animation = 'fadeIn 0.3s ease-in-out';
+            
+            // Reativar campos obrigatórios
+            const inputs = questionElement.querySelectorAll('input, select, textarea');
+            inputs.forEach(input => {
+                if (input.dataset.originalRequired === 'true') {
+                    input.required = true;
                 }
             });
         }
-    }
+    });
+}
 
-    // CONFIGURAR LISTENERS PARA RADIO
-    function setupRadioListeners(group, config) {
-        const radios = group.querySelectorAll('.multi-redirect-input');
-        const items = group.querySelectorAll('.multi-redirect-item');
-        
-        radios.forEach((radio, index) => {
-            radio.addEventListener('change', function(e) {
-                if (e.target.checked) {
-                    // Remover seleção anterior
-                    items.forEach(item => item.classList.remove('selected'));
-                    
-                    // Adicionar seleção atual
-                    const selectedItem = e.target.closest('.multi-redirect-item');
-                    if (selectedItem) {
-                        selectedItem.classList.add('selected');
-                    }
-                    
-                    const optionIndex = parseInt(e.target.getAttribute('data-option-index'));
-                    handleOptionSelected(config, optionIndex, config.options[optionIndex]);
+function hideChildrenQuestions() {
+    // IDs ou seletores das perguntas 2-5 sobre filhos
+    const childrenQuestionIds = [
+        '#question-2-children',  // Substitua pelos IDs reais
+        '#question-3-children', 
+        '#question-4-children',
+        '#question-5-children'
+    ];
+    
+    childrenQuestionIds.forEach(questionId => {
+        const questionElement = document.querySelector(questionId);
+        if (questionElement) {
+            questionElement.style.display = 'none';
+            
+            // Salvar estado required e desativar
+            const inputs = questionElement.querySelectorAll('input, select, textarea');
+            inputs.forEach(input => {
+                // Salvar estado original
+                if (!input.dataset.originalRequired) {
+                    input.dataset.originalRequired = input.required.toString();
                 }
-            });
-        });
-    }
-
-    // CONFIGURAR LISTENERS PARA DROPDOWN
-    function setupDropdownListeners(group, config) {
-        const select = group.querySelector('.multi-redirect-input');
-        
-        if (select) {
-            select.addEventListener('change', function(e) {
-                const selectedOption = e.target.selectedOptions[0];
+                input.required = false;
                 
-                if (selectedOption && selectedOption.value) {
-                    const optionIndex = parseInt(selectedOption.getAttribute('data-option-index'));
-                    handleOptionSelected(config, optionIndex, config.options[optionIndex]);
+                // Limpar valores
+                if (input.type === 'checkbox' || input.type === 'radio') {
+                    input.checked = false;
                 } else {
-                    handleOptionDeselected(config);
+                    input.value = '';
                 }
             });
         }
-    }
+    });
+}
 
-    // GERENCIAR OPÇÃO SELECIONADA
-    function handleOptionSelected(config, optionIndex, option) {
-        console.log(`🎯 Opção selecionada: "${option.value}" - Ação: ${option.action}`);
-        
-        const fieldId = config.fieldId;
-        const group = document.querySelector(`[data-field-id="${fieldId}"]`);
-        
-        // Limpar ações anteriores
-        clearPreviousActions(fieldId);
-        
-        // Mostrar mensagem se configurada
-        if (option.message) {
-            showRedirectMessage(fieldId, optionIndex, option.message);
+// Modificar a função handleSmartNavigation para incluir a lógica de filhos
+function handleSmartNavigation(element) {
+    const fieldContainer = element.closest('[data-field-type="smart_navigation_field"]');
+    if (!fieldContainer) return;
+    
+    const fieldId = fieldContainer.dataset.fieldId;
+    const selectedValue = getSelectedValue(element);
+    
+    // Verificar se é a pergunta sobre filhos (substitua pelo ID real)
+    if (fieldId.includes('filhos') || fieldContainer.querySelector('label').textContent.toLowerCase().includes('filhos')) {
+        // Encontrar dados de navegação
+        if (!navigationData[fieldId] || !selectedValue) {
+            return;
         }
         
-        // Processar ação baseada no tipo
-        switch (option.action) {
-            case 'continue':
-                // Não fazer nada, apenas continuar
-                console.log('➡️ Continuando normalmente');
-                break;
-                
-            case 'next_step':
-                schedulePendingAction(fieldId, {
-                    type: 'next_step',
-                    delay: option.delay || 1,
-                    message: option.message
-                });
-                break;
-                
-            case 'specific_section':
-                if (option.targetSection) {
-                    schedulePendingAction(fieldId, {
-                        type: 'specific_section',
-                        target: option.targetSection,
-                        delay: option.delay || 1,
-                        message: option.message
-                    });
-                }
-                break;
-                
-            case 'skip_to_end':
-                schedulePendingAction(fieldId, {
-                    type: 'skip_to_end',
-                    delay: option.delay || 2,
-                    message: option.message
-                });
-                break;
-                
-            case 'show_fields':
-                showConditionalFields(fieldId, option.value);
-                break;
+        const actionData = navigationData[fieldId][selectedValue];
+        if (!actionData) {
+            return;
         }
-    }
-
-    // GERENCIAR OPÇÃO DESELECIONADA
-    function handleOptionDeselected(config) {
-        const fieldId = config.fieldId;
-        console.log(`❌ Opção deselecionada: ${fieldId}`);
         
-        clearPreviousActions(fieldId);
-        hideAllConditionalFields(fieldId);
+        // Executar lógica específica para filhos
+        handleChildrenNavigation(selectedValue, actionData.target_section);
+        return;
     }
-
-    // AGENDAR AÇÃO PENDENTE
-    function schedulePendingAction(fieldId, action) {
-        // Adicionar indicador visual
-        const group = document.querySelector(`[data-field-id="${fieldId}"]`);
-        if (group) {
-            group.classList.add('action-pending');
-            
-            let pendingText = '🔄 Processando...';
-            if (action.type === 'next_step') pendingText = '⏩ Próxima etapa...';
-            else if (action.type === 'specific_section') pendingText = '🎯 Redirecionando...';
-            else if (action.type === 'skip_to_end') pendingText = '⏭️ Finalizando...';
-            
-            group.setAttribute('data-pending-action', pendingText);
-        }
-        
-        // Agendar execução
-        pendingActions.set(fieldId, action);
-        
-        console.log(`📅 Ação agendada para ${action.delay}s: ${action.type}`);
+    
+    // Continuar com lógica normal para outros campos
+    if (!navigationData[fieldId] || !selectedValue) {
+        return;
     }
-
-    // LIMPAR AÇÕES ANTERIORES
-    function clearPreviousActions(fieldId) {
-        // Remover ação pendente
-        pendingActions.delete(fieldId);
-        
-        // Remover indicador visual
-        const group = document.querySelector(`[data-field-id="${fieldId}"]`);
-        if (group) {
-            group.classList.remove('action-pending');
-            group.removeAttribute('data-pending-action');
-        }
-        
-        // Ocultar mensagens
-        hideAllRedirectMessages(fieldId);
+    
+    const actionData = navigationData[fieldId][selectedValue];
+    if (!actionData) {
+        return;
     }
-
-    // MOSTRAR MENSAGEM DE REDIRECIONAMENTO
-    function showRedirectMessage(fieldId, optionIndex, message) {
-        const blockId = fieldId.split('_').pop();
-        const messageElement = document.getElementById(`redirect_message_${blockId}_${optionIndex}`);
-        
-        if (messageElement) {
-            messageElement.style.display = 'block';
+    
+    console.log(`Navegação ativada: ${fieldId} -> ${selectedValue}`);
+    
+    // Executar ação baseada no tipo
+    switch (actionData.action_type) {
+        case 'continue':
+            console.log('Continuando navegação normal');
+            break;
             
-            setTimeout(() => {
-                messageElement.scrollIntoView({ 
-                    behavior: 'smooth', 
-                    block: 'center' 
-                });
-            }, 100);
-        }
-    }
-
-    // OCULTAR TODAS AS MENSAGENS
-    function hideAllRedirectMessages(fieldId) {
-        const blockId = fieldId.split('_').pop();
-        const messages = document.querySelectorAll(`[id^="redirect_message_${blockId}_"]`);
-        
-        messages.forEach(message => {
-            message.style.display = 'none';
-        });
-    }
-
-    // MOSTRAR CAMPOS CONDICIONAIS
-    function showConditionalFields(fieldId, optionValue) {
-        const conditionalField = document.querySelector(`[data-parent-field="${fieldId}"][data-option-value="${optionValue}"]`);
-        
-        if (conditionalField) {
-            conditionalField.style.display = 'block';
-            conditionalFieldsVisible.add(`${fieldId}_${optionValue}`);
+        case 'jump_to_section':
+            handleJumpToSection(actionData.target_section);
+            break;
             
-            console.log(`👁️ Campos condicionais mostrados para: ${optionValue}`);
+        case 'finish_form':
+            handleFinishForm();
+            break;
             
-            setTimeout(() => {
-                conditionalField.scrollIntoView({ 
-                    behavior: 'smooth', 
-                    block: 'center' 
-                });
-            }, 200);
-        }
-    }
-
-    // OCULTAR TODOS OS CAMPOS CONDICIONAIS
-    function hideAllConditionalFields(fieldId) {
-        const conditionalFields = document.querySelectorAll(`[data-parent-field="${fieldId}"]`);
-        
-        conditionalFields.forEach(field => {
-            field.style.display = 'none';
-        });
-        
-        // Limpar controle
-        Array.from(conditionalFieldsVisible).forEach(key => {
-            if (key.startsWith(fieldId)) {
-                conditionalFieldsVisible.delete(key);
-            }
-        });
-    }
-
-    // EXECUTAR AÇÃO PENDENTE
-    function executePendingAction(action) {
-        console.log(`🚀 Executando ação: ${action.type}`);
-        
-        switch (action.type) {
-            case 'next_step':
-                executeNextStep();
-                break;
-                
-            case 'specific_section':
-                executeSpecificSection(action.target);
-                break;
-                
-            case 'skip_to_end':
-                executeSkipToEnd();
-                break;
-        }
-    }
-
-    // EXECUTAR PRÓXIMA ETAPA
-    function executeNextStep() {
-        console.log(`➡️ Indo para próxima etapa`);
-        
-        if (currentStep < formSteps) {
-            currentStep++;
-            showStep(currentStep);
-        } else {
-            const form = document.getElementById('wagtailForm');
-            if (form) {
-                form.submit();
-            }
-        }
-    }
-
-    // EXECUTAR SEÇÃO ESPECÍFICA
-    function executeSpecificSection(sectionTitle) {
-        console.log(`🎯 Redirecionando para: "${sectionTitle}"`);
-        
-        const success = redirectToSpecificSection(sectionTitle);
-        if (!success) {
-            console.log(`⚠️ Seção não encontrada, indo para próxima etapa`);
-            executeNextStep();
-        }
+        case 'show_message_and_finish':
+            handleShowMessageAndFinish(actionData);
+            break;
     }
+}
 
-    // EXECUTAR PULAR PARA O FINAL
-    function executeSkipToEnd() {
-        console.log(`⏭️ Pulando para o final`);
-        
-        const form = document.getElementById('wagtailForm');
-        if (form) {
-            let skipField = form.querySelector('input[name="form_multi_redirected"]');
-            if (!skipField) {
-                skipField = document.createElement('input');
-                skipField.type = 'hidden';
-                skipField.name = 'form_multi_redirected';
-                form.appendChild(skipField);
-            }
-            skipField.value = 'true';
-        }
-        
-        currentStep = totalSteps - 1;
-        showStep(currentStep);
-        
-        // Auto-submeter após delay
-        setTimeout(() => {
-            if (form) {
-                console.log('📨 Auto-submetendo formulário');
-                form.submit();
-            }
-        }, 1500);
-    }
-
-    // MODIFICAR VALIDAÇÃO PARA CONSIDERAR AÇÕES PENDENTES
-    const originalValidateCurrentStep = validateCurrentStep;
-    validateCurrentStep = function() {
-        // Executar ações pendentes antes da validação
-        if (pendingActions.size > 0) {
-            console.log(`🔀 ${pendingActions.size} ações pendentes`);
-            
-            const actions = Array.from(pendingActions.values());
-            pendingActions.clear();
-            
-            // Limpar indicadores visuais
-            document.querySelectorAll('.action-pending').forEach(group => {
-                group.classList.remove('action-pending');
-                group.removeAttribute('data-pending-action');
-            });
-            
-            if (actions.length > 0) {
-                setTimeout(() => executePendingAction(actions[0]), (actions[0].delay || 1) * 1000);
-                return true;
-            }
-        }
-        
-        return originalValidateCurrentStep();
-    };
-
-    // MODIFICAR NEXTSTEP PARA CONSIDERAR AÇÕES
-    const originalNextStep = nextStep;
-    nextStep = function() {
-        if (pendingActions.size > 0) {
-            console.log('🔀 Executando ações pendentes...');
-            
-            const actions = Array.from(pendingActions.values());
-            pendingActions.clear();
-            
-            // Limpar indicadores visuais
-            document.querySelectorAll('.action-pending').forEach(group => {
-                group.classList.remove('action-pending');
-                group.removeAttribute('data-pending-action');
-            });
-            
-            if (actions.length > 0) {
-                executePendingAction(actions[0]);
-                return;
-            }
-        }
-        
-        originalNextStep();
-    };
-
-    // FUNÇÃO PARA REDIRECIONAR PARA SEÇÃO ESPECÍFICA (reutilizada)
-    function redirectToSpecificSection(sectionTitle) {
-        console.log(`🎯 Procurando seção: "${sectionTitle}"`);
-        
-        const dividers = document.querySelectorAll('[data-block-type="divider"], .divider-title');
-        
-        for (const divider of dividers) {
-            let dividerTitle = '';
-            
-            if (divider.classList.contains('divider-title')) {
-                dividerTitle = divider.textContent?.trim() || '';
-            } else {
-                const titleElement = divider.querySelector('.divider-title');
-                if (titleElement) {
-                    dividerTitle = titleElement.textContent?.trim() || '';
-                }
-            }
-            
-            if (dividerTitle.toLowerCase().includes(sectionTitle.toLowerCase()) ||
-                sectionTitle.toLowerCase().includes(dividerTitle.toLowerCase())) {
-                
-                console.log(`✅ Seção encontrada: "${dividerTitle}"`);
+// Função melhorada para redirecionar para seção específica
+function redirectToSpecificSection(sectionTitle) {
+    console.log(`Procurando seção: "${sectionTitle}"`);
+    
+    // Procurar por diferentes tipos de elementos que podem conter o título da seção
+    const selectors = [
+        '.divider-title',
+        '.section-title', 
+        '[data-section-title]',
+        'h2', 'h3', 'h4'
+    ];
+    
+    for (let selector of selectors) {
+        const elements = document.querySelectorAll(selector);
+        
+        for (let element of elements) {
+            const elementText = element.textContent?.trim() || '';
+            const dataTitle = element.dataset.sectionTitle || '';
+            
+            // Verificar se o texto corresponde (ignorando case e espaços extras)
+            if (elementText.toLowerCase().includes(sectionTitle.toLowerCase()) ||
+                dataTitle.toLowerCase().includes(sectionTitle.toLowerCase()) ||
+                sectionTitle.toLowerCase().includes(elementText.toLowerCase())) {
                 
-                let stepElement = divider;
-                while (stepElement && !stepElement.classList.contains('step-content')) {
-                    stepElement = stepElement.parentElement;
-                }
+                console.log(`Seção encontrada: "${elementText}"`);
                 
-                if (stepElement && stepElement.id) {
-                    const stepMatch = stepElement.id.match(/step(\d+)/);
-                    if (stepMatch) {
-                        const targetStep = parseInt(stepMatch[1]);
+                // Scroll suave para a seção
+                setTimeout(() => {
+                    const formContent = document.getElementById('formContent');
+                    if (formContent) {
+                        const offset = 120;
+                        const elementPosition = element.getBoundingClientRect().top + 
+                                              formContent.scrollTop - offset;
+                        
+                        formContent.scrollTo({
+                            top: elementPosition,
+                            behavior: 'smooth'
+                        });
+                        
+                        // Destacar temporariamente a seção
+                        element.style.background = 'rgba(42, 94, 44, 0.1)';
+                        element.style.padding = '1rem';
+                        element.style.borderRadius = '8px';
+                        element.style.transition = 'all 0.3s ease';
                         
-                        if (targetStep >= 1 && targetStep <= formSteps) {
-                            currentStep = targetStep;
-                            showStep(currentStep);
-                            
-                            setTimeout(() => {
-                                const formContent = document.getElementById('formContent');
-                                if (formContent) {
-                                    const offset = 150;
-                                    const elementTop = divider.offsetTop - offset;
-                                    
-                                    formContent.scrollTo({
-                                        top: Math.max(0, elementTop),
-                                        behavior: 'smooth'
-                                    });
-                                }
-                            }, 300);
-                            
-                            return true;
-                        }
+                        setTimeout(() => {
+                            element.style.background = '';
+                            element.style.padding = '';
+                        }, 2000);
                     }
-                }
+                }, 100);
+                
+                return true;
             }
         }
-        
-        console.log(`❌ Seção "${sectionTitle}" não encontrada`);
-        return false;
     }
-
-    // INICIALIZAÇÃO
-    document.addEventListener('DOMContentLoaded', function() {
-        setTimeout(() => {
-            initializeMultiRedirectFields();
-        }, 300);
-    });
-
-    // DEBUGGING
-    window.debugMultiRedirect = {
-        fields: () => multiRedirectFields,
-        pending: () => pendingActions,
-        conditionals: () => conditionalFieldsVisible,
-        testSection: (name) => redirectToSpecificSection(name),
-        clearAll: () => {
-            pendingActions.clear();
-            conditionalFieldsVisible.clear();
-            document.querySelectorAll('.action-pending').forEach(group => {
-                group.classList.remove('action-pending');
-                group.removeAttribute('data-pending-action');
-            });
-            console.log('🧹 Multi-redirect limpo');
-        },
-        executeAction: (type, target) => {
-            executePendingAction({ type: type, target: target });
-        }
-    };
-
-    console.log('🔀 Sistema Multi-Redirecionamento Avançado carregado');
-    console.log('🔧 Debug: window.debugMultiRedirect');
-
+    
+    console.log(`Seção "${sectionTitle}" não encontrada`);
+    return false;
+}
 </script>
-{% endif %}
+
 
 {% endblock %}