<?php
// Desabilitar display de erros para não quebrar o JSON
ini_set('display_errors', 0);
error_reporting(E_ALL);

// Definir timezone
date_default_timezone_set('America/Sao_Paulo');

// Função de log de emergência (sempre funciona)
function emergencyLog($message) {
    $logDir = dirname(dirname(__FILE__)) . '/logs';
    if (!is_dir($logDir)) {
        @mkdir($logDir, 0755, true);
    }
    
    $logFile = $logDir . '/newsletter_emergency.log';
    $timestamp = date('Y-m-d H:i:s');
    $logMessage = "[$timestamp] $message" . PHP_EOL;
    @file_put_contents($logFile, $logMessage, FILE_APPEND | LOCK_EX);
}

// Log de início
emergencyLog("=== INÍCIO DO PROCESSAMENTO ===");

// Capturar qualquer erro fatal
register_shutdown_function(function() {
    $error = error_get_last();
    if ($error && in_array($error['type'], [E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR])) {
        emergencyLog("ERRO FATAL: " . $error['message'] . " em " . $error['file'] . ":" . $error['line']);
        
        if (!headers_sent()) {
            header('Content-Type: application/json');
            echo json_encode([
                'success' => false,
                'message' => 'Erro interno do servidor',
                'debug' => 'Erro fatal capturado: ' . $error['message']
            ]);
        }
    }
});

// Define BASE_PATH de forma mais robusta
if (!defined('BASE_PATH')) {
    $possiblePaths = [
        dirname(dirname(__FILE__)),
        dirname(dirname(dirname(__FILE__))),
        realpath(dirname(__FILE__) . '/../'),
        $_SERVER['DOCUMENT_ROOT']
    ];
    
    foreach ($possiblePaths as $path) {
        if (file_exists($path . '/includes/config.php')) {
            define('BASE_PATH', $path);
            break;
        }
    }
    
    if (!defined('BASE_PATH')) {
        emergencyLog("ERRO: BASE_PATH não pôde ser definido");
        header('Content-Type: application/json');
        echo json_encode(['success' => false, 'message' => 'Configuração inválida']);
        exit;
    }
}

emergencyLog("BASE_PATH definido como: " . BASE_PATH);

// Lista de arquivos necessários
$requiredFiles = [
    'includes/config.php',
    'includes/db.php',
    'includes/functions.php'
];

// Verificar e incluir arquivos
foreach ($requiredFiles as $file) {
    $fullPath = BASE_PATH . '/' . $file;
    emergencyLog("Verificando arquivo: $fullPath");
    
    if (!file_exists($fullPath)) {
        emergencyLog("ERRO: Arquivo não encontrado: $fullPath");
        header('Content-Type: application/json');
        echo json_encode([
            'success' => false, 
            'message' => 'Arquivo de configuração não encontrado: ' . $file
        ]);
        exit;
    }
    
    try {
        require_once $fullPath;
        emergencyLog("Arquivo incluído com sucesso: $file");
    } catch (Throwable $e) {
        emergencyLog("ERRO ao incluir $file: " . $e->getMessage());
        header('Content-Type: application/json');
        echo json_encode([
            'success' => false, 
            'message' => 'Erro ao carregar configurações: ' . $file,
            'debug' => $e->getMessage()
        ]);
        exit;
    }
}

// Verificar se a classe Database foi carregada
if (!class_exists('Database')) {
    emergencyLog("ERRO: Classe Database não encontrada");
    header('Content-Type: application/json');
    echo json_encode(['success' => false, 'message' => 'Classe Database não encontrada']);
    exit;
}

// Verificar se $db foi instanciado
if (!isset($db) || !is_object($db)) {
    emergencyLog("ERRO: Objeto \$db não foi instanciado");
    header('Content-Type: application/json');
    echo json_encode(['success' => false, 'message' => 'Conexão com banco não estabelecida']);
    exit;
}

emergencyLog("Conexão com banco verificada");

