<?php
// includes/whatsapp-dynamic.php

class WhatsAppDynamic {
    private $whatsappHelper;
    private $db;
    
    public function __construct() {
        global $whatsappHelper, $db;
        $this->whatsappHelper = $whatsappHelper;
        $this->db = $db;
    }
    
    /**
     * Processa o conteúdo substituindo placeholders do WhatsApp
     */
    public function processContent($content) {
        try {
            // Verificar se o WhatsApp está ativo
            if (!$this->whatsappHelper || !$this->whatsappHelper->isActive()) {
                // Se inativo, remover todos os placeholders
                return $this->removePlaceholders($content);
            }
            
            // Processar diferentes tipos de placeholders
            $content = $this->processBasicPlaceholders($content);
            $content = $this->processAdvancedPlaceholders($content);
            $content = $this->processContainerPlaceholders($content);
            
            return $content;
        } catch (Exception $e) {
            logError("Erro no processamento de conteúdo WhatsApp: " . $e->getMessage());
            return $content; // Retornar conteúdo original em caso de erro
        }
    }
    
    /**
     * Remove todos os placeholders do WhatsApp
     */
    private function removePlaceholders($content) {
        $patterns = [
            '/\{whatsapp[^}]*\}/',
            '/\[whatsapp[^\]]*\]/',
            '/<div[^>]*class="[^"]*whatsapp-placeholder[^"]*"[^>]*>.*?<\/div>/s',
            '/<!--\s*WHATSAPP\s*-->.*?<!--\s*\/WHATSAPP\s*-->/s'
        ];
        
        foreach ($patterns as $pattern) {
            $content = preg_replace($pattern, '', $content);
        }
        
        return $content;
    }
    
    /**
     * Processa placeholders básicos
     */
    private function processBasicPlaceholders($content) {
        try {
            $settings = $this->whatsappHelper->getSettings();
            
            $replacements = [
                '{whatsapp}' => $this->whatsappHelper->generateWhatsAppHTML(),
                '{whatsapp_button}' => $this->whatsappHelper->generateButtonHTML(),
                '{whatsapp_url}' => $this->whatsappHelper->getUrlBySelection(),
                '{whatsapp_title}' => isset($settings['title']) ? $settings['title'] : '',
                '{whatsapp_text}' => isset($settings['button_text']) ? $settings['button_text'] : '',
                '[whatsapp]' => $this->whatsappHelper->generateWhatsAppHTML(),
                '[whatsapp_button]' => $this->whatsappHelper->generateButtonHTML()
            ];
            
            return str_replace(array_keys($replacements), array_values($replacements), $content);
        } catch (Exception $e) {
            logError("Erro no processamento de placeholders básicos: " . $e->getMessage());
            return $content;
        }
    }
    
    /**
     * Processa placeholders avançados com parâmetros
     */
    private function processAdvancedPlaceholders($content) {
        try {
            // Processar {whatsapp:param="value"}
            $content = preg_replace_callback('/\{whatsapp:([^}]+)\}/', [$this, 'replaceAdvancedPlaceholder'], $content);
            
            // Processar [whatsapp param="value"]
            $content = preg_replace_callback('/\[whatsapp\s+([^\]]+)\]/', [$this, 'replaceAdvancedPlaceholder'], $content);
            
            return $content;
        } catch (Exception $e) {
            logError("Erro no processamento de placeholders avançados: " . $e->getMessage());
            return $content;
        }
    }
    
    /**
     * Callback para placeholders avançados
     */
    private function replaceAdvancedPlaceholder($matches) {
        try {
            $params = $this->parseParameters($matches[1]);
            
            return $this->whatsappHelper->generateCustomHTML(
                $params['title'] ?? null,
                $params['text'] ?? null,
                $params['url'] ?? null,
                $params['url_select'] ?? null
            );
        } catch (Exception $e) {
            logError("Erro no callback de placeholder avançado: " . $e->getMessage());
            return $this->whatsappHelper->generateWhatsAppHTML();
        }
    }
    
