<?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 (MANTIDAS 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;
    }
}

// ✅ FUNÇÃO ATUALIZADA: Adicionar wrapper HTML com alinhamento à esquerda
function adicionarWrapperHTML($conteudo) {
    return "
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset=\"UTF-8\">
        <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\">
                " . $conteudo . "
            </div>
        </div>
    </body>
    </html>";
}

// ============================================================================
// ✅ FUNÇÕES DE ENVIO DE EMAIL (COPIADAS DO ENVIAR_EMAIL.PHP)
// ============================================================================

/**
 * Função para enviar email usando PHPMailer + SMTP (SaaS)
 */
function enviarEmailPHPMailer($destinatario, $assunto, $mensagem, $nomeRemetente, $emailRemetenteReplyTo = null) {
    try {
        // Incluir arquivo de configurações SMTP externo
        require_once 'config_smtp.php';
        
        // Verificar se o PHPMailer está disponível
        $phpmailer_paths = [
            'PHPMailer/PHPMailer.php',
            'PHPMailer/src/PHPMailer.php',
            '../PHPMailer/PHPMailer.php',
            'vendor/phpmailer/phpmailer/src/PHPMailer.php'
        ];
        
        $phpmailer_file = null;
        $smtp_file = null;
        $exception_file = null;
        
        foreach ($phpmailer_paths as $path) {
            if (file_exists($path)) {
                $phpmailer_file = $path;
                $smtp_file = str_replace('PHPMailer.php', 'SMTP.php', $path);
                $exception_file = str_replace('PHPMailer.php', 'Exception.php', $path);
                break;
            }
        }
        
        if (!$phpmailer_file || !file_exists($phpmailer_file)) {
            return [
                'success' => false,
                'message' => 'PHPMailer não encontrado.'
            ];
        }
        
        // Incluir PHPMailer
        require_once $phpmailer_file;
        require_once $smtp_file;
        if (file_exists($exception_file)) {
            require_once $exception_file;
        }
        
        // Usar namespaces se disponível
        if (class_exists('PHPMailer\PHPMailer\PHPMailer')) {
            $mail = new PHPMailer\PHPMailer\PHPMailer(true);
            $mail->isSMTP();
            $mail->Host       = SMTP_HOST;
            $mail->SMTPAuth   = true;
            $mail->Username   = SMTP_USER;
            $mail->Password   = SMTP_PASS;
            $mail->SMTPSecure = PHPMailer\PHPMailer\PHPMailer::ENCRYPTION_STARTTLS;
            $mail->Port       = SMTP_PORT;
        } else {
            // Fallback para versão sem namespace
            $mail = new PHPMailer(true);
            $mail->isSMTP();
            $mail->Host       = SMTP_HOST;
            $mail->SMTPAuth   = true;
            $mail->Username   = SMTP_USER;
            $mail->Password   = SMTP_PASS;
            $mail->SMTPSecure = 'tls';
            $mail->Port       = SMTP_PORT;
        }
        
        $mail->CharSet    = 'UTF-8';
        $mail->SMTPDebug  = 0;
        
        // Remetente (usando e-mail do usuário se disponível)
        $emailRemetente = (!empty($emailRemetenteReplyTo) && filter_var($emailRemetenteReplyTo, FILTER_VALIDATE_EMAIL)) 
            ? $emailRemetenteReplyTo 
            : SMTP_USER;
            
        $mail->setFrom($emailRemetente, $nomeRemetente);
        
        // Reply-To personalizado (e-mail do usuário)
        if ($emailRemetenteReplyTo && filter_var($emailRemetenteReplyTo, FILTER_VALIDATE_EMAIL)) {
            $mail->addReplyTo($emailRemetenteReplyTo, $nomeRemetente);
        }
        
        // Destinatário
        $mail->addAddress($destinatario);
        
        // Conteúdo
        $mail->isHTML(true);
        $mail->Subject = $assunto;
        $mail->Body    = $mensagem;
        $mail->AltBody = strip_tags($mensagem);
        
        // Enviar
        if ($mail->send()) {
            return ['success' => true, 'message' => 'E-mail enviado com sucesso'];
        } else {
            return ['success' => false, 'message' => 'Erro ao enviar: ' . $mail->ErrorInfo];
        }
        
    } catch (Exception $e) {
        return ['success' => false, 'message' => 'Exception: ' . $e->getMessage()];
    }
}

/**
 * Função para enviar email usando mail() nativo (fallback)
 */
function enviarEmailNativo($destinatario, $assunto, $mensagem, $nomeRemetente, $emailRemetenteReplyTo = null) {
    // Usar e-mail do usuário como remetente se disponível
    $remetenteEmail = (!empty($emailRemetenteReplyTo) && filter_var($emailRemetenteReplyTo, FILTER_VALIDATE_EMAIL))
        ? $emailRemetenteReplyTo
        : 'notificacao@son.tvitecnologia.com.br';
        
    $headers = "From: $nomeRemetente <$remetenteEmail>\r\n";
    
    if ($emailRemetenteReplyTo && filter_var($emailRemetenteReplyTo, FILTER_VALIDATE_EMAIL)) {
        $headers .= "Reply-To: $emailRemetenteReplyTo\r\n";
    }
    
    $headers .= "Content-Type: text/html; charset=UTF-8\r\n";
    
    if (mail($destinatario, $assunto, $mensagem, $headers)) {
        return ['success' => true, 'message' => 'E-mail enviado com sucesso (mail())'];
    }
    
    return ['success' => false, 'message' => 'Falha no envio via mail()'];
}

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

// ============================================================================
// PROCESSAMENTO PRINCIPAL (ATUALIZADO COM SISTEMA DO ENVIAR_EMAIL.PHP)
// ============================================================================

// 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 = nl2br(htmlspecialchars($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 WRAPPER HTML COM ALINHAMENTO À ESQUERDA
$mensagemFinal = adicionarWrapperHTML($mensagemFinal);

// 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 o mesmo sistema do enviar_email.php
        $resultadoEmail = enviarEmail(
            $email_destinatario, 
            $assuntoFinal, 
            $mensagemFinal,
            $remetenteNome,
            $remetenteEmail
        );
        
        $email_enviado = $resultadoEmail['success'];
        $emails_enviados[$email_destinatario] = $email_enviado;
        
        // Log do envio
        if ($email_enviado) {
            error_log("✅ [AGENDAMENTO] Email enviado com sucesso para $email_destinatario");
        } else {
            error_log("❌ [AGENDAMENTO] Falha no envio para $email_destinatario: " . $resultadoEmail['message']);
        }
        
        // 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();
    }
}
?>