<?php
/**
 * Função para criar atividades automaticamente baseadas em fluxos
 * VERSÃO COMPLETA CORRIGIDA - Assinatura funcionando igual ao enviar_email.php
 */

/**
 * Função para carregar configurações de e-mail DO USUÁRIO LOGADO
 */
function carregarConfiguracoesEmailFluxo($conn, $tenant_id, $usuario_id = null) {
    try {
        // ✅ CORREÇÃO: Se não receber usuario_id, usar o usuário logado
        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;
        }
        
        // ✅ ATUALIZAÇÃO: Buscar dados do usuário para criar remetente personalizado
        $stmt = $conn->prepare("
            SELECT u.nome as usuario_nome, u.email as usuario_email, t.nome as tenant_nome 
            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();
            
            // ✅ ATUALIZAÇÃO: Criar configuração com remetente personalizado
            $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']
            ];
            
            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 {
        // Verificar se a coluna incluir_assinatura existe
        $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']}");
            error_log("📝 Assunto do template: " . $template['assunto']);
            error_log("📄 Conteúdo do template (primeiros 100 chars): " . substr($template['conteudo'] ?? '', 0, 100) . "...");
            error_log("🖋️ Incluir assinatura: " . ($template['incluir_assinatura'] ? 'Sim' : 'Não'));
            
            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ção para converter caminho relativo em URL absoluta
 * MESMA FUNÇÃO DO enviar_email.php
 */
function converterParaUrlAbsoluta($caminhoRelativo) {
    // Se já for uma URL completa, retorna como está
    if (filter_var($caminhoRelativo, FILTER_VALIDATE_URL)) {
        return $caminhoRelativo;
    }
    
    // Determinar a URL base do sistema
    $protocolo = isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on' ? "https" : "http";
    $host = $_SERVER['HTTP_HOST'];
    
    // Se o caminho começar com /, usar como está
    if (strpos($caminhoRelativo, '/') === 0) {
        return $protocolo . "://" . $host . $caminhoRelativo;
    }
    
    // Caso contrário, adicionar ao diretório base
    $diretorioBase = dirname($_SERVER['PHP_SELF']);
    return $protocolo . "://" . $host . $diretorioBase . '/' . ltrim($caminhoRelativo, '/');
}

/**
 * Função para carregar dados da assinatura
 * MESMA FUNÇÃO DO enviar_email.php
 */
function carregarDadosAssinatura($conn, $tenantId, $usuarioId) {
    try {
        // Carregar logo do tenant
        $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();
        
        // Carregar dados do usuário
        $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 gerar assinatura HTML
 * MESMA FUNÇÃO DO enviar_email.php - COMPLETA
 */
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'] ?? '';
    
    // Se o usuário tem uma assinatura personalizada, usar ela
    if (!empty($dadosAssinatura['usuario']['assinatura_email'])) {
        return $dadosAssinatura['usuario']['assinatura_email'];
    }
    
    // Senão, gerar assinatura padrão
    $assinatura = "\n\n<div style='margin-top: 30px; padding-top: 20px; border-top: 2px solid #007bff; font-family: Arial, sans-serif; color: #333;'>\n";
    
    // Logo do tenant - CORREÇÃO: Usar URL absoluta
    if (!empty($logo)) {
        // Converter caminho relativo para URL absoluta
        $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";
    }
    
    // Dados do usuário
    $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
 * MESMA FUNÇÃO DO enviar_email.php
 */
function aplicarAssinatura($conteudo, $assinatura) {
    if (empty($assinatura)) {
        return $conteudo;
    }
    
    // Adicionar assinatura no final
    return $conteudo . $assinatura;
}

/**
 * Função para substituir variáveis no conteúdo do e-mail
 * FUNÇÃO MELHORADA baseada no enviar_email.php
 */
function substituirVariaveisEmail($conteudo, $clienteId, $conn, $tenantId) {
    try {
        // Carregar dados completos do cliente
        $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; // Retorna conteúdo original se cliente não encontrado
        }
        
        $cliente = $result->fetch_assoc();
        $stmt->close();
        
        // ✅ CORREÇÃO: Buscar informações do usuário logado
        $usuario_logado_info = [];
        $usuario_logado_id = $_SESSION['usuario_id'] ?? null;
        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();
        }
        
        // Dados básicos do cliente
        $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'] ?? '',
            
            // Endereço
            '{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'] ?? '',
            
            // Documentos
            '{cliente_cpf_cnpj}' => $cliente['CPF_CNPJ'] ?? '',
            '{cpf_cnpj_cliente}' => $cliente['CPF_CNPJ'] ?? '',
            '{cliente_origem}' => $cliente['Origem'] ?? '',
            '{origem_cliente}' => $cliente['Origem'] ?? '',
            
            // Redes sociais
            '{cliente_instagram}' => $cliente['instagram'] ?? '',
            '{instagram_cliente}' => $cliente['instagram'] ?? '',
            '{cliente_linkedin}' => $cliente['linkedin'] ?? '',
            '{linkedin_cliente}' => $cliente['linkedin'] ?? '',
            
            // Funil e responsáveis
            '{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'] ?? '',
            
            // Datas
            '{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'),
            
            // Sistema e tenant
            '{url_sistema}' => 'https://' . $_SERVER['HTTP_HOST'],
            '{sistema_nome}' => 'SON',
            '{tenant_nome}' => $cliente['nome_tenant'] ?? '',
            
            // Responsáveis
            '{responsavel_nome}' => $cliente['nome_responsavel'] ?? '',
            '{responsavel_email}' => $cliente['email_responsavel'] ?? '',
            '{usuario_cadastro}' => $cliente['nome_usuario_cadastro'] ?? '',
            
            // ✅ CORREÇÃO: Variáveis do usuário logado
            '{usuario_nome}' => $usuario_logado_info['nome'] ?? ($_SESSION['nome_usuario'] ?? ''),
            '{usuario_email}' => $usuario_logado_info['email'] ?? ($_SESSION['email_usuario'] ?? ''),
            '{usuario_telefone}' => $usuario_logado_info['telefone'] ?? '',
            '{usuario_cargo}' => $usuario_logado_info['cargo'] ?? ($_SESSION['cargo_usuario'] ?? '')
        ];
        
        // Aplicar substituições
        return str_replace(
            array_keys($substituicoes),
            array_values($substituicoes),
            $conteudo
        );
        
    } catch (Exception $e) {
        error_log("❌ Erro ao substituir variáveis: " . $e->getMessage());
        return $conteudo; // Retorna conteúdo original em caso de erro
    }
}