// Verificar se a tabela existe
try {
    $tableCheck = $db->query("SHOW TABLES LIKE 'newsletter_subscribers'");
    $db->execute();
    $tableExists = $db->single();
    
    if (!$tableExists) {
        emergencyLog("ERRO: Tabela newsletter_subscribers não existe");
        header('Content-Type: application/json');
        echo json_encode(['success' => false, 'message' => 'Tabela newsletter_subscribers não encontrada']);
        exit;
    }
    
    emergencyLog("Tabela newsletter_subscribers verificada");
} catch (Exception $e) {
    emergencyLog("ERRO ao verificar tabela: " . $e->getMessage());
    header('Content-Type: application/json');
    echo json_encode(['success' => false, 'message' => 'Erro ao verificar banco de dados']);
    exit;
}

// Configurar headers de resposta
if (!headers_sent()) {
    header('Content-Type: application/json; charset=utf-8');
    header('Cache-Control: no-cache, must-revalidate');
}

// Função para resposta JSON limpa
function jsonResponse($success, $message, $data = null) {
    $response = [
        'success' => $success,
        'message' => $message,
        'timestamp' => date('Y-m-d H:i:s')
    ];
    
    if ($data !== null) {
        $response['data'] = $data;
    }
    
    emergencyLog("Resposta JSON: " . json_encode($response));
    
    // Limpar qualquer output anterior
    if (ob_get_level()) {
        ob_clean();
    }
    
    echo json_encode($response, JSON_UNESCAPED_UNICODE);
    exit;
}

// Verificar método HTTP
if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
    emergencyLog("Método inválido: " . $_SERVER['REQUEST_METHOD']);
    jsonResponse(false, 'Método não permitido');
}

emergencyLog("Método POST confirmado");

// Obter dados do POST
$rawInput = file_get_contents('php://input');
emergencyLog("Input bruto recebido: " . substr($rawInput, 0, 500));

$data = null;
if (!empty($rawInput)) {
    $data = json_decode($rawInput, true);
    if (json_last_error() === JSON_ERROR_NONE) {
        emergencyLog("JSON decodificado com sucesso");
    } else {
        emergencyLog("Erro ao decodificar JSON: " . json_last_error_msg());
        $data = null;
    }
}

// Fallback para $_POST
if (!$data && !empty($_POST)) {
    $data = $_POST;
    emergencyLog("Usando dados do \$_POST");
}

// Verificar se temos dados
if (empty($data)) {
    emergencyLog("Nenhum dado recebido");
    jsonResponse(false, 'Nenhum dado foi recebido');
}

emergencyLog("Dados recebidos: " . json_encode($data, JSON_UNESCAPED_UNICODE));

// Extrair e validar campos
$email = isset($data['email']) ? trim(strtolower($data['email'])) : '';
$name = isset($data['name']) ? trim($data['name']) : '';
$source = isset($data['source']) ? trim($data['source']) : 'footer_form';

emergencyLog("Email: '$email', Name: '$name', Source: '$source'");

// Validações
if (empty($email)) {
    emergencyLog("Email está vazio");
    jsonResponse(false, 'O email é obrigatório');
}

if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
    emergencyLog("Email inválido: $email");
    jsonResponse(false, 'Por favor, insira um email válido');
}

