<?php
// includes/page-flow-helpers.php
// Funções auxiliares para gerenciamento de fluxos de páginas

// Evita execução direta
if (!defined('BASE_PATH')) {
    die('Acesso negado.');
}

/**
 * Valida se um tipo de página é válido
 * @param string $type
 * @return bool
 */
if (!function_exists('isValidPageType')) {
    function isValidPageType($type) {
        $validTypes = ['landing', 'step1', 'step2', 'step3', 'registration'];
        return in_array($type, $validTypes, true);
    }
}

/**
 * Obtém o nome amigável do tipo de página
 * @param string $type
 * @return string
 */
if (!function_exists('getPageTypeName')) {
    function getPageTypeName($type) {
        $types = [
            'landing' => 'Página de Aterrisagem (PA)',
            'step1' => 'Primeira Etapa',
            'step2' => 'Segunda Etapa',
            'step3' => 'Terceira Etapa',
            'registration' => 'Página de Registro'
        ];
        
        return $types[$type] ?? 'Tipo Desconhecido';
    }
}

/**
 * Gera ícone para tipo de página
 * @param string $type
 * @return string
 */
if (!function_exists('getPageTypeIcon')) {
    function getPageTypeIcon($type) {
        $icons = [
            'landing' => 'fa-bullhorn',
            'step1' => 'fa-step-forward',
            'step2' => 'fa-step-forward', 
            'step3' => 'fa-step-forward',
            'registration' => 'fa-user-plus'
        ];
        
        return $icons[$type] ?? 'fa-file-alt';
    }
}

/**
 * Obtém a cor temática para tipo de página
 * @param string $type
 * @return string
 */
if (!function_exists('getPageTypeColor')) {
    function getPageTypeColor($type) {
        $colors = [
            'landing' => 'primary',
            'step1' => 'info',
            'step2' => 'warning',
            'step3' => 'danger',
            'registration' => 'success'
        ];
        
        return $colors[$type] ?? 'secondary';
    }
}

/**
 * Valida se uma posição de inserção é válida
 * @param string $position
 * @return bool
 */
if (!function_exists('isValidInsertPosition')) {
    function isValidInsertPosition($position) {
        $validPositions = [
            'after-first', 'after-second', 'after-third',
            'middle', 'before-last', 'end'
        ];
        
        return in_array($position, $validPositions, true) || is_numeric($position);
    }
}

/**
 * Obtém lista de posições disponíveis para inserção
 * @return array
 */
if (!function_exists('getAvailablePositions')) {
    function getAvailablePositions() {
        return [
            'after-first' => 'Após o 1º parágrafo',
            'after-second' => 'Após o 2º parágrafo',
            'after-third' => 'Após o 3º parágrafo',
            'middle' => 'No meio do conteúdo',
            'before-last' => 'Antes do último parágrafo',
            'end' => 'No final do conteúdo'
        ];
    }
}

/**
 * Calcula a posição numérica baseada na posição nomeada
 * @param string $position
 * @param int $totalParagraphs
 * @return int
 */
if (!function_exists('calculateInsertPosition')) {
    function calculateInsertPosition($position, $totalParagraphs) {
        switch ($position) {
            case 'after-first':
                return 0;
            case 'after-second':
                return min(1, $totalParagraphs - 1);
            case 'after-third':
                return min(2, $totalParagraphs - 1);
            case 'middle':
                return floor($totalParagraphs / 2);
            case 'before-last':
                return max(0, $totalParagraphs - 2);
            case 'end':
                return $totalParagraphs - 1;
            default:
                if (is_numeric($position)) {
                    return max(0, min(intval($position) - 1, $totalParagraphs - 1));
                }
                return $totalParagraphs - 1;
        }
    }
}

/**
 * Conta parágrafos em um conteúdo HTML
 * @param string $content
 * @return int
 */