/**
 * ✅ CORREÇÃO CRÍTICA: Função para enviar email via SendGrid (IGUAL AO enviar_email.php)
 */
function enviarEmail($destinatarios, $assunto, $mensagem, $cliente, $etapa_destino, $remetenteNome = null, $remetenteEmail = null) {
    try {
        // ✅ CONFIGURAÇÃO SENDGRID - USE UM E-MAIL VERIFICADO
        $sendgrid_api_key = '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';
        
        // Verificar se a API Key está no formato correto
        if (empty($sendgrid_api_key) || strlen($sendgrid_api_key) < 20) {
            return [
                'success' => false,
                'message' => 'API Key do SendGrid não configurada ou inválida'
            ];
        }
        
        // ✅ E-MAIL VERIFICADO NO SENDGRID - DEVE SER UM E-MAIL QUE VOCÊ VERIFICOU NO PAINEL DO SENDGRID
        $emailRemetenteVerificado = 'sistema@notificacaoson.tvitecnologia.com.br';
        $nomeRemetenteVerificado = 'Sistema SON';
        
        // Se o usuário logado tiver um e-mail verificado, usar ele, senão usar o padrão verificado
        if (!empty($remetenteEmail) && filter_var($remetenteEmail, FILTER_VALIDATE_EMAIL)) {
            // Mesmo usando o e-mail do usuário no "name", mas o from continua sendo o verificado
            $nomeRemetenteVerificado = $remetenteNome ?: 'Sistema SON';
        }
        
        $enviados_com_sucesso = 0;
        $erros = [];
        
        foreach ($destinatarios as $destinatario) {
            // Validar e-mail do destinatário
            if (!filter_var($destinatario, FILTER_VALIDATE_EMAIL)) {
                $erros[] = "E-mail do destinatário inválido: $destinatario";
                continue;
            }
            
            $url = 'https://api.sendgrid.com/v3/mail/send';
            
            // ✅ CORREÇÃO: Estrutura correta do payload do SendGrid
            $data = [
                'personalizations' => [
                    [
                        'to' => [
                            [
                                'email' => $destinatario,
                                'name' => $cliente['Nome_Cliente'] ?? 'Cliente'
                            ]
                        ],
                        'subject' => $assunto
                    ]
                ],
                'from' => [
                    'email' => $emailRemetenteVerificado, // ✅ SEMPRE USAR E-MAIL VERIFICADO
                    'name' => $nomeRemetenteVerificado // ✅ NOME PERSONALIZADO DO USUÁRIO
                ],
                'reply_to' => [ // ✅ CORREÇÃO: Reply-To no nível raiz, não nos headers
                    'email' => !empty($remetenteEmail) && filter_var($remetenteEmail, FILTER_VALIDATE_EMAIL) ? $remetenteEmail : $emailRemetenteVerificado,
                    'name' => $nomeRemetenteVerificado
                ],
                'content' => [
                    [
                        'type' => 'text/html',
                        'value' => $mensagem
                    ]
                ]
            ];
            
            // Log dos dados que serão enviados (sem a API key por segurança)
            error_log("📤 Tentando enviar email via SendGrid - Remetente: $nomeRemetenteVerificado <$emailRemetenteVerificado> - Reply-To: " . ($remetenteEmail ?: $emailRemetenteVerificado) . " - Para: $destinatario");
            
            $ch = curl_init();
            curl_setopt($ch, CURLOPT_URL, $url);
            curl_setopt($ch, CURLOPT_POST, 1);
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
            curl_setopt($ch, CURLOPT_HTTPHEADER, [
                'Authorization: Bearer ' . $sendgrid_api_key,
                'Content-Type: application/json',
                'User-Agent: SON-Sistema/1.0'
            ]);
            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
            curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
            curl_setopt($ch, CURLOPT_TIMEOUT, 30);
            
            $response = curl_exec($ch);
            $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
            $curl_error = curl_error($ch);
            $curl_errno = curl_errno($ch);
            
            curl_close($ch);
            
            if ($curl_errno) {
                $erros[] = "Erro cURL ($curl_errno): $curl_error";
                error_log("❌ Erro cURL para $destinatario: $curl_error");
                continue;
            }
            
            if ($http_code === 202) {
                $enviados_com_sucesso++;
                error_log("✅ SendGrid: Email enviado com sucesso para $destinatario - HTTP: $http_code");
                error_log("✅ Remetente exibido: $nomeRemetenteVerificado");
                error_log("✅ Reply-To configurado: " . ($remetenteEmail ?: $emailRemetenteVerificado));
            } else {
                $erro_msg = "Falha no envio para $destinatario - HTTP: $http_code";
                if ($response) {
                    $response_data = json_decode($response, true);
                    if (isset($response_data['errors'][0]['message'])) {
                        $erro_msg .= " - Mensagem: " . $response_data['errors'][0]['message'];
                    } else {
                        $erro_msg .= " - Response: " . substr($response, 0, 200);
                    }
                }
                $erros[] = $erro_msg;
                error_log("❌ SendGrid: $erro_msg");
                
                // Log detalhado para debug
                error_log("❌ Debug - From Email: $emailRemetenteVerificado");
                error_log("❌ Debug - From Name: $nomeRemetenteVerificado");
                error_log("❌ Debug - Reply-To: " . ($remetenteEmail ?: $emailRemetenteVerificado));
            }
        }
        
        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 SendGrid: " . $e->getMessage());
        return [
            'success' => false,
            'message' => 'Erro exception: ' . $e->getMessage()
        ];
    }
}