// Processar inscrição
try {
    emergencyLog("Iniciando processo de inscrição...");
    
    // Verificar se email já existe
    $db->query("SELECT id, status FROM newsletter_subscribers WHERE email = :email");
    $db->bind(':email', $email);
    $existing = $db->single();
    
    emergencyLog("Verificação de email existente: " . ($existing ? json_encode($existing) : 'não encontrado'));
    
    if ($existing) {
        if ($existing['status'] === 'active') {
            emergencyLog("Email já ativo: $email");
            jsonResponse(false, '¡Este email ya está suscrito a nuestro boletín!');
        } else if ($existing['status'] === 'unsubscribed') {
            emergencyLog("Reativando email: $email");
            
            // Reativar inscrição
            $db->query("UPDATE newsletter_subscribers SET 
                       status = 'active',
                       subscription_date = NOW(),
                       updated_at = NOW()
                       WHERE email = :email");
            $db->bind(':email', $email);
            $success = $db->execute();
            
            emergencyLog("Resultado da reativação: " . ($success ? 'sucesso' : 'falha'));
            
            if ($success) {
                jsonResponse(true, '¡Bienvenido de vuelta! Tu suscripción ha sido reactivada.');
            } else {
                jsonResponse(false, 'Error al reactivar la suscripción');
            }
        } else {
            // Status diferente - ativar
            emergencyLog("Ativando email com status: " . $existing['status']);
            
            $db->query("UPDATE newsletter_subscribers SET 
                       status = 'active',
                       subscription_date = NOW(),
                       updated_at = NOW()
                       WHERE email = :email");
            $db->bind(':email', $email);
            $success = $db->execute();
            
            if ($success) {
                jsonResponse(true, '¡Tu suscripción ha sido activada!');
            } else {
                jsonResponse(false, 'Error al activar la suscripción');
            }
        }
    }
    
    emergencyLog("Criando nova inscrição...");
    
    // Gerar tokens seguros
    $verificationToken = bin2hex(random_bytes(32));
    $unsubscribeToken = bin2hex(random_bytes(32));
    
    // Dados do cliente
    $ipAddress = $_SERVER['REMOTE_ADDR'] ?? '';
    $userAgent = substr($_SERVER['HTTP_USER_AGENT'] ?? '', 0, 500); // Limitar tamanho
    
    emergencyLog("Tokens gerados, inserindo no banco...");
    
    // Inserir nova inscrição
    $db->query("INSERT INTO newsletter_subscribers 
               (email, name, status, source, ip_address, user_agent, 
                verification_token, unsubscribe_token, verified, verification_sent_at, subscription_date)
               VALUES 
               (:email, :name, 'active', :source, :ip_address, :user_agent, 
                :verification_token, :unsubscribe_token, 1, NOW(), NOW())");
    
    $db->bind(':email', $email);
    $db->bind(':name', $name);
    $db->bind(':source', $source);
    $db->bind(':ip_address', $ipAddress);
    $db->bind(':user_agent', $userAgent);
    $db->bind(':verification_token', $verificationToken);
    $db->bind(':unsubscribe_token', $unsubscribeToken);
    
    $success = $db->execute();
    
    emergencyLog("Resultado da inserção: " . ($success ? 'sucesso' : 'falha'));
    
    if (!$success) {
        $error = method_exists($db, 'getError') ? $db->getError() : 'Erro desconhecido';
        emergencyLog("Erro na inserção: $error");
        jsonResponse(false, 'Error interno del servidor al guardar');
    }
    
    $subscriberId = $db->lastInsertId();
    emergencyLog("ID do novo inscrito: $subscriberId");
    
    // Log de sucesso
    if (function_exists('logInfo')) {
        logInfo("Nova inscrição no newsletter: $email (ID: $subscriberId)");
    }
    
    emergencyLog("Inscrição concluída com sucesso");
    
    jsonResponse(true, '¡Gracias por suscribirte! Recibirás contenido exclusivo en tu email.', [
        'subscriber_id' => $subscriberId,
        'email' => $email
    ]);
    
} catch (Exception $e) {
    emergencyLog("Exceção capturada: " . $e->getMessage());
    emergencyLog("Arquivo: " . $e->getFile() . ", Linha: " . $e->getLine());
    emergencyLog("Stack trace: " . $e->getTraceAsString());
    
    if (function_exists('logError')) {
        logError("Erro na inscrição do newsletter: " . $e->getMessage());
    }
    
    jsonResponse(false, 'Error interno del servidor. Por favor, intenta nuevamente.');
} catch (Throwable $e) {
    emergencyLog("Erro fatal capturado: " . $e->getMessage());
    emergencyLog("Arquivo: " . $e->getFile() . ", Linha: " . $e->getLine());
    
    jsonResponse(false, 'Error crítico del servidor.');
}

emergencyLog("=== FIM DO PROCESSAMENTO ===");
?>