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

// 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");

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

// 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, $assunto, $mensagem);
        
        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;
        
        // Tentar enviar o email individual
        $email_enviado = enviarEmail([$email_destinatario], $assunto, $mensagem, $cliente, $etapa_destino);
        $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. Inserir atividade única para todos os emails (apenas se pelo menos um foi enviado)
    $emails_enviados_com_sucesso = array_filter($emails_enviados);
    if (!empty($emails_enviados_com_sucesso)) {
        $destinatarios_str = implode(', ', array_keys($emails_enviados_com_sucesso));
        $descricao_atividade = "Email enviado para: $destinatarios_str\nAssunto: $assunto\nMensagem: " . substr($mensagem, 0, 100) . "...";
        
$nome_atividade = "Email enviado para cliente";
$data_atividade = date('Y-m-d H:i:s'); // Data atual
$descricao_atividade = "Email enviado para: $destinatarios_str\nAssunto: $assunto";

$stmt_atividade = $conn->prepare("INSERT INTO atividades 
                           (cliente_id, usuario_id, tenant_id, nome, descricao, tipo,
                            data_agendada, concluida, data_conclusao) 
                           VALUES (?, ?, ?, ?, ?, 'email', ?, 0, NULL)");

$stmt_atividade->bind_param("iiisss", $cliente_id, $usuario_id, $tenant_id, 
                           $nome_atividade, $descricao_atividade, $data_atividade);
    }

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

    $total_enviados = count($emails_enviados_com_sucesso);
    $total_emails = count($emails_validos);

    $mensagem_status = "Processamento concluído: $total_enviados de $total_emails emails enviados com sucesso";

    sendJsonResponse(true, $mensagem_status, [
        'agendamentos_ids' => $agendamentos_ids,
        'emails_enviados' => $emails_enviados,
        'total_enviados' => $total_enviados,
        'total_emails' => $total_emails
    ]);
    
} 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();
    }
}

/**
 * Função para enviar email
 * @param array $destinatarios Array de emails dos destinatários
 * @param string $assunto Assunto do email
 * @param string $mensagem Mensagem do email
 * @param array $cliente Dados do cliente
 * @param array $etapa_destino Dados da etapa de destino
 * @return bool True se o email foi enviado com sucesso, False caso contrário
 */
function enviarEmail($destinatarios, $assunto, $mensagem, $cliente, $etapa_destino) {
    // Configurações do email
    $headers = [
        'From: ' . ($_SESSION['email_usuario'] ?? 'sistema@son.com'),
        'Reply-To: ' . ($_SESSION['email_usuario'] ?? 'sistema@son.com'),
        'Content-Type: text/plain; charset=UTF-8',
        'X-Mailer: PHP/' . phpversion()
    ];
    
    // Adicionar informações do sistema à mensagem
    $mensagem_completa = $mensagem . "\n\n";
    $mensagem_completa .= "---\n";
    $mensagem_completa .= "Sistema de Organização de Negócios\n";
    $mensagem_completa .= "Cliente: " . ($cliente['Nome_Cliente'] ?? $cliente['Nome'] ?? 'Cliente') . "\n";
    $mensagem_completa .= "Etapa: " . ($etapa_destino['nome'] ?? 'Nova etapa') . "\n";
    $mensagem_completa .= "Enviado por: " . ($_SESSION['nome_usuario'] ?? 'Sistema SON') . "\n";
    $mensagem_completa .= "Data: " . date('d/m/Y H:i');
    
    try {
        $enviados_com_sucesso = 0;
        
        // Enviar para cada destinatário
        foreach ($destinatarios as $destinatario) {
            // Tentar enviar o email usando a função mail do PHP
            $enviado = mail($destinatario, $assunto, $mensagem_completa, implode("\r\n", $headers));
            
            if ($enviado) {
                $enviados_com_sucesso++;
            } else {
                // Log do erro (em produção, use um sistema de logging adequado)
                error_log("Falha ao enviar email para: $destinatario - Assunto: $assunto");
            }
        }
        
        // Considerar sucesso se pelo menos um email foi enviado
        return $enviados_com_sucesso > 0;
        
    } catch (Exception $e) {
        error_log("Erro ao enviar email: " . $e->getMessage());
        return false;
    }
}
?>