/**
 * ✅ CORREÇÃO CRÍTICA: FUNÇÃO DE ENVIO DE EMAIL PARA FLUXOS COMPLETAMENTE REESCRITA
 * AGORA SEGUE EXATAMENTE O MESMO PADRÃO DO enviar_email.php
 */
function enviarEmailFluxo($conn, $fluxo, $acao, $cliente_id, $tenant_id) {
    try {
        error_log("
        📧 ===========================================
        📧 INICIANDO ENVIO DE E-MAIL POR FLUXO (SENDGRID)
        📧 ===========================================");
        error_log("🎯 Fluxo: {$fluxo['nome']} (ID: {$fluxo['id']})");
        error_log("👤 Cliente ID: $cliente_id");
        error_log("🏢 Tenant ID: $tenant_id");
        error_log("🔍 Ação recebida: " . json_encode($acao));
        
        // ✅ CORREÇÃO CRÍTICA: Usar usuário logado em vez do responsável pelo cliente
        $usuario_logado_id = $_SESSION['usuario_id'] ?? null;
        if (!$usuario_logado_id) {
            error_log("❌ ERRO CRÍTICO: Nenhum usuário logado identificado");
            return false;
        }
        
        error_log("👤 ✅ Usuário logado identificado: ID $usuario_logado_id");
        
        // Buscar dados COMPLETOS do cliente
        $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;
        }
        
        error_log("✅ Cliente encontrado: {$cliente['Nome_Cliente']} ({$cliente['Email']})");
        
        // Verificar se o cliente tem e-mail
        if (empty($cliente['Email'])) {
            error_log("❌ ERRO: Cliente não possui e-mail cadastrado");
            return false;
        }
        
        // ✅ CORREÇÃO: Buscar configurações de e-mail DO USUÁRIO LOGADO
        $config_email = carregarConfiguracoesEmailFluxo($conn, $tenant_id, $usuario_logado_id);
        
        if (!$config_email) {
            error_log("❌ ERRO: Configurações de e-mail não encontradas para o usuário logado $usuario_logado_id");
            return false;
        }
        
        // Verificar e-mail do remetente
        if (empty($config_email['email_remetente'])) {
            error_log("❌ ERRO: E-mail do remetente não configurado");
            return false;
        }
        
        error_log("✅ Configurações de e-mail carregadas para usuário logado");
        error_log("📧 Remetente: {$config_email['nome_remetente']} <{$config_email['email_remetente']}>");
        
        // ✅ CORREÇÃO CRÍTICA: Lógica completamente revisada para templates
        $assunto_final = '';
        $mensagem_final = '';
        $template_incluir_assinatura = false;
        
        // ✅ PRIMEIRO: Sempre buscar o template se template_id estiver definido
        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) {
                error_log("✅ Template encontrado: {$template['nome']}");
                
                // ✅ DEFINIR ASSUNTO: Template tem prioridade sobre ação
                $assunto_final = !empty($template['assunto']) ? $template['assunto'] : ($acao['assunto'] ?? 'Comunicação do Sistema');
                
                // ✅ DEFINIR CONTEÚDO: Usar conteúdo do template como BASE
                $mensagem_final = $template['conteudo'] ?? '';
                
                // ✅ DEFINIR CONFIGURAÇÃO DE ASSINATURA
                $template_incluir_assinatura = (bool)($template['incluir_assinatura'] ?? true);
                
                error_log("📝 Assunto definido: " . $assunto_final);
                error_log("📄 Conteúdo do template carregado (" . strlen($mensagem_final) . " caracteres)");
                error_log("🖋️ Template inclui assinatura: " . ($template_incluir_assinatura ? 'Sim' : 'Não'));
                
                // ✅ ADICIONAR MENSAGEM PERSONALIZADA SE EXISTIR (como complemento)
                if (!empty($acao['mensagem_personalizada'])) {
                    $mensagem_final .= "\n\n---\n" . $acao['mensagem_personalizada'];
                    error_log("📝 Mensagem personalizada adicionada ao final do template");
                }
            } else {
                error_log("❌ Template não encontrado, usando dados da ação");
                $assunto_final = $acao['assunto'] ?? 'Comunicação do Sistema';
                $mensagem_final = $acao['mensagem_personalizada'] ?? '';
                $template_incluir_assinatura = true; // Padrão: incluir assinatura
            }
        } else {
            error_log("ℹ️  Nenhum template_id especificado, usando apenas dados da ação");
            $assunto_final = $acao['assunto'] ?? 'Comunicação do Sistema';
            $mensagem_final = $acao['mensagem_personalizada'] ?? '';
            $template_incluir_assinatura = true; // Padrão: incluir assinatura
        }
        
        // Se ainda não temos mensagem, usar fallback
        if (empty($mensagem_final)) {
            $mensagem_final = "Prezado cliente, segue comunicação do sistema.";
            error_log("⚠️  Usando mensagem de fallback");
        }
        
        // ✅ CORREÇÃO: Carregar dados da assinatura (MESMO MÉTODO DO enviar_email.php)
        $dados_assinatura = carregarDadosAssinatura($conn, $tenant_id, $usuario_logado_id);
        $assinatura_html = $dados_assinatura ? gerarAssinatura($dados_assinatura) : '';
        
        error_log("🖋️ Assinatura carregada: " . (!empty($assinatura_html) ? 'Sim' : 'Não'));
        
        // ✅ CORREÇÃO: Aplicar substituição de variáveis (MESMO MÉTODO DO enviar_email.php)
        $assunto_final = substituirVariaveisEmail($assunto_final, $cliente_id, $conn, $tenant_id);
        $mensagem_final = substituirVariaveisEmail($mensagem_final, $cliente_id, $conn, $tenant_id);
        
        error_log("🔄 Variáveis substituídas no assunto e mensagem");
        
        // ✅ CORREÇÃO CRÍTICA: Aplicar assinatura se necessário (MESMA LÓGICA DO enviar_email.php)
        $deve_incluir_assinatura = $template_incluir_assinatura;
        
        // ✅ CORREÇÃO CRÍTICA: Preparar mensagem final EXATAMENTE como no enviar_email.php
        $mensagem_html = nl2br(htmlspecialchars($mensagem_final));
        
        if ($deve_incluir_assinatura && !empty($assinatura_html)) {
            $mensagem_html = aplicarAssinatura($mensagem_html, $assinatura_html);
            error_log("✅ Assinatura aplicada ao e-mail");
        } else {
            error_log("ℹ️  Assinatura não aplicada (configuração: " . ($deve_incluir_assinatura ? 'sim' : 'não') . ", assinatura: " . (!empty($assinatura_html) ? 'disponível' : 'não disponível') . ")");
        }
        
        // ✅ CORREÇÃO CRÍTICA: Construir email HTML completo COM ALINHAMENTO À ESQUERDA
        $email_html = "
        <!DOCTYPE html>
        <html lang='pt-BR'>
        <head>
            <meta charset='UTF-8'>
            <meta name='viewport' content='width=device-width, initial-scale=1.0'>
            <title>" . htmlspecialchars($assunto_final) . "</title>
            <style>
                /* ✅ RESET COMPLETO PARA GARANTIR ALINHAMENTO À ESQUERDA */
                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;
                }
                /* ✅ FORÇAR ALINHAMENTO À ESQUERDA EM TODOS OS ELEMENTOS */
                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;
                }
                /* ✅ REMOVER QUALQUER CENTRALIZAÇÃO */
                .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'>
                    " . $mensagem_html . "
                </div>
            </div>
        </body>
        </html>";
        
        error_log("
        📨 ===========================================
        📨 DETALHES FINAIS DO E-MAIL (SENDGRID)
        📨 ===========================================");
        error_log("📧 Para: " . $cliente['Email']);
        error_log("📝 Assunto: " . $assunto_final);
        error_log("👤 De: " . $config_email['nome_remetente'] . " <" . $config_email['email_remetente'] . ">");
        error_log("🖋️ Assinatura incluída: " . ($deve_incluir_assinatura ? 'Sim' : 'Não'));
        error_log("📄 Conteúdo HTML preparado");
        
        // ✅ CORREÇÃO CRÍTICA: Usar a função de envio do enviar_email.php
        $resultadoEnvio = enviarEmail(
            [$cliente['Email']], // Array com um único destinatário
            $assunto_final,
            $email_html,
            $cliente, // Dados do cliente
            ['nome' => 'Fluxo Automatizado'], // Dados da etapa
            $config_email['nome_remetente'], // Nome do remetente (usuário logado)
            $config_email['email_remetente'] // Email do remetente (usuário logado) - usado no Reply-To
        );
        
        if ($resultadoEnvio['success']) {
            error_log("✅ ✅ ✅ E-mail enviado com SUCESSO via SendGrid");
            
            // Registrar log do e-mail enviado
            registrarLogEmailFluxo($conn, $cliente_id, $usuario_logado_id, $assunto_final, $cliente['Email'], $mensagem_final, $tenant_id);
            
            return true;
        } else {
            error_log("❌ ❌ ❌ Falha no envio do e-mail via SendGrid: " . $resultadoEnvio['message']);
            return false;
        }
        
    } catch (Exception $e) {
        error_log("❌ ❌ ❌ Exceção ao enviar e-mail: " . $e->getMessage());
        error_log("🔧 Stack trace: " . $e->getTraceAsString());
        return false;
    }
}