if (!function_exists('countParagraphs')) {
    function countParagraphs($content) {
        $pattern = '/<p>(.*?)<\/p>/s';
        preg_match_all($pattern, $content, $matches);
        return count($matches[0]);
    }
}

/**
 * Extrai parágrafos de um conteúdo HTML
 * @param string $content
 * @return array
 */
if (!function_exists('extractParagraphs')) {
    function extractParagraphs($content) {
        $pattern = '/<p>(.*?)<\/p>/s';
        preg_match_all($pattern, $content, $matches);
        return $matches[0];
    }
}

/**
 * Remove elementos específicos do conteúdo
 * @param string $content
 * @param array $elements Elementos a remover (ex: ['whatsapp-cta-container', 'adsense-container'])
 * @return string
 */
if (!function_exists('removeContentElements')) {
    function removeContentElements($content, $elements = []) {
        if (empty($elements)) {
            $elements = ['whatsapp-cta-container', 'adsense-container'];
        }
        
        foreach ($elements as $element) {
            $pattern = '/<div class="' . preg_quote($element, '/') . '">.*?<\/div>/s';
            $content = preg_replace($pattern, '', $content);
        }
        
        return $content;
    }
}

/**
 * Gera HTML para botão WhatsApp
 * @param string $url
 * @param string $text
 * @return string
 */
if (!function_exists('generateWhatsAppButton')) {
    function generateWhatsAppButton($url, $text = 'Entre no nosso grupo do WhatsApp') {
        return sprintf(
            '<div class="whatsapp-cta-container">
                <h3 class="whatsapp-title">¿Quieres recibir contenido exclusivo y conectar con otros estudiantes?</h3>
                <a href="%s" class="whatsapp-cta-button" target="_blank">
                    <i class="fab fa-whatsapp"></i> %s
                </a>
            </div>',
            htmlspecialchars($url),
            htmlspecialchars($text)
        );
    }
}

/**
 * Gera HTML para container AdSense
 * @param string $code
 * @return string
 */
if (!function_exists('generateAdSenseContainer')) {
    function generateAdSenseContainer($code) {
        return sprintf(
            '<div class="adsense-container">%s</div>',
            $code
        );
    }
}

/**
 * Valida URL do WhatsApp
 * @param string $url
 * @return bool
 */
if (!function_exists('isValidWhatsAppUrl')) {
    function isValidWhatsAppUrl($url) {
        return filter_var($url, FILTER_VALIDATE_URL) && 
               (strpos($url, 'chat.whatsapp.com') !== false || 
                strpos($url, 'wa.me') !== false ||
                strpos($url, 'api.whatsapp.com') !== false);
    }
}

/**
 * Gera slug único baseado no título
 * @param string $title
 * @param object $db Objeto de database
 * @param int $excludeId ID para excluir da verificação
 * @return string
 */
if (!function_exists('generateUniqueSlug')) {
    function generateUniqueSlug($title, $db = null, $excludeId = null) {
        // Converte título para slug básico
        $slug = strtolower(trim($title));
        $slug = preg_replace('/[^a-z0-9-]/', '-', $slug);
        $slug = preg_replace('/-+/', '-', $slug);
        $slug = trim($slug, '-');
        
        // Se não temos conexão de DB, retorna slug básico
        if (!$db) {
            return $slug;
        }
        
        // Verifica se slug já existe
        $baseSlug = $slug;
        $counter = 1;
        
        while (true) {
            $sql = "SELECT COUNT(*) as count FROM pages WHERE slug = :slug";
            $params = [':slug' => $slug];
            
            if ($excludeId) {
                $sql .= " AND id != :exclude_id";
                $params[':exclude_id'] = $excludeId;
            }
            
            $db->query($sql);
            foreach ($params as $key => $value) {
                $db->bind($key, $value);
            }
            
            $result = $db->single();
            
            if ($result['count'] == 0) {
                break;
            }
            
            $slug = $baseSlug . '-' . $counter;
            $counter++;
        }
        
        return $slug;
    }
}

