/**
 * CHECKOUT.JS - Sistema Modular de Checkout
 * Versão 3.0 - Arquitetura Modular com Múltiplos Gateways
 * 
 * @author Checkout Pro 2025
 * @version 3.0.0
 */

// ============================================================
// VARIÁVEIS GLOBAIS
// ============================================================

let valorProduto = 0;
let valorTotal = 0;

// ============================================================
// HELPERS GLOBAIS
// ============================================================

/**
 * Obtém dados do checkout do Data Store seguro
 * @returns {Object} {prodId, afId}
 */
function getCheckoutData() {
    const store = document.getElementById('checkout-safe-data');
    const hiddenProd = document.getElementById('hidden_produto_id') || document.getElementById('global_produto_id') || document.getElementById('produto_id');
    const hiddenAf = document.getElementById('hidden_afiliado_id') || document.getElementById('global_afiliado_id') || document.getElementById('ref');
    
    let prodId = store ? store.getAttribute('data-produto-id') : (hiddenProd ? hiddenProd.value : '');
    let afId = store ? store.getAttribute('data-afiliado-id') : (hiddenAf ? hiddenAf.value : '');
    
    // Fallback para URL se ainda não tiver encontrado
    if (!prodId) {
        const urlParams = new URLSearchParams(window.location.search);
        prodId = urlParams.get('produto_id') || '';
        afId = afId || urlParams.get('ref') || urlParams.get('af') || '';
    }
    
    return { prodId, afId };
}

/**
 * Captura produtos adicionais selecionados (Order Bump)
 * @returns {Array} Array de produtos adicionais
 */
function capturarProdutosAdicionais() {
    const produtosAdicionaisSelecionados = [];
    const adicionaisIds = new Set();
    
    document.querySelectorAll('input[name="produto_adicional[]"]:checked').forEach(checkbox => {
        const id = checkbox.value;
        if (!adicionaisIds.has(id)) {
            adicionaisIds.add(id);
            produtosAdicionaisSelecionados.push({
                id: id,
                nome: checkbox.getAttribute('data-nome'),
                preco: parseFloat(checkbox.getAttribute('data-preco'))
            });
        }
    });
    
    return produtosAdicionaisSelecionados;
}

/**
 * Calcula o valor total incluindo produtos adicionais
 * @returns {number} Valor total
 */
function calcularValorTotal() {
    let total = valorProduto;
    const produtosAdicionais = capturarProdutosAdicionais();
    produtosAdicionais.forEach(produto => {
        total += produto.preco;
    });
    return total;
}

/**
 * Atualiza o resumo do pedido na tela
 * @param {string} prefixId - Prefixo do ID para identificar qual resumo atualizar (ex: 'mp-cartao', 'pagarme-pix')
 */
function atualizarResumoPedido(prefixId = '') {
    valorTotal = calcularValorTotal();
    const produtosAdicionais = capturarProdutosAdicionais();
    
    const resumoListaId = prefixId ? `resumo-lista-${prefixId}` : 'resumo-lista';
    const totalContainerId = prefixId ? `total-container-${prefixId}` : 'total-container';
    const totalPedidoClass = prefixId ? `.total-pedido-${prefixId}` : '.total-pedido';
    
    const resumoLista = document.getElementById(resumoListaId);
    const totalContainer = document.getElementById(totalContainerId);
    
    if (resumoLista) {
        resumoLista.innerHTML = '';
        produtosAdicionais.forEach(produto => {
            const li = document.createElement('li');
            li.textContent = `${produto.nome} - R$ ${produto.preco.toLocaleString('pt-BR', { minimumFractionDigits: 2 })}`;
            resumoLista.appendChild(li);
        });
    }
    
    if (totalContainer && produtosAdicionais.length > 0) {
        totalContainer.style.display = 'block';
    } else if (totalContainer) {
        totalContainer.style.display = 'none';
    }
    
    // Atualizar total em todos os seletores
    document.querySelectorAll(totalPedidoClass).forEach(el => {
        el.innerText = 'R$ ' + valorTotal.toLocaleString('pt-BR', { minimumFractionDigits: 2 });
    });
    
    // Atualizar também classes genéricas
    document.querySelectorAll('.total-pedido').forEach(el => {
        el.innerText = 'R$ ' + valorTotal.toLocaleString('pt-BR', { minimumFractionDigits: 2 });
    });
}

/**
 * Obtém dados do pagador dos cookies
 * @returns {Object} Dados do pagador
 */
function getDadosPagador() {
    function getCookie(name) {
        const cname = name + "=";
        const decodedCookie = decodeURIComponent(document.cookie);
        const ca = decodedCookie.split(';');
        for (let i = 0; i < ca.length; i++) {
            let c = ca[i].trim();
            if (c.indexOf(cname) === 0) {
                return c.substring(cname.length);
            }
        }
        return "";
    }
    
    const full_name = getCookie('full-name') || '';
    const nameParts = full_name.split(' ');
    const first_name = nameParts[0] || '';
    const last_name = nameParts.slice(1).join(' ') || '';
    
    return {
        full_name: full_name,
        first_name: first_name,
        last_name: last_name,
        email: getCookie('email') || 'cliente@gestor.click',
        cpf: getCookie('cpf') || '00000000000',
        celular: getCookie('celular') || ''
    };
}

/**
 * Detecta qual aba de pagamento está ativa e retorna o sufixo correspondente
 * @returns {string} Sufixo da aba ativa ou null se não encontrar
 */
function detectarSufixoAbaAtiva() {
    console.log('🔍 [DEBUG] detectarSufixoAbaAtiva() - Iniciando detecção...');
    
    // Lista de abas conhecidas com seus respectivos sufixos
    const tabs = [
        { id: 'mercadopago-cartao', sufixo: 'mp_cartao' },
        { id: 'mercadopago-pix', sufixo: 'mp_pix' },
        { id: 'mercadopago-boleto', sufixo: 'mp_boleto' },
        { id: 'pagarme-cartao', sufixo: 'pagarme_cartao' },
        { id: 'pagarme-pix', sufixo: 'pagarme_pix' },
        { id: 'pagarme-boleto', sufixo: 'pagarme_boleto' },
        { id: 'stripe', sufixo: 'mp_cartao' }, // Stripe usa mesmos campos que cartão
        { id: 'paypal', sufixo: 'mp_cartao' } // PayPal usa mesmos campos que cartão
    ];
    
    // Iterar sobre as abas e verificar qual está visível
    for (const tab of tabs) {
        const element = document.getElementById(tab.id);
        if (element) {
            // Verificar se a aba está visível
            const computedStyle = window.getComputedStyle(element);
            const isVisible = computedStyle.display !== 'none' && 
                            element.offsetParent !== null;
            
            if (isVisible) {
                console.log('✅ [DEBUG] Aba ativa detectada:', tab.id, '-> Sufixo:', tab.sufixo);
                return tab.sufixo;
            }
        }
    }
    
    console.log('⚠️ [DEBUG] Nenhuma aba visível encontrada, retornando null');
    return null;
}

/**
 * Obtém endereço de entrega (apenas para produtos físicos ou boleto)
 * @returns {Object|null} Dados do endereço ou null
 */