/**
 * Registrar log de e-mail enviado por fluxo
 */
function registrarLogEmailFluxo($conn, $clienteId, $usuarioId, $assunto, $destinatario, $mensagem, $tenantId) {
    try {
        // Buscar nome do usuário
        $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_fluxo";
        $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 de e-mail: " . $e->getMessage());
        return false;
    }
}

/**
 * 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
    🎯 ===========================================");
    error_log("📅 Evento: $evento_tipo");
    error_log("👤 Cliente ID: $cliente_id");
    error_log("📋 Dados adicionais: " . json_encode($dados_adicionais));
    
    // CORREÇÃO: Obter tenant_id dos dados adicionais ou da sessão
    $tenant_id = $dados_adicionais['tenant_id'] ?? ($_SESSION['tenant_id'] ?? null);
    if (!$tenant_id) {
        error_log("❌ ERRO CRÍTICO: tenant_id não encontrado");
        return 0;
    }
    
    error_log("🏢 Tenant ID: $tenant_id");
    
    // Buscar fluxos ativos
    $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;
    
    error_log("📊 Total de fluxos ativos encontrados: $total_fluxos");
    
    while ($fluxo = $result->fetch_assoc()) {
        error_log("
        🔍 ===========================================
        🔍 Analisando fluxo: {$fluxo['nome']} (ID: {$fluxo['id']})
        🔍 ===========================================");
        
        // Verificar se este fluxo se aplica ao evento atual
        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;
            error_log("📝 Criadas $criadas ações para este fluxo");
        } else {
            error_log("❌ Fluxo '{$fluxo['nome']}' NÃO se aplica ao evento");
        }
    }
    
    $stmt->close();
    error_log("
    🎯 ===========================================
    🎯 FINALIZADO: Total de $atividades_criadas ações executadas
    🎯 ===========================================");
    return $atividades_criadas;
}

/**
 * FUNÇÃO DE VERIFICAÇÃO DE EVENTOS COMPLETAMENTE REESCRITA
 */
function fluxoAplicaAoEvento($fluxo, $evento_tipo, $cliente_id, $dados_adicionais) {
    error_log("🔍 Verificando aplicabilidade do fluxo '{$fluxo['nome']}' para evento: $evento_tipo");
    
    // Decodificar condições
    $condicoes = json_decode($fluxo['condicoes'], true);
    
    if (empty($condicoes)) {
        error_log("❌ Fluxo sem condições definidas");
        return false;
    }
    
    error_log("📋 Condições do fluxo: " . json_encode($condicoes));
    
    // ✅ CORREÇÃO: Verificar cada condição individualmente
    foreach ($condicoes as $index => $condicao) {
        error_log("📋 Condição $index: " . json_encode($condicao));
        
        // Verificar se a condição corresponde ao evento atual
        if (condicaoCorrespondeEvento($condicao, $evento_tipo, $cliente_id, $dados_adicionais)) {
            error_log("✅ ✅ ✅ Condição $index CORRESPONDE ao evento");
            return true;
        } else {
            error_log("❌ Condição $index NÃO corresponde ao evento");
        }
    }
    
    error_log("❌ Nenhuma condição correspondeu ao evento");
    return false;
}