/**
 * Formata tempo em formato legível
 * @param int $seconds
 * @return string
 */
if (!function_exists('formatTime')) {
    function formatTime($seconds) {
        if ($seconds < 60) {
            return $seconds . 's';
        } elseif ($seconds < 3600) {
            return floor($seconds / 60) . 'm ' . ($seconds % 60) . 's';
        } else {
            $hours = floor($seconds / 3600);
            $minutes = floor(($seconds % 3600) / 60);
            return $hours . 'h ' . $minutes . 'm';
        }
    }
}

/**
 * Calcula taxa de conversão
 * @param int $conversions
 * @param int $total
 * @return float
 */
if (!function_exists('calculateConversionRate')) {
    function calculateConversionRate($conversions, $total) {
        if ($total == 0) {
            return 0.0;
        }
        return round(($conversions / $total) * 100, 2);
    }
}

/**
 * Formata número para exibição
 * @param mixed $number
 * @param int $decimals
 * @return string
 */
if (!function_exists('formatNumber')) {
    function formatNumber($number, $decimals = 0) {
        return number_format((float)$number, $decimals, ',', '.');
    }
}

/**
 * Gera código de cores de status
 * @param string $status
 * @return string
 */
if (!function_exists('getStatusColor')) {
    function getStatusColor($status) {
        $colors = [
            'published' => 'success',
            'draft' => 'warning',
            'inactive' => 'secondary',
            'error' => 'danger'
        ];
        
        return $colors[$status] ?? 'secondary';
    }
}

/**
 * Verifica se página pode ser acessada em sequência
 * @param string $currentType
 * @param string $requestedType
 * @param array $completedSteps
 * @return bool
 */
if (!function_exists('canAccessStep')) {
    function canAccessStep($currentType, $requestedType, $completedSteps = []) {
        $stepOrder = ['landing', 'step1', 'step2', 'step3', 'registration'];
        
        $currentIndex = array_search($currentType, $stepOrder);
        $requestedIndex = array_search($requestedType, $stepOrder);
        
        // Se não encontrou os tipos, permite acesso
        if ($currentIndex === false || $requestedIndex === false) {
            return true;
        }
        
        // Permite voltar para etapas anteriores
        if ($requestedIndex <= $currentIndex) {
            return true;
        }
        
        // Para ir para próxima etapa, deve ter completado a atual
        return $requestedIndex <= $currentIndex + 1;
    }
}

/**
 * Gera breadcrumb do fluxo
 * @param array $flow
 * @param int $currentPageId
 * @return string
 */
if (!function_exists('generateFlowBreadcrumb')) {
    function generateFlowBreadcrumb($flow, $currentPageId) {
        if (empty($flow)) {
            return '';
        }
        
        $breadcrumb = '<nav aria-label="breadcrumb"><ol class="breadcrumb">';
        
        foreach ($flow as $index => $page) {
            $isActive = $page['id'] == $currentPageId;
            $class = $isActive ? 'breadcrumb-item active' : 'breadcrumb-item';
            
            $breadcrumb .= '<li class="' . $class . '">';
            
            if (!$isActive && $page['published']) {
                $breadcrumb .= '<a href="/pages/' . htmlspecialchars($page['slug']) . '">';
            }
            
            $breadcrumb .= htmlspecialchars($page['title']);
            
            if (!$isActive && $page['published']) {
                $breadcrumb .= '</a>';
            }
            
            $breadcrumb .= '</li>';
        }
        
        $breadcrumb .= '</ol></nav>';
        
        return $breadcrumb;
    }
}

/**
 * Obtém próxima etapa no fluxo
 * @param string $currentType
 * @return string|null
 */