function getEnderecoEntrega() {
    const tipoProduto = document.getElementById('hidden_tipo_produto')?.value;
    console.log('📍 [DEBUG] getEnderecoEntrega() chamada. Tipo produto:', tipoProduto);
    
    // Tentar detectar a aba ativa (com tratamento de erro caso a função não exista)
    let sufixo = null;
    let isBoleto = false;
    try {
        if (typeof detectarSufixoAbaAtiva === 'function') {
            sufixo = detectarSufixoAbaAtiva();
        } else {
            console.warn('⚠️ [DEBUG] detectarSufixoAbaAtiva() não é uma função, usando fallback direto');
        }
    } catch (error) {
        console.warn('⚠️ [DEBUG] Erro ao chamar detectarSufixoAbaAtiva():', error);
    }
    
    // DETECÇÃO CORRETA DE BOLETO:
    // NÃO usar offsetParent de outras abas (isso pode retornar true em cenários de layout/CSS e marcar boleto erroneamente).
    // Considerar apenas a aba ativa (sufixo) ou o tab-content.active atual.
    const activeTabContent = document.querySelector('.tab-content.active');
    const activeTabId = activeTabContent ? String(activeTabContent.id || '') : '';
    isBoleto = (sufixo && sufixo.includes('boleto')) || activeTabId.includes('boleto');
    
    console.log('🎯 [DEBUG] Sufixo detectado pela função:', sufixo, '| Aba ativa:', activeTabId, '| É boleto:', isBoleto);
    
    // CRÍTICO: Se não é físico e não é boleto, não precisa de endereço
    if (tipoProduto !== 'fisico' && !isBoleto) {
        console.log('ℹ️ [DEBUG] Produto não físico e não é boleto, retornando null');
        return null;
    }
    
    // FALLBACK INTELIGENTE: Se a detecção falhar, buscar onde o usuário digitou
    // Este é o fallback PRINCIPAL que garante que sempre encontra os dados
    // CRÍTICO: Se é boleto, priorizar sufixos de boleto
    if (!sufixo) {
        console.log('🔄 [DEBUG] Detecção de aba falhou ou retornou null, tentando Fallback Inteligente...');
        // Se é boleto, priorizar sufixos de boleto
        const possiveis = isBoleto 
            ? ['mp_boleto', 'pagarme_boleto', 'mp_cartao', 'mp_pix', 'pagarme_cartao', 'pagarme_pix']
            : ['mp_cartao', 'mp_pix', 'mp_boleto', 'pagarme_cartao', 'pagarme_pix', 'pagarme_boleto'];
        for (const s of possiveis) {
            const cepElement = document.getElementById('input_cep_' + s);
            if (cepElement && cepElement.value && cepElement.value.trim().length > 0) {
                sufixo = s;
                console.log('✅ [DEBUG] Fallback encontrou sufixo com valor preenchido:', sufixo);
                // Atualizar isBoleto baseado no sufixo encontrado
                if (s.includes('boleto')) isBoleto = true;
                break;
            }
        }
    }
    
    // Se ainda não encontrou sufixo, usar padrão baseado no tipo
    if (!sufixo) {
        if (isBoleto) {
            console.warn('⚠️ [DEBUG] Nenhum sufixo encontrado, usando mp_boleto como padrão (é boleto)');
            sufixo = 'mp_boleto';
        } else {
            console.warn('⚠️ [DEBUG] Nenhum sufixo encontrado, usando mp_cartao como padrão');
            sufixo = 'mp_cartao';
        }
    }
    
    // Construir IDs dos campos usando o sufixo descoberto
    const id_cep = 'input_cep_' + sufixo;
    const id_rua = 'input_logradouro_' + sufixo;
    const id_numero = 'input_numero_' + sufixo;
    const id_complemento = 'input_complemento_' + sufixo;
    const id_bairro = 'input_bairro_' + sufixo;
    const id_cidade = 'input_cidade_' + sufixo;
    const id_estado = 'input_estado_' + sufixo;
    
    console.log('🔍 [DEBUG] IDs que serão buscados (sufixo:', sufixo + '):', {
        cep: id_cep,
        rua: id_rua,
        numero: id_numero,
        bairro: id_bairro,
        cidade: id_cidade,
        estado: id_estado
    });
    
    // Capturar valores dos campos
    const cepEl = document.getElementById(id_cep);
    const ruaEl = document.getElementById(id_rua);
    const numeroEl = document.getElementById(id_numero);
    const complementoEl = document.getElementById(id_complemento);
    const bairroEl = document.getElementById(id_bairro);
    const cidadeEl = document.getElementById(id_cidade);
    const estadoEl = document.getElementById(id_estado);
    
    // Verificar se os elementos existem
    if (!cepEl || !ruaEl || !numeroEl || !bairroEl || !cidadeEl || !estadoEl) {
        console.error('❌ [DEBUG] Alguns elementos não foram encontrados:', {
            cep: !!cepEl,
            rua: !!ruaEl,
            numero: !!numeroEl,
            bairro: !!bairroEl,
            cidade: !!cidadeEl,
            estado: !!estadoEl
        });
    }
    
    const cep = cepEl?.value?.replace(/\D/g, '') || '';
    const rua = ruaEl?.value?.trim() || '';
    const numero = numeroEl?.value?.trim() || '';
    const complemento = complementoEl?.value?.trim() || '';
    const bairro = bairroEl?.value?.trim() || '';
    const cidade = cidadeEl?.value?.trim() || '';
    const estado = estadoEl?.value?.trim().toUpperCase() || '';
    
    console.log('📝 [DEBUG] Valores capturados:', {
        cep: cep ? cep.substring(0, 5) + '...' : 'VAZIO',
        rua: rua || 'VAZIO',
        numero: numero || 'VAZIO',
        bairro: bairro || 'VAZIO',
        cidade: cidade || 'VAZIO',
        estado: estado || 'VAZIO'
    });
    
    // FALLBACK INTELIGENTE FINAL: Se os campos estão vazios, tentar encontrar em outras abas
    // Este fallback é CRÍTICO: garante que mesmo se a detecção falhar, encontra os dados preenchidos
    if (!cep || !rua || !numero || !bairro || !cidade || !estado) {
        console.log('🔄 [DEBUG] Campos principais vazios ou incompletos, tentando Fallback Inteligente Final...');
        const possiveis = ['mp_cartao', 'mp_pix', 'mp_boleto', 'pagarme_cartao', 'pagarme_pix', 'pagarme_boleto'];
        for (const s of possiveis) {
            const cep_fallback = document.getElementById('input_cep_' + s)?.value?.replace(/\D/g, '');
            const rua_fallback = document.getElementById('input_logradouro_' + s)?.value?.trim();
            const numero_fallback = document.getElementById('input_numero_' + s)?.value?.trim();
            const bairro_fallback = document.getElementById('input_bairro_' + s)?.value?.trim() || '';
            const cidade_fallback = document.getElementById('input_cidade_' + s)?.value?.trim() || '';
            const estado_fallback = document.getElementById('input_estado_' + s)?.value?.trim().toUpperCase() || '';
            const complemento_fallback = document.getElementById('input_complemento_' + s)?.value?.trim() || '';
            
            // Se encontrou TODOS os valores obrigatórios preenchidos, usar esse sufixo
            if (cep_fallback && rua_fallback && numero_fallback && bairro_fallback && cidade_fallback && estado_fallback) {
                console.log('✅ [DEBUG] Fallback Final encontrou valores completos no sufixo:', s);
                return {
                    cep: cep_fallback,
                    rua: rua_fallback,
                    numero: numero_fallback,
                    complemento: complemento_fallback,
                    bairro: bairro_fallback,
                    cidade: cidade_fallback,
                    estado: estado_fallback
                };
            }
        }
    }
    
    // Validar campos obrigatórios
    if (!cep || !rua || !numero || !bairro || !cidade || !estado) {
        const campos_faltando = [];
        if (!cep) campos_faltando.push('CEP');
        if (!rua) campos_faltando.push('Rua');
        if (!numero) campos_faltando.push('Número');
        if (!bairro) campos_faltando.push('Bairro');
        if (!cidade) campos_faltando.push('Cidade');
        if (!estado) campos_faltando.push('Estado');
        
        console.error('❌ [DEBUG] Campos faltando:', campos_faltando.join(', '));
        console.error('❌ [DEBUG] IDs tentados:', { id_cep, id_rua, id_numero, id_bairro, id_cidade, id_estado });
        console.error('❌ [DEBUG] Sufixo usado:', sufixo);
        
        throw new Error('Por favor, preencha todos os campos de endereço obrigatórios: ' + campos_faltando.join(', '));
    }
    
    console.log('✅ [DEBUG] Endereço capturado com sucesso! (sufixo:', sufixo + ')');
    
    return {
        cep: cep,
        rua: rua,
        numero: numero,
        complemento: complemento,
        bairro: bairro,
        cidade: cidade,
        estado: estado
    };
}

/**
 * Obtém valor do frete cobrado (apenas para produtos físicos)
 * @returns {number} Valor do frete ou 0
 */
function getFreteCobrado() {
    const tipoProduto = document.getElementById('hidden_tipo_produto')?.value;
    if (tipoProduto !== 'fisico') {
        return 0;
    }
    
    const freteHidden = document.getElementById('hidden_frete_cobrado');
    return freteHidden ? parseFloat(freteHidden.value || 0) : 0;
}

/**
 * Filtra métodos de pagamento baseado na configuração do produto
 */
function filtrarMetodosPagamento() {
    const metodosPagamentoInput = document.getElementById('hidden_metodos_pagamento');
    const metodosPagamento = metodosPagamentoInput ? metodosPagamentoInput.value : 'todos';
    
    console.log('🔍 [FILTRO PAGAMENTO] Métodos configurados:', metodosPagamento);
    
    // IDs corretos das abas e conteúdos no checkout
    const tabIds = {
        'pix': ['mercadopago-pix-tab', 'pagarme-pix-tab'],
        'cartao': ['mercadopago-cartao-tab', 'stripe-tab', 'paypal-tab', 'pagarme-cartao-tab'],
        'boleto': ['mercadopago-boleto-tab', 'pagarme-boleto-tab']
    };
    
    const contentIds = {
        'pix': ['mercadopago-pix', 'pagarme-pix'],
        'cartao': ['mercadopago-cartao', 'stripe', 'paypal', 'pagarme-cartao'],
        'boleto': ['mercadopago-boleto', 'pagarme-boleto']
    };
    
    // Função auxiliar para ocultar elementos
    function ocultarElementos(ids, tipo) {
        ids.forEach(id => {
            const element = document.getElementById(id);
            if (element) {
                element.style.setProperty('display', 'none', 'important');
                console.log(`  ❌ Ocultando ${tipo}: ${id}`);
            }
        });
    }
    
    // Função auxiliar para mostrar elementos
    function mostrarElementos(ids, tipo) {
        ids.forEach(id => {
            const element = document.getElementById(id);
            if (element) {
                element.style.removeProperty('display');
                console.log(`  ✅ Mostrando ${tipo}: ${id}`);
            }
        });
    }
    
    // Aplicar filtro baseado na configuração
    if (metodosPagamento === 'pix') {
        console.log('🔒 [FILTRO PAGAMENTO] Filtrando: Mostrar apenas PIX');
        ocultarElementos([...tabIds.cartao, ...tabIds.boleto], 'aba');
        ocultarElementos([...contentIds.cartao, ...contentIds.boleto], 'conteúdo');
        mostrarElementos(tabIds.pix, 'aba');
        mostrarElementos(contentIds.pix, 'conteúdo');
        console.log(`  ✅ Abas PIX configuradas`);
        
    } else if (metodosPagamento === 'pix_cartao') {
        console.log('🔒 [FILTRO PAGAMENTO] Filtrando: Mostrar PIX + Cartão');
        ocultarElementos(tabIds.boleto, 'aba');
        ocultarElementos(contentIds.boleto, 'conteúdo');
        mostrarElementos([...tabIds.pix, ...tabIds.cartao], 'aba');
        mostrarElementos([...contentIds.pix, ...contentIds.cartao], 'conteúdo');
        console.log(`  ✅ Abas PIX + Cartão configuradas`);
        
    } else if (metodosPagamento === 'pix_cartao_boleto' || metodosPagamento === 'todos') {
        console.log('🔒 [FILTRO PAGAMENTO] Filtrando: Mostrar PIX + Cartão + Boleto (Todos)');
        // Mostrar todas as abas (PIX, Cartão e Boleto)
        mostrarElementos([...tabIds.pix, ...tabIds.cartao, ...tabIds.boleto], 'aba');
        mostrarElementos([...contentIds.pix, ...contentIds.cartao, ...contentIds.boleto], 'conteúdo');
        console.log(`  ✅ Todas as abas configuradas`);
        
    } else {
        // Valor desconhecido - mostrar todas por padrão
        console.warn('⚠️ [FILTRO PAGAMENTO] Valor desconhecido:', metodosPagamento, '- Mostrando todas as abas');
        mostrarElementos([...tabIds.pix, ...tabIds.cartao, ...tabIds.boleto], 'aba');
        mostrarElementos([...contentIds.pix, ...contentIds.cartao, ...contentIds.boleto], 'conteúdo');
    }
}

/**
 * Determina a URL de redirecionamento após pagamento (físico ou digital)
 * @param {string} transacaoId - ID da transação
 * @returns {string} URL de redirecionamento
 */