/**
 * FUNÇÃO DE CORRESPONDÊNCIA DE CONDIÇÕES COMPLETAMENTE REESCRITA
 */
function condicaoCorrespondeEvento($condicao, $evento_tipo, $cliente_id, $dados_adicionais) {
    error_log("🔍 Verificando correspondência da condição: " . json_encode($condicao));
    
    // ✅ CORREÇÃO: Verificação específica para cada tipo de condição
    switch ($condicao['tipo']) {
        
        // CONDIÇÕES DE CRIAÇÃO
        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');
            
        // CONDIÇÕES DE ETAPA - CRÍTICO!
        case 'etapa_funil':
            if ($evento_tipo === 'cliente_etapa_alterada') {
                $etapa_atual = $dados_adicionais['etapa_funil_id'] ?? null;
                $etapa_condicao = $condicao['etapa_funil_id'] ?? null;
                
                $corresponde = ($etapa_atual && $etapa_condicao && $etapa_atual == $etapa_condicao);
                error_log("🔍 Comparando etapa: $etapa_atual === $etapa_condicao = " . ($corresponde ? 'SIM' : 'NÃO'));
                return $corresponde;
            }
            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();
                    
                    $corresponde = ($etapa['tipo_entrada'] === 'agendamento');
                    error_log("🔍 Verificando agendamento: etapa $etapa_atual_id, tipo_entrada = " . ($etapa['tipo_entrada'] ?? 'N/D') . " = " . ($corresponde ? 'SIM' : 'NÃO'));
                    return $corresponde;
                }
            }
            return false;
            
        // CONDIÇÕES DE QUESTIONÁRIO
        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;
                
                $corresponde = ($questionario_evento && $questionario_condicao && $questionario_evento == $questionario_condicao);
                error_log("🔍 Comparando questionário: $questionario_evento === $questionario_condicao = " . ($corresponde ? 'SIM' : 'NÃO'));
                return $corresponde;
            }
            return false;
            
        // CONDIÇÃO DE FORMULÁRIO
        case 'envio_formulario':
            return ($evento_tipo === 'formulario_enviado');
            
        default:
            error_log("❌ Tipo de condição desconhecido: {$condicao['tipo']}");
            return false;
    }
}

/**
 * FUNÇÃO EXECUTAR AÇÕES FLUXO - CORRIGIDA (NÃO CONTA EMAIL COMO ATIVIDADE)
 */
function executarAcoesFluxo($conn, $fluxo, $cliente_id, $tenant_id) {
    // Decodificar ações
    $acoes = json_decode($fluxo['acoes'], true);
    $atividades_criadas = 0;
    
    error_log("🔄 Executando ações do fluxo '{$fluxo['nome']}' para cliente $cliente_id");
    error_log("📋 Ações encontradas: " . json_encode($acoes));
    
    if (empty($acoes)) {
        error_log("❌ Nenhuma ação definida para este fluxo");
        return 0;
    }
    
    foreach ($acoes as $index => $acao) {
        error_log("🔧 Processando ação $index: " . json_encode($acao));
        
        // Verificar tipo de ação
        if (isset($acao['tipo']) && $acao['tipo'] === 'criar_atividade') {
            error_log("📝 Executando ação: Criar Atividade");
            $sucesso = criarAtividadeDoFluxo($conn, $fluxo, $acao, $cliente_id, $tenant_id);
            if ($sucesso) {
                $atividades_criadas++; // ✅ CORRETO - só conta quando cria atividade
                error_log("✅ Atividade criada com sucesso");
            } else {
                error_log("❌ Falha ao criar atividade");
            }
        } elseif (isset($acao['tipo']) && $acao['tipo'] === 'enviar_email') {
            error_log("📧 Executando ação: Enviar E-mail");
            $sucesso = enviarEmailFluxo($conn, $fluxo, $acao, $cliente_id, $tenant_id);
            if ($sucesso) {
                error_log("✅ E-mail enviado com sucesso via fluxo");
                // ✅ CORREÇÃO APLICADA: NÃO incrementa $atividades_criadas para e-mails
                // Apenas registra o sucesso, mas não conta como atividade criada
            } else {
                error_log("❌ Falha no envio do e-mail via fluxo");
            }
        } else {
            // Para compatibilidade com ações antigas (sem tipo definido)
            error_log("⚡ Executando ação legada (sem tipo definido)");
            if (isset($acao['template_id'])) {
                // É uma ação de e-mail
                $sucesso = enviarEmailFluxo($conn, $fluxo, $acao, $cliente_id, $tenant_id);
                if ($sucesso) {
                    error_log("✅ E-mail enviado com sucesso via fluxo (ação legada)");
                    // ✅ CORREÇÃO APLICADA: NÃO incrementa $atividades_criadas para e-mails
                } else {
                    error_log("❌ Falha no envio do e-mail via fluxo (ação legada)");
                }
            } else {
                // É uma ação de atividade
                $sucesso = criarAtividadeDoFluxo($conn, $fluxo, $acao, $cliente_id, $tenant_id);
                if ($sucesso) {
                    $atividades_criadas++; // ✅ CORRETO - conta apenas atividades
                    error_log("✅ Atividade criada com sucesso (ação legada)");
                } else {
                    error_log("❌ Falha ao criar atividade (ação legada)");
                }
            }
        }
    }
    
    return $atividades_criadas;
}