    /**
     * Processa containers específicos do WhatsApp
     */
    private function processContainerPlaceholders($content) {
        try {
            // Processar containers com classe whatsapp-placeholder
            $content = preg_replace_callback(
                '/<div[^>]*class="[^"]*whatsapp-placeholder[^"]*"[^>]*>(.*?)<\/div>/s',
                [$this, 'replaceWhatsAppContainer'],
                $content
            );
            
            // Processar comentários HTML
            $content = preg_replace_callback(
                '/<!--\s*WHATSAPP\s*-->.*?<!--\s*\/WHATSAPP\s*-->/s',
                [$this, 'replaceWhatsAppContainer'],
                $content
            );
            
            return $content;
        } catch (Exception $e) {
            logError("Erro no processamento de containers: " . $e->getMessage());
            return $content;
        }
    }
    
    /**
     * Callback para substituir containers do WhatsApp
     */
    private function replaceWhatsAppContainer($matches) {
        try {
            // Tentar extrair parâmetros do HTML
            $html = $matches[0];
            $params = [];
            
            // Extrair data attributes
            if (preg_match_all('/data-whatsapp-(\w+)="([^"]*)"/', $html, $dataMatches)) {
                for ($i = 0; $i < count($dataMatches[1]); $i++) {
                    $params[$dataMatches[1][$i]] = $dataMatches[2][$i];
                }
            }
            
            // Extrair parâmetros de comentários
            if (preg_match('/<!--\s*WHATSAPP\s+([^-]*?)-->/', $html, $commentMatch)) {
                $commentParams = $this->parseParameters($commentMatch[1]);
                $params = array_merge($params, $commentParams);
            }
            
            return $this->whatsappHelper->generateCustomHTML(
                $params['title'] ?? null,
                $params['text'] ?? null,
                $params['url'] ?? null,
                $params['url_select'] ?? null
            );
        } catch (Exception $e) {
            logError("Erro ao processar container WhatsApp: " . $e->getMessage());
            return $this->whatsappHelper->generateWhatsAppHTML();
        }
    }
    
    /**
     * Parse parâmetros de string
     */
    private function parseParameters($paramString) {
        $params = [];
        
        try {
            // Parse formato key="value"
            if (preg_match_all('/(\w+)="([^"]*)"/', $paramString, $matches)) {
                for ($i = 0; $i < count($matches[1]); $i++) {
                    $params[$matches[1][$i]] = $matches[2][$i];
                }
            }
            
            // Parse formato key='value'
            if (preg_match_all('/(\w+)=\'([^\']*)\'/', $paramString, $matches)) {
                for ($i = 0; $i < count($matches[1]); $i++) {
                    $params[$matches[1][$i]] = $matches[2][$i];
                }
            }
            
            // Parse formato key=value (sem aspas)
            if (preg_match_all('/(\w+)=([^\s]+)/', $paramString, $matches)) {
                for ($i = 0; $i < count($matches[1]); $i++) {
                    if (!isset($params[$matches[1][$i]])) {
                        $params[$matches[1][$i]] = $matches[2][$i];
                    }
                }
            }
        } catch (Exception $e) {
            logError("Erro no parse de parâmetros: " . $e->getMessage());
        }
        
        return $params;
    }
    
    /**
     * Adiciona WhatsApp automaticamente baseado na posição
     */
    public function autoInsertWhatsApp($content) {
        try {
            if (!$this->whatsappHelper || !$this->whatsappHelper->isActive()) {
                return $content;
            }
            
            // Verificar se já tem WhatsApp no conteúdo
            if (strpos($content, 'whatsapp-cta-container') !== false) {
                return $content; // Já tem WhatsApp
            }
            
            // Inserir automaticamente
            return $this->whatsappHelper->insertWhatsAppInContent($content);
        } catch (Exception $e) {
            logError("Erro na inserção automática do WhatsApp: " . $e->getMessage());
            return $content;
        }
    }
    
