<?php
// includes/functions.php

/**
 * ============================================
 * FUNÇÕES DE REDIRECIONAMENTO E URL
 * ============================================
 */

function redirect($path) {
    header("Location: " . SITE_URL . "/" . ltrim($path, "/"));
    exit;
}

function getCurrentUrl() {
    return (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on' ? "https" : "http") . 
           "://$_SERVER[HTTP_HOST]$_SERVER[REQUEST_URI]";
}

/**
 * Busca página por slug individual
 */
function getPageBySlug($slug) {
    global $db;
    
    try {
        $db->query("SELECT * FROM pages WHERE slug = :slug AND published = 1");
        $db->bind(':slug', $slug);
        $page = $db->single();
        
        if ($page) {
            // Se não for landing, busca informações da landing pai
            if ($page['type'] !== 'landing' && !empty($page['landing_page_id'])) {
                $db->query("SELECT slug, title, id FROM pages WHERE id = :id AND type = 'landing' AND published = 1");
                $db->bind(':id', $page['landing_page_id']);
                $landing = $db->single();
                
                if ($landing) {
                    $page['landing_slug'] = $landing['slug'];
                    $page['landing_title'] = $landing['title'];
                }
            }
        }
        
        return $page;
        
    } catch (Exception $e) {
        logError("Erro ao buscar página por slug: " . $e->getMessage());
        return false;
    }
}

/**
 * Atualizada para funcionar com slugs individuais
 */
function getPageUrl($pageType, $landingId = null) {
    global $db;
    
    try {
        // Se for uma string (tipo de página) e tiver landingId
        if (is_string($pageType) && $landingId) {
            if ($pageType === 'landing') {
                $db->query("SELECT slug FROM pages WHERE id = :id AND type = 'landing' AND published = 1");
                $db->bind(':id', $landingId);
            } else {
                $db->query("SELECT slug FROM pages WHERE landing_page_id = :landing_page_id AND type = :type AND published = 1");
                $db->bind(':landing_page_id', $landingId);
                $db->bind(':type', $pageType);
            }
            $result = $db->single();
            
            if ($result) {
                return SITE_URL . '/' . $result['slug'];
            }
        }
        
        // Se for uma string (tipo de página) sem landingId - busca qualquer página
        if (is_string($pageType)) {
            $db->query("SELECT slug FROM pages WHERE type = :type AND published = 1 ORDER BY id ASC LIMIT 1");
            $db->bind(':type', $pageType);
            $result = $db->single();
            
            if ($result) {
                return SITE_URL . '/' . $result['slug'];
            }
        }
        
        // Se for um array (dados da página)
        if (is_array($pageType) && isset($pageType['slug'])) {
            return SITE_URL . '/' . $pageType['slug'];
        }
        
        // Se for um número (ID da página)
        if (is_numeric($pageType)) {
            $db->query("SELECT slug FROM pages WHERE id = :id AND published = 1");
            $db->bind(':id', $pageType);
            $result = $db->single();
            
            if ($result) {
                return SITE_URL . '/' . $result['slug'];
            }
        }
        
        return '#';
        
    } catch (Exception $e) {
        logError("Erro ao obter URL da página: " . $e->getMessage());
        return '#';
    }
}

/**
 * Converte URLs antigas para URLs amigáveis com slugs individuais
 */
function convertToFriendlyUrl($url) {
    global $db;
    
    try {
        // Verifica se é uma URL antiga com formato php?id=X
        if (preg_match('/^(landing|step1|step2|step3|registration)\.php\?id=(\d+)$/', $url, $matches)) {
            $pageType = $matches[1];
            $pageId = $matches[2];
            
            // Busca o slug da página no banco de dados
            $db->query("SELECT slug FROM pages WHERE id = :id AND published = 1");
            $db->bind(':id', $pageId);
            $result = $db->single();
            
            if ($result) {
                return SITE_URL . '/' . $result['slug'];
            }
        }
        
        // Verifica se é URL no formato /pages/tipo?landing=id
        if (preg_match('/\/pages\/(landing|step1|step2|step3|registration)\?landing=(\d+)/', $url, $matches)) {
            $pageType = $matches[1];
            $landingId = $matches[2];
            
            $slug = convertLegacyUrlToSlug($pageType, $landingId);
            if ($slug) {
                return SITE_URL . '/' . $slug;
            }
        }
        
        return $url;
        
    } catch (Exception $e) {
        logError("Erro ao converter URL para formato amigável: " . $e->getMessage());
        return $url;
    }
}

/**
 * ============================================
 * FUNÇÕES DE FUNIL/NAVEGAÇÃO
 * ============================================
 */

/**
 * Busca todas as páginas de um funil específico por landing ID
 */
function getFunnelPagesByLandingId($landingId) {
    global $db;
    
    try {
        $funnelPages = [];
        
        // Busca a landing
        $db->query("SELECT * FROM pages WHERE id = :id AND type = 'landing' AND published = 1");
        $db->bind(':id', $landingId);
        $landing = $db->single();
        
        if ($landing) {
            $funnelPages['landing'] = $landing;
            
            // Busca as demais páginas do funil
            $types = ['step1', 'step2', 'step3', 'registration'];
            foreach ($types as $type) {
                $db->query("SELECT * FROM pages WHERE landing_page_id = :landing_page_id AND type = :type AND published = 1");
                $db->bind(':landing_page_id', $landingId);
                $db->bind(':type', $type);
                $stepPage = $db->single();
                
                if ($stepPage) {
                    $funnelPages[$type] = $stepPage;
                }
            }
        }
        
        return $funnelPages;
        
    } catch (Exception $e) {
        logError("Erro ao buscar páginas do funil: " . $e->getMessage());
        return [];
    }
}

/**
 * Busca página específica de um funil por landing ID e tipo
 */
function getFunnelPageByType($landingId, $pageType) {
    global $db;
    
    try {
        if ($pageType === 'landing') {
            $db->query("SELECT * FROM pages WHERE id = :id AND type = 'landing' AND published = 1");
            $db->bind(':id', $landingId);
        } else {
            $db->query("SELECT * FROM pages WHERE landing_page_id = :landing_page_id AND type = :type AND published = 1");
            $db->bind(':landing_page_id', $landingId);
            $db->bind(':type', $pageType);
        }
        
        return $db->single();
        
    } catch (Exception $e) {
        logError("Erro ao buscar página do funil por tipo: " . $e->getMessage());
        return false;
    }
}

/**
 * Gera URLs para navegação do funil baseado no slug individual de cada página
 */
function generateFunnelNavigation($funnelPages, $currentType) {
    $sequence = ['landing', 'step1', 'step2', 'step3', 'registration'];
    $currentIndex = array_search($currentType, $sequence);
    
    $navigation = [
        'prev' => '#',
        'next' => '#',
        'current' => isset($funnelPages[$currentType]) ? '/' . $funnelPages[$currentType]['slug'] : '#'
    ];
    
    // URL da página anterior
    if ($currentIndex > 0) {
        $prevType = $sequence[$currentIndex - 1];
        if (isset($funnelPages[$prevType])) {
            $navigation['prev'] = '/' . $funnelPages[$prevType]['slug'];
        }
    }
    
    // URL da próxima página
    if ($currentIndex < count($sequence) - 1) {
        $nextType = $sequence[$currentIndex + 1];
        if (isset($funnelPages[$nextType])) {
            $navigation['next'] = '/' . $funnelPages[$nextType]['slug'];
        }
    }
    
    return $navigation;
}

/**
 * Gera breadcrumb para navegação do funil com slugs individuais
 */
function generateFunnelBreadcrumb($funnelPages, $currentType) {
    $steps = [
        'landing' => 'Página Inicial',
        'step1' => 'Etapa 1',
        'step2' => 'Etapa 2', 
        'step3' => 'Etapa 3',
        'registration' => 'Inscrição'
    ];
    
    $breadcrumb = [];
    $sequence = array_keys($steps);
    $currentIndex = array_search($currentType, $sequence);
    
    foreach ($steps as $type => $label) {
        $stepIndex = array_search($type, $sequence);
        $isActive = ($type === $currentType);
        $isVisited = ($stepIndex <= $currentIndex);
        
        $breadcrumb[] = [
            'label' => $label,
            'url' => isset($funnelPages[$type]) ? '/' . $funnelPages[$type]['slug'] : '#',
            'active' => $isActive,
            'visited' => $isVisited,
            'available' => isset($funnelPages[$type])
        ];
    }
    
    return $breadcrumb;
}

/**
 * Converte URL antiga para slug específico da página
 */
function convertLegacyUrlToSlug($pageType, $landingId) {
    global $db;
    
    try {
        if ($pageType === 'landing') {
            // Para landing, busca diretamente pelo ID
            $db->query("SELECT slug FROM pages WHERE id = :id AND type = 'landing' AND published = 1");
            $db->bind(':id', $landingId);
        } else {
            // Para outros tipos, busca pela landing_page_id e tipo
            $db->query("SELECT slug FROM pages WHERE landing_page_id = :landing_page_id AND type = :type AND published = 1");
            $db->bind(':landing_page_id', $landingId);
            $db->bind(':type', $pageType);
        }
        
        $page = $db->single();
        return $page ? $page['slug'] : false;
        
    } catch (Exception $e) {
        logError("Erro ao converter URL antiga para slug: " . $e->getMessage());
        return false;
    }
}

/**
 * Verifica se um slug é válido e retorna informações da página
 */
function validatePageSlug($slug) {
    return getPageBySlug($slug);
}

function getNextPageInFlow($currentType) {
    $flow = [
        'landing' => 'step1',
        'step1' => 'step2',
        'step2' => 'step3',
        'step3' => 'registration',
        'registration' => null
    ];
    
    return isset($flow[$currentType]) ? $flow[$currentType] : null;
}

function isValidPageType($type) {
    return in_array($type, ['landing', 'step1', 'step2', 'step3', 'registration']);
}

/**
 * ============================================
 * FUNÇÕES DE MENSAGENS E ALERTAS
 * ============================================
 */

function setAlert($message, $type = ALERT_INFO) {
    $_SESSION['alert'] = [
        'message' => $message,
        'type' => $type
    ];
}

function getAlert() {
    if (isset($_SESSION['alert'])) {
        $alert = $_SESSION['alert'];
        unset($_SESSION['alert']);
        return $alert;
    }
    return null;
}

/**
 * ============================================
 * FUNÇÕES DE SEGURANÇA
 * ============================================
 */

function sanitizeInput($data) {
    if (is_array($data)) {
        return array_map('sanitizeInput', $data);
    }
    return htmlspecialchars(trim($data), ENT_QUOTES, 'UTF-8');
}

function generateToken() {
    return bin2hex(random_bytes(32));
}

function validateToken($token) {
    return isset($_SESSION['token']) && hash_equals($_SESSION['token'], $token);
}

/**
 * ============================================
 * FUNÇÕES DE UPLOAD E MANIPULAÇÃO DE ARQUIVOS
 * ============================================
 */

function uploadImage($file, $directory) {
    try {
        if ($file['error'] !== UPLOAD_ERR_OK) {
            throw new Exception('Erro no upload do arquivo');
        }

        $fileInfo = pathinfo($file['name']);
        $extension = strtolower($fileInfo['extension']);

        if (!in_array($extension, ALLOWED_EXTENSIONS)) {
            throw new Exception('Tipo de arquivo não permitido');
        }

        if ($file['size'] > MAX_UPLOAD_SIZE) {
            throw new Exception('Arquivo muito grande');
        }

        $fileName = uniqid() . '.' . $extension;
        $uploadPath = UPLOAD_DIR . '/' . $directory . '/' . $fileName;

        if (!move_uploaded_file($file['tmp_name'], $uploadPath)) {
            throw new Exception('Falha ao mover arquivo');
        }

        return '/uploads/' . $directory . '/' . $fileName;
    } catch (Exception $e) {
        error_log("Erro no upload de imagem: " . $e->getMessage());
        throw $e;
    }
}

function deleteImage($path) {
    $fullPath = BASE_PATH . $path;
    if (file_exists($fullPath)) {
        unlink($fullPath);
    }
}

/**
 * ============================================
 * FUNÇÕES DE FORMATAÇÃO
 * ============================================
 */

function formatDate($date, $format = 'd/m/Y H:i') {
    return date($format, strtotime($date));
}

function generateSlug($text) {
    $text = strtolower($text);
    $text = preg_replace('/[^a-zA-Z0-9\s]/', '', $text);
    $text = preg_replace('/\s+/', '-', $text);
    return trim($text, '-');
}

function generateUniqueSlug($text, $table) {
    global $db;
    
    $slug = generateSlug($text);
    $originalSlug = $slug;
    $counter = 1;
    
    while (true) {
        $db->query("SELECT id FROM {$table} WHERE slug = :slug");
        $db->bind(':slug', $slug);
        if (!$db->single()) {
            break;
        }
        $slug = $originalSlug . '-' . $counter;
        $counter++;
    }
    
    return $slug;
}

function formatTimeAgo($datetime) {
    $timestamp = strtotime($datetime);
    $diff = time() - $timestamp;
    
    if ($diff < 60) {
        return "agora mesmo";
    } elseif ($diff < 3600) {
        $mins = round($diff / 60);
        return $mins . " min" . ($mins > 1 ? "s" : "") . " atrás";
    } elseif ($diff < 86400) {
        $hours = round($diff / 3600);
        return $hours . " hora" . ($hours > 1 ? "s" : "") . " atrás";
    } elseif ($diff < 2592000) {
        $days = round($diff / 86400);
        return $days . " dia" . ($days > 1 ? "s" : "") . " atrás";
    } else {
        return date("d/m/Y H:i", $timestamp);
    }
}

/**
 * ============================================
 * FUNÇÕES DE CACHE
 * ============================================
 */

function setCache($key, $data, $expiration = CACHE_TIME) {
    if (!defined('CACHE_ENABLED') || !CACHE_ENABLED) return false;
    
    $cacheFile = CACHE_DIR . '/' . md5($key) . '.cache';
    $cacheData = [
        'expiration' => time() + $expiration,
        'data' => $data
    ];
    
    return file_put_contents($cacheFile, serialize($cacheData));
}

function getCache($key) {
    if (!defined('CACHE_ENABLED') || !CACHE_ENABLED) return false;
    
    $cacheFile = CACHE_DIR . '/' . md5($key) . '.cache';
    
    if (!file_exists($cacheFile)) {
        return false;
    }
    
    $cacheData = unserialize(file_get_contents($cacheFile));
    
    if ($cacheData['expiration'] < time()) {
        unlink($cacheFile);
        return false;
    }
    
    return $cacheData['data'];
}

/**
 * ============================================
 * FUNÇÕES DE LOGGING E REDIRECIONAMENTO
 * ============================================
 */

function logInfo($message) {
    error_log("[INFO] " . date('Y-m-d H:i:s') . " - " . $message);
}

function logError($message) {
    error_log("[ERROR] " . date('Y-m-d H:i:s') . " - " . $message);
}

/**
 * Log de redirecionamentos para análise
 */
function logRedirect($oldUrl, $newUrl, $userAgent = '') {
    // Verifica se a tabela existe antes de tentar inserir
    if (!function_exists('tableExists')) {
        function tableExists($tableName) {
            global $db;
            try {
                $db->query("SELECT 1 FROM $tableName LIMIT 1");
                $db->execute();
                return true;
            } catch (Exception $e) {
                return false;
            }
        }
    }
    
    // Só tenta logar se a tabela existir
    if (tableExists('redirect_logs')) {
        global $db;
        try {
            $db->query("INSERT INTO redirect_logs (old_url, new_url, user_agent, created_at) 
                        VALUES (:old_url, :new_url, :user_agent, NOW())");
            $db->bind(':old_url', $oldUrl);
            $db->bind(':new_url', $newUrl);
            $db->bind(':user_agent', $userAgent);
            $db->execute();
        } catch (Exception $e) {
            // Não interrompe o fluxo se não conseguir logar
            error_log("Erro ao logar redirecionamento: " . $e->getMessage());
        }
    }
}

/**
 * Obtém estatísticas de redirecionamentos
 */
function getRedirectStats($days = 30) {
    global $db;
    
    try {
        // Redirecionamentos mais frequentes
        $db->query("SELECT old_url, new_url, COUNT(*) as count 
                    FROM redirect_logs 
                    WHERE created_at >= DATE_SUB(NOW(), INTERVAL :days DAY)
                    GROUP BY old_url, new_url 
                    ORDER BY count DESC 
                    LIMIT 10");
        $db->bind(':days', $days);
        $topRedirects = $db->resultSet();
        
        // Total de redirecionamentos
        $db->query("SELECT COUNT(*) as total 
                    FROM redirect_logs 
                    WHERE created_at >= DATE_SUB(NOW(), INTERVAL :days DAY)");
        $db->bind(':days', $days);
        $total = $db->single();
        
        return [
            'total_redirects' => $total['total'],
            'top_redirects' => $topRedirects,
            'period_days' => $days
        ];
        
    } catch (Exception $e) {
        logError("Erro ao obter estatísticas de redirecionamento: " . $e->getMessage());
        return [
            'total_redirects' => 0,
            'top_redirects' => [],
            'period_days' => $days
        ];
    }
}

/**
 * ============================================
 * FUNÇÕES DE VALIDAÇÃO DE FORMULÁRIO
 * ============================================
 */

function validateRequired($value, $fieldName) {
    if (empty(trim($value))) {
        throw new Exception("O campo {$fieldName} é obrigatório.");
    }
    return true;
}

function validateEmail($email) {
    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        throw new Exception("E-mail inválido.");
    }
    return true;
}

function validateLength($value, $min, $max, $fieldName) {
    $length = strlen(trim($value));
    if ($length < $min || $length > $max) {
        throw new Exception("O campo {$fieldName} deve ter entre {$min} e {$max} caracteres.");
    }
    return true;
}

/**
 * ============================================
 * FUNÇÕES DE UTILITÁRIOS E SISTEMA
 * ============================================
 */

/**
 * Gera mapa do site baseado nas páginas publicadas
 */
function generateSiteMap() {
    global $db;
    
    try {
        $db->query("SELECT slug, type, title, updated_at 
                    FROM pages 
                    WHERE published = 1 
                    ORDER BY type, title");
        $pages = $db->resultSet();
        
        $sitemap = [];
        foreach ($pages as $page) {
            $sitemap[] = [
                'url' => '/' . $page['slug'],
                'type' => $page['type'],
                'title' => $page['title'],
                'lastmod' => $page['updated_at']
            ];
        }
        
        return $sitemap;
        
    } catch (Exception $e) {
        logError("Erro ao gerar mapa do site: " . $e->getMessage());
        return [];
    }
}

/**
 * Verifica disponibilidade do sistema de cache
 */
function isCacheAvailable() {
    return defined('CACHE_ENABLED') && CACHE_ENABLED && defined('CACHE_DIR') && is_writable(CACHE_DIR);
}

/**
 * Limpa cache expirado
 */
function clearExpiredCache() {
    if (!isCacheAvailable()) return false;
    
    $cacheDir = CACHE_DIR;
    $files = glob($cacheDir . '/*.cache');
    $cleared = 0;
    
    foreach ($files as $file) {
        $cacheData = unserialize(file_get_contents($file));
        if ($cacheData['expiration'] < time()) {
            unlink($file);
            $cleared++;
        }
    }
    
    return $cleared;
}
// Carregar funções de anúncios (se o arquivo existir)
if (file_exists(BASE_PATH . '/includes/ads-functions.php')) {
    require_once BASE_PATH . '/includes/ads-functions.php';
}
/**
 * Obtém estatísticas gerais do sistema
 */
function getSystemStats() {
    global $db;
    
    try {
        // Total de páginas
        $db->query("SELECT COUNT(*) as total FROM pages WHERE published = 1");
        $totalPages = $db->single()['total'];
        
        // Páginas por tipo
        $db->query("SELECT type, COUNT(*) as count FROM pages WHERE published = 1 GROUP BY type");
        $pagesByType = $db->resultSet();
        
        // Visualizações hoje
        $db->query("SELECT COUNT(*) as today FROM page_views WHERE DATE(created_at) = CURDATE()");
        $viewsToday = $db->single()['today'];
        
        // Visualizações última semana
        $db->query("SELECT COUNT(*) as week FROM page_views WHERE created_at >= DATE_SUB(NOW(), INTERVAL 7 DAY)");
        $viewsWeek = $db->single()['week'];
        
        return [
            'total_pages' => $totalPages,
            'pages_by_type' => $pagesByType,
            'views_today' => $viewsToday,
            'views_week' => $viewsWeek,
            'cache_available' => isCacheAvailable()
        ];
        
    } catch (Exception $e) {
        logError("Erro ao obter estatísticas do sistema: " . $e->getMessage());
        return [
            'total_pages' => 0,
            'pages_by_type' => [],
            'views_today' => 0,
            'views_week' => 0,
            'cache_available' => false
        ];
    }
}
function trackPixelEvent($eventType, $value = 1, $additionalData = []) {
    global $pixelIntegraOn;
    
    if (areUtmParamsValid() && isset($pixelIntegraOn)) {
        return sendConversionEvent($eventType, $value, $additionalData);
    }
    
    return false;
}

// Função para obter dados do pixel para exibição
function getPixelSummary() {
    global $db;
    
    try {
        $db->query("SELECT 
            COUNT(*) as total_events,
            COUNT(DISTINCT visitor_ip) as unique_visitors,
            COUNT(DISTINCT utm_campaign) as active_campaigns
            FROM pixel_events 
            WHERE created_at >= DATE_SUB(NOW(), INTERVAL 30 DAY)");
        
        return $db->single() ?: [
            'total_events' => 0,
            'unique_visitors' => 0,
            'active_campaigns' => 0
        ];
    } catch (Exception $e) {
        return [
            'total_events' => 0,
            'unique_visitors' => 0,
            'active_campaigns' => 0
        ];
    }
}
?>