function criarAtividadeDoFluxo($conn, $fluxo, $acao, $cliente_id, $tenant_id) {
    try {
        // Buscar dados do cliente
        $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;
        }
        
        // Buscar tipo de atividade
        $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;
        }
        
        // Calcular data (agora + tempo configurado)
        $data_agendada = new DateTime();
        $tempo_execucao = intval($acao['tempo_execucao'] ?? 0);
        
        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;
            }
        }
        
        // Criar atividade
        $nome_atividade = $tipo_atividade['nome'] . " - " . $cliente['Nome_Cliente'];
        $descricao = $acao['descricao'] ?? '';
        
        if (!empty($descricao)) {
            $descricao .= "\n\n";
        }
        $descricao .= "Criado automaticamente pelo fluxo: " . $fluxo['nome'];
        
        // Query SQL CORRIGIDA - garantir que todos os campos obrigatórios sejam preenchidos
        $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);
        $data_formatada = $data_agendada->format('Y-m-d H:i:s');
        
        // Buscar nome do usuário para o campo nome_usuario
        $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 - '$nome_atividade' para cliente {$cliente['Nome_Cliente']}");
            $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;
    }
}

// ✅ CORREÇÃO: Para chamar quando cliente é criado manualmente
function executarFluxosClienteCriado($conn, $cliente_id, $tipo_cadastro = 'cadastro_manual') {
    error_log("👤 EXECUTANDO FLUXOS PARA CLIENTE CRIADO: $cliente_id, Tipo: $tipo_cadastro");
    
    $dados_adicionais = [
        'tipo_cadastro' => $tipo_cadastro,
        'tenant_id' => $_SESSION['tenant_id'] ?? null
    ];
    
    return criarAtividadesPorFluxo($conn, 'cliente_criado', $cliente_id, $dados_adicionais);
}

// ✅ CORREÇÃO: Para chamar quando cliente muda de etapa - FUNÇÃO CRÍTICA
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);
}

// ✅ Para chamar quando questionário é respondido
function executarFluxosQuestionarioRespondido($conn, $cliente_id, $questionario_id = null) {
    error_log("📝 EXECUTANDO FLUXOS PARA QUESTIONÁRIO RESPONDIDO: $cliente_id, Questionário: $questionario_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);
}

// Função para testar manualmente
function testarFluxoManual($conn, $fluxo_id, $cliente_id) {
    $sql = "SELECT * FROM fluxos_automatizados WHERE id = ?";
    $stmt = $conn->prepare($sql);
    $stmt->bind_param("i", $fluxo_id);
    $stmt->execute();
    $fluxo = $stmt->get_result()->fetch_assoc();
    $stmt->close();
    
    if ($fluxo) {
        return executarAcoesFluxo($conn, $fluxo, $cliente_id, $fluxo['tenant_id']);
    }
    
    return 0;
}

/**
 * FUNÇÃO PARA TESTAR ENVIO DE EMAIL MANUALMENTE
 * ATUALIZADA PARA USAR SENDGRID
 */
function testarEnvioEmailManual($conn, $cliente_id, $tenant_id, $template_id = null) {
    error_log("🧪 ===========================================");
    error_log("🧪 TESTE MANUAL DE ENVIO DE E-MAIL (SENDGRID)");
    error_log("🧪 ===========================================");
    
    // ✅ CORREÇÃO: Usar usuário logado
    $usuario_logado_id = $_SESSION['usuario_id'] ?? null;
    if (!$usuario_logado_id) {
        error_log("❌ Nenhum usuário logado identificado");
        return false;
    }
    
    // Buscar cliente
    $sql_cliente = "SELECT id, responsavel, Nome_Cliente, Email 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 não encontrado");
        return false;
    }
    
    error_log("✅ Cliente: {$cliente['Nome_Cliente']} ({$cliente['Email']})");
    
    // ✅ CORREÇÃO: Buscar configurações de email do USUÁRIO LOGADO
    $config_email = carregarConfiguracoesEmailFluxo($conn, $tenant_id, $usuario_logado_id);
    
    if (!$config_email) {
        error_log("❌ Configurações de email não encontradas para usuário logado: " . $usuario_logado_id);
        return false;
    }
    
    error_log("✅ Configurações de email encontradas para usuário logado");
    error_log("📧 Remetente: {$config_email['nome_remetente']} <{$config_email['email_remetente']}>");
    
    // Testar envio simples
    $assunto = "🎯 TESTE SendGrid - " . date('d/m/Y H:i:s');
    $mensagem = "Este é um e-mail de teste do sistema de fluxos usando SendGrid.\n\nCliente: {$cliente['Nome_Cliente']}\nData: " . date('d/m/Y H:i:s');
    
    // ✅ ATUALIZAÇÃO: Usar SendGrid para teste também
    $email_html = "
    <!DOCTYPE html>
    <html lang='pt-BR'>
    <head>
        <meta charset='UTF-8'>
        <meta name='viewport' content='width=device-width, initial-scale=1.0'>
        <title>" . htmlspecialchars($assunto) . "</title>
        <style>
            /* ✅ RESET COMPLETO PARA GARANTIR ALINHAMENTO À ESQUERDA */
            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;
            }
            /* ✅ FORÇAR ALINHAMENTO À ESQUERDA EM TODOS OS ELEMENTOS */
            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;
            }
            /* ✅ REMOVER QUALQUER CENTRALIZAÇÃO */
            .center, [align=\"center\"], [style*=\"text-align:center\"], [style*=\"text-align: center\"] {
                text-align: left !important;
            }
        </style>
    </head>
    <body>
        <div class='email-container'>
            " . nl2br(htmlspecialchars($mensagem)) . "
        </div>
    </body>
    </html>";
    
    $resultadoEnvio = enviarEmail(
        [$cliente['Email']], // Array com um único destinatário
        $assunto,
        $email_html,
        $cliente, // Dados do cliente
        ['nome' => 'Teste Manual'], // Dados da etapa
        $config_email['nome_remetente'], // Nome do remetente (usuário logado)
        $config_email['email_remetente'] // Email do remetente (usuário logado) - usado no Reply-To
    );
    
    if ($resultadoEnvio['success']) {
        error_log("✅ ✅ ✅ E-MAIL DE TESTE ENVIADO COM SUCESSO VIA SENDGRID!");
        return true;
    } else {
        error_log("❌ ❌ ❌ FALHA NO ENVIO DO E-MAIL DE TESTE VIA SENDGRID: " . $resultadoEnvio['message']);
        return false;
    }
}