    /**
     * Processa shortcodes do WhatsApp
     */
    public function processShortcodes($content) {
        try {
            if (!$this->whatsappHelper || !$this->whatsappHelper->isActive()) {
                return $this->removeShortcodes($content);
            }
            
            // Shortcode simples [whatsapp]
            $content = str_replace('[whatsapp]', $this->whatsappHelper->generateWhatsAppHTML(), $content);
            
            // Shortcode com parâmetros [whatsapp title="Custom Title"]
            $content = preg_replace_callback(
                '/\[whatsapp\s+([^\]]+)\]/',
                [$this, 'processShortcodeWithParams'],
                $content
            );
            
            return $content;
        } catch (Exception $e) {
            logError("Erro no processamento de shortcodes WhatsApp: " . $e->getMessage());
            return $content;
        }
    }
    
    /**
     * Remove shortcodes do WhatsApp
     */
    private function removeShortcodes($content) {
        return preg_replace('/\[whatsapp[^\]]*\]/', '', $content);
    }
    
    /**
     * Processa shortcode com parâmetros
     */
    private function processShortcodeWithParams($matches) {
        try {
            $params = $this->parseParameters($matches[1]);
            
            return $this->whatsappHelper->generateCustomHTML(
                $params['title'] ?? null,
                $params['text'] ?? null,
                $params['url'] ?? null,
                $params['url_select'] ?? null
            );
        } catch (Exception $e) {
            logError("Erro no processamento de shortcode com parâmetros: " . $e->getMessage());
            return $this->whatsappHelper->generateWhatsAppHTML();
        }
    }
    
    /**
     * Processa conteúdo para uma página específica
     */
    public function processPageContent($content, $pageId = null, $pageType = null) {
        try {
            // Processar todos os placeholders
            $content = $this->processContent($content);
            
            // Processar shortcodes
            $content = $this->processShortcodes($content);
            
            // Se não tem WhatsApp no conteúdo, inserir automaticamente
            if (strpos($content, 'whatsapp-cta-container') === false) {
                $content = $this->autoInsertWhatsApp($content);
            }
            
            // Registrar que a página foi processada
            if ($pageId) {
                $this->logPageProcessing($pageId, $pageType);
            }
            
            return $content;
        } catch (Exception $e) {
            logError("Erro no processamento de página WhatsApp: " . $e->getMessage());
            return $content;
        }
    }
    
    /**
     * Log do processamento da página
     */
    private function logPageProcessing($pageId, $pageType) {
        try {
            // Log simples sem fazer query adicional
            logInfo("WhatsApp processado para página ID: $pageId, Tipo: $pageType");
        } catch (Exception $e) {
            // Ignorar erros de log
        }
    }
    