function getUrlObrigado(transacaoId) {
    // Tentar múltiplas fontes para obter tipo_produto
    let tipoProduto = document.getElementById('hidden_tipo_produto')?.value;
    if (!tipoProduto) {
        const safeData = document.getElementById('checkout-safe-data');
        tipoProduto = safeData ? safeData.getAttribute('data-tipo-produto') : 'digital';
    }
    
    if (tipoProduto === 'fisico') {
        return `/views/obrigado_fisico.php?transacao_id=${transacaoId || ''}`;
    }
    return `/views/obrigado.php?transacao_id=${transacaoId || ''}`;
}

/**
 * Rastreia eventos do Facebook Pixel
 * @param {string} evento - Nome do evento
 * @param {Object} parametros - Parâmetros do evento
 */
function rastrearFacebookPixel(evento, parametros) {
    if (typeof fbq !== 'undefined') {
        fbq('track', evento, parametros);
    }
}

/**
 * Mostra/esconde popup de processamento
 * @param {boolean} mostrar - true para mostrar, false para esconder
 */
function toggleProcessingPopup(mostrar) {
    const popup = document.getElementById('processing-popup');
    if (popup) {
        if (mostrar) {
            popup.style.display = 'flex';
            popup.style.pointerEvents = 'auto'; // Permitir interação quando visível
        } else {
            popup.style.display = 'none';
            popup.style.pointerEvents = 'none'; // CRÍTICO: Desbloquear quando oculto
        }
    }
}

// ============================================================
// GERENCIADOR DE ABAS
// ============================================================

/**
 * Gerencia a troca de abas entre gateways
 */