if (!function_exists('getNextStepType')) {
    function getNextStepType($currentType) {
        $steps = [
            'landing' => 'step1',
            'step1' => 'step2',
            'step2' => 'step3',
            'step3' => 'registration',
            'registration' => null
        ];
        
        return $steps[$currentType] ?? null;
    }
}

/**
 * Obtém etapa anterior no fluxo
 * @param string $currentType
 * @return string|null
 */
if (!function_exists('getPreviousStepType')) {
    function getPreviousStepType($currentType) {
        $steps = [
            'step1' => 'landing',
            'step2' => 'step1',
            'step3' => 'step2',
            'registration' => 'step3'
        ];
        
        return $steps[$currentType] ?? null;
    }
}

/**
 * Valida estrutura de fluxo
 * @param array $pages
 * @return array Lista de problemas
 */
if (!function_exists('validateFlowStructure')) {
    function validateFlowStructure($pages) {
        $issues = [];
        $types = array_column($pages, 'type');
        
        // Verifica se tem landing page
        if (!in_array('landing', $types)) {
            $issues[] = 'Fluxo deve ter uma Landing Page';
        }
        
        // Verifica sequência lógica
        $expectedSequence = ['landing', 'step1', 'step2', 'step3', 'registration'];
        foreach ($expectedSequence as $expectedType) {
            if (!in_array($expectedType, $types)) {
                $issues[] = 'Falta etapa: ' . getPageTypeName($expectedType);
            }
        }
        
        // Verifica duplicatas
        $typeCounts = array_count_values($types);
        foreach ($typeCounts as $type => $count) {
            if ($count > 1) {
                $issues[] = 'Múltiplas páginas do tipo: ' . getPageTypeName($type);
            }
        }
        
        return $issues;
    }
}

/**
 * Cache simples para operações de fluxo
 * @param string $key
 * @param mixed $data
 * @param int $expiry
 * @return mixed
 */
if (!function_exists('flowCache')) {
    function flowCache($key, $data = null, $expiry = 3600) {
        static $cache = [];
        
        // Se não tem CACHE_ENABLED, não faz cache
        if (!defined('CACHE_ENABLED') || !CACHE_ENABLED) {
            return $data;
        }
        
        $cacheKey = 'flow_' . md5($key);
        
        // Se está salvando
        if ($data !== null) {
            $cache[$cacheKey] = [
                'data' => $data,
                'expires' => time() + $expiry
            ];
            return $data;
        }
        
        // Se está lendo
        if (isset($cache[$cacheKey])) {
            if (time() < $cache[$cacheKey]['expires']) {
                return $cache[$cacheKey]['data'];
            } else {
                unset($cache[$cacheKey]);
            }
        }
        
        return null;
    }
}

/**
 * Log específico para operações de fluxo
 * @param string $message
 * @param string $level
 */
if (!function_exists('flowLog')) {
    function flowLog($message, $level = 'info') {
        $timestamp = date('Y-m-d H:i:s');
        $logMessage = "[$timestamp] [FLOW:$level] $message\n";
        
        // Tenta usar função de log existente
        if (function_exists('logInfo') && $level === 'info') {
            logInfo("[FLOW] $message");
        } elseif (function_exists('logError') && $level === 'error') {
            logError("[FLOW] $message");
        } else {
            // Log de fallback
            $logFile = defined('BASE_PATH') ? BASE_PATH . '/logs/flow.log' : 'flow.log';
            @file_put_contents($logFile, $logMessage, FILE_APPEND | LOCK_EX);
        }
    }
}

/**
 * Debug helper para desenvolvimento
 * @param mixed $data
 * @param string $label
 */
if (!function_exists('flowDebug')) {
    function flowDebug($data, $label = 'Debug') {
        if (!defined('ENVIRONMENT') || ENVIRONMENT !== 'development') {
            return;
        }
        
        $output = "\n=== FLOW DEBUG: $label ===\n";
        $output .= print_r($data, true);
        $output .= "\n=========================\n";
        
        error_log($output);
    }
}
?>