/**
 * Verificar configuração do servidor de email
 */
function verificarConfiguracaoEmail($conn, $tenant_id, $usuario_id = null) {
    error_log("🔧 VERIFICANDO CONFIGURAÇÃO DE E-MAIL");
    
    // ✅ CORREÇÃO: Se não receber usuario_id, usar usuário logado
    if (!$usuario_id) {
        $usuario_id = $_SESSION['usuario_id'] ?? null;
    }
    
    if (!$usuario_id) {
        error_log("❌ Nenhum usuário logado identificado");
        return false;
    }
    
    $config = carregarConfiguracoesEmailFluxo($conn, $tenant_id, $usuario_id);
    
    if (!$config) {
        error_log("❌ Nenhuma configuração de email encontrada para usuário logado ID: $usuario_id");
        return false;
    }
    
    error_log("📧 Configurações encontradas para usuário logado:");
    error_log("   - Remetente: {$config['nome_remetente']} <{$config['email_remetente']}>");
    
    return true;
}

/**
 * DIAGNÓSTICO COMPLETO DO SISTEMA DE FLUXOS
 */
function diagnosticoSistemaFluxos($conn, $tenant_id) {
    error_log("🎯 ===========================================");
    error_log("🎯 DIAGNÓSTICO COMPLETO DO SISTEMA DE FLUXOS");
    error_log("🎯 ===========================================");
    
    // 1. Verificar se há fluxos ativos
    $sql_fluxos = "SELECT COUNT(*) as total 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();
    $total_fluxos = $result->fetch_assoc()['total'];
    $stmt->close();
    
    error_log("📊 Total de fluxos ativos: $total_fluxos");
    
    // 2. Listar fluxos e suas condições
    $sql_detalhes = "SELECT id, nome, condicoes, acoes FROM fluxos_automatizados WHERE ativo = 1 AND tenant_id = ?";
    $stmt = $conn->prepare($sql_detalhes);
    $stmt->bind_param("i", $tenant_id);
    $stmt->execute();
    $result = $stmt->get_result();
    
    while ($fluxo = $result->fetch_assoc()) {
        error_log("🔍 Fluxo: {$fluxo['nome']} (ID: {$fluxo['id']})");
        error_log("   Condições: " . $fluxo['condicoes']);
        error_log("   Ações: " . $fluxo['acoes']);
    }
    $stmt->close();
    
    // 3. Verificar templates de email
    $sql_templates = "SELECT COUNT(*) as total FROM templates_email WHERE ativo = 1 AND tenant_id = ?";
    $stmt = $conn->prepare($sql_templates);
    $stmt->bind_param("i", $tenant_id);
    $stmt->execute();
    $result = $stmt->get_result();
    $total_templates = $result->fetch_assoc()['total'];
    $stmt->close();
    
    error_log("📧 Total de templates de email ativos: $total_templates");
    
    return [
        'total_fluxos' => $total_fluxos,
        'total_templates' => $total_templates
    ];
}

function executarFluxosAgendados($conn) {
    error_log("🕒 Executando verificação de fluxos agendados");
    
    $tenant_id = $_SESSION['tenant_id'] ?? null;
    if (!$tenant_id) {
        error_log("❌ Tenant ID não encontrado para fluxos agendados");
        return 0;
    }
    
    $sql = "SELECT * FROM fluxos_automatizados WHERE ativo = 1 AND tipo_trigger = 'agendamento' AND tenant_id = ?";
    $stmt = $conn->prepare($sql);
    $stmt->bind_param("i", $tenant_id);
    $stmt->execute();
    $result = $stmt->get_result();
    
    $fluxos_executados = 0;
    
    while ($fluxo = $result->fetch_assoc()) {
        if (deveExecutarFluxoAgendado($fluxo)) {
            error_log("✅ Executando fluxo agendado: {$fluxo['nome']}");
            
            // Buscar clientes que se encaixam nas condições do fluxo
            $clientes = buscarClientesParaFluxoAgendado($conn, $fluxo);
            
            foreach ($clientes as $cliente_id) {
                $criadas = executarAcoesFluxo($conn, $fluxo, $cliente_id, $tenant_id);
                $fluxos_executados += $criadas;
            }
            
            // Atualizar última execução
            atualizarUltimaExecucaoFluxo($conn, $fluxo['id']);
        }
    }
    
    $stmt->close();
    return $fluxos_executados;
}

function deveExecutarFluxoAgendado($fluxo) {
    $config_agendamento = json_decode($fluxo['config_agendamento'], true);
    
    if (empty($config_agendamento)) {
        return false;
    }
    
    $agora = new DateTime();
    $ultima_execucao = $fluxo['ultima_execucao'] ? new DateTime($fluxo['ultima_execucao']) : null;
    
    switch ($config_agendamento['frequencia']) {
        case 'diario':
            // Executar uma vez por dia
            if (!$ultima_execucao || $ultima_execucao->format('Y-m-d') !== $agora->format('Y-m-d')) {
                return verificarHorarioAgendamento($config_agendamento['horario'], $agora);
            }
            break;
            
        case 'semanal':
            // Executar uma vez por semana no dia especificado
            if (!$ultima_execucao || $ultima_execucao->format('Y-W') !== $agora->format('Y-W')) {
                $dia_semana = $agora->format('w'); // 0 (domingo) a 6 (sábado)
                if ($dia_semana == $config_agendamento['dia_semana']) {
                    return verificarHorarioAgendamento($config_agendamento['horario'], $agora);
                }
            }
            break;
            
        case 'mensal':
            // Executar uma vez por mês no dia especificado
            if (!$ultima_execucao || $ultima_execucao->format('Y-m') !== $agora->format('Y-m')) {
                $dia_mes = $agora->format('j');
                if ($dia_mes == $config_agendamento['dia_mes']) {
                    return verificarHorarioAgendamento($config_agendamento['horario'], $agora);
                }
            }
            break;
    }
    
    return false;
}