const TabManager = {
    /**
     * Mostra uma aba específica e esconde as outras
     * @param {string} tabId - ID da aba a ser mostrada (sem sufixo '-tab')
     */
    showTab: function(tabId) {
        console.log(`🔄 [TABS] Alternando para aba: ${tabId}`);
        
        // Remover active de todos os tabs
        document.querySelectorAll('.tab').forEach(t => {
            t.classList.remove('active');
        });
        
        // Esconder todos os conteúdos
        document.querySelectorAll('.tab-content').forEach(c => {
            c.style.display = 'none';
            c.classList.remove('active');
        });
        
        // Ativar o tab clicado
        const tabElement = document.getElementById(tabId + '-tab');
        if (tabElement) {
            tabElement.classList.add('active');
        }
        
        // Mostrar conteúdo correspondente
        const contentElement = document.getElementById(tabId);
        if (contentElement) {
            contentElement.style.display = 'block';
            contentElement.classList.add('active');
        }
        
        // Disparar evento para módulos que precisam ser inicializados ao trocar de aba
        document.dispatchEvent(new CustomEvent('tabChanged', { detail: { tabId } }));
    },
    
    /**
     * Inicializa os listeners das abas
     */
    init: function() {
        console.log('🚀 [TABS] Inicializando gerenciador de abas...');
        
        document.querySelectorAll('.tab').forEach(tab => {
            tab.addEventListener('click', function(e) {
                e.preventDefault();
                const onclick = this.getAttribute('onclick');
                if (onclick && onclick.includes('showTab')) {
                    // Extrair o ID da aba do onclick
                    const match = onclick.match(/showTab\(['"](.+?)['"]\)/);
                    if (match && match[1]) {
                        TabManager.showTab(match[1]);
                    }
                }
            });
        });
        
        console.log('✅ [TABS] Gerenciador de abas inicializado');
    }
};

// Expor globalmente para compatibilidade
window.showTab = TabManager.showTab.bind(TabManager);

// ============================================================
// MÓDULO MERCADO PAGO
// ============================================================

const MercadoPagoModule = {
    cardFormInstance: null,
    _initCartaoAttempts: 0,
    _maxInitCartaoAttempts: 10,
    _initCartaoTimeout: null,
    _cartaoObserver: null,
    _pendingCartaoPayment: false,
    
    /**
     * Inicializa o módulo Mercado Pago
     */
    init: function() {
        console.log('🚀 [MERCADO PAGO] Inicializando módulo...');
        
        // Verificar se o SDK está carregado
        if (typeof window.mp === 'undefined') {
            console.warn('⏳ [MERCADO PAGO] SDK ainda não carregou, aguardando...');
            setTimeout(() => this.init(), 500);
            return;
        }
        
        // Inicializar formulário de cartão (só se a aba estiver visível)
        this.initCartao();
        
        // Inicializar botão PIX (sempre, mesmo se a aba estiver oculta)
        this.initPix();
        this.initBoleto();
        
        // NÃO chamar attachPixDelegation aqui - initPix já chama se necessário
        
        console.log('✅ [MERCADO PAGO] Módulo inicializado');
    },
    
    /**
     * Verifica qual aba está ativa no momento
     * @returns {string|null} ID da aba ativa ou null se nenhuma estiver ativa
     */
    _getActiveTab: function() {
        const tabs = ['mercadopago-cartao', 'mercadopago-pix', 'mercadopago-boleto', 
                      'pagarme-cartao', 'pagarme-pix', 'pagarme-boleto',
                      'stripe-cartao', 'paypal-cartao'];
        for (const tabId of tabs) {
            const tab = document.getElementById(tabId);
            if (tab) {
                const style = window.getComputedStyle(tab);
                if (style.display !== 'none' && style.visibility !== 'hidden' && tab.offsetParent !== null) {
                    // Verificar se a aba tem a classe active
                    if (tab.classList.contains('active')) {
                        return tabId;
                    }
                }
            }
        }
        return null;
    },
    
    /**
     * Inicializa o formulário de cartão
     * Só inicializa se a aba estiver visível para evitar problemas com iframes em elementos ocultos
     */
    initCartao: function() {
        // Verificar se já foi inicializado
        if (this.cardFormInstance) {
            return;
        }
        
        // Verificar qual aba está ativa - se for PIX ou Boleto, não tentar inicializar cartão
        const activeTab = this._getActiveTab();
        if (activeTab && (activeTab.includes('pix') || activeTab.includes('boleto'))) {
            // Usuário está em PIX ou Boleto, não inicializar cartão
            if (this._cartaoObserver) {
                this._cartaoObserver.disconnect();
                this._cartaoObserver = null;
            }
            return;
        }
        
        const formContainer = document.getElementById('form-card-mp');
        if (!formContainer) {
            return;
        }
        
        // Limpar observer anterior se existir
        if (this._cartaoObserver) {
            this._cartaoObserver.disconnect();
            this._cartaoObserver = null;
        }
        
        // Limpar timeout anterior se existir
        if (this._initCartaoTimeout) {
            clearTimeout(this._initCartaoTimeout);
            this._initCartaoTimeout = null;
        }
        
        // Verificar se a aba está visível
        const tabContent = document.getElementById('mercadopago-cartao');
        if (tabContent) {
            const computedStyle = window.getComputedStyle(tabContent);
            const isVisible = computedStyle.display !== 'none' && 
                            computedStyle.visibility !== 'hidden' &&
                            tabContent.offsetParent !== null;
            
            if (!isVisible) {
                // Limitar tentativas para evitar loop infinito
                if (this._initCartaoAttempts >= this._maxInitCartaoAttempts) {
                    console.log('⏹️ [MERCADO PAGO] Limite de tentativas de inicialização do cartão atingido');
                    this._initCartaoAttempts = 0;
                    return;
                }
                
                this._initCartaoAttempts++;
                
                // Timeout de segurança: parar após 5 segundos
                this._initCartaoTimeout = setTimeout(() => {
                    if (this._cartaoObserver) {
                        this._cartaoObserver.disconnect();
                        this._cartaoObserver = null;
                    }
                    this._initCartaoAttempts = 0;
                }, 5000);
                
                // Aguardar até que a aba seja mostrada
                this._cartaoObserver = new MutationObserver(() => {
                    // Verificar novamente se usuário está em outra aba
                    const currentActiveTab = this._getActiveTab();
                    if (currentActiveTab && (currentActiveTab.includes('pix') || currentActiveTab.includes('boleto'))) {
                        // Usuário mudou para PIX ou Boleto, parar observer
                        if (this._cartaoObserver) {
                            this._cartaoObserver.disconnect();
                            this._cartaoObserver = null;
                        }
                        if (this._initCartaoTimeout) {
                            clearTimeout(this._initCartaoTimeout);
                            this._initCartaoTimeout = null;
                        }
                        this._initCartaoAttempts = 0;
                        return;
                    }
                    
                    const newStyle = window.getComputedStyle(tabContent);
                    if (newStyle.display !== 'none' && newStyle.visibility !== 'hidden') {
                        if (this._cartaoObserver) {
                            this._cartaoObserver.disconnect();
                            this._cartaoObserver = null;
                        }
                        if (this._initCartaoTimeout) {
                            clearTimeout(this._initCartaoTimeout);
                            this._initCartaoTimeout = null;
                        }
                        this._initCartaoAttempts = 0;
                        setTimeout(() => this.initCartao(), 100);
                    }
                });
                
                this._cartaoObserver.observe(tabContent, { 
                    attributes: true, 
                    attributeFilter: ['style', 'class'] 
                });
                
                // Também escutar eventos de mudança de aba (só uma vez)
                if (!this._tabChangedListenerAdded) {
                    this._tabChangedListenerAdded = true;
                    document.addEventListener('tabChanged', (e) => {
                        if (e.detail.tabId === 'mercadopago-cartao') {
                            this._initCartaoAttempts = 0;
                            setTimeout(() => this.initCartao(), 100);
                        } else if (e.detail.tabId.includes('pix') || e.detail.tabId.includes('boleto')) {
                            // Usuário mudou para PIX ou Boleto, parar tentativas
                            if (this._cartaoObserver) {
                                this._cartaoObserver.disconnect();
                                this._cartaoObserver = null;
                            }
                            if (this._initCartaoTimeout) {
                                clearTimeout(this._initCartaoTimeout);
                                this._initCartaoTimeout = null;
                            }
                            this._initCartaoAttempts = 0;
                        }
                    });
                }
                return;
            } else {
                // Aba está visível, resetar contador
                this._initCartaoAttempts = 0;
            }
        }
        
        const cardNumberContainer = document.getElementById('form-checkout__cardNumber');
        const expirationDateContainer = document.getElementById('form-checkout__expirationDate');
        const securityCodeContainer = document.getElementById('form-checkout__securityCode');
        
        if (!cardNumberContainer || !expirationDateContainer || !securityCodeContainer) {
            console.warn('⚠️ [MERCADO PAGO] Containers de cartão não encontrados');
            return;
        }
        
        // Verificar se já foi inicializado
        if (this.cardFormInstance) {
            console.log('⏭️ [MERCADO PAGO] CardForm já foi inicializado');
            return;
        }
        
        // Inicializar cardForm usando mp.cardForm (API correta do SDK V2)
        try {
            // Obter email do pagador (de cookies ou campo)
            const dadosPagador = getDadosPagador();
            const emailInput = document.getElementById('form-checkout__cardholderEmail');
            if (emailInput && dadosPagador.email) {
                emailInput.value = dadosPagador.email;
            }
            
            // Usar mp.cardForm ao invés de mp.fields().create('card')
            // OBS: amount é usado pelo SDK para parcelas/issuer; o valor final enviado ao backend continua sendo calculado no submit.
            const amountBase = (typeof totalAtual === 'number' && totalAtual > 0)
                ? totalAtual
                : (typeof valorTotal === 'number' && valorTotal > 0 ? valorTotal : (typeof valorProduto === 'number' && valorProduto > 0 ? valorProduto : 100));

            this.cardFormInstance = window.mp.cardForm({
                amount: String(amountBase).replace(',', '.'),
                iframe: true,
                form: {
                    id: "form-card-mp",
                    cardNumber: {
                        id: "form-checkout__cardNumber",
                        placeholder: "Número do cartão"
                    },
                    expirationDate: {
                        id: "form-checkout__expirationDate",
                        placeholder: "MM/AA"
                    },
                    securityCode: {
                        id: "form-checkout__securityCode",
                        placeholder: "CVV"
                    },
                    cardholderName: {
                        id: "form-checkout__cardholderName",
                        placeholder: "Nome do titular"
                    },
                    cardholderEmail: {
                        id: "form-checkout__cardholderEmail"
                    },
                    issuer: {
                        id: "form-checkout__issuer"
                    },
                    installments: {
                        id: "form-checkout__installments"
                    },
                    identificationType: {
                        id: "form-checkout__identificationType"
                    },
                    identificationNumber: {
                        id: "form-checkout__identificationNumber",
                        placeholder: "CPF"
                    }
                },
                callbacks: {
                    onFormMounted: (error) => {
                        if (error) {
                            console.error('❌ [MERCADO PAGO] Erro ao montar formulário:', error);
                            alert('Erro ao inicializar formulário de pagamento. Recarregue a página.');
                        } else {
                            console.log('✅ [MERCADO PAGO] CardForm montado com sucesso!');
                            // Garantir que os iframes sejam clicáveis
                            this.ensureIframesClickable();
                        }
                    },
                    onSubmit: async (event) => {
                        // Fluxo CORRETO (igual arquivo de teste):
                        // Botão -> requestSubmit() -> onSubmit -> getCardFormData() (token já gerado) -> backend
                        event.preventDefault();

                        if (!this._pendingCartaoPayment) {
                            // submit disparado “sem querer” (ex: enter em campo), ignorar
                            return;
                        }

                        try {
                            let cardFormData;
                            if (typeof this.cardFormInstance.getCardFormData === 'function') {
                                cardFormData = this.cardFormInstance.getCardFormData();
                            } else {
                                throw new Error('getCardFormData não está disponível');
                            }

                            // 🔍 LOG DETALHADO
                            console.log('🔍 [DEBUG COMPLETO] cardFormData (onSubmit):', JSON.stringify(cardFormData, null, 2));

                            if (!cardFormData.token || String(cardFormData.token).trim() === '') {
                                throw new Error('Token do cartão não foi gerado. Verifique principalmente VALIDADE e CVV.');
                            }

                            const paymentMethodId = cardFormData.paymentMethodId || cardFormData.payment_method_id;
                            if (!paymentMethodId) {
                                throw new Error('Método de pagamento não identificado. Verifique o número do cartão.');
                            }

                            await this._processarCartaoComCardFormData(cardFormData, paymentMethodId);
                        } catch (error) {
                            console.error('❌ [MERCADO PAGO] Erro no onSubmit (cartão):', error);
                            alert('Erro ao processar pagamento: ' + error.message);
                            toggleProcessingPopup(false);
                        } finally {
                            this._pendingCartaoPayment = false;
                        }
                    }
                }
            });
            
            // Listener do botão de submit
            const submitBtn = document.getElementById('btn-submit-mp-cartao');
            if (submitBtn) {
                // Remover listener antigo se existir
                const newBtn = submitBtn.cloneNode(true);
                submitBtn.parentNode.replaceChild(newBtn, submitBtn);
                
                newBtn.addEventListener('click', (e) => {
                    e.preventDefault();
                    e.stopPropagation();
                    this.processarCartao();
                });
            }
            
            console.log('✅ [MERCADO PAGO] Formulário de cartão inicializado');
        } catch (error) {
            console.error('❌ [MERCADO PAGO] Erro ao inicializar cardForm:', error);
        }
    },
    
    /**
     * Garante que os iframes do Mercado Pago sejam clicáveis
     */
    ensureIframesClickable: function() {
        setTimeout(() => {
            const containers = [
                'form-checkout__cardNumber',
                'form-checkout__expirationDate',
                'form-checkout__securityCode'
            ];
            
            containers.forEach(containerId => {
                const container = document.getElementById(containerId);
                if (container) {
                    const iframe = container.querySelector('iframe');
                    if (iframe) {
                        iframe.style.pointerEvents = 'auto';
                        iframe.style.zIndex = '10000';
                        container.style.pointerEvents = 'auto';
                        container.style.zIndex = '10';
                    }
                }
            });
        }, 500);
    },
    
    /**
     * Processa pagamento com cartão
     */
    processarCartao: async function() {
        console.log('💳 [MERCADO PAGO] Iniciando processamento de cartão...');
        
        if (!this.cardFormInstance) {
            alert('Erro: Formulário não inicializado. Recarregue a página.');
            return;
        }
        
        try {
            // Exibir spinner e disparar submit real para gerar token no callback onSubmit
            toggleProcessingPopup(true);
            this._pendingCartaoPayment = true;

            const form = document.getElementById('form-card-mp');
            if (!form) {
                throw new Error('Formulário de cartão não encontrado.');
            }

            if (typeof form.requestSubmit === 'function') {
                form.requestSubmit();
            } else {
                form.dispatchEvent(new Event('submit', { bubbles: true, cancelable: true }));
            }
        } catch (error) {
            console.error('❌ [MERCADO PAGO] Erro no processamento:', error);
            alert('Erro ao processar pagamento: ' + error.message);
            toggleProcessingPopup(false);
            this._pendingCartaoPayment = false;
        }
    },

    /**
     * Finaliza pagamento com os dados do cardForm (token já gerado no onSubmit)
     * @param {object} cardFormData
     * @param {string} paymentMethodId
     */
    _processarCartaoComCardFormData: async function(cardFormData, paymentMethodId) {
        try {
            const { prodId, afId } = getCheckoutData();
            if (!prodId) {
                throw new Error('ID do produto não encontrado');
            }

            const dadosPagador = getDadosPagador();
            const produtosAdicionais = capturarProdutosAdicionais();

            // Capturar endereço se produto for físico
            let enderecoJson = null;
            try {
                const endereco = getEnderecoEntrega();
                if (endereco) {
                    enderecoJson = JSON.stringify(endereco);
                }
            } catch (error) {
                throw new Error(error.message);
            }

            const freteCobrado = getFreteCobrado();
            const valorFinal = calcularValorTotal() + freteCobrado; // Incluir frete no total

            const produtoTitulo = document.getElementById('titulo-produto')?.innerText || '';
            const produtoDescricao = document.getElementById('descricao-produto')?.innerText || '';
            const linkEntregavel = document.getElementById('link-entregavel')?.value || '';

            // Validar CPF antes de enviar
            const cpfLimpo = String(dadosPagador.cpf || '').replace(/\D/g, '');
            if (!cpfLimpo || cpfLimpo.length !== 11) {
                throw new Error('Por favor, informe um CPF válido para processar o pagamento.');
            }

            const requestData = {
                token: cardFormData.token,
                issuer: cardFormData.issuerId || cardFormData.issuer,
                installments: parseInt(cardFormData.installments) || 1,
                payment_method_id: paymentMethodId,
                transaction_amount: valorFinal,
                description: produtoTitulo,
                product: {
                    id: prodId,
                    title: produtoTitulo,
                    description: produtoDescricao,
                    price: valorProduto || valorFinal,
                    link_entregavel: linkEntregavel
                },
                additional_products: produtosAdicionais,
                payer: {
                    email: dadosPagador.email,
                    first_name: dadosPagador.first_name,
                    last_name: dadosPagador.last_name,
                    full_name: dadosPagador.full_name,
                    identification: {
                        type: 'CPF',
                        number: cpfLimpo
                    },
                    phone: {
                        area_code: dadosPagador.celular && dadosPagador.celular.length >= 10 ? dadosPagador.celular.substring(0, 2) : '11',
                        number: dadosPagador.celular && dadosPagador.celular.length >= 10 ? dadosPagador.celular.substring(2) : '000000000'
                    }
                },
                afiliado: afId || null,
                endereco_json: enderecoJson,
                frete_cobrado: freteCobrado
            };

            console.log('🔍 [DEBUG COMPLETO] Payload (cartão) enviado ao backend:', JSON.stringify(requestData, null, 2));

            const response = await fetch('/backend/process_payment.php', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(requestData)
            });

            if (!response.ok) {
                const errorText = await response.text();
                let errorData;
                try {
                    errorData = JSON.parse(errorText);
                } catch (e) {
                    errorData = { message: `Erro HTTP ${response.status}: ${errorText}` };
                }
                throw new Error(errorData.message || `Erro do servidor (${response.status})`);
            }

            const data = await response.json();

            if (data.status === 'success') {
                rastrearFacebookPixel('Purchase', {
                    value: valorFinal,
                    currency: 'BRL'
                });
                window.location.href = getUrlObrigado(data.transaction_id);
            } else if (data.status === 'failure' || data.status === 'rejected') {
                throw new Error(data.message || 'O pagamento foi recusado. Verifique os detalhes do cartão ou tente outra forma de pagamento.');
            }

            throw new Error(data.message || 'Erro ao processar pagamento');
        } finally {
            toggleProcessingPopup(false);
        }
    },
    
    /**
     * Inicializa o botão PIX
     * Usa Event Delegation para garantir funcionamento mesmo se a aba estiver oculta
     */
    initPix: function() {
        // Sempre configurar Event Delegation primeiro (funciona mesmo se botão estiver oculto)
        this.attachPixDelegation();
        
        // Tentar encontrar o botão imediatamente para adicionar listener direto também
        let pixBtn = document.getElementById('btn-pix-mp');
        
        if (pixBtn) {
            this.attachPixListener(pixBtn);
            console.log('✅ [MERCADO PAGO] Botão PIX inicializado (listener direto)');
        } else {
            // Se não encontrou, tentar novamente após um delay (pode estar em aba oculta)
            console.log('⏳ [MERCADO PAGO] Botão PIX não encontrado, usando apenas Event Delegation');
            setTimeout(() => {
                pixBtn = document.getElementById('btn-pix-mp');
                if (pixBtn) {
                    this.attachPixListener(pixBtn);
                    console.log('✅ [MERCADO PAGO] Botão PIX encontrado após delay');
                }
            }, 500);
        }
    },
    
    /**
     * Anexa listener ao botão PIX
     */
    attachPixListener: function(btn) {
        // Remover listeners antigos se existirem
        const newBtn = btn.cloneNode(true);
        btn.parentNode.replaceChild(newBtn, btn);
        
        newBtn.addEventListener('click', (e) => {
            e.preventDefault();
            e.stopPropagation();
            e.stopImmediatePropagation();
            console.log('🔲 [MERCADO PAGO] Botão PIX clicado (listener direto)!');
            // Não duplicar - Event Delegation também vai capturar, mas este tem prioridade
            this.processarPix();
        }, false); // Não usar capture para não conflitar com delegation
    },
    
    /**
     * Usa Event Delegation como fallback para garantir que o clique seja capturado
     * CRÍTICO: Só adiciona UM listener global, não múltiplos
     */
    attachPixDelegation: function() {
        // Evitar adicionar múltiplos listeners
        if (this._delegationAttached) {
            return;
        }
        this._delegationAttached = true;
        
        // Usar Event Delegation no document para capturar cliques mesmo se o botão for adicionado depois
        document.addEventListener('click', (e) => {
            const target = e.target.closest('#btn-pix-mp');
            if (target) {
                e.preventDefault();
                e.stopPropagation();
                e.stopImmediatePropagation();
                console.log('🔲 [MERCADO PAGO] Botão PIX clicado (via delegation)!');
                this.processarPix();
            }
        }, true); // Use capture phase para garantir que seja executado primeiro
        console.log('✅ [MERCADO PAGO] Event Delegation configurado para botão PIX');
    },
    
    /**
     * Processa pagamento PIX
     */
    processarPix: async function() {
        console.log('🔲 [MERCADO PAGO] Iniciando processamento PIX...');
        
        const pixBtn = document.getElementById('btn-pix-mp');
        if (pixBtn) {
            pixBtn.disabled = true;
            pixBtn.innerHTML = '🔄 Gerando PIX...';
        }
        
        try {
            const { prodId, afId } = getCheckoutData();
            if (!prodId) {
                throw new Error('ID do produto não encontrado');
            }
            
            const dadosPagador = getDadosPagador();
            const produtosAdicionais = capturarProdutosAdicionais();
            
            // Capturar endereço se produto for físico
            let enderecoJson = null;
            try {
                const endereco = getEnderecoEntrega();
                if (endereco) {
                    enderecoJson = JSON.stringify(endereco);
                }
            } catch (error) {
                if (pixBtn) {
                    pixBtn.disabled = false;
                    pixBtn.innerHTML = 'GERAR PIX <i class="fas fa-qrcode"></i>';
                }
                throw new Error(error.message);
            }
            
            const freteCobrado = getFreteCobrado();
            const valorFinal = calcularValorTotal() + freteCobrado; // Incluir frete no total
            
            const produtoTitulo = document.getElementById('titulo-produto')?.innerText || '';
            const produtoDescricao = document.getElementById('descricao-produto')?.innerText || '';
            const linkEntregavel = document.getElementById('link-entregavel')?.value || '';
            
            // Validar CPF antes de enviar
            const cpfLimpo = dadosPagador.cpf.replace(/\D/g, '');
            if (!cpfLimpo || cpfLimpo.length !== 11) {
                if (pixBtn) {
                    pixBtn.disabled = false;
                    pixBtn.innerHTML = 'GERAR PIX <i class="fas fa-qrcode"></i>';
                }
                throw new Error('Por favor, informe um CPF válido para gerar o PIX.');
            }
            
            // DEBUG: Log do Product ID sendo enviado
            console.log("🔍 [MERCADO PAGO PIX] Enviando Produto ID:", prodId);
            console.log("🔍 [MERCADO PAGO PIX] Valor calculado (frontend):", valorFinal);
            console.log("🔍 [MERCADO PAGO PIX] Frete cobrado:", freteCobrado);
            
            const requestData = {
                transaction_amount: valorFinal,
                valor_total: valorFinal,
                description: produtoTitulo,
                link_entregavel: linkEntregavel,
                product: {
                    id: prodId, // ✅ CRÍTICO: Backend usa este ID para buscar preço real
                    title: produtoTitulo,
                    description: produtoDescricao,
                    price: valorProduto || valorFinal
                },
                additional_products: produtosAdicionais,
                payer: {
                    email: dadosPagador.email,
                    first_name: dadosPagador.first_name,
                    last_name: dadosPagador.last_name,
                    full_name: dadosPagador.full_name,
                    identification: {
                        type: 'CPF',
                        number: cpfLimpo
                    },
                    phone: {
                        area_code: dadosPagador.celular && dadosPagador.celular.length >= 10 ? dadosPagador.celular.substring(0, 2) : '11',
                        number: dadosPagador.celular && dadosPagador.celular.length >= 10 ? dadosPagador.celular.substring(2) : '000000000'
                    }
                },
                afiliado: afId || null,
                endereco_json: enderecoJson,
                frete_cobrado: freteCobrado
            };
            
            const response = await fetch('/backend/process_payment_pix.php', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(requestData)
            });
            
            // Verificar se a resposta é válida
            if (!response.ok) {
                const errorText = await response.text();
                let errorData;
                try {
                    errorData = JSON.parse(errorText);
                } catch (e) {
                    errorData = { message: `Erro HTTP ${response.status}: ${errorText}` };
                }
                throw new Error(errorData.message || `Erro do servidor (${response.status})`);
            }
            
            const data = await response.json();
            
            if (data.status === 'success' || data.qr_code) {
                // CRÍTICO: Usar valorFinal calculado (não data.transaction_amount que pode ser undefined)
                // CRÍTICO: Incluir produto_id na URL para pix.php encontrar o produto
                const valorTotalFormatado = valorFinal ? parseFloat(valorFinal).toFixed(2) : (data.transaction_amount || '0.00');
                const url = `/backend/pix.php?produto_id=${prodId}&qr_code_base64=${encodeURIComponent(data.qr_code_base64)}&qr_code=${encodeURIComponent(data.qr_code)}&valor_total=${valorTotalFormatado}&transacao_id=${data.transaction_id || 0}`;
                console.log('🔗 [MERCADO PAGO] Redirecionando para PIX:', { produto_id: prodId, valor_total: valorTotalFormatado, transacao_id: data.transaction_id });
                window.location.href = url;
            } else {
                throw new Error(data.message || 'Erro ao gerar PIX');
            }
        } catch (error) {
            console.error('❌ [MERCADO PAGO] Erro no PIX:', error);
            alert('Erro ao gerar PIX: ' + error.message);
            if (pixBtn) {
                pixBtn.disabled = false;
                pixBtn.innerHTML = 'GERAR PIX <i class="fas fa-qrcode"></i>';
            }
        }
    },
    
    /**
     * Inicializa o botão Boleto
     */
    initBoleto: function() {
        // Sempre configurar Event Delegation primeiro
        this.attachBoletoDelegation();
        
        // Tentar encontrar o botão imediatamente
        let boletoBtn = document.getElementById('btn-boleto-mp');
        
        if (boletoBtn) {
            this.attachBoletoListener(boletoBtn);
            console.log('✅ [MERCADO PAGO] Botão Boleto inicializado (listener direto)');
        } else {
            console.log('⏳ [MERCADO PAGO] Botão Boleto não encontrado, usando apenas Event Delegation');
            setTimeout(() => {
                boletoBtn = document.getElementById('btn-boleto-mp');
                if (boletoBtn) {
                    this.attachBoletoListener(boletoBtn);
                    console.log('✅ [MERCADO PAGO] Botão Boleto encontrado após delay');
                }
            }, 500);
        }
    },
    
    /**
     * Anexa listener ao botão Boleto
     */
    attachBoletoListener: function(btn) {
        // Remover listeners antigos se existirem
        const newBtn = btn.cloneNode(true);
        btn.parentNode.replaceChild(newBtn, btn);
        
        newBtn.addEventListener('click', (e) => {
            e.preventDefault();
            e.stopPropagation();
            e.stopImmediatePropagation();
            console.log('🔲 [MERCADO PAGO] Botão Boleto clicado (listener direto)!');
            this.processarBoleto();
        }, false);
    },
    
    /**
     * Usa Event Delegation para botão Boleto
     */
    attachBoletoDelegation: function() {
        // Evitar adicionar múltiplos listeners
        if (this._boletoDelegationAttached) {
            return;
        }
        this._boletoDelegationAttached = true;
        
        document.addEventListener('click', (e) => {
            const target = e.target.closest('#btn-boleto-mp');
            if (target) {
                e.preventDefault();
                e.stopPropagation();
                e.stopImmediatePropagation();
                console.log('🔲 [MERCADO PAGO] Botão Boleto clicado (via delegation)!');
                this.processarBoleto();
            }
        }, true);
        console.log('✅ [MERCADO PAGO] Event Delegation configurado para botão Boleto');
    },
    
    /**
     * Processa pagamento Boleto
     */
    processarBoleto: async function() {
        console.log('🔲 [MERCADO PAGO] Iniciando processamento Boleto...');
        
        const boletoBtn = document.getElementById('btn-boleto-mp');
        if (boletoBtn) {
            boletoBtn.disabled = true;
            boletoBtn.innerHTML = '🔄 Gerando Boleto...';
        }
        
        try {
            const { prodId, afId } = getCheckoutData();
            if (!prodId) {
                throw new Error('ID do produto não encontrado');
            }
            
            const dadosPagador = getDadosPagador();
            const produtosAdicionais = capturarProdutosAdicionais();
            
            // CRÍTICO: Para BOLETO, endereço é SEMPRE obrigatório (independente do tipo do produto)
            let enderecoJson = null;
            try {
                const endereco = getEnderecoEntrega();
                if (endereco) {
                    // Validação adicional do endereço antes de enviar
                    if (!endereco.cep || endereco.cep.length !== 8) {
                        throw new Error('CEP inválido. Deve conter 8 dígitos.');
                    }
                    if (!endereco.rua || endereco.rua.trim().length < 3) {
                        throw new Error('Nome da rua é obrigatório e deve ter pelo menos 3 caracteres.');
                    }
                    if (!endereco.numero || endereco.numero.trim() === '' || endereco.numero === '0') {
                        throw new Error('Número do endereço é obrigatório.');
                    }
                    if (!endereco.bairro || endereco.bairro.trim().length < 2) {
                        throw new Error('Bairro é obrigatório e deve ter pelo menos 2 caracteres.');
                    }
                    if (!endereco.cidade || endereco.cidade.trim().length < 2) {
                        throw new Error('Cidade é obrigatória e deve ter pelo menos 2 caracteres.');
                    }
                    if (!endereco.estado || endereco.estado.length !== 2) {
                        throw new Error('Estado (UF) é obrigatório e deve ter 2 caracteres.');
                    }
                    
                    enderecoJson = JSON.stringify(endereco);
                    console.log('✅ [BOLETO] Endereço capturado e validado:', endereco);
                } else {
                    // Se getEnderecoEntrega() retornar null, é porque não é físico e não é boleto
                    // Mas como estamos processando boleto, isso não deveria acontecer
                    throw new Error('Endereço é obrigatório para gerar boleto. Por favor, preencha todos os campos de endereço.');
                }
            } catch (error) {
                console.error('❌ [BOLETO] Erro ao capturar endereço:', error);
                throw new Error(error.message);
            }
            
            const freteCobrado = getFreteCobrado();
            const valorFinal = calcularValorTotal() + freteCobrado;
            
            const produtoTitulo = document.getElementById('titulo-produto')?.innerText || '';
            const produtoDescricao = document.getElementById('descricao-produto')?.innerText || '';
            const linkEntregavel = document.getElementById('link-entregavel')?.value || '';
            
            // Capturar CPF do campo específico do boleto ou dos dados do pagador
            const cpfBoleto = document.getElementById('cpf_boleto_mp')?.value?.replace(/\D/g, '') || dadosPagador.cpf?.replace(/\D/g, '') || '';
            
            if (!cpfBoleto || cpfBoleto.length !== 11) {
                throw new Error('Por favor, informe um CPF válido para gerar o boleto.');
            }
            
            const requestData = {
                transaction_amount: valorFinal,
                description: produtoTitulo,
                link_entregavel: linkEntregavel,
                product: {
                    id: prodId,
                    title: produtoTitulo,
                    description: produtoDescricao,
                    price: valorProduto || valorFinal
                },
                additional_products: produtosAdicionais,
                payer: {
                    email: dadosPagador.email,
                    first_name: dadosPagador.first_name,
                    last_name: dadosPagador.last_name,
                    full_name: dadosPagador.full_name,
                    identification: {
                        type: 'CPF',
                        number: cpfBoleto
                    },
                    phone: {
                        area_code: dadosPagador.celular && dadosPagador.celular.length >= 10 ? dadosPagador.celular.substring(0, 2) : '11',
                        number: dadosPagador.celular && dadosPagador.celular.length >= 10 ? dadosPagador.celular.substring(2) : '000000000',
                        country_code: '+55'
                    }
                },
                afiliado: afId || null,
                endereco_json: enderecoJson, // Usar endereco_json que vem de getEnderecoEntrega()
                frete_cobrado: freteCobrado
            };
            
            const response = await fetch('/backend/process_payment_boleto_mercadopago.php', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(requestData)
            });
            
            // Verificar se a resposta é válida
            if (!response.ok) {
                const errorText = await response.text();
                let errorData;
                try {
                    errorData = JSON.parse(errorText);
                } catch (e) {
                    errorData = { message: `Erro HTTP ${response.status}: ${errorText}` };
                }
                throw new Error(errorData.message || `Erro interno do servidor. Por favor, tente novamente. (${response.status})`);
            }
            
            const data = await response.json();
            
            if (data.status === 'success') {
                // Exibir boleto na tela
                const boletoContainer = document.getElementById('mercadopago-boleto');
                if (boletoContainer) {
                    // Criar ou atualizar área de exibição do boleto
                    let boletoDisplay = boletoContainer.querySelector('.boleto-display');
                    if (!boletoDisplay) {
                        boletoDisplay = document.createElement('div');
                        boletoDisplay.className = 'boleto-display';
                        boletoDisplay.style.cssText = 'margin-top: 20px; padding: 20px; background: rgba(255,255,255,0.1); border-radius: 8px; text-align: center;';
                        boletoContainer.insertBefore(boletoDisplay, boletoContainer.querySelector('form'));
                    }
                    
                    const ticketUrl = data.ticket_url || data.external_resource_url || '';
                    const barcode = data.barcode || '';
                    
                    boletoDisplay.innerHTML = `
                        <div style="margin-bottom: 20px;">
                            <h3 style="color: #009846; margin-bottom: 10px;">✅ Boleto Gerado com Sucesso!</h3>
                            <p style="color: #fff; margin-bottom: 15px;">O boleto vence em 3 dias úteis. Após o pagamento, o acesso será liberado automaticamente.</p>
                        </div>
                        <div style="margin-bottom: 20px; display: flex; gap: 10px; justify-content: center; flex-wrap: wrap;">
                            ${ticketUrl ? `
                            <a href="${ticketUrl}" target="_blank" class="btn" style="background: linear-gradient(90deg, #009846, #00A85A); display: inline-block; padding: 15px 30px; text-decoration: none; color: white; border-radius: 8px; font-weight: 600; margin: 5px;">
                                <i class="fas fa-file-pdf"></i> Visualizar/Imprimir Boleto (PDF)
                            </a>
                            ` : '<p style="color: #ff6b6b; margin: 10px 0;">URL do boleto não disponível. Verifique o payment_id: ' + (data.payment_id || 'N/A') + '</p>'}
                        </div>
                        ${barcode ? `
                        <div style="margin-top: 20px; padding: 15px; background: rgba(255,255,255,0.1); border-radius: 6px; border: 1px solid rgba(255,255,255,0.2);">
                            <p style="font-size: 12px; color: #fff; margin-bottom: 8px; font-weight: 600;">Código de Barras:</p>
                            <p style="font-family: monospace; font-size: 16px; color: #fff; word-break: break-all; background: rgba(0,0,0,0.2); padding: 10px; border-radius: 4px;">${barcode}</p>
                        </div>
                        ` : ''}
                        <div style="margin-top: 15px; padding: 10px; background: rgba(255,193,7,0.2); border-radius: 6px; border: 1px solid rgba(255,193,7,0.4);">
                            <p style="font-size: 12px; color: #fff; margin: 0;">
                                <i class="fas fa-info-circle"></i> 
                                <strong>Importante:</strong> Após o pagamento, aguarde a confirmação. O acesso será enviado para seu e-mail.
                            </p>
                        </div>
                    `;
                    
                    if (boletoBtn) {
                        boletoBtn.style.display = 'none';
                    }
                }
                
                rastrearFacebookPixel('InitiateCheckout', {
                    value: valorFinal,
                    currency: 'BRL'
                });
            } else {
                throw new Error(data.message || 'Erro ao gerar boleto');
            }
        } catch (error) {
            console.error('❌ [MERCADO PAGO] Erro no processamento de boleto:', error);
            alert('Erro ao gerar boleto: ' + error.message);
            if (boletoBtn) {
                boletoBtn.disabled = false;
                boletoBtn.innerHTML = 'GERAR BOLETO <i class="fas fa-barcode"></i>';
            }
            toggleProcessingPopup(false);
        }
    }
};

