<?php
session_start();

// Configurar headers para JSON
header('Content-Type: application/json');

// Função para enviar resposta JSON padronizada
function sendJsonResponse($success, $message, $additionalData = []) {
    $response = ['success' => $success, 'message' => $message];
    if (!empty($additionalData)) {
        $response = array_merge($response, $additionalData);
    }
    echo json_encode($response);
    exit;
}

// Verificar se o usuário está logado
if (!isset($_SESSION['logado']) || $_SESSION['logado'] !== true) {
    sendJsonResponse(false, 'Usuário não autenticado');
}

// Verificar tenant_id
$tenant_id = $_SESSION['tenant_id'] ?? null;
$usuario_id = $_SESSION['usuario_id'] ?? null;

if (!$tenant_id) {
    sendJsonResponse(false, 'Tenant não identificado');
}

// Verificar se a requisição é POST
if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
    sendJsonResponse(false, 'Método não permitido');
}

// Ler os dados JSON do corpo da requisição
$input = file_get_contents('php://input');
if (empty($input)) {
    sendJsonResponse(false, 'Dados não recebidos');
}

$input_data = json_decode($input, true);

if (!$input_data || json_last_error() !== JSON_ERROR_NONE) {
    sendJsonResponse(false, 'Dados JSON inválidos: ' . json_last_error_msg());
}

// DEBUG: Log dos dados recebidos
error_log("Dados recebidos: " . print_r($input_data, true));

// Verificar CSRF token do BODY
$csrf_token = $input_data['csrf_token'] ?? '';
if (empty($csrf_token) || $csrf_token !== ($_SESSION['csrf_token'] ?? '')) {
    sendJsonResponse(false, 'Token de segurança inválido!');
}

// Validar dados obrigatórios
$cliente_id = intval($input_data['cliente_id'] ?? 0);
$emails_destinatarios = $input_data['emails_destinatarios'] ?? [];
$assunto = trim($input_data['assunto'] ?? '');
$mensagem = trim($input_data['mensagem'] ?? '');
$etapa_destino_id = intval($input_data['etapa_destino_id'] ?? 0);
$incluir_assinatura = boolval($input_data['incluir_assinatura'] ?? true);
$template_id = intval($input_data['template_id'] ?? 0);

// DEBUG: Log dos dados validados
error_log("Cliente ID: $cliente_id");
error_log("Emails: " . print_r($emails_destinatarios, true));
error_log("Assunto: $assunto");
error_log("Mensagem: $mensagem");
error_log("Etapa Destino ID: $etapa_destino_id");
error_log("Incluir Assinatura: " . ($incluir_assinatura ? 'Sim' : 'Não'));
error_log("Template ID: $template_id");

// Validar se emails_destinatarios é um array e tem pelo menos um email válido
$emails_validos = [];
if (is_array($emails_destinatarios)) {
    foreach ($emails_destinatarios as $email) {
        $email_clean = filter_var(trim($email), FILTER_VALIDATE_EMAIL);
        if ($email_clean) {
            $emails_validos[] = $email_clean;
        }
    }
}

if (!$cliente_id) {
    sendJsonResponse(false, 'ID do cliente não informado');
}

if (empty($emails_validos)) {
    sendJsonResponse(false, 'Nenhum email válido informado');
}

if (empty($assunto)) {
    sendJsonResponse(false, 'Assunto do email não informado');
}

if (empty($mensagem)) {
    sendJsonResponse(false, 'Mensagem do email não informada');
}

if (!$etapa_destino_id) {
    sendJsonResponse(false, 'ID da etapa de destino não informado');
}

// Incluir conexão
require_once 'conexao.php';

// Verificar se a conexão foi estabelecida
if (!$conn) {
    sendJsonResponse(false, 'Erro de conexão com o banco de dados');
}

// ============================================================================
// FUNÇÕES DE ASSINATURA DO enviar_email.php
// ============================================================================

// Função para carregar dados da assinatura
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 converter caminho relativo em URL absoluta
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 . '/' . $caminhoRelativo;
}

// Função para gerar assinatura HTML
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
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
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();
        
        // 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'] ?? ''
        ];
        
        // 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
    }
}

