<?php
/**
 * Função para criar atividades automaticamente baseadas em fluxos
 * Chamada diretamente quando um evento ocorre
 */

/**
 * Função para carregar configurações de e-mail DO USUÁRIO RESPONSÁVEL PELO CLIENTE
 */
function carregarConfiguracoesEmailFluxo($conn, $tenant_id, $usuario_id) {
    try {
        $stmt = $conn->prepare("SELECT * FROM configuracoes_email WHERE tenant_id = ? AND usuario_id = ?");
        $stmt->bind_param("ii", $tenant_id, $usuario_id);
        $stmt->execute();
        $result = $stmt->get_result();
        
        if ($result->num_rows > 0) {
            $configuracoes = $result->fetch_assoc();
            $stmt->close();
            return $configuracoes;
        } else {
            $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 - CORRIGIDA
 */
function buscarTemplateEmail($conn, $template_id, $tenant_id) {
    try {
        $sql = "SELECT id, nome, assunto, conteudo 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) . "...");
            
            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 processar template de e-mail com variáveis - COMPLETAMENTE REVISADA
 */
function processarTemplateComConteudo($template_conteudo, $cliente) {
    // Buscar dados completos do cliente
    global $conn;
    $sql_cliente = "SELECT Nome_Cliente, Email, Telefone FROM clientes WHERE id = ?";
    $stmt = $conn->prepare($sql_cliente);
    $stmt->bind_param("i", $cliente['id']);
    $stmt->execute();
    $result = $stmt->get_result();
    $cliente_completo = $result->fetch_assoc();
    $stmt->close();
    
    $variaveis = [
        '{cliente_nome}' => $cliente_completo['Nome_Cliente'] ?? '',
        '{cliente_email}' => $cliente_completo['Email'] ?? '',
        '{nome_cliente}' => $cliente_completo['Nome_Cliente'] ?? '',
        '{email_cliente}' => $cliente_completo['Email'] ?? '',
        '{telefone_cliente}' => $cliente_completo['Telefone'] ?? '',
        '{data}' => date('d/m/Y'),
        '{hora}' => date('H:i:s'),
        '{data_atual}' => date('d/m/Y'),
        '{data_hora}' => date('d/m/Y H:i:s'),
        '{url_sistema}' => 'https://seusistema.com'
    ];
    
    $conteudo_processado = str_replace(array_keys($variaveis), array_values($variaveis), $template_conteudo);
    
    error_log("🔄 Variáveis processadas para: " . $cliente_completo['Nome_Cliente']);
    
    return $conteudo_processado;
}

/**
 * FUNÇÃO DE ENVIO DE EMAIL PARA FLUXOS (COMPLETAMENTE REESCRITA)
 */
function enviarEmailFluxo($conn, $fluxo, $acao, $cliente_id, $tenant_id) {
    try {
        error_log("
        📧 ===========================================
        📧 INICIANDO ENVIO DE E-MAIL POR FLUXO
        📧 ===========================================");
        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));
        
        // Buscar dados COMPLETOS do cliente
        $sql_cliente = "SELECT id, responsavel, Nome_Cliente, Email, Telefone 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;
        }
        
        // Buscar configurações de e-mail DO USUÁRIO RESPONSÁVEL
        $usuario_id = $cliente['responsavel'] ?? ($_SESSION['usuario_id'] ?? null);
        
        if (!$usuario_id) {
            error_log("❌ ERRO: Usuário responsável não identificado");
            return false;
        }
        
        error_log("👤 Usuário responsável ID: $usuario_id");
        
        $config_email = carregarConfiguracoesEmailFluxo($conn, $tenant_id, $usuario_id);
        
        if (!$config_email) {
            error_log("❌ ERRO: Configurações de e-mail não encontradas para o usuário $usuario_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");
        
        // ✅ CORREÇÃO CRÍTICA: Lógica completamente revisada para templates
        $assunto_final = '';
        $mensagem_final = '';
        
        // ✅ 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'] ?? '';
                
                error_log("📝 Assunto definido: " . $assunto_final);
                error_log("📄 Conteúdo do template carregado (" . strlen($mensagem_final) . " caracteres)");
                
                // ✅ 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'] ?? '';
            }
        } 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'] ?? '';
        }
        
        // 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: Processar variáveis com dados completos do cliente
        $assunto_final = processarTemplateComConteudo($assunto_final, $cliente);
        $mensagem_final = processarTemplateComConteudo($mensagem_final, $cliente);
        
        error_log("
        📨 ===========================================
        📨 DETALHES FINAIS DO E-MAIL
        📨 ===========================================");
        error_log("📧 Para: " . $cliente['Email']);
        error_log("📝 Assunto: " . $assunto_final);
        error_log("👤 De: " . $config_email['nome_remetente'] . " <" . $config_email['email_remetente'] . ">");
        error_log("📄 Conteúdo completo:");
        error_log($mensagem_final);
        error_log("📄 Tamanho do conteúdo: " . strlen($mensagem_final) . " caracteres");
        
        // ENVIAR E-MAIL
        $headers = "From: " . $config_email['nome_remetente'] . " <" . $config_email['email_remetente'] . ">\r\n";
        $headers .= "Reply-To: " . $config_email['email_remetente'] . "\r\n";
        $headers .= "Content-Type: text/html; charset=UTF-8\r\n";
        $headers .= "MIME-Version: 1.0\r\n";
        
        // Converter quebras de linha para HTML
        $mensagem_html = nl2br(htmlspecialchars($mensagem_final));
        
        $enviado = mail($cliente['Email'], $assunto_final, $mensagem_html, $headers);
        
        if ($enviado) {
            error_log("✅ ✅ ✅ E-mail enviado com SUCESSO via fluxo");
            
            // Registrar log do e-mail enviado
            registrarLogEmailFluxo($conn, $cliente_id, $usuario_id, $assunto_final, $cliente['Email'], $mensagem_final, $tenant_id);
            
            return true;
        } else {
            error_log("❌ ❌ ❌ Falha no envio do e-mail via fluxo");
            error_log("🔧 Debug - Último erro: " . error_get_last()['message'] ?? 'Desconhecido');
            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;
    }
}

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++;
            }
        } 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");
                $atividades_criadas++;
            } 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) {
                    $atividades_criadas++;
                }
            } else {
                // É uma ação de atividade
                $sucesso = criarAtividadeDoFluxo($conn, $fluxo, $acao, $cliente_id, $tenant_id);
                if ($sucesso) {
                    $atividades_criadas++;
                }
            }
        }
    }
    
    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;
}

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);
}