    /**
     * Verifica se o conteúdo tem placeholders do WhatsApp
     */
    public function hasWhatsAppPlaceholders($content) {
        $patterns = [
            '/\{whatsapp[^}]*\}/',
            '/\[whatsapp[^\]]*\]/',
            '/<div[^>]*class="[^"]*whatsapp-placeholder[^"]*"/',
            '/<!--\s*WHATSAPP\s*-->/'
        ];
        
        foreach ($patterns as $pattern) {
            if (preg_match($pattern, $content)) {
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * Conta quantos elementos WhatsApp tem no conteúdo
     */
    public function countWhatsAppElements($content) {
        return substr_count($content, 'whatsapp-cta-container');
    }
    
    /**
     * Verifica se o sistema está funcionando corretamente
     */
    public function isWorking() {
        try {
            return ($this->whatsappHelper && $this->whatsappHelper->isActive());
        } catch (Exception $e) {
            return false;
        }
    }
    
    /**
     * Obtém estatísticas de uso
     */
    public function getUsageStats() {
        try {
            $stats = [
                'active' => $this->whatsappHelper ? $this->whatsappHelper->isActive() : false,
                'available_urls' => $this->whatsappHelper ? count($this->whatsappHelper->getAvailableUrls()) : 0,
                'last_updated' => null
            ];
            
            // Tentar obter data da última atualização
            if ($this->whatsappHelper) {
                $settings = $this->whatsappHelper->getSettings();
                if (isset($settings['updated_at'])) {
                    $stats['last_updated'] = $settings['updated_at'];
                }
            }
            
            return $stats;
        } catch (Exception $e) {
            logError("Erro ao obter estatísticas de uso: " . $e->getMessage());
            return [
                'active' => false,
                'available_urls' => 0,
                'last_updated' => null
            ];
        }
    }
    
    /**
     * Limpa cache do WhatsApp se necessário
     */
    public function clearCache() {
        try {
            // Implementar limpeza de cache se houver
            logInfo("Cache do WhatsApp limpo");
            return true;
        } catch (Exception $e) {
            logError("Erro ao limpar cache WhatsApp: " . $e->getMessage());
            return false;
        }
    }
    
    /**
     * Executa diagnóstico completo do sistema
     */
    public function runDiagnostic() {
        $results = [
            'helper_loaded' => false,
            'helper_active' => false,
            'db_connected' => false,
            'table_exists' => false,
            'settings_valid' => false,
            'urls_available' => 0,
            'errors' => []
        ];
        
        try {
            // Verificar se helper está carregado
            if ($this->whatsappHelper) {
                $results['helper_loaded'] = true;
                
                // Verificar se está ativo
                $results['helper_active'] = $this->whatsappHelper->isActive();
                
                // Verificar settings
                $settings = $this->whatsappHelper->getSettings();
                if (is_array($settings) && !empty($settings['title'])) {
                    $results['settings_valid'] = true;
                }
                
                // Contar URLs disponíveis
                $results['urls_available'] = count($this->whatsappHelper->getAvailableUrls());
            }
            
            // Verificar conexão com banco
            if ($this->db) {
                $this->db->query("SELECT 1");
                $this->db->execute();
                $results['db_connected'] = true;
                
                // Verificar se tabela existe
                $results['table_exists'] = $this->db->tableExists('whatsapp_settings');
            }
            
        } catch (Exception $e) {
            $results['errors'][] = $e->getMessage();
        }
        
        return $results;
    }
}

// Instanciar a classe globalmente se as dependências estiverem disponíveis
if (isset($whatsappHelper) && isset($db)) {
    try {
        $whatsappDynamic = new WhatsAppDynamic();
    } catch (Exception $e) {
        logError("Erro ao instanciar WhatsAppDynamic: " . $e->getMessage());
        
        // Criar um objeto mock para evitar erros
        $whatsappDynamic = new class {
            public function processContent($content) { return $content; }
            public function processPageContent($content, $pageId = null, $pageType = null) { return $content; }
            public function autoInsertWhatsApp($content) { return $content; }
            public function processShortcodes($content) { return $content; }
            public function hasWhatsAppPlaceholders($content) { return false; }
            public function countWhatsAppElements($content) { return 0; }
            public function isWorking() { return false; }
            public function getUsageStats() { return ['active' => false, 'available_urls' => 0, 'last_updated' => null]; }
            public function clearCache() { return false; }
            public function runDiagnostic() { return ['helper_loaded' => false, 'errors' => ['WhatsAppDynamic não pôde ser inicializado']]; }
        };
    }
} else {
    // Criar objeto mock se dependências não estiverem disponíveis
    $whatsappDynamic = new class {
        public function processContent($content) { return $content; }
        public function processPageContent($content, $pageId = null, $pageType = null) { return $content; }
        public function autoInsertWhatsApp($content) { return $content; }
        public function processShortcodes($content) { return $content; }
        public function hasWhatsAppPlaceholders($content) { return false; }
        public function countWhatsAppElements($content) { return 0; }
        public function isWorking() { return false; }
        public function getUsageStats() { return ['active' => false, 'available_urls' => 0, 'last_updated' => null]; }
        public function clearCache() { return false; }
        public function runDiagnostic() { return ['helper_loaded' => false, 'errors' => ['Dependências não disponíveis']]; }
    };
}