// Função para verificar configuração de assinatura do template
function verificarAssinaturaTemplate($conn, $templateId, $tenantId) {
    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) {
            $stmt = $conn->prepare("SELECT incluir_assinatura FROM templates_email WHERE id = ? AND tenant_id = ? AND ativo = 1");
        } else {
            $stmt = $conn->prepare("SELECT 1 as incluir_assinatura FROM templates_email WHERE id = ? AND tenant_id = ? AND ativo = 1");
        }
        
        $stmt->bind_param("ii", $templateId, $tenantId);
        $stmt->execute();
        $result = $stmt->get_result();
        
        if ($result->num_rows > 0) {
            $template = $result->fetch_assoc();
            return $template['incluir_assinatura'];
        } else {
            return false;
        }
        
        $stmt->close();
    } catch (Exception $e) {
        error_log("Erro ao verificar assinatura do template: " . $e->getMessage());
        return false;
    }
}

// ============================================================================
// ✅ NOVA FUNÇÃO: Enviar email COM SENDGRID (COPIADA DO enviar_email.php)
// ============================================================================

/**
 * ✅ FUNÇÃO ATUALIZADA: Enviar email COM SENDGRID
 * @param array $destinatarios Array de emails dos destinatários
 * @param string $assunto Assunto do email
 * @param string $mensagem Mensagem do email (HTML)
 * @param array $cliente Dados do cliente
 * @param array $etapa_destino Dados da etapa de destino
 * @param string $remetenteNome Nome do remetente
 * @param string $remetenteEmail Email do remetente (apenas para exibição, não para envio)
 * @return array Resultado do envio
 */