function verificarHorarioAgendamento($horario_config, $agora) {
    $hora_atual = $agora->format('H:i');
    $hora_config = $horario_config . ':00'; // Adicionar segundos para comparação
    
    // Executar se estiver na hora ou até 5 minutos após (para tolerância)
    $hora_config_obj = DateTime::createFromFormat('H:i:s', $hora_config);
    $hora_atual_obj = DateTime::createFromFormat('H:i:s', $hora_atual . ':00');
    
    if (!$hora_config_obj || !$hora_atual_obj) {
        return false;
    }
    
    $diferenca = $hora_atual_obj->getTimestamp() - $hora_config_obj->getTimestamp();
    
    return $diferenca >= 0 && $diferenca <= 300; // 5 minutos de tolerância
}

function buscarClientesParaFluxoAgendado($conn, $fluxo) {
    $condicoes = json_decode($fluxo['condicoes'], true);
    $clientes_ids = [];
    
    if (empty($condicoes)) {
        return $clientes_ids;
    }
    
    // Construir query baseada nas condições
    $where_conditions = [];
    $params = [];
    $types = '';
    
    foreach ($condicoes as $condicao) {
        switch ($condicao['tipo']) {
            case 'etapa_funil':
                $where_conditions[] = "etapa_funil_id = ?";
                $params[] = $condicao['etapa_funil_id'];
                $types .= 'i';
                break;
                
            case 'tempo_sem_atividade':
                $dias = intval($condicao['dias']);
                $where_conditions[] = "id NOT IN (
                    SELECT DISTINCT cliente_id FROM atividades 
                    WHERE data_agendada >= DATE_SUB(NOW(), INTERVAL ? DAY)
                    AND tenant_id = ?
                )";
                $params[] = $dias;
                $params[] = $fluxo['tenant_id'];
                $types .= 'ii';
                break;
                
            case 'sem_responsavel':
                $where_conditions[] = "(responsavel IS NULL OR responsavel = '')";
                break;
        }
    }
    
    if (empty($where_conditions)) {
        return $clientes_ids;
    }
    
    $sql = "SELECT id FROM clientes WHERE tenant_id = ? AND " . implode(' AND ', $where_conditions);
    array_unshift($params, $fluxo['tenant_id']);
    array_unshift($types, 'i');
    
    $stmt = $conn->prepare($sql);
    $stmt->bind_param($types, ...$params);
    $stmt->execute();
    $result = $stmt->get_result();
    
    while ($row = $result->fetch_assoc()) {
        $clientes_ids[] = $row['id'];
    }
    
    $stmt->close();
    return $clientes_ids;
}

function atualizarUltimaExecucaoFluxo($conn, $fluxo_id) {
    $sql = "UPDATE fluxos_automatizados SET ultima_execucao = NOW() WHERE id = ?";
    $stmt = $conn->prepare($sql);
    $stmt->bind_param("i", $fluxo_id);
    $stmt->execute();
    $stmt->close();
}

// Função para limpar atividades antigas de fluxos (manutenção)
function limparAtividadesFluxosAntigas($conn, $dias_manter = 30) {
    $sql = "DELETE FROM atividades WHERE criado_por_fluxo IS NOT NULL AND data_agendada < DATE_SUB(NOW(), INTERVAL ? DAY)";
    $stmt = $conn->prepare($sql);
    $stmt->bind_param("i", $dias_manter);
    $stmt->execute();
    $linhas_afetadas = $stmt->affected_rows;
    $stmt->close();
    
    error_log("🧹 Limpas $linhas_afetadas atividades antigas de fluxos (mais de $dias_manter dias)");
    return $linhas_afetadas;
}

// ✅ NOVA FUNÇÃO: Para testar especificamente o envio de e-mail por fluxo
function testarEnvioEmailFluxo($conn, $cliente_id, $tenant_id) {
    error_log("🧪 INICIANDO TESTE DE ENVIO DE E-MAIL POR FLUXO");
    
    // Dados de teste
    $fluxo_teste = [
        'id' => 999,
        'nome' => 'Fluxo de Teste',
        'tenant_id' => $tenant_id
    ];
    
    $acao_teste = [
        'tipo' => 'enviar_email',
        'assunto' => '🎯 TESTE Fluxo Automatizado - {data}',
        'mensagem' => 'Olá {cliente_nome},\n\nEste é um e-mail de teste enviado automaticamente pelo sistema de fluxos.\n\nData: {data}\nHora: {hora}\n\nAtenciosamente,\nSistema SON'
    ];
    
    return enviarEmailFluxo($conn, $fluxo_teste, $acao_teste, $cliente_id, $tenant_id);
}

/**
 * FUNÇÃO PARA FORÇAR EXECUÇÃO DE FLUXO ESPECÍFICO
 * Útil para testes e depuração
 */
function forcarExecucaoFluxo($conn, $fluxo_id, $cliente_id, $tenant_id) {
    error_log("⚡ FORÇANDO EXECUÇÃO DO FLUXO ID: $fluxo_id");
    
    $sql = "SELECT * FROM fluxos_automatizados WHERE id = ? AND tenant_id = ?";
    $stmt = $conn->prepare($sql);
    $stmt->bind_param("ii", $fluxo_id, $tenant_id);
    $stmt->execute();
    $result = $stmt->get_result();
    $fluxo = $result->fetch_assoc();
    $stmt->close();
    
    if (!$fluxo) {
        error_log("❌ Fluxo não encontrado: ID $fluxo_id");
        return false;
    }
    
    error_log("✅ Fluxo encontrado: {$fluxo['nome']}");
    
    // Executar ações do fluxo independentemente das condições
    $resultado = executarAcoesFluxo($conn, $fluxo, $cliente_id, $tenant_id);
    
    error_log("📊 Resultado da execução forçada: $resultado ações executadas");
    
    return $resultado;
}

?>