<?php
/**
 * Função para criar atividades automaticamente baseadas em fluxos
 * VERSÃO COMPLETA CORRIGIDA - Com agendamento de tempo para envio de e-mails
 * E CORREÇÃO PARA RECUPERAÇÃO AUTOMÁTICA DE CLIENTES PERDIDOS
 * 
 * ATUALIZADO: Corrigido problema de verificação de motivos e recuperação automática
 * ATUALIZADO: Substituído sistema de e-mail pela versão do enviar_email_agendamento.php
 */

// Inicializar sessão se não estiver ativa
if (session_status() === PHP_SESSION_NONE) {
    session_start();
}

/**
 * Função para verificar e criar tabela de e-mails agendados se não existir
 */
function verificarTabelaEmailsAgendados($conn) {
    $result = $conn->query("SHOW TABLES LIKE 'emails_agendados'");
    if ($result->num_rows == 0) {
        $sql = "CREATE TABLE emails_agendados (
            id INT PRIMARY KEY AUTO_INCREMENT,
            tenant_id INT NOT NULL,
            fluxo_id INT,
            cliente_id INT NOT NULL,
            usuario_id INT,
            template_id INT,
            assunto VARCHAR(500) NOT NULL,
            mensagem TEXT,
            destinatario_email VARCHAR(255) NOT NULL,
            destinatario_nome VARCHAR(255),
            data_agendamento DATETIME NOT NULL,
            data_envio DATETIME DEFAULT NULL,
            status ENUM('agendado', 'processando', 'enviado', 'erro', 'cancelado') DEFAULT 'agendado',
            tentativas INT DEFAULT 0,
            ultima_tentativa DATETIME DEFAULT NULL,
            erro_mensagem TEXT,
            config_email JSON,
            criado_em DATETIME DEFAULT CURRENT_TIMESTAMP,
            atualizado_em DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
            INDEX idx_status_data (status, data_agendamento),
            INDEX idx_cliente (cliente_id),
            INDEX idx_tenant (tenant_id)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci";
        
        if ($conn->query($sql) === TRUE) {
            error_log("✅ Tabela emails_agendados criada com sucesso");
            return true;
        } else {
            error_log("❌ Erro ao criar tabela emails_agendados: " . $conn->error);
            return false;
        }
    }
    return true;
}

/**
 * Função para carregar configurações de e-mail DO USUÁRIO LOGADO
 */