function enviarEmailSendGrid($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("📤 [AGENDAMENTO] 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("❌ [AGENDAMENTO] Erro cURL para $destinatario: $curl_error");
                continue;
            }
            
            if ($http_code === 202) {
                $enviados_com_sucesso++;
                error_log("✅ [AGENDAMENTO] SendGrid: Email enviado com sucesso para $destinatario - HTTP: $http_code");
                error_log("✅ [AGENDAMENTO] Remetente exibido: $nomeRemetenteVerificado");
                error_log("✅ [AGENDAMENTO] 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("❌ [AGENDAMENTO] SendGrid: $erro_msg");
                
                // Log detalhado para debug
                error_log("❌ [AGENDAMENTO] Debug - From Email: $emailRemetenteVerificado");
                error_log("❌ [AGENDAMENTO] Debug - From Name: $nomeRemetenteVerificado");
                error_log("❌ [AGENDAMENTO] 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("❌ [AGENDAMENTO] Exceção no SendGrid: " . $e->getMessage());
        return [
            'success' => false,
            'message' => 'Erro exception: ' . $e->getMessage()
        ];
    }
}

// ============================================================================
// PROCESSAMENTO PRINCIPAL (ATUALIZADO COM SENDGRID)
// ============================================================================

// Carregar dados da assinatura
$dadosAssinatura = carregarDadosAssinatura($conn, $tenant_id, $usuario_id);
$assinatura = $dadosAssinatura ? gerarAssinatura($dadosAssinatura) : '';

// Verificar se deve incluir assinatura baseado no template
$templateIncluirAssinatura = false;
if ($template_id > 0) {
    $templateIncluirAssinatura = verificarAssinaturaTemplate($conn, $template_id, $tenant_id);
}

// Determinar se deve incluir assinatura
$deveIncluirAssinatura = $incluir_assinatura || $templateIncluirAssinatura;

// Preparar mensagem final
$mensagemFinal = $mensagem;

// APLICAR SUBSTITUIÇÃO DE VARIÁVEIS NA MENSAGEM
$mensagemFinal = substituirVariaveisEmail($mensagemFinal, $cliente_id, $conn, $tenant_id);

// APLICAR ASSINATURA SE NECESSÁRIO
if ($deveIncluirAssinatura && !empty($assinatura)) {
    $mensagemFinal = aplicarAssinatura($mensagemFinal, $assinatura);
}

// APLICAR SUBSTITUIÇÃO DE VARIÁVEIS NO ASSUNTO
$assuntoFinal = substituirVariaveisEmail($assunto, $cliente_id, $conn, $tenant_id);

// Carregar dados do usuário para remetente
$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) {
    $dadosUsuario = $result->fetch_assoc();
    $remetenteNome = $dadosUsuario['usuario_nome'] . ' - ' . $dadosUsuario['tenant_nome'];
    $remetenteEmail = $dadosUsuario['usuario_email'];
} else {
    $remetenteNome = 'Sistema SON';
    $remetenteEmail = 'sistema@notificacaoson.tvitecnologia.com.br';
}
$stmt->close();

// Iniciar transação
$conn->begin_transaction();

try {
    // 1. Verificar se o cliente pertence ao tenant
    $stmt = $conn->prepare("SELECT c.*, e.nome as etapa_nome, f.nome as funil_nome 
                           FROM clientes c 
                           LEFT JOIN etapas_funis e ON c.etapa_funil_id = e.id 
                           LEFT JOIN funis f ON e.funil_id = f.id 
                           WHERE c.id = ? AND c.tenant_id = ?");
    $stmt->bind_param("ii", $cliente_id, $tenant_id);
    $stmt->execute();
    $result = $stmt->get_result();
    
    if ($result->num_rows === 0) {
        throw new Exception("Cliente não encontrado ou não pertence ao seu tenant");
    }
    
    $cliente = $result->fetch_assoc();
    
    // 2. Verificar se a etapa de destino pertence ao tenant
    $stmt = $conn->prepare("SELECT e.*, f.nome as funil_nome 
                           FROM etapas_funis e 
                           LEFT JOIN funis f ON e.funil_id = f.id 
                           WHERE e.id = ? AND f.tenant_id = ?");
    $stmt->bind_param("ii", $etapa_destino_id, $tenant_id);
    $stmt->execute();
    $result = $stmt->get_result();
    
    if ($result->num_rows === 0) {
        throw new Exception("Etapa de destino não encontrada");
    }
    
    $etapa_destino = $result->fetch_assoc();
    
    // 3. Registrar os agendamentos de email no banco de dados
    $agendamentos_ids = [];
    $emails_enviados = [];

    // Preparar statement para inserção de agendamentos
    $stmt_agendamento = $conn->prepare("INSERT INTO agendamentos_email 
                       (cliente_id, etapa_funil_id, usuario_id, tenant_id, 
                        email_destinatario, assunto, mensagem, status, data_agendamento) 
                       VALUES (?, ?, ?, ?, ?, ?, ?, 'agendado', NOW())");
    
    if (!$stmt_agendamento) {
        throw new Exception("Erro ao preparar inserção de agendamento: " . $conn->error);
    }

    foreach ($emails_validos as $email_destinatario) {
        // Inserir agendamento individual para cada email
        $stmt_agendamento->bind_param("iiiisss", $cliente_id, $etapa_destino_id, $usuario_id, $tenant_id, 
                                     $email_destinatario, $assuntoFinal, $mensagemFinal);
        
        if (!$stmt_agendamento->execute()) {
            throw new Exception("Erro ao inserir agendamento para $email_destinatario: " . $stmt_agendamento->error);
        }
        
        $agendamento_id = $conn->insert_id;
        $agendamentos_ids[] = $agendamento_id;
        
        // ✅ ATUALIZADO: Tentar enviar o email individual usando SENDGRID
        $resultadoEmail = enviarEmailSendGrid(
            [$email_destinatario], 
            $assuntoFinal, 
            $mensagemFinal, 
            $cliente, 
            $etapa_destino, 
            $remetenteNome, 
            $remetenteEmail
        );
        
        $email_enviado = $resultadoEmail['success'];
        $emails_enviados[$email_destinatario] = $email_enviado;
        
        // Atualizar status do agendamento individual
        $status_individual = $email_enviado ? 'enviado' : 'erro_envio';
        
        $stmt_update = $conn->prepare("UPDATE agendamentos_email SET status = ? WHERE id = ?");
        if (!$stmt_update) {
            throw new Exception("Erro ao preparar atualização: " . $conn->error);
        }
        
        $stmt_update->bind_param("si", $status_individual, $agendamento_id);
        
        if (!$stmt_update->execute()) {
            throw new Exception("Erro ao atualizar status: " . $stmt_update->error);
        }
    }

    // 4. Commit da transação
    $conn->commit();

    $total_enviados = count(array_filter($emails_enviados));
    $total_emails = count($emails_validos);

    $infoAssinatura = $deveIncluirAssinatura ? " com assinatura" : " sem assinatura";
    $mensagem_status = "Processamento concluído: $total_enviados de $total_emails emails enviados com sucesso{$infoAssinatura}";

    sendJsonResponse(true, $mensagem_status, [
        'agendamentos_ids' => $agendamentos_ids,
        'emails_enviados' => $emails_enviados,
        'total_enviados' => $total_enviados,
        'total_emails' => $total_emails,
        'incluiu_assinatura' => $deveIncluirAssinatura
    ]);
    
} catch (Exception $e) {
    // Rollback em caso de erro
    if ($conn) {
        $conn->rollback();
    }
    
    sendJsonResponse(false, 'Erro ao processar agendamento: ' . $e->getMessage());
} finally {
    // Fechar conexão
    if ($conn) {
        $conn->close();
    }
}
?>