// ============================================================
// MÓDULO STRIPE
// ============================================================

const StripeModule = {
    stripe: null,
    cardElement: null,
    elements: null,
    
    /**
     * Inicializa o módulo Stripe
     */
    init: function() {
        console.log('🚀 [STRIPE] Inicializando módulo...');
        
        if (typeof Stripe === 'undefined') {
            console.warn('⏳ [STRIPE] SDK ainda não carregou, aguardando...');
            setTimeout(() => this.init(), 500);
            return;
        }
        
        // Aqui você deve obter a public key do Stripe (pode vir de um elemento hidden ou configuração)
        const stripePublicKey = this.getStripePublicKey();
        if (!stripePublicKey) {
            console.error('❌ [STRIPE] Public key não encontrada');
            return;
        }
        
        this.stripe = Stripe(stripePublicKey);
        this.elements = this.stripe.elements();
        
        // Inicializar card element
        this.initCardElement();
        
        // Listener do botão
        const submitBtn = document.getElementById('btn-submit-stripe');
        if (submitBtn) {
            submitBtn.addEventListener('click', (e) => {
                e.preventDefault();
                this.processar();
            });
        }
        
        console.log('✅ [STRIPE] Módulo inicializado');
    },
    
    /**
     * Obtém a public key do Stripe (implementar conforme sua estrutura)
     */
    getStripePublicKey: function() {
        // TODO: Implementar busca da public key (pode vir de um elemento hidden, API, etc.)
        return null; // Retornar a chave real aqui
    },
    
    /**
     * Inicializa o card element do Stripe
     */
    initCardElement: function() {
        const cardElementContainer = document.getElementById('card-element');
        if (!cardElementContainer) {
            console.log('⏭️ [STRIPE] Container card-element não encontrado');
            return;
        }
        
        this.cardElement = this.elements.create('card', {
            style: {
                base: {
                    fontSize: '16px',
                    color: '#000',
                    '::placeholder': {
                        color: '#888'
                    }
                }
            }
        });
        
        this.cardElement.mount('#card-element');
        
        this.cardElement.on('change', (event) => {
            const displayError = document.getElementById('card-errors');
            if (event.error) {
                displayError.textContent = event.error.message;
            } else {
                displayError.textContent = '';
            }
        });
        
        console.log('✅ [STRIPE] Card element inicializado');
    },
    
    /**
     * Processa pagamento Stripe
     */
    processar: async function() {
        console.log('💳 [STRIPE] Iniciando processamento...');
        
        if (!this.cardElement) {
            alert('Erro: Formulário não inicializado. Recarregue a página.');
            return;
        }
        
        toggleProcessingPopup(true);
        
        try {
            const { prodId, afId } = getCheckoutData();
            if (!prodId) {
                throw new Error('ID do produto não encontrado');
            }
            
            const dadosPagador = getDadosPagador();
            const produtosAdicionais = capturarProdutosAdicionais();
            
            // Capturar endereço se produto for físico
            let enderecoJson = null;
            try {
                const endereco = getEnderecoEntrega();
                if (endereco) {
                    enderecoJson = JSON.stringify(endereco);
                }
            } catch (error) {
                toggleProcessingPopup(false);
                throw new Error(error.message);
            }
            
            const freteCobrado = getFreteCobrado();
            const valorFinal = calcularValorTotal() + freteCobrado; // Incluir frete no total
            
            // Criar payment method
            const { paymentMethod, error } = await this.stripe.createPaymentMethod({
                type: 'card',
                card: this.cardElement,
                billing_details: {
                    name: dadosPagador.full_name,
                    email: dadosPagador.email
                }
            });
            
            if (error) {
                throw new Error(error.message);
            }
            
            // Enviar para backend
            const requestData = {
                payment_method_id: paymentMethod.id,
                transaction_amount: valorFinal,
                product: { id: prodId },
                additional_products: produtosAdicionais,
                payer: {
                    email: dadosPagador.email,
                    first_name: dadosPagador.first_name,
                    last_name: dadosPagador.last_name,
                    identification: {
                        type: 'CPF',
                        number: dadosPagador.cpf.replace(/\D/g, '')
                    }
                },
                afiliado: afId || null,
                endereco_json: enderecoJson,
                frete_cobrado: freteCobrado
            };
            
            const response = await fetch('/backend/process_payment_stripe.php', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(requestData)
            });
            
            const data = await response.json();
            
            if (data.status === 'success') {
                rastrearFacebookPixel('Purchase', {
                    value: valorFinal,
                    currency: 'BRL'
                });
                window.location.href = getUrlObrigado(data.transaction_id);
            } else {
                throw new Error(data.message || 'Erro ao processar pagamento');
            }
        } catch (error) {
            console.error('❌ [STRIPE] Erro no processamento:', error);
            alert('Erro ao processar pagamento: ' + error.message);
            toggleProcessingPopup(false);
        }
    }
};

// ============================================================
// MÓDULO PAYPAL
// ============================================================

const PayPalModule = {
    /**
     * Inicializa o módulo PayPal
     */
    init: function() {
        console.log('🚀 [PAYPAL] Inicializando módulo...');
        
        const container = document.getElementById('paypal-button-container');
        if (!container) {
            console.log('⏭️ [PAYPAL] Container não encontrado');
            return;
        }
        
        // TODO: Implementar integração com PayPal SDK
        // Por enquanto, apenas log
        console.log('⏳ [PAYPAL] Integração PayPal ainda não implementada');
        
        console.log('✅ [PAYPAL] Módulo inicializado');
    }
};

// ============================================================
// MÓDULO PAGAR.ME
// ============================================================

const PagarMeModule = {
    /**
     * Inicializa o módulo Pagar.me
     */
    init: function() {
        console.log('🚀 [PAGAR.ME] Inicializando módulo...');
        
        // Inicializar formulário de cartão
        this.initCartao();
        
        // Inicializar botão PIX
        this.initPix();
        this.initBoleto();
        
        console.log('✅ [PAGAR.ME] Módulo inicializado');
    },
    
    /**
     * Inicializa o formulário de cartão
     */
    initCartao: function() {
        const formContainer = document.getElementById('form-card-pagarme');
        if (!formContainer) {
            console.log('⏭️ [PAGAR.ME] Formulário de cartão não encontrado');
            return;
        }
        
        // Listener do botão de submit
        const submitBtn = document.getElementById('btn-submit-pagarme-cartao');
        if (submitBtn) {
            submitBtn.addEventListener('click', (e) => {
                e.preventDefault();
                this.processarCartao();
            });
        }
        
        // Listeners para atualizar resumo quando produtos adicionais forem selecionados
        document.querySelectorAll('input[name="produto_adicional[]"]').forEach(checkbox => {
            checkbox.addEventListener('change', () => {
                atualizarResumoPedido('pagarme-cartao');
            });
        });
        
        console.log('✅ [PAGAR.ME] Formulário de cartão inicializado');
    },
    
    /**
     * Processa pagamento com cartão
     */
    processarCartao: async function() {
        console.log('💳 [PAGAR.ME] Iniciando processamento de cartão...');
        
        // Validação básica dos campos
        const cardNumber = document.getElementById('pagarme-card-number')?.value.trim();
        const cardExpiry = document.getElementById('pagarme-card-expiry')?.value.trim();
        const cardCvv = document.getElementById('pagarme-card-cvv')?.value.trim();
        const cardName = document.getElementById('pagarme-card-name')?.value.trim();
        const cardCpf = document.getElementById('pagarme-card-cpf')?.value.trim();
        
        if (!cardNumber || !cardExpiry || !cardCvv || !cardName || !cardCpf) {
            alert('Por favor, preencha todos os campos do cartão.');
            return;
        }
        
        toggleProcessingPopup(true);
        
        try {
            const { prodId, afId } = getCheckoutData();
            if (!prodId) {
                throw new Error('ID do produto não encontrado');
            }
            
            const dadosPagador = getDadosPagador();
            const produtosAdicionais = capturarProdutosAdicionais();
            
            // Capturar endereço se produto for físico
            let enderecoJson = null;
            try {
                const endereco = getEnderecoEntrega();
                if (endereco) {
                    enderecoJson = JSON.stringify(endereco);
                }
            } catch (error) {
                toggleProcessingPopup(false);
                throw new Error(error.message);
            }
            
            const freteCobrado = getFreteCobrado();
            const valorFinal = calcularValorTotal() + freteCobrado; // Incluir frete no total
            
            const produtoTitulo = document.getElementById('titulo-produto')?.innerText || '';
            const produtoDescricao = document.getElementById('descricao-produto')?.innerText || '';
            const linkEntregavel = document.getElementById('link-entregavel')?.value || '';
            
            // Preparar dados do cartão
            const [expiryMonth, expiryYear] = cardExpiry.split('/');
            const cardData = {
                number: cardNumber.replace(/\D/g, ''),
                holder_name: cardName,
                exp_month: parseInt(expiryMonth) || 12,
                exp_year: 2000 + parseInt(expiryYear) || 2025,
                cvv: cardCvv
            };
            
            const requestData = {
                transaction_amount: valorFinal,
                description: produtoTitulo,
                payment_method: 'credit_card',
                card: cardData,
                product: {
                    id: prodId,
                    title: produtoTitulo,
                    description: produtoDescricao,
                    price: valorProduto || valorFinal,
                    link_entregavel: linkEntregavel
                },
                additional_products: produtosAdicionais,
                payer: {
                    email: dadosPagador.email,
                    first_name: dadosPagador.first_name,
                    last_name: dadosPagador.last_name,
                    full_name: dadosPagador.full_name,
                    identification: {
                        type: 'CPF',
                        number: cardCpf.replace(/\D/g, '')
                    },
                    phone: {
                        area_code: dadosPagador.celular && dadosPagador.celular.length >= 10 ? dadosPagador.celular.substring(0, 2) : '11',
                        number: dadosPagador.celular && dadosPagador.celular.length >= 10 ? dadosPagador.celular.substring(2) : '000000000'
                    }
                },
                afiliado: afId || null,
                endereco_json: enderecoJson,
                frete_cobrado: freteCobrado
            };
            
            console.log('🌐 [PAGAR.ME] Enviando requisição para /backend/process_payment_pagarme.php');
            
            const response = await fetch('/backend/process_payment_pagarme.php', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(requestData)
            });
            
            const data = await response.json();
            
            if (data.status === 'success') {
                rastrearFacebookPixel('Purchase', {
                    value: valorFinal,
                    currency: 'BRL'
                });
                window.location.href = getUrlObrigado(data.transaction_id);
            } else {
                throw new Error(data.message || 'Erro ao processar pagamento');
            }
        } catch (error) {
            console.error('❌ [PAGAR.ME] Erro no processamento:', error);
            alert('Erro ao processar pagamento: ' + error.message);
            toggleProcessingPopup(false);
        }
    },
    
    /**
     * Inicializa o botão PIX
     */
    initPix: function() {
        const pixBtn = document.getElementById('btn-pix-pagarme');
        if (!pixBtn) {
            console.log('⏭️ [PAGAR.ME] Botão PIX não encontrado');
            return;
        }
        
        pixBtn.addEventListener('click', (e) => {
            e.preventDefault();
            e.stopPropagation();
            this.processarPix();
        });
        
        // Listeners para atualizar resumo quando produtos adicionais forem selecionados
        document.querySelectorAll('input[name="produto_adicional[]"]').forEach(checkbox => {
            checkbox.addEventListener('change', () => {
                atualizarResumoPedido('pagarme-pix');
            });
        });
        
        console.log('✅ [PAGAR.ME] Botão PIX inicializado');
    },
    
    /**
     * Inicializa o botão Boleto
     */
    initBoleto: function() {
        const boletoBtn = document.getElementById('btn-boleto-pagarme');
        if (!boletoBtn) {
            console.log('⏭️ [PAGAR.ME] Botão Boleto não encontrado');
            return;
        }
        
        boletoBtn.addEventListener('click', (e) => {
            e.preventDefault();
            e.stopPropagation();
            this.processarBoleto();
        });
        
        // Listeners para atualizar resumo quando produtos adicionais forem selecionados
        document.querySelectorAll('input[name="produto_adicional[]"]').forEach(checkbox => {
            checkbox.addEventListener('change', () => {
                atualizarResumoPedido('pagarme-boleto');
            });
        });
        
        console.log('✅ [PAGAR.ME] Botão Boleto inicializado');
    },
    
    /**
     * Processa pagamento Boleto
     */
    processarBoleto: async function() {
        console.log('🔲 [PAGAR.ME] Iniciando processamento Boleto...');
        
        const boletoBtn = document.getElementById('btn-boleto-pagarme');
        if (boletoBtn) {
            boletoBtn.disabled = true;
            boletoBtn.innerHTML = '🔄 Gerando Boleto...';
        }
        
        try {
            const { prodId, afId } = getCheckoutData();
            if (!prodId) {
                throw new Error('ID do produto não encontrado');
            }
            
            const dadosPagador = getDadosPagador();
            const produtosAdicionais = capturarProdutosAdicionais();
            
            // Capturar endereço se produto for físico
            let enderecoJson = null;
            try {
                const endereco = getEnderecoEntrega();
                if (endereco) {
                    enderecoJson = JSON.stringify(endereco);
                }
            } catch (error) {
                throw new Error(error.message);
            }
            
            const freteCobrado = getFreteCobrado();
            const valorFinal = calcularValorTotal() + freteCobrado;
            
            const produtoTitulo = document.getElementById('titulo-produto')?.innerText || '';
            const produtoDescricao = document.getElementById('descricao-produto')?.innerText || '';
            const linkEntregavel = document.getElementById('link-entregavel')?.value || '';
            
            const requestData = {
                transaction_amount: valorFinal,
                valor_total: valorFinal,
                description: produtoTitulo,
                payment_method: 'boleto',
                link_entregavel: linkEntregavel,
                product: {
                    id: prodId,
                    title: produtoTitulo,
                    description: produtoDescricao,
                    price: valorProduto || valorFinal
                },
                additional_products: produtosAdicionais,
                payer: {
                    email: dadosPagador.email,
                    first_name: dadosPagador.first_name,
                    last_name: dadosPagador.last_name,
                    full_name: dadosPagador.full_name,
                    identification: {
                        type: 'CPF',
                        number: dadosPagador.cpf.replace(/\D/g, '')
                    },
                    phone: {
                        area_code: dadosPagador.celular && dadosPagador.celular.length >= 10 ? dadosPagador.celular.substring(0, 2) : '11',
                        number: dadosPagador.celular && dadosPagador.celular.length >= 10 ? dadosPagador.celular.substring(2) : '000000000'
                    }
                },
                endereco_json: enderecoJson,
                frete_cobrado: freteCobrado
            };
            
            const response = await fetch('/backend/process_payment_boleto_pagarme.php', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(requestData)
            });
            
            const data = await response.json();
            
            if (data.status === 'success') {
                // Exibir boleto na tela
                const boletoContainer = document.getElementById('pagarme-boleto');
                if (boletoContainer) {
                    // Criar ou atualizar área de exibição do boleto
                    let boletoDisplay = boletoContainer.querySelector('.boleto-display');
                    if (!boletoDisplay) {
                        boletoDisplay = document.createElement('div');
                        boletoDisplay.className = 'boleto-display';
                        boletoDisplay.style.cssText = 'margin-top: 20px; padding: 20px; background: #f5f5f5; border-radius: 8px; text-align: center;';
                        boletoContainer.appendChild(boletoDisplay);
                    }
                    
                    boletoDisplay.innerHTML = `
                        <div style="margin-bottom: 20px;">
                            <h3 style="color: #009846; margin-bottom: 10px;">Boleto Gerado com Sucesso!</h3>
                            <p style="color: #666; margin-bottom: 15px;">O boleto vence em 3 dias úteis. Após o pagamento, o acesso será liberado automaticamente.</p>
                        </div>
                        <div style="margin-bottom: 20px;">
                            <a href="${data.ticket_url}" target="_blank" class="btn" style="background: linear-gradient(90deg, #009846, #00A85A); display: inline-block; padding: 15px 30px; text-decoration: none; color: white; border-radius: 8px; font-weight: 600;">
                                <i class="fas fa-download"></i> Baixar Boleto
                            </a>
                        </div>
                        <div style="margin-top: 20px; padding: 15px; background: white; border-radius: 6px; border: 1px solid #ddd;">
                            <p style="font-size: 12px; color: #666; margin-bottom: 8px;"><strong>Código de Barras:</strong></p>
                            <p style="font-family: monospace; font-size: 14px; color: #333; word-break: break-all;">${data.barcode || 'N/A'}</p>
                        </div>
                        <div style="margin-top: 15px; padding: 10px; background: #fff3cd; border-radius: 6px; border: 1px solid #ffc107;">
                            <p style="font-size: 12px; color: #856404; margin: 0;">
                                <i class="fas fa-info-circle"></i> 
                                <strong>Importante:</strong> Após o pagamento, aguarde a confirmação. O acesso será enviado para seu e-mail.
                            </p>
                        </div>
                    `;
                    
                    if (boletoBtn) {
                        boletoBtn.style.display = 'none';
                    }
                }
                
                rastrearFacebookPixel('InitiateCheckout', {
                    value: valorFinal,
                    currency: 'BRL'
                });
            } else {
                throw new Error(data.message || 'Erro ao gerar boleto');
            }
        } catch (error) {
            console.error('❌ [PAGAR.ME] Erro no processamento de boleto:', error);
            alert('Erro ao gerar boleto: ' + error.message);
            if (boletoBtn) {
                boletoBtn.disabled = false;
                boletoBtn.innerHTML = 'GERAR BOLETO <i class="fas fa-barcode"></i>';
            }
            toggleProcessingPopup(false);
        }
    },
    
    /**
     * Processa pagamento PIX
     */
    processarPix: async function() {
        console.log('🔲 [PAGAR.ME] Iniciando processamento PIX...');
        
        const pixBtn = document.getElementById('btn-pix-pagarme');
        if (pixBtn) {
            pixBtn.disabled = true;
            pixBtn.innerHTML = '🔄 Gerando PIX...';
        }
        
        try {
            const { prodId, afId } = getCheckoutData();
            if (!prodId) {
                throw new Error('ID do produto não encontrado');
            }
            
            const dadosPagador = getDadosPagador();
            const produtosAdicionais = capturarProdutosAdicionais();
            
            // Capturar endereço se produto for físico
            let enderecoJson = null;
            try {
                const endereco = getEnderecoEntrega();
                if (endereco) {
                    enderecoJson = JSON.stringify(endereco);
                }
            } catch (error) {
                throw new Error(error.message);
            }
            
            const freteCobrado = getFreteCobrado();
            const valorFinal = calcularValorTotal() + freteCobrado; // Incluir frete no total
            
            const produtoTitulo = document.getElementById('titulo-produto')?.innerText || '';
            const produtoDescricao = document.getElementById('descricao-produto')?.innerText || '';
            const linkEntregavel = document.getElementById('link-entregavel')?.value || '';
            
            const requestData = {
                transaction_amount: valorFinal,
                valor_total: valorFinal,
                description: produtoTitulo,
                payment_method: 'pix',
                link_entregavel: linkEntregavel,
                product: {
                    id: prodId,
                    title: produtoTitulo,
                    description: produtoDescricao,
                    price: valorProduto || valorFinal
                },
                additional_products: produtosAdicionais,
                payer: {
                    email: dadosPagador.email,
                    first_name: dadosPagador.first_name,
                    last_name: dadosPagador.last_name,
                    full_name: dadosPagador.full_name,
                    identification: {
                        type: 'CPF',
                        number: dadosPagador.cpf.replace(/\D/g, '')
                    },
                    phone: {
                        area_code: dadosPagador.celular && dadosPagador.celular.length >= 10 ? dadosPagador.celular.substring(0, 2) : '11',
                        number: dadosPagador.celular && dadosPagador.celular.length >= 10 ? dadosPagador.celular.substring(2) : '000000000'
                    }
                },
                afiliado: afId || null,
                endereco_json: enderecoJson,
                frete_cobrado: freteCobrado
            };
            
            console.log('🌐 [PAGAR.ME] Enviando requisição para /backend/process_payment_pagarme.php');
            
            const response = await fetch('/backend/process_payment_pagarme.php', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(requestData)
            });
            
            const data = await response.json();
            
            if (data.status === 'success' || data.qr_code) {
                const url = `/backend/pix.php?qr_code_base64=${encodeURIComponent(data.qr_code_base64)}&qr_code=${encodeURIComponent(data.qr_code)}&valor_total=${data.transaction_amount}&transacao_id=${data.transaction_id || 0}`;
                window.location.href = url;
            } else {
                throw new Error(data.message || 'Erro ao gerar PIX');
            }
        } catch (error) {
            console.error('❌ [PAGAR.ME] Erro no PIX:', error);
            alert('Erro ao gerar PIX: ' + error.message);
            if (pixBtn) {
                pixBtn.disabled = false;
                pixBtn.innerHTML = 'GERAR PIX <i class="fas fa-qrcode"></i>';
            }
        }
    }
};