function carregarConfiguracoesEmailFluxo($conn, $tenant_id, $usuario_id = null) {
    try {
        if (!$usuario_id) {
            $usuario_id = $_SESSION['usuario_id'] ?? null;
        }
        
        if (!$usuario_id) {
            error_log("❌ ERRO: Nenhum usuário logado identificado para carregar configurações de e-mail");
            return null;
        }
        
        $stmt = $conn->prepare("
            SELECT u.nome as usuario_nome, u.email as usuario_email, 
                   u.telefone, u.cargo, u.assinatura_email,
                   t.nome as tenant_nome, t.logo_path as tenant_logo 
            FROM usuarios u 
            LEFT JOIN tenants t ON u.tenant_id = t.id 
            WHERE u.id = ? AND u.tenant_id = ?
        ");
        $stmt->bind_param("ii", $usuario_id, $tenant_id);
        $stmt->execute();
        $result = $stmt->get_result();
        
        if ($result->num_rows > 0) {
            $dados = $result->fetch_assoc();
            $stmt->close();
            
            $remetenteNome = $dados['usuario_nome'] . ' - ' . $dados['tenant_nome'];
            $remetenteEmail = $dados['usuario_email'];
            
            $configuracoes = [
                'email_remetente' => $remetenteEmail,
                'nome_remetente' => $remetenteNome,
                'usuario_nome' => $dados['usuario_nome'],
                'tenant_nome' => $dados['tenant_nome'],
                'tenant_logo' => $dados['tenant_logo'],
                'usuario_telefone' => $dados['telefone'] ?? '',
                'usuario_cargo' => $dados['cargo'] ?? '',
                'assinatura_personalizada' => $dados['assinatura_email'] ?? ''
            ];
            
            error_log("✅ Configurações de e-mail carregadas para usuário logado: $remetenteNome <$remetenteEmail>");
            return $configuracoes;
        }
        
        $stmt->close();
        return null;
        
    } catch (Exception $e) {
        error_log("❌ Erro ao carregar configurações de e-mail: " . $e->getMessage());
        return null;
    }
}

/**
 * Função para buscar conteúdo do template de e-mail
 */
function buscarTemplateEmail($conn, $template_id, $tenant_id) {
    try {
        $checkColumn = $conn->query("SHOW COLUMNS FROM templates_email LIKE 'incluir_assinatura'");
        $hasAssinaturaColumn = $checkColumn->num_rows > 0;
        
        if ($hasAssinaturaColumn) {
            $sql = "SELECT id, nome, assunto, conteudo, incluir_assinatura FROM templates_email WHERE id = ? AND tenant_id = ? AND ativo = 1";
        } else {
            $sql = "SELECT id, nome, assunto, conteudo, 1 as incluir_assinatura FROM templates_email WHERE id = ? AND tenant_id = ? AND ativo = 1";
        }
        
        $stmt = $conn->prepare($sql);
        $stmt->bind_param("ii", $template_id, $tenant_id);
        $stmt->execute();
        $result = $stmt->get_result();
        
        if ($result->num_rows > 0) {
            $template = $result->fetch_assoc();
            $stmt->close();
            
            error_log("✅ Template encontrado: ID {$template['id']}, Nome: {$template['nome']}");
            return $template;
        } else {
            $stmt->close();
            error_log("❌ Template de e-mail não encontrado: ID $template_id, Tenant: $tenant_id");
            return null;
        }
        
    } catch (Exception $e) {
        error_log("❌ Erro ao buscar template de e-mail: " . $e->getMessage());
        return null;
    }
}

// ============================================================================
// FUNÇÕES DE E-MAIL - VERSÃO CORRIGIDA (IGUAL AO enviar_email_agendamento.php)
// ============================================================================

/**
 * Função para carregar dados da assinatura (CÓPIA DO enviar_email_agendamento.php)
 */
function carregarDadosAssinatura($conn, $tenantId, $usuarioId) {
    try {
        $stmt = $conn->prepare("SELECT logo_path, nome as nome_tenant FROM tenants WHERE id = ?");
        $stmt->bind_param("i", $tenantId);
        $stmt->execute();
        $result = $stmt->get_result();
        $tenant = $result->fetch_assoc();
        $stmt->close();
        
        $stmt = $conn->prepare("SELECT nome, email, assinatura_email, telefone, cargo FROM usuarios WHERE id = ?");
        $stmt->bind_param("i", $usuarioId);
        $stmt->execute();
        $result = $stmt->get_result();
        $usuario = $result->fetch_assoc();
        $stmt->close();
        
        return [
            'tenant' => $tenant,
            'usuario' => $usuario
        ];
        
    } catch (Exception $e) {
        error_log("❌ Erro ao carregar dados da assinatura: " . $e->getMessage());
        return null;
    }
}

/**
 * Função para converter caminho relativo em URL absoluta (CÓPIA DO enviar_email_agendamento.php)
 */
function converterParaUrlAbsoluta($caminhoRelativo) {
    if (filter_var($caminhoRelativo, FILTER_VALIDATE_URL)) {
        return $caminhoRelativo;
    }
    
    $protocolo = isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on' ? "https" : "http";
    $host = $_SERVER['HTTP_HOST'];
    
    if (strpos($caminhoRelativo, '/') === 0) {
        return $protocolo . "://" . $host . $caminhoRelativo;
    }
    
    $diretorioBase = dirname($_SERVER['PHP_SELF']);
    return $protocolo . "://" . $host . $diretorioBase . '/' . ltrim($caminhoRelativo, '/');
}

/**
 * Função para gerar assinatura HTML (CÓPIA DO enviar_email_agendamento.php)
 */
function gerarAssinatura($dadosAssinatura) {
    if (!$dadosAssinatura) return '';
    
    $logo = $dadosAssinatura['tenant']['logo_path'] ?? '';
    $nomeUsuario = $dadosAssinatura['usuario']['nome'] ?? '';
    $emailUsuario = $dadosAssinatura['usuario']['email'] ?? '';
    $telefoneUsuario = $dadosAssinatura['usuario']['telefone'] ?? '';
    $cargoUsuario = $dadosAssinatura['usuario']['cargo'] ?? '';
    $nomeTenant = $dadosAssinatura['tenant']['nome_tenant'] ?? '';
    
    if (!empty($dadosAssinatura['usuario']['assinatura_email'])) {
        return $dadosAssinatura['usuario']['assinatura_email'];
    }
    
    $assinatura = "\n\n<div style='margin-top: 30px; padding-top: 20px; border-top: 2px solid #007bff; font-family: Arial, sans-serif; color: #333;'>\n";
    
    if (!empty($logo)) {
        $logoUrl = converterParaUrlAbsoluta($logo);
        $assinatura .= "    <div style='margin-bottom: 15px;'>\n";
        $assinatura .= "        <img src='{$logoUrl}' alt='{$nomeTenant}' style='max-height: 50px; max-width: 200px;' />\n";
        $assinatura .= "    </div>\n";
    }
    
    $assinatura .= "    <div style='line-height: 1.6;'>\n";
    $assinatura .= "        <strong>{$nomeUsuario}</strong>\n";
    
    if (!empty($cargoUsuario)) {
        $assinatura .= "        <br>{$cargoUsuario}\n";
    }
    
    if (!empty($nomeTenant)) {
        $assinatura .= "        <br>{$nomeTenant}\n";
    }
    
    if (!empty($emailUsuario)) {
        $assinatura .= "        <br>E-mail: <a href='mailto:{$emailUsuario}' style='color: #007bff; text-decoration: none;'>{$emailUsuario}</a>\n";
    }
    
    if (!empty($telefoneUsuario)) {
        $assinatura .= "        <br>Telefone: {$telefoneUsuario}\n";
    }
    
    $assinatura .= "    </div>\n";
    $assinatura .= "</div>";
    
    return $assinatura;
}

/**
 * Função para aplicar assinatura ao conteúdo do e-mail (CÓPIA DO enviar_email_agendamento.php)
 */
function aplicarAssinatura($conteudo, $assinatura) {
    if (empty($assinatura)) {
        return $conteudo;
    }
    return $conteudo . $assinatura;
}

/**
 * Função para substituir variáveis no conteúdo do e-mail (CÓPIA MELHORADA)
 */
function substituirVariaveisEmail($conteudo, $clienteId, $conn, $tenantId) {
    try {
        $stmt = $conn->prepare("
            SELECT 
                c.*,
                f.nome as nome_funil,
                ef.nome as nome_etapa,
                u_resp.nome as nome_responsavel,
                u_resp.email as email_responsavel,
                u_cad.nome as nome_usuario_cadastro,
                t.nome as nome_tenant
            FROM clientes c
            LEFT JOIN funis f ON c.funil_id = f.id AND f.tenant_id = ?
            LEFT JOIN etapas_funis ef ON c.etapa_funil_id = ef.id
            LEFT JOIN usuarios u_resp ON c.responsavel = u_resp.id
            LEFT JOIN usuarios u_cad ON c.usuario_cadastro = u_cad.id
            LEFT JOIN tenants t ON c.tenant_id = t.id
            WHERE c.id = ? AND c.tenant_id = ?
        ");
        $stmt->bind_param("iii", $tenantId, $clienteId, $tenantId);
        $stmt->execute();
        $result = $stmt->get_result();
        
        if ($result->num_rows === 0) {
            return $conteudo;
        }
        
        $cliente = $result->fetch_assoc();
        $stmt->close();
        
        $usuario_logado_id = $_SESSION['usuario_id'] ?? null;
        $usuario_logado_info = [];
        if ($usuario_logado_id) {
            $sql_usuario_logado = "SELECT nome, email, telefone, cargo FROM usuarios WHERE id = ?";
            $stmt_usuario_logado = $conn->prepare($sql_usuario_logado);
            $stmt_usuario_logado->bind_param("i", $usuario_logado_id);
            $stmt_usuario_logado->execute();
            $result_usuario_logado = $stmt_usuario_logado->get_result();
            $usuario_logado_info = $result_usuario_logado->fetch_assoc() ?? [];
            $stmt_usuario_logado->close();
        }
        
        $substituicoes = [
            '{cliente_id}' => $cliente['id'],
            '{cliente_nome}' => $cliente['Nome_Cliente'] ?? '',
            '{nome_cliente}' => $cliente['Nome_Cliente'] ?? '',
            '{cliente_email}' => $cliente['Email'] ?? '',
            '{email_cliente}' => $cliente['Email'] ?? '',
            '{cliente_telefone}' => $cliente['Telefone'] ?? '',
            '{telefone_cliente}' => $cliente['Telefone'] ?? '',
            '{cliente_telefone2}' => $cliente['Telefone2'] ?? '',
            '{telefone2_cliente}' => $cliente['Telefone2'] ?? '',
            '{cliente_celular}' => $cliente['Celular'] ?? '',
            '{celular_cliente}' => $cliente['Celular'] ?? '',
            '{cliente_endereco}' => $cliente['Endereco'] ?? '',
            '{endereco_cliente}' => $cliente['Endereco'] ?? '',
            '{cliente_cidade}' => $cliente['Cidade'] ?? '',
            '{cidade_cliente}' => $cliente['Cidade'] ?? '',
            '{cliente_bairro}' => $cliente['Bairro'] ?? '',
            '{bairro_cliente}' => $cliente['Bairro'] ?? '',
            '{cliente_complemento}' => $cliente['Complemento'] ?? '',
            '{complemento_cliente}' => $cliente['Complemento'] ?? '',
            '{cliente_cep}' => $cliente['CEP'] ?? '',
            '{cep_cliente}' => $cliente['CEP'] ?? '',
            '{cliente_estado}' => $cliente['Estado'] ?? '',
            '{estado_cliente}' => $cliente['Estado'] ?? '',
            '{cliente_provincia}' => $cliente['provincia'] ?? '',
            '{provincia_cliente}' => $cliente['provincia'] ?? '',
            '{cliente_pais}' => $cliente['Pais'] ?? '',
            '{pais_cliente}' => $cliente['Pais'] ?? '',
            '{cliente_cpf_cnpj}' => $cliente['CPF_CNPJ'] ?? '',
            '{cpf_cnpj_cliente}' => $cliente['CPF_CNPJ'] ?? '',
            '{cliente_origem}' => $cliente['Origem'] ?? '',
            '{origem_cliente}' => $cliente['Origem'] ?? '',
            '{cliente_instagram}' => $cliente['instagram'] ?? '',
            '{instagram_cliente}' => $cliente['instagram'] ?? '',
            '{cliente_linkedin}' => $cliente['linkedin'] ?? '',
            '{linkedin_cliente}' => $cliente['linkedin'] ?? '',
            '{cliente_funil}' => $cliente['nome_funil'] ?? '',
            '{funil_cliente}' => $cliente['nome_funil'] ?? '',
            '{cliente_etapa}' => $cliente['nome_etapa'] ?? '',
            '{etapa_cliente}' => $cliente['nome_etapa'] ?? '',
            '{cliente_responsavel}' => $cliente['nome_responsavel'] ?? '',
            '{responsavel_cliente}' => $cliente['nome_responsavel'] ?? '',
            '{cliente_observacoes}' => $cliente['Observacoes'] ?? '',
            '{observacoes_cliente}' => $cliente['Observacoes'] ?? '',
            '{data_cadastro}' => date('d/m/Y', strtotime($cliente['Data_Cadastro'])),
            '{data_atual}' => date('d/m/Y'),
            '{data}' => date('d/m/Y'),
            '{hora_atual}' => date('H:i:s'),
            '{hora}' => date('H:i:s'),
            '{data_hora}' => date('d/m/Y H:i:s'),
            '{url_sistema}' => 'https://' . $_SERVER['HTTP_HOST'],
            '{sistema_nome}' => 'SON',
            '{tenant_nome}' => $cliente['nome_tenant'] ?? '',
            '{responsavel_nome}' => $cliente['nome_responsavel'] ?? '',
            '{responsavel_email}' => $cliente['email_responsavel'] ?? '',
            '{usuario_cadastro}' => $cliente['nome_usuario_cadastro'] ?? '',
            '{usuario_nome}' => $usuario_logado_info['nome'] ?? '',
            '{usuario_email}' => $usuario_logado_info['email'] ?? '',
            '{usuario_telefone}' => $usuario_logado_info['telefone'] ?? '',
            '{usuario_cargo}' => $usuario_logado_info['cargo'] ?? ''
        ];
        
        return str_replace(
            array_keys($substituicoes),
            array_values($substituicoes),
            $conteudo
        );
        
    } catch (Exception $e) {
        error_log("❌ Erro ao substituir variáveis: " . $e->getMessage());
        return $conteudo;
    }
}

/**
 * Função para verificar configuração de assinatura do template (CÓPIA DO enviar_email_agendamento.php)
 */
function verificarAssinaturaTemplate($conn, $templateId, $tenantId) {
    try {
        $checkColumn = $conn->query("SHOW COLUMNS FROM templates_email LIKE 'incluir_assinatura'");
        $hasAssinaturaColumn = $checkColumn->num_rows > 0;
        
        if ($hasAssinaturaColumn) {
            $stmt = $conn->prepare("SELECT incluir_assinatura FROM templates_email WHERE id = ? AND tenant_id = ? AND ativo = 1");
        } else {
            $stmt = $conn->prepare("SELECT 1 as incluir_assinatura FROM templates_email WHERE id = ? AND tenant_id = ? AND ativo = 1");
        }
        
        $stmt->bind_param("ii", $templateId, $tenantId);
        $stmt->execute();
        $result = $stmt->get_result();
        
        if ($result->num_rows > 0) {
            $template = $result->fetch_assoc();
            return $template['incluir_assinatura'];
        }
        $stmt->close();
        return false;
        
    } catch (Exception $e) {
        error_log("❌ Erro ao verificar assinatura do template: " . $e->getMessage());
        return false;
    }
}

/**
 * Função para adicionar wrapper HTML com alinhamento à esquerda (CÓPIA DO enviar_email_agendamento.php)
 */
function adicionarWrapperHTML($conteudo) {
    return "
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset=\"UTF-8\">
        <style>
            body, html {
                margin: 0;
                padding: 20px;
                font-family: Arial, sans-serif;
                line-height: 1.6;
                color: #333;
                background-color: #f9f9f9;
                text-align: left !important;
            }
            .email-container {
                max-width: 100%;
                margin: 0;
                background: white;
                padding: 20px;
                border-radius: 0;
                box-shadow: none;
                text-align: left !important;
            }
            .conteudo-email {
                line-height: 1.6;
                text-align: left !important;
            }
            body * {
                text-align: left !important;
                margin-left: 0 !important;
                margin-right: auto !important;
            }
            p, div, span, td, h1, h2, h3, h4, h5, h6 {
                text-align: left !important;
                margin-left: 0 !important;
                margin-right: auto !important;
            }
            .center, [align=\"center\"], [style*=\"text-align:center\"], [style*=\"text-align: center\"] {
                text-align: left !important;
            }
        </style>
    </head>
    <body>
        <div class=\"email-container\">
            <div class=\"conteudo-email\">
                " . $conteudo . "
            </div>
        </div>
    </body>
    </html>";
}

/**
 * Função para enviar email usando PHPMailer + SMTP (CÓPIA DO enviar_email_agendamento.php)
 */
function enviarEmailPHPMailer($destinatario, $assunto, $mensagem, $nomeRemetente, $emailRemetenteReplyTo = null) {
    try {
        require_once 'config_smtp.php';
        
        $phpmailer_paths = [
            'PHPMailer/PHPMailer.php',
            'PHPMailer/src/PHPMailer.php',
            '../PHPMailer/PHPMailer.php',
            'vendor/phpmailer/phpmailer/src/PHPMailer.php'
        ];
        
        $phpmailer_file = null;
        $smtp_file = null;
        $exception_file = null;
        
        foreach ($phpmailer_paths as $path) {
            if (file_exists($path)) {
                $phpmailer_file = $path;
                $smtp_file = str_replace('PHPMailer.php', 'SMTP.php', $path);
                $exception_file = str_replace('PHPMailer.php', 'Exception.php', $path);
                break;
            }
        }
        
        if (!$phpmailer_file || !file_exists($phpmailer_file)) {
            return [
                'success' => false,
                'message' => 'PHPMailer não encontrado.'
            ];
        }
        
        require_once $phpmailer_file;
        require_once $smtp_file;
        if (file_exists($exception_file)) {
            require_once $exception_file;
        }
        
        if (class_exists('PHPMailer\PHPMailer\PHPMailer')) {
            $mail = new PHPMailer\PHPMailer\PHPMailer(true);
        } else {
            $mail = new PHPMailer(true);
        }
        
        $mail->isSMTP();
        $mail->Host       = SMTP_HOST;
        $mail->SMTPAuth   = true;
        $mail->Username   = SMTP_USER;
        $mail->Password   = SMTP_PASS;
        $mail->SMTPSecure = defined('SMTP_SECURE') ? SMTP_SECURE : 'tls';
        $mail->Port       = SMTP_PORT;
        $mail->CharSet    = 'UTF-8';
        $mail->SMTPDebug  = 0;
        
        $mail->SMTPOptions = [
            'ssl' => [
                'verify_peer' => false,
                'verify_peer_name' => false,
                'allow_self_signed' => true
            ]
        ];
        
        $fromNome = $nomeRemetente . '';
        $fromEmail = SMTP_USER;
        
        $mail->setFrom($fromEmail, $fromNome);
        
        if (!empty($emailRemetenteReplyTo) && filter_var($emailRemetenteReplyTo, FILTER_VALIDATE_EMAIL)) {
            $mail->addReplyTo($emailRemetenteReplyTo, $nomeRemetente);
        } else {
            $mail->addReplyTo(SMTP_USER, 'Sistema SON');
        }
        
        $mail->addAddress($destinatario);
        
        $mail->isHTML(true);
        $mail->Subject = $assunto;
        $mail->Body    = $mensagem;
        $mail->AltBody = strip_tags($mensagem);
        
        $mail->send();
        return ['success' => true, 'message' => 'E-mail enviado com sucesso'];
        
    } catch (Exception $e) {
        error_log("❌ Erro PHPMailer: " . $e->getMessage());
        return ['success' => false, 'message' => 'Erro: ' . $e->getMessage()];
    }
}

/**
 * Função para enviar email usando mail() nativo (fallback) - CÓPIA DO enviar_email_agendamento.php
 */
function enviarEmailNativo($destinatario, $assunto, $mensagem, $nomeRemetente, $emailRemetenteReplyTo = null) {
    if (!defined('SMTP_USER')) {
        define('SMTP_USER', 'notificacao@son.tvitecnologia.com.br');
    }
    
    $remetenteNome = $nomeRemetente . ' (via SON)';
    $remetenteEmail = SMTP_USER;
    
    $headers = "From: $remetenteNome <$remetenteEmail>\r\n";
    
    if (!empty($emailRemetenteReplyTo) && filter_var($emailRemetenteReplyTo, FILTER_VALIDATE_EMAIL)) {
        $headers .= "Reply-To: $emailRemetenteReplyTo\r\n";
    }
    
    $headers .= "Content-Type: text/html; charset=UTF-8\r\n";
    $headers .= "X-Mailer: PHP/" . phpversion();
    
    if (mail($destinatario, $assunto, $mensagem, $headers)) {
        return ['success' => true, 'message' => 'E-mail enviado com sucesso (mail())'];
    }
    
    return ['success' => false, 'message' => 'Falha no envio via mail()'];
}

/**
 * Função principal para enviar email (tenta PHPMailer, depois fallback para mail())
 */
function enviarEmailSistema($destinatario, $assunto, $mensagem, $nomeRemetente, $emailRemetenteReplyTo = null) {
    $resultado = enviarEmailPHPMailer($destinatario, $assunto, $mensagem, $nomeRemetente, $emailRemetenteReplyTo);
    
    if (!$resultado['success']) {
        error_log("PHPMailer falhou, tentando mail() nativo: " . $resultado['message']);
        $resultado = enviarEmailNativo($destinatario, $assunto, $mensagem, $nomeRemetente, $emailRemetenteReplyTo);
    }
    
    return $resultado;
}

/**
 * ✅ FUNÇÃO CORRIGIDA: Enviar email usando o mesmo sistema do enviar_email_agendamento.php
 */
function enviarEmail($destinatarios, $assunto, $mensagem, $cliente, $etapa_destino, $remetenteNome = null, $remetenteEmail = null) {
    try {
        $enviados_com_sucesso = 0;
        $erros = [];
        
        foreach ($destinatarios as $destinatario) {
            if (!filter_var($destinatario, FILTER_VALIDATE_EMAIL)) {
                $erros[] = "E-mail do destinatário inválido: $destinatario";
                error_log("❌ E-mail do destinatário inválido: $destinatario");
                continue;
            }
            
            error_log("📤 Tentando enviar email via sistema corrigido");
            error_log("👤 De: $remetenteNome <$remetenteEmail>");
            error_log("📧 Para: $destinatario");
            
            $resultadoEnvio = enviarEmailSistema(
                $destinatario,
                $assunto,
                $mensagem,
                $remetenteNome,
                $remetenteEmail
            );
            
            if ($resultadoEnvio['success']) {
                $enviados_com_sucesso++;
                error_log("✅ Email enviado com sucesso para $destinatario");
            } else {
                $erro_msg = "Falha no envio para $destinatario: " . $resultadoEnvio['message'];
                $erros[] = $erro_msg;
                error_log("❌ $erro_msg");
            }
        }
        
        if ($enviados_com_sucesso > 0) {
            return [
                'success' => true,
                'message' => "Emails enviados com sucesso: $enviados_com_sucesso de " . count($destinatarios),
                'enviados' => $enviados_com_sucesso,
                'total' => count($destinatarios)
            ];
        } else {
            return [
                'success' => false,
                'message' => 'Falha no envio de todos os emails: ' . implode('; ', $erros),
                'erros' => $erros
            ];
        }
        
    } catch (Exception $e) {
        error_log("❌ Exceção no envio de email: " . $e->getMessage());
        return [
            'success' => false,
            'message' => 'Erro exception: ' . $e->getMessage()
        ];
    }
}

// ============================================================================
// FIM DAS FUNÇÕES DE E-MAIL CORRIGIDAS
// ============================================================================

/**
 * ✅ CORREÇÃO MELHORADA: Função para verificar se deve processar cliente baseado no motivo
 */
function verificarMotivoClientePermitido($motivoCliente, $motivosConfigurados) {
    if (empty($motivosConfigurados)) {
        return true;
    }
    
    if (!is_array($motivosConfigurados)) {
        $motivosConfigurados = [$motivosConfigurados];
    }
    
    if (in_array('qualquer', $motivosConfigurados) || in_array('todos', $motivosConfigurados)) {
        return true;
    }
    
    if (empty($motivoCliente)) {
        return true;
    }
    
    return in_array($motivoCliente, $motivosConfigurados);
}

/**
 * ✅ CORREÇÃO CRÍTICA: Função para recuperar cliente perdido automaticamente
 */
function recuperarClientePerdidoAutomatico($conn, $acao, $clientePerdido, $tenant_id, $usuario_id) {
    try {
        $cliente_id = $clientePerdido['cliente_id'];
        $nome_cliente = $clientePerdido['Nome_Cliente'] ?? 'Cliente ' . $cliente_id;
        $motivo_cliente = $clientePerdido['motivo'] ?? '';
        
        error_log("🔄 PROCESSANDO RECUPERAÇÃO: $nome_cliente (ID: $cliente_id)");
        error_log("📅 Perdido em: " . ($clientePerdido['data_perdido'] ?? 'N/A'));
        error_log("🎯 Motivo: $motivo_cliente");
        
        if (isset($acao['motivos_perda']) && !empty($acao['motivos_perda'])) {
            $motivos_permitidos = is_array($acao['motivos_perda']) ? $acao['motivos_perda'] : [$acao['motivos_perda']];
            
            if (!verificarMotivoClientePermitido($motivo_cliente, $motivos_permitidos)) {
                error_log("⏭️ MOTIVO NÃO PERMITIDO: '$motivo_cliente' não está em [" . implode(', ', $motivos_permitidos) . "]");
                return false;
            }
        }
        
        $funil_destino_id = $acao['funil_destino_id'] ?? null;
        $etapa_destino_id = $acao['etapa_destino_id'] ?? null;
        
        if (!$funil_destino_id || !$etapa_destino_id) {
            error_log("❌ Funil ou etapa de destino não configurados");
            return false;
        }
        
        $conn->begin_transaction();
        
        try {
            $sql_cliente = "UPDATE clientes 
                           SET status = 1, 
                               funil_id = ?, 
                               etapa_funil_id = ?,
                               atualizado_em = NOW()
                           WHERE id = ? AND tenant_id = ?";
            
            $stmt = $conn->prepare($sql_cliente);
            if (!$stmt) {
                throw new Exception("Erro ao preparar SQL cliente: " . $conn->error);
            }
            
            $stmt->bind_param("iiii", $funil_destino_id, $etapa_destino_id, $cliente_id, $tenant_id);
            if (!$stmt->execute()) {
                throw new Exception("Erro ao atualizar cliente: " . $stmt->error);
            }
            $stmt->close();
            
            $sql_perdido = "UPDATE clientes_perdidos 
                           SET restaurado = 1, 
                               data_restaurado = NOW(),
                               observacoes = CONCAT(COALESCE(observacoes, ''), '\nRecuperado automaticamente em ', NOW(), ' - Motivo: " . ($acao['motivo_recuperacao'] ?? 'Recuperação automática') . "')
                           WHERE cliente_id = ? AND tenant_id = ? AND restaurado = 0";
            
            $stmt2 = $conn->prepare($sql_perdido);
            if ($stmt2) {
                $stmt2->bind_param("ii", $cliente_id, $tenant_id);
                $stmt2->execute();
                $stmt2->close();
            }
            
            $sql_log = "INSERT INTO cliente_logs 
                       (cliente_id, usuario_id, nome_usuario, acao, detalhes, tenant_id, observacao_id) 
                       VALUES (?, ?, ?, 'cliente_recuperado', ?, ?, 0)";
            
            $stmt3 = $conn->prepare($sql_log);
            if ($stmt3) {
                $sql_usuario_nome = "SELECT nome FROM usuarios WHERE id = ?";
                $stmt_usuario = $conn->prepare($sql_usuario_nome);
                $stmt_usuario->bind_param("i", $usuario_id);
                $stmt_usuario->execute();
                $result_usuario = $stmt_usuario->get_result();
                $usuario_nome = $result_usuario->fetch_assoc()['nome'] ?? 'Sistema';
                $stmt_usuario->close();
                
                $detalhes = "Cliente recuperado automaticamente por fluxo.\n";
                $detalhes .= "Motivo original da perda: $motivo_cliente\n";
                $detalhes .= "Movido para funil ID: $funil_destino_id, etapa ID: $etapa_destino_id\n";
                $detalhes .= "Motivo da recuperação: " . ($acao['motivo_recuperacao'] ?? 'Recuperação automática');
                
                $stmt3->bind_param("iisss", $cliente_id, $usuario_id, $usuario_nome, $detalhes, $tenant_id);
                $stmt3->execute();
                $stmt3->close();
            }
            
            $conn->commit();
            
            error_log("✅ ✅ ✅ CLIENTE RECUPERADO: $nome_cliente (ID: $cliente_id)");
            error_log("🎯 Destino: Funil $funil_destino_id, Etapa $etapa_destino_id");
            
            if (isset($acao['enviar_email_recuperacao']) && $acao['enviar_email_recuperacao'] && 
                isset($acao['template_recuperacao_id']) && $acao['template_recuperacao_id']) {
                
                error_log("📧 Preparando e-mail de reengajamento...");
                
                $sql_email = "SELECT Email FROM clientes WHERE id = ?";
                $stmt_email = $conn->prepare($sql_email);
                $stmt_email->bind_param("i", $cliente_id);
                $stmt_email->execute();
                $result_email = $stmt_email->get_result();
                $cliente_email = $result_email->fetch_assoc()['Email'] ?? null;
                $stmt_email->close();
                
                if ($cliente_email) {
                    $acao_email = [
                        'tipo' => 'enviar_email',
                        'template_id' => $acao['template_recuperacao_id'],
                        'assunto' => 'Bem-vindo de volta!',
                        'mensagem_personalizada' => 'Estamos felizes em tê-lo de volta!'
                    ];
                    
                    $fluxo_ficticio = [
                        'id' => 0,
                        'nome' => 'Recuperação Automática'
                    ];
                    
                    $sucesso_email = enviarEmailFluxo($conn, $fluxo_ficticio, $acao_email, $cliente_id, $tenant_id);
                    
                    if ($sucesso_email) {
                        error_log("✅ E-mail de reengajamento enviado com sucesso");
                    } else {
                        error_log("❌ Falha ao enviar e-mail de reengajamento");
                    }
                }
            }
            
            return true;
            
        } catch (Exception $e) {
            $conn->rollback();
            throw $e;
        }
        
    } catch (Exception $e) {
        error_log("❌ ERRO NA RECUPERAÇÃO: " . $e->getMessage());
        error_log("🔧 Stack trace: " . $e->getTraceAsString());
        return false;
    }
}

/**
 * ✅ CORREÇÃO CRÍTICA: Função para executar recuperação automática de clientes perdidos
 */
function executarFluxosRecuperacaoClientesPerdidos($conn) {
    try {
        error_log("
        💔 ===========================================
        💔 EXECUTANDO FLUXOS DE RECUPERAÇÃO DE CLIENTES PERDIDOS
        💔 ===========================================");
        
        $tenant_id = $_SESSION['tenant_id'] ?? null;
        if (!$tenant_id) {
            error_log("❌ Tenant ID não encontrado na sessão");
            return 0;
        }
        
        error_log("🏢 Tenant ID: $tenant_id");
        
        $sql_fluxos = "SELECT * FROM fluxos_automatizados 
                      WHERE ativo = 1 
                      AND tenant_id = ?";
        
        $stmt = $conn->prepare($sql_fluxos);
        $stmt->bind_param("i", $tenant_id);
        $stmt->execute();
        $result = $stmt->get_result();
        
        $clientes_recuperados = 0;
        $fluxos_processados = 0;
        $total_fluxos = $result->num_rows;
        
        error_log("📊 Total de fluxos ativos encontrados: $total_fluxos");
        
        while ($fluxo = $result->fetch_assoc()) {
            $fluxos_processados++;
            
            error_log("
            🔍 ===========================================
            🔍 PROCESSANDO FLUXO #$fluxos_processados: {$fluxo['nome']}
            🔍 ===========================================");
            
            $condicoes = json_decode($fluxo['condicoes'], true);
            $is_fluxo_recuperacao = false;
            
            if (!empty($condicoes)) {
                foreach ($condicoes as $condicao) {
                    if (isset($condicao['tipo']) && $condicao['tipo'] === 'cliente_perdido') {
                        $is_fluxo_recuperacao = true;
                        break;
                    }
                }
            }
            
            if (!$is_fluxo_recuperacao) {
                continue;
            }
            
            error_log("✅ É um fluxo de recuperação de clientes perdidos");
            
            $acoes = json_decode($fluxo['acoes'], true);
            
            if (empty($acoes)) {
                error_log("❌ Fluxo sem ações configuradas");
                continue;
            }
            
            foreach ($acoes as $index => $acao) {
                error_log("🔧 Analisando ação $index: " . json_encode($acao));
                
                $is_acao_recuperacao = false;
                $config_recuperacao = null;
                
                if (isset($acao['tipo']) && $acao['tipo'] === 'recuperacao') {
                    $is_acao_recuperacao = true;
                    $config_recuperacao = $acao;
                } elseif (isset($acao['funil_destino_id'])) {
                    $is_acao_recuperacao = true;
                    $config_recuperacao = [
                        'tipo' => 'recuperacao',
                        'funil_destino_id' => $acao['funil_destino_id'],
                        'etapa_destino_id' => $acao['etapa_destino_id'] ?? null,
                        'tempo_apos_perda' => $acao['tempo_apos_perda'] ?? $acao['tempo'] ?? 7,
                        'unidade_tempo' => $acao['unidade_tempo'] ?? 'dias',
                        'motivos_perda' => $acao['motivos_perda'] ?? [],
                        'motivo_recuperacao' => $acao['motivo_recuperacao'] ?? 'Recuperação automática',
                        'enviar_email_recuperacao' => $acao['enviar_email_recuperacao'] ?? false,
                        'template_recuperacao_id' => $acao['template_recuperacao_id'] ?? null
                    ];
                }
                
                if (!$is_acao_recuperacao || !$config_recuperacao) {
                    continue;
                }
                
                error_log("✅ Ação $index é de recuperação");
                
                $tempo_apos_perda = $config_recuperacao['tempo_apos_perda'] ?? 7;
                $unidade_tempo = $config_recuperacao['unidade_tempo'] ?? 'dias';
                
                $intervalo_sql = "$tempo_apos_perda $unidade_tempo";
                
                error_log("⏰ Configuração de recuperação: $tempo_apos_perda $unidade_tempo");
                
                $sql_clientes = "SELECT cp.cliente_id, c.Nome_Cliente, cp.motivo, cp.data_perdido,
                                        cp.restaurado, c.status as status_cliente
                                FROM clientes_perdidos cp
                                JOIN clientes c ON cp.cliente_id = c.id
                                WHERE cp.tenant_id = ?
                                AND cp.restaurado = 0
                                AND cp.data_perdido <= DATE_SUB(NOW(), INTERVAL $intervalo_sql)
                                AND (c.status = 'perdido' OR c.status = 0 OR c.status IS NULL)
                                ORDER BY cp.data_perdido ASC";
                
                $stmt_clientes = $conn->prepare($sql_clientes);
                $stmt_clientes->bind_param("i", $tenant_id);
                $stmt_clientes->execute();
                $result_clientes = $stmt_clientes->get_result();
                
                $total_encontrados = 0;
                
                while ($cliente = $result_clientes->fetch_assoc()) {
                    $total_encontrados++;
                    
                    error_log("👤 CLIENTE PERDIDO: {$cliente['Nome_Cliente']} (Motivo: {$cliente['motivo']})");
                    
                    $deve_recuperar = true;
                    
                    if (isset($config_recuperacao['motivos_perda']) && !empty($config_recuperacao['motivos_perda'])) {
                        $motivos_permitidos = is_array($config_recuperacao['motivos_perda']) ? 
                                            $config_recuperacao['motivos_perda'] : 
                                            [$config_recuperacao['motivos_perda']];
                        
                        if (!verificarMotivoClientePermitido($cliente['motivo'], $motivos_permitidos)) {
                            error_log("⏭️ MOTIVO NÃO PERMITIDO");
                            $deve_recuperar = false;
                        }
                    }
                    
                    if ($deve_recuperar) {
                        error_log("✅ Motivo permitido, processando recuperação...");
                        
                        $usuario_id = $_SESSION['usuario_id'] ?? 1;
                        $sucesso = recuperarClientePerdidoAutomatico($conn, $config_recuperacao, $cliente, $tenant_id, $usuario_id);
                        
                        if ($sucesso) {
                            $clientes_recuperados++;
                            error_log("✅ Cliente recuperado com sucesso!");
                        } else {
                            error_log("❌ Falha na recuperação do cliente");
                        }
                    }
                }
                
                $stmt_clientes->close();
                
                $sql_update = "UPDATE fluxos_automatizados SET ultima_execucao = NOW() WHERE id = ?";
                $stmt_update = $conn->prepare($sql_update);
                $stmt_update->bind_param("i", $fluxo['id']);
                $stmt_update->execute();
                $stmt_update->close();
            }
        }
        
        $stmt->close();
        
        error_log("📊 RESUMO: $clientes_recuperados clientes recuperados");
        
        return $clientes_recuperados;
        
    } catch (Exception $e) {
        error_log("❌ ERRO GERAL: " . $e->getMessage());
        return 0;
    }
}

/**
 * ✅ FUNÇÃO CORRIGIDA: Agendar e-mail para envio futuro
 */
function agendarEmailFluxo($conn, $fluxo, $acao, $cliente_id, $tenant_id) {
    try {
        error_log("📅 AGENDANDO E-MAIL PARA ENVIO FUTURO");
        
        $sql_cliente = "SELECT id, responsavel, Nome_Cliente, Email, tenant_id FROM clientes WHERE id = ? AND tenant_id = ?";
        $stmt = $conn->prepare($sql_cliente);
        $stmt->bind_param("ii", $cliente_id, $tenant_id);
        $stmt->execute();
        $result = $stmt->get_result();
        $cliente = $result->fetch_assoc();
        $stmt->close();
        
        if (!$cliente) {
            error_log("❌ ERRO: Cliente $cliente_id não encontrado");
            return false;
        }
        
        $data_envio = new DateTime();
        $tempo_envio = intval($acao['tempo_envio'] ?? 0);
        $unidade_tempo = $acao['unidade_tempo'] ?? 'dias';
        
        switch ($unidade_tempo) {
            case 'minutos':
                $data_envio->modify("+{$tempo_envio} minutes");
                break;
            case 'horas':
                $data_envio->modify("+{$tempo_envio} hours");
                break;
            case 'dias':
                $data_envio->modify("+{$tempo_envio} days");
                break;
            case 'semanas':
                $data_envio->modify("+{$tempo_envio} weeks");
                break;
            default:
                $data_envio->modify("+{$tempo_envio} days");
        }
        
        $usuario_logado_id = $_SESSION['usuario_id'] ?? null;
        if (!$usuario_logado_id) {
            error_log("❌ ERRO: Nenhum usuário logado identificado");
            return false;
        }
        
        $config_email = carregarConfiguracoesEmailFluxo($conn, $tenant_id, $usuario_logado_id);
        
        if (!$config_email) {
            error_log("❌ ERRO: Configurações de e-mail não encontradas");
            return false;
        }
        
        $sql_agendar = "INSERT INTO emails_agendados (
            tenant_id,
            fluxo_id,
            cliente_id,
            usuario_id,
            template_id,
            assunto,
            mensagem,
            destinatario_email,
            destinatario_nome,
            data_agendamento,
            status,
            config_email,
            criado_em
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'agendado', ?, NOW())";
        
        $stmt = $conn->prepare($sql_agendar);
        
        $destinatario_nome = $cliente['Nome_Cliente'] ?? 'Cliente';
        $destinatario_email = $cliente['Email'] ?? '';
        
        $template_id = $acao['template_id'] ?? null;
        $assunto = $acao['assunto'] ?? 'Comunicação do Sistema';
        $mensagem = $acao['mensagem_personalizada'] ?? '';
        
        $config_email_json = json_encode([
            'remetente_nome' => $config_email['nome_remetente'],
            'remetente_email' => $config_email['email_remetente'],
            'usuario_nome' => $config_email['usuario_nome'] ?? '',
            'tenant_nome' => $config_email['tenant_nome'] ?? ''
        ]);
        
        $data_envio_formatada = $data_envio->format('Y-m-d H:i:s');
        
        $stmt->bind_param(
            "iiiiissssss",
            $tenant_id,
            $fluxo['id'],
            $cliente_id,
            $usuario_logado_id,
            $template_id,
            $assunto,
            $mensagem,
            $destinatario_email,
            $destinatario_nome,
            $data_envio_formatada,
            $config_email_json
        );
        
        if ($stmt->execute()) {
            $email_agendado_id = $conn->insert_id;
            error_log("✅ E-mail agendado com sucesso! ID: $email_agendado_id");
            error_log("📅 Data de envio: $data_envio_formatada");
            $stmt->close();
            return true;
        } else {
            error_log("❌ Erro ao agendar e-mail: " . $stmt->error);
            $stmt->close();
            return false;
        }
        
    } catch (Exception $e) {
        error_log("❌ Exceção ao agendar e-mail: " . $e->getMessage());
        return false;
    }
}

/**
 * ✅ FUNÇÃO DE ENVIO DE EMAIL PARA FLUXOS - USANDO SISTEMA CORRIGIDO
 */
function enviarEmailFluxo($conn, $fluxo, $acao, $cliente_id, $tenant_id) {
    try {
        error_log("
        📧 ===========================================
        📧 INICIANDO ENVIO DE E-MAIL POR FLUXO
        📧 ===========================================");
        
        $tempo_envio = intval($acao['tempo_envio'] ?? 0);
        $unidade_tempo = $acao['unidade_tempo'] ?? 'dias';
        
        if ($tempo_envio > 0) {
            error_log("⏰ Tempo agendado detectado: $tempo_envio $unidade_tempo");
            return agendarEmailFluxo($conn, $fluxo, $acao, $cliente_id, $tenant_id);
        }
        
        error_log("⏱️  Envio imediato");
        
        $usuario_logado_id = $_SESSION['usuario_id'] ?? null;
        if (!$usuario_logado_id) {
            error_log("❌ ERRO: Nenhum usuário logado");
            return false;
        }
        
        error_log("👤 Usuário logado: ID $usuario_logado_id");
        
        $sql_cliente = "SELECT id, responsavel, Nome_Cliente, Email, tenant_id FROM clientes WHERE id = ? AND tenant_id = ?";
        $stmt = $conn->prepare($sql_cliente);
        $stmt->bind_param("ii", $cliente_id, $tenant_id);
        $stmt->execute();
        $result = $stmt->get_result();
        $cliente = $result->fetch_assoc();
        $stmt->close();
        
        if (!$cliente) {
            error_log("❌ ERRO: Cliente $cliente_id não encontrado");
            return false;
        }
        
        if (empty($cliente['Email'])) {
            error_log("❌ ERRO: Cliente não possui e-mail");
            return false;
        }
        
        $config_email = carregarConfiguracoesEmailFluxo($conn, $tenant_id, $usuario_logado_id);
        
        if (!$config_email) {
            error_log("❌ ERRO: Configurações de e-mail não encontradas");
            return false;
        }
        
        if (empty($config_email['email_remetente'])) {
            error_log("❌ ERRO: E-mail do remetente não configurado");
            return false;
        }
        
        $assunto_final = '';
        $mensagem_final = '';
        $template_incluir_assinatura = false;
        
        if (isset($acao['template_id']) && !empty($acao['template_id'])) {
            error_log("🎯 Buscando template ID: " . $acao['template_id']);
            $template = buscarTemplateEmail($conn, $acao['template_id'], $tenant_id);
            
            if ($template) {
                $assunto_final = !empty($template['assunto']) ? $template['assunto'] : ($acao['assunto'] ?? 'Comunicação do Sistema');
                $mensagem_final = $template['conteudo'] ?? '';
                $template_incluir_assinatura = (bool)($template['incluir_assinatura'] ?? true);
                
                if (!empty($acao['mensagem_personalizada'])) {
                    $mensagem_final .= "\n\n---\n" . $acao['mensagem_personalizada'];
                }
            } else {
                $assunto_final = $acao['assunto'] ?? 'Comunicação do Sistema';
                $mensagem_final = $acao['mensagem_personalizada'] ?? '';
                $template_incluir_assinatura = true;
            }
        } else {
            $assunto_final = $acao['assunto'] ?? 'Comunicação do Sistema';
            $mensagem_final = $acao['mensagem_personalizada'] ?? '';
            $template_incluir_assinatura = true;
        }
        
        if (empty($mensagem_final)) {
            $mensagem_final = "Prezado cliente, segue comunicação do sistema.";
        }
        
        $dados_assinatura = carregarDadosAssinatura($conn, $tenant_id, $usuario_logado_id);
        $assinatura_html = $dados_assinatura ? gerarAssinatura($dados_assinatura) : '';
        
        $assunto_final = substituirVariaveisEmail($assunto_final, $cliente_id, $conn, $tenant_id);
        $mensagem_final = substituirVariaveisEmail($mensagem_final, $cliente_id, $conn, $tenant_id);
        
        $deve_incluir_assinatura = $template_incluir_assinatura;
        
        $mensagem_html = nl2br(htmlspecialchars($mensagem_final));
        
        if ($deve_incluir_assinatura && !empty($assinatura_html)) {
            $mensagem_html = aplicarAssinatura($mensagem_html, $assinatura_html);
        }
        
        $email_html = adicionarWrapperHTML($mensagem_html);
        
        error_log("📧 Para: " . $cliente['Email']);
        error_log("📝 Assunto: " . $assunto_final);
        
        $resultadoEnvio = enviarEmail(
            [$cliente['Email']],
            $assunto_final,
            $email_html,
            $cliente,
            ['nome' => 'Fluxo Automatizado'],
            $config_email['nome_remetente'],
            $config_email['email_remetente']
        );
        
        if ($resultadoEnvio['success']) {
            error_log("✅ ✅ ✅ E-mail enviado com SUCESSO");
            registrarLogEmailFluxo($conn, $cliente_id, $usuario_logado_id, $assunto_final, $cliente['Email'], $mensagem_final, $tenant_id);
            return true;
        } else {
            error_log("❌ ❌ ❌ Falha no envio: " . $resultadoEnvio['message']);
            return false;
        }
        
    } catch (Exception $e) {
        error_log("❌ ❌ ❌ Exceção: " . $e->getMessage());
        return false;
    }
}

/**
 * Registrar log de e-mail enviado por fluxo
 */
function registrarLogEmailFluxo($conn, $clienteId, $usuarioId, $assunto, $destinatario, $mensagem, $tenantId) {
    try {
        $sql_usuario = "SELECT nome FROM usuarios WHERE id = ?";
        $stmt_usuario = $conn->prepare($sql_usuario);
        $stmt_usuario->bind_param("i", $usuarioId);
        $stmt_usuario->execute();
        $result_usuario = $stmt_usuario->get_result();
        $usuario_nome = $result_usuario->fetch_assoc()['nome'] ?? 'Sistema';
        $stmt_usuario->close();
        
        $acao = "Email Enviado Via Fluxo Automatizado";
        $detalhes = "E-mail enviado automaticamente por fluxo.\nAssunto: \"$assunto\"\nDestinatário: $destinatario\n\nConteúdo:\n$mensagem";
        
        $stmt = $conn->prepare("
            INSERT INTO cliente_logs 
            (cliente_id, usuario_id, nome_usuario, acao, detalhes, tenant_id, observacao_id) 
            VALUES (?, ?, ?, ?, ?, ?, 0)
        ");
        $stmt->bind_param("iissss", $clienteId, $usuarioId, $usuario_nome, $acao, $detalhes, $tenantId);
        $result = $stmt->execute();
        $stmt->close();
        
        return $result;
        
    } catch (Exception $e) {
        error_log("❌ Erro ao registrar log: " . $e->getMessage());
        return false;
    }
}

/**
 * Registrar log de agendamento de e-mail
 */
function registrarLogAgendamentoEmail($conn, $clienteId, $usuarioId, $assunto, $dataAgendamento, $tenantId) {
    try {
        $sql_usuario = "SELECT nome FROM usuarios WHERE id = ?";
        $stmt_usuario = $conn->prepare($sql_usuario);
        $stmt_usuario->bind_param("i", $usuarioId);
        $stmt_usuario->execute();
        $result_usuario = $stmt_usuario->get_result();
        $usuario_nome = $result_usuario->fetch_assoc()['nome'] ?? 'Sistema';
        $stmt_usuario->close();
        
        $acao = "E-mail Agendado Via Fluxo Automatizado";
        $detalhes = "E-mail agendado automaticamente por fluxo.\nAssunto: \"$assunto\"\nData agendada: $dataAgendamento";
        
        $stmt = $conn->prepare("
            INSERT INTO cliente_logs 
            (cliente_id, usuario_id, nome_usuario, acao, detalhes, tenant_id, observacao_id) 
            VALUES (?, ?, ?, ?, ?, ?, 0)
        ");
        $stmt->bind_param("iissss", $clienteId, $usuarioId, $usuario_nome, $acao, $detalhes, $tenantId);
        $result = $stmt->execute();
        $stmt->close();
        
        return $result;
        
    } catch (Exception $e) {
        error_log("❌ Erro ao registrar log: " . $e->getMessage());
        return false;
    }
}

/**
 * ✅ Processar emails agendados
 */
function processarEmailsAgendados($conn) {
    try {
        error_log("
        📧 ===========================================
        📧 PROCESSANDO E-MAILS AGENDADOS
        📧 ===========================================");
        
        verificarTabelaEmailsAgendados($conn);
        
        $sql = "SELECT ea.*, c.Nome_Cliente, c.Email as cliente_email 
                FROM emails_agendados ea
                LEFT JOIN clientes c ON ea.cliente_id = c.id
                WHERE ea.status = 'agendado' 
                AND ea.data_agendamento <= NOW()
                AND (ea.tentativas < 3 OR ea.tentativas IS NULL)
                ORDER BY ea.data_agendamento ASC
                LIMIT 10";
        
        $result = $conn->query($sql);
        
        $emails_processados = 0;
        $total_encontrados = $result->num_rows;
        
        while ($email = $result->fetch_assoc()) {
            try {
                $stmt = $conn->prepare("UPDATE emails_agendados SET status = 'processando', tentativas = tentativas + 1, ultima_tentativa = NOW() WHERE id = ?");
                $stmt->bind_param("i", $email['id']);
                $stmt->execute();
                $stmt->close();
                
                $_SESSION['usuario_id'] = $email['usuario_id'];
                $_SESSION['tenant_id'] = $email['tenant_id'];
                
                $config_email = json_decode($email['config_email'], true);
                $assunto = $email['assunto'];
                $mensagem_final = $email['mensagem'] ?? '';
                
                if ($email['template_id']) {
                    $template = buscarTemplateEmail($conn, $email['template_id'], $email['tenant_id']);
                    if ($template) {
                        if (empty($assunto) || $assunto === 'Comunicação do Sistema') {
                            $assunto = $template['assunto'];
                        }
                        if (!empty($template['conteudo'])) {
                            $mensagem_final = $template['conteudo'];
                            if (!empty($email['mensagem'])) {
                                $mensagem_final .= "\n\n---\n" . $email['mensagem'];
                            }
                        }
                    }
                }
                
                $assunto_final = substituirVariaveisEmail($assunto, $email['cliente_id'], $conn, $email['tenant_id']);
                $mensagem_final = substituirVariaveisEmail($mensagem_final, $email['cliente_id'], $conn, $email['tenant_id']);
                
                $dados_assinatura = carregarDadosAssinatura($conn, $email['tenant_id'], $email['usuario_id']);
                $assinatura_html = $dados_assinatura ? gerarAssinatura($dados_assinatura) : '';
                
                $mensagem_html = nl2br(htmlspecialchars($mensagem_final));
                if (!empty($assinatura_html)) {
                    $mensagem_html = aplicarAssinatura($mensagem_html, $assinatura_html);
                }
                
                $email_html = adicionarWrapperHTML($mensagem_html);
                
                $cliente_dados = [
                    'Nome_Cliente' => $email['destinatario_nome'],
                    'Email' => $email['destinatario_email']
                ];
                
                $resultadoEnvio = enviarEmail(
                    [$email['destinatario_email']],
                    $assunto_final,
                    $email_html,
                    $cliente_dados,
                    ['nome' => 'E-mail Agendado'],
                    $config_email['remetente_nome'] ?? 'Sistema SON',
                    $config_email['remetente_email'] ?? 'sistema@notificacaoson.tvitecnologia.com.br'
                );
                
                if ($resultadoEnvio['success']) {
                    $stmt = $conn->prepare("UPDATE emails_agendados SET status = 'enviado', data_envio = NOW() WHERE id = ?");
                    $stmt->bind_param("i", $email['id']);
                    $stmt->execute();
                    $stmt->close();
                    
                    registrarLogEmailFluxo($conn, $email['cliente_id'], $email['usuario_id'], $assunto_final, $email['destinatario_email'], $mensagem_final, $email['tenant_id']);
                    
                    $emails_processados++;
                    error_log("✅ E-mail agendado ID {$email['id']} enviado");
                } else {
                    $tentativas = $email['tentativas'] + 1;
                    if ($tentativas >= 3) {
                        $stmt = $conn->prepare("UPDATE emails_agendados SET status = 'erro', erro_mensagem = ? WHERE id = ?");
                        $erro_msg = substr("Falha após 3 tentativas: " . $resultadoEnvio['message'], 0, 500);
                        $stmt->bind_param("si", $erro_msg, $email['id']);
                        $stmt->execute();
                        $stmt->close();
                    } else {
                        $stmt = $conn->prepare("UPDATE emails_agendados SET status = 'agendado' WHERE id = ?");
                        $stmt->bind_param("i", $email['id']);
                        $stmt->execute();
                        $stmt->close();
                    }
                }
                
            } catch (Exception $e) {
                error_log("❌ Exceção ao processar e-mail ID {$email['id']}: " . $e->getMessage());
                
                $stmt = $conn->prepare("UPDATE emails_agendados SET status = 'erro', erro_mensagem = ? WHERE id = ?");
                $erro_msg = substr($e->getMessage(), 0, 500);
                $stmt->bind_param("si", $erro_msg, $email['id']);
                $stmt->execute();
                $stmt->close();
            }
        }
        
        return $emails_processados;
        
    } catch (Exception $e) {
        error_log("❌ Erro geral: " . $e->getMessage());
        return 0;
    }
}

/**
 * FUNÇÃO PRINCIPAL CORRIGIDA - COM DETECÇÃO DE EVENTOS MELHORADA
 */
function criarAtividadesPorFluxo($conn, $evento_tipo, $cliente_id, $dados_adicionais = []) {
    error_log("
    🎯 ===========================================
    🎯 INICIANDO VERIFICAÇÃO DE FLUXOS
    🎯 Evento: $evento_tipo | Cliente ID: $cliente_id
    🎯 ===========================================");
    
    $tenant_id = $dados_adicionais['tenant_id'] ?? ($_SESSION['tenant_id'] ?? null);
    if (!$tenant_id) {
        error_log("❌ ERRO: tenant_id não encontrado");
        return 0;
    }
    
    $sql_fluxos = "SELECT * FROM fluxos_automatizados WHERE ativo = 1 AND tenant_id = ?";
    $stmt = $conn->prepare($sql_fluxos);
    $stmt->bind_param("i", $tenant_id);
    $stmt->execute();
    $result = $stmt->get_result();
    
    $atividades_criadas = 0;
    $total_fluxos = $result->num_rows;
    
    while ($fluxo = $result->fetch_assoc()) {
        if (fluxoAplicaAoEvento($fluxo, $evento_tipo, $cliente_id, $dados_adicionais)) {
            error_log("✅ Fluxo '{$fluxo['nome']}' APLICA-SE ao evento");
            $criadas = executarAcoesFluxo($conn, $fluxo, $cliente_id, $tenant_id);
            $atividades_criadas += $criadas;
        }
    }
    
    $stmt->close();
    return $atividades_criadas;
}

/**
 * FUNÇÃO DE VERIFICAÇÃO DE EVENTOS
 */
function fluxoAplicaAoEvento($fluxo, $evento_tipo, $cliente_id, $dados_adicionais) {
    $condicoes = json_decode($fluxo['condicoes'], true);
    
    if (empty($condicoes)) {
        return false;
    }
    
    foreach ($condicoes as $condicao) {
        if (condicaoCorrespondeEvento($condicao, $evento_tipo, $cliente_id, $dados_adicionais)) {
            return true;
        }
    }
    
    return false;
}

/**
 * FUNÇÃO DE CORRESPONDÊNCIA DE CONDIÇÕES
 */
function condicaoCorrespondeEvento($condicao, $evento_tipo, $cliente_id, $dados_adicionais) {
    switch ($condicao['tipo']) {
        case 'cadastro_manual':
            return ($evento_tipo === 'cliente_criado' && 
                   isset($dados_adicionais['tipo_cadastro']) && 
                   $dados_adicionais['tipo_cadastro'] === 'cadastro_manual');
            
        case 'cadastro_importacao':
            return ($evento_tipo === 'cliente_criado' && 
                   isset($dados_adicionais['tipo_cadastro']) && 
                   $dados_adicionais['tipo_cadastro'] === 'cadastro_importacao');
            
        case 'etapa_funil':
            if ($evento_tipo === 'cliente_etapa_alterada') {
                $etapa_atual = $dados_adicionais['etapa_funil_id'] ?? null;
                $etapa_condicao = $condicao['etapa_funil_id'] ?? null;
                return ($etapa_atual && $etapa_condicao && $etapa_atual == $etapa_condicao);
            }
            return false;
            
        case 'agendamento':
            if ($evento_tipo === 'cliente_etapa_alterada') {
                $etapa_atual_id = $dados_adicionais['etapa_funil_id'] ?? null;
                if ($etapa_atual_id) {
                    global $conn;
                    $sql_etapa = "SELECT tipo_entrada FROM etapas_funis WHERE id = ?";
                    $stmt = $conn->prepare($sql_etapa);
                    $stmt->bind_param("i", $etapa_atual_id);
                    $stmt->execute();
                    $result = $stmt->get_result();
                    $etapa = $result->fetch_assoc();
                    $stmt->close();
                    
                    return ($etapa['tipo_entrada'] === 'agendamento');
                }
            }
            return false;
            
        case 'qualificado_qualquer':
            return ($evento_tipo === 'cliente_qualificado' || $evento_tipo === 'questionario_respondido');
            
        case 'qualificado_especifico':
            if ($evento_tipo === 'cliente_qualificado' || $evento_tipo === 'questionario_respondido') {
                $questionario_evento = $dados_adicionais['questionario_id'] ?? null;
                $questionario_condicao = $condicao['questionario_id'] ?? null;
                return ($questionario_evento && $questionario_condicao && $questionario_evento == $questionario_condicao);
            }
            return false;
            
        case 'envio_formulario':
            return ($evento_tipo === 'formulario_enviado');
            
        case 'cliente_perdido':
            if ($evento_tipo === 'cliente_perdido') {
                return true;
            }
            if ($evento_tipo === 'cliente_etapa_alterada' || $evento_tipo === 'cliente_atualizado') {
                global $conn;
                $tenant_id = $_SESSION['tenant_id'] ?? null;
                
                if ($tenant_id && $cliente_id) {
                    $sql = "SELECT status FROM clientes WHERE id = ? AND tenant_id = ?";
                    $stmt = $conn->prepare($sql);
                    $stmt->bind_param("ii", $cliente_id, $tenant_id);
                    $stmt->execute();
                    $result = $stmt->get_result();
                    
                    if ($result->num_rows > 0) {
                        $cliente = $result->fetch_assoc();
                        $stmt->close();
                        return ($cliente['status'] === 'perdido' || $cliente['status'] === 0);
                    }
                    $stmt->close();
                }
            }
            return false;
            
        default:
            return false;
    }
}

/**
 * FUNÇÃO EXECUTAR AÇÕES FLUXO
 */
function executarAcoesFluxo($conn, $fluxo, $cliente_id, $tenant_id) {
    $acoes = json_decode($fluxo['acoes'], true);
    $atividades_criadas = 0;
    
    if (empty($acoes)) {
        return 0;
    }
    
    foreach ($acoes as $acao) {
        if (isset($acao['tipo'])) {
            switch ($acao['tipo']) {
                case 'criar_atividade':
                case 'atividade':
                    $sucesso = criarAtividadeDoFluxo($conn, $fluxo, $acao, $cliente_id, $tenant_id);
                    if ($sucesso) $atividades_criadas++;
                    break;
                    
                case 'enviar_email':
                case 'email':
                    enviarEmailFluxo($conn, $fluxo, $acao, $cliente_id, $tenant_id);
                    break;
                    
                case 'recuperacao':
                    $usuario_id = $_SESSION['usuario_id'] ?? 1;
                    recuperarClientePerdidoAutomatico($conn, $acao, ['cliente_id' => $cliente_id], $tenant_id, $usuario_id);
                    break;
            }
        } else {
            if (isset($acao['template_id'])) {
                enviarEmailFluxo($conn, $fluxo, $acao, $cliente_id, $tenant_id);
            } elseif (isset($acao['funil_destino_id'])) {
                $usuario_id = $_SESSION['usuario_id'] ?? 1;
                $acao_recuperacao = [
                    'tipo' => 'recuperacao',
                    'funil_destino_id' => $acao['funil_destino_id'],
                    'etapa_destino_id' => $acao['etapa_destino_id'] ?? null,
                    'motivos_perda' => $acao['motivos_perda'] ?? [],
                    'motivo_recuperacao' => $acao['motivo_recuperacao'] ?? 'Recuperação automática',
                    'enviar_email_recuperacao' => $acao['enviar_email_recuperacao'] ?? false,
                    'template_recuperacao_id' => $acao['template_recuperacao_id'] ?? null
                ];
                recuperarClientePerdidoAutomatico($conn, $acao_recuperacao, ['cliente_id' => $cliente_id], $tenant_id, $usuario_id);
            } else {
                $sucesso = criarAtividadeDoFluxo($conn, $fluxo, $acao, $cliente_id, $tenant_id);
                if ($sucesso) $atividades_criadas++;
            }
        }
    }
    
    return $atividades_criadas;
}

/**
 * Criar atividade do fluxo
 */
/**
 * ✅ VERSÃO CORRIGIDA - Criar atividade do fluxo com data correta
 */
function criarAtividadeDoFluxo($conn, $fluxo, $acao, $cliente_id, $tenant_id) {
    try {
        $sql_cliente = "SELECT responsavel, Nome_Cliente FROM clientes WHERE id = ? AND tenant_id = ?";
        $stmt = $conn->prepare($sql_cliente);
        $stmt->bind_param("ii", $cliente_id, $tenant_id);
        $stmt->execute();
        $result = $stmt->get_result();
        $cliente = $result->fetch_assoc();
        $stmt->close();
        
        if (!$cliente) {
            error_log("❌ Cliente $cliente_id não encontrado");
            return false;
        }
        
        $sql_tipo = "SELECT nome FROM lista_atividades WHERE id = ? AND tenant_id = ?";
        $stmt = $conn->prepare($sql_tipo);
        $stmt->bind_param("ii", $acao['tipo_atividade_id'], $tenant_id);
        $stmt->execute();
        $result = $stmt->get_result();
        $tipo_atividade = $result->fetch_assoc();
        $stmt->close();
        
        if (!$tipo_atividade) {
            error_log("❌ Tipo de atividade não encontrado: " . $acao['tipo_atividade_id']);
            return false;
        }
        
        // ✅ CORREÇÃO: Definir fuso horário explicitamente
        date_default_timezone_set('America/Sao_Paulo'); // Ajuste para seu fuso
        
        $data_agendada = new DateTime();
        $tempo_execucao = intval($acao['tempo_execucao'] ?? 0);
        
        error_log("📅 Data/hora atual do servidor: " . $data_agendada->format('Y-m-d H:i:s'));
        
        if ($tempo_execucao > 0) {
            switch ($acao['unidade_tempo'] ?? 'dias') {
                case 'minutos': 
                    $data_agendada->modify("+{$tempo_execucao} minutes");
                    break;
                case 'horas': 
                    $data_agendada->modify("+{$tempo_execucao} hours");
                    break;
                case 'dias': 
                    $data_agendada->modify("+{$tempo_execucao} days");
                    break;
                case 'semanas': 
                    $data_agendada->modify("+{$tempo_execucao} weeks");
                    break;
            }
            error_log("➕ Após adicionar {$tempo_execucao} minutos: " . $data_agendada->format('Y-m-d H:i:s'));
        }
        
        $nome_atividade = $tipo_atividade['nome'] . " - " . $cliente['Nome_Cliente'];
        $descricao = $acao['descricao'] ?? '';
        
        if (!empty($descricao)) {
            $descricao .= "\n\n";
        }
        $descricao .= "Criado automaticamente pelo fluxo: " . $fluxo['nome'];
        
        // ✅ CORREÇÃO: Usar formato compatível com MySQL
        $data_formatada = $data_agendada->format('Y-m-d H:i:s');
        
        $sql = "INSERT INTO atividades (
            tenant_id, 
            usuario_id, 
            nome, 
            descricao, 
            data_agendada, 
            cliente_id, 
            lista_atividade_id, 
            ativo, 
            concluida,
            criado_por_fluxo,
            duracao_minutos,
            notificacao_minutos_antes,
            tipo,
            nome_usuario
        ) VALUES (?, ?, ?, ?, ?, ?, ?, 1, 0, ?, 30, 0, 'geral', ?)";
        
        $stmt = $conn->prepare($sql);
        $usuario_id = $cliente['responsavel'] ?: ($_SESSION['usuario_id'] ?? 1);
        
        $sql_usuario = "SELECT nome FROM usuarios WHERE id = ?";
        $stmt_usuario = $conn->prepare($sql_usuario);
        $stmt_usuario->bind_param("i", $usuario_id);
        $stmt_usuario->execute();
        $result_usuario = $stmt_usuario->get_result();
        $usuario_nome = $result_usuario->fetch_assoc()['nome'] ?? 'Sistema';
        $stmt_usuario->close();
        
        $stmt->bind_param("iisssiiis", 
            $tenant_id, 
            $usuario_id, 
            $nome_atividade, 
            $descricao, 
            $data_formatada, 
            $cliente_id, 
            $acao['tipo_atividade_id'],
            $fluxo['id'],
            $usuario_nome
        );
        
        if ($stmt->execute()) {
            $atividade_id = $conn->insert_id;
            error_log("✅ Atividade criada: ID $atividade_id para {$data_formatada}");
            $stmt->close();
            return true;
        } else {
            error_log("❌ Erro ao criar atividade: " . $stmt->error);
            $stmt->close();
            return false;
        }
        
    } catch (Exception $e) {
        error_log("❌ Exceção ao criar atividade: " . $e->getMessage());
        return false;
    }
}

/**
 * Funções de entrada para eventos
 */
function executarFluxosClienteCriado($conn, $cliente_id, $tipo_cadastro = 'cadastro_manual') {
    error_log("👤 EXECUTANDO FLUXOS PARA CLIENTE CRIADO: $cliente_id");
    
    $dados_adicionais = [
        'tipo_cadastro' => $tipo_cadastro,
        'tenant_id' => $_SESSION['tenant_id'] ?? null
    ];
    
    return criarAtividadesPorFluxo($conn, 'cliente_criado', $cliente_id, $dados_adicionais);
}

function executarFluxosEtapaAlterada($conn, $cliente_id, $etapa_funil_id) {
    error_log("🔄 EXECUTANDO FLUXOS PARA MUDANÇA DE ETAPA: $cliente_id, Etapa: $etapa_funil_id");
    
    $dados_adicionais = [
        'etapa_funil_id' => $etapa_funil_id,
        'tenant_id' => $_SESSION['tenant_id'] ?? null
    ];
    
    return criarAtividadesPorFluxo($conn, 'cliente_etapa_alterada', $cliente_id, $dados_adicionais);
}

function executarFluxosQuestionarioRespondido($conn, $cliente_id, $questionario_id = null) {
    error_log("📝 EXECUTANDO FLUXOS PARA QUESTIONÁRIO: $cliente_id");
    
    $dados_adicionais = [
        'questionario_id' => $questionario_id,
        'tenant_id' => $_SESSION['tenant_id'] ?? null
    ];
    
    $evento = $questionario_id ? 'cliente_qualificado' : 'questionario_respondido';
    
    return criarAtividadesPorFluxo($conn, $evento, $cliente_id, $dados_adicionais);
}

function executarFluxosClientePerdido($conn, $cliente_id, $motivo_perda = null) {
    error_log("💔 EXECUTANDO FLUXOS PARA CLIENTE PERDIDO: $cliente_id");
    
    $dados_adicionais = [
        'motivo_perda' => $motivo_perda,
        'tenant_id' => $_SESSION['tenant_id'] ?? null,
        'evento_tipo' => 'cliente_perdido'
    ];
    
    return criarAtividadesPorFluxo($conn, 'cliente_perdido', $cliente_id, $dados_adicionais);
}

/**
 * FUNÇÃO DE ENTRADA PRINCIPAL PARA EXECUÇÃO AUTOMÁTICA
 */
function executarProcessamentoAutomatico($conn, $tipo = 'todos') {
    try {
        error_log("
        ⚡ ===========================================
        ⚡ INICIANDO PROCESSAMENTO AUTOMÁTICO: $tipo
        ⚡ ===========================================");
        
        $resultados = [
            'clientes_recuperados' => 0,
            'emails_processados' => 0,
            'status' => 'sucesso'
        ];
        
        verificarTabelaEmailsAgendados($conn);
        
        if ($tipo === 'recuperacao' || $tipo === 'todos') {
            error_log("💔 Executando recuperação de clientes perdidos...");
            $resultados['clientes_recuperados'] = executarFluxosRecuperacaoClientesPerdidos($conn);
        }
        
        if ($tipo === 'emails' || $tipo === 'todos') {
            error_log("📧 Processando e-mails agendados...");
            $resultados['emails_processados'] = processarEmailsAgendados($conn);
        }
        
        error_log("📋 RESUMO: {$resultados['clientes_recuperados']} recuperados, {$resultados['emails_processados']} emails");
        
        return $resultados;
        
    } catch (Exception $e) {
        error_log("❌ ERRO NO PROCESSAMENTO: " . $e->getMessage());
        return [
            'clientes_recuperados' => 0,
            'emails_processados' => 0,
            'status' => 'erro',
            'erro' => $e->getMessage()
        ];
    }
}

// Inicializar tabela de e-mails agendados quando o arquivo é incluído
if (function_exists('conectarBancoDados')) {
    $conn_temp = conectarBancoDados();
    if ($conn_temp) {
        verificarTabelaEmailsAgendados($conn_temp);
        $conn_temp->close();
    }
}

// Se este arquivo for executado diretamente via CLI
if (php_sapi_name() === 'cli' && isset($argv[0]) && basename($argv[0]) === basename(__FILE__)) {
    $_SESSION = [];
    
    $tipo = $argv[1] ?? 'todos';
    $tenant_id = $argv[2] ?? null;
    
    if ($tenant_id) {
        $_SESSION['tenant_id'] = $tenant_id;
        $_SESSION['usuario_id'] = 1;
    }
    
    require_once 'conexao.php';
    $conn = conectarBancoDados();
    
    if ($conn) {
        $resultado = executarProcessamentoAutomatico($conn, $tipo);
        
        echo "=========================================\n";
        echo "RESULTADO DO PROCESSAMENTO\n";
        echo "=========================================\n";
        echo "Tipo: $tipo\n";
        echo "Status: " . $resultado['status'] . "\n";
        echo "Clientes recuperados: " . $resultado['clientes_recuperados'] . "\n";
        echo "E-mails processados: " . $resultado['emails_processados'] . "\n";
        echo "=========================================\n";
        
        $conn->close();
    } else {
        echo "❌ ERRO: Não foi possível conectar ao banco de dados\n";
        exit(1);
    }
    
    exit(0);
}

?>