// ============================================================
// INICIALIZADOR MESTRE
// ============================================================

/**
 * Função global para voltar para dados pessoais
 */
window.voltarParaDadosPessoais = function() {
    const { prodId, afId } = getCheckoutData();
    let url = `/views/dados_pessoais.php?produto_id=${prodId}`;
    if (afId && afId !== '0' && afId !== '') {
        url += `&af=${afId}`;
    }
    window.location.href = url;
};

/**
 * Inicialização principal quando o DOM estiver pronto
 */
document.addEventListener('DOMContentLoaded', function() {
    console.log('🚀 [CHECKOUT] Iniciando sistema de checkout modular...');
    
    // Obter valor do produto da página
    const priceElement = document.getElementById('product-price');
    if (priceElement) {
        const priceText = priceElement.innerText.replace(/[^\d,]/g, '').replace(',', '.');
        valorProduto = parseFloat(priceText) || 0;
        valorTotal = valorProduto;
    }
    
    // Inicializar gerenciador de abas PRIMEIRO
    TabManager.init();
    
    // Filtrar métodos de pagamento baseado na configuração do produto (após tabs estarem prontas)
    setTimeout(() => {
        filtrarMetodosPagamento();
    }, 100);
    
    // Inicializar módulos baseado na presença dos elementos no HTML
    if (document.getElementById('form-card-mp')) {
        MercadoPagoModule.init();
    }
    
    if (document.getElementById('form-card-stripe')) {
        StripeModule.init();
    }
    
    if (document.getElementById('paypal-button-container')) {
        PayPalModule.init();
    }
    
    if (document.getElementById('form-card-pagarme')) {
        PagarMeModule.init();
    }
    
    // Listeners para Order Bump (produtos adicionais)
    document.querySelectorAll('input[name="produto_adicional[]"]').forEach(checkbox => {
        checkbox.addEventListener('change', function() {
            // Atualizar resumo em todas as abas ativas
            ['mercadopago-cartao', 'mercadopago-pix', 'mercadopago-boleto', 'stripe', 'paypal', 'pagarme-cartao', 'pagarme-pix', 'pagarme-boleto'].forEach(prefix => {
                atualizarResumoPedido(prefix);
            });
        });
    });
    
    console.log('✅ [CHECKOUT] Sistema de checkout inicializado');
});
