<?php
// includes/unique-visits-tracker.php - VERSÃO CORRIGIDA

class UniqueVisitsTracker {
    private $db;
    private $debug = false; // Ative para debug
    
    public function __construct() {
        global $db;
        $this->db = $db;
        
        // Ativa debug se parâmetro estiver presente
        $this->debug = isset($_GET['debug_visits']) && $_GET['debug_visits'] == '1';
    }
    
    /**
     * Gera um hash único e CONSISTENTE para identificar o visitante
     */
    private function generateVisitorHash() {
        $ip = $_SERVER['REMOTE_ADDR'] ?? '';
        $userAgent = $_SERVER['HTTP_USER_AGENT'] ?? '';
        
        // Remove partes que podem variar do user agent
        $userAgent = preg_replace('/;\s*[^;)]+\)/', ')', $userAgent); // Remove versões específicas
        
        // Combina informações estáveis para criar hash único
        $visitorData = $ip . '|' . $userAgent;
        
        // Usa sha256 para hash consistente
        $hash = hash('sha256', $visitorData);
        
        if ($this->debug) {
            error_log("DEBUG: Visitor hash gerado: $hash para IP: $ip");
        }
        
        return $hash;
    }
    
    /**
     * Captura parâmetros UTM da URL ou sessão
     */
    private function getUtmParams() {
        $utmParams = [
            'utm_source' => $_GET['utm_source'] ?? $_SESSION['utm_source'] ?? null,
            'utm_medium' => $_GET['utm_medium'] ?? $_SESSION['utm_medium'] ?? null,
            'utm_campaign' => $_GET['utm_campaign'] ?? $_SESSION['utm_campaign'] ?? null,
            'utm_term' => $_GET['utm_term'] ?? $_SESSION['utm_term'] ?? null,
            'utm_content' => $_GET['utm_content'] ?? $_SESSION['utm_content'] ?? null,
            'gclid' => $_GET['gclid'] ?? $_SESSION['gclid'] ?? null,
            'fbclid' => $_GET['fbclid'] ?? $_SESSION['fbclid'] ?? null,
        ];
        
        // Salva UTMs na sessão para persistir durante a navegação
        foreach ($utmParams as $key => $value) {
            if ($value && !isset($_SESSION[$key])) {
                $_SESSION[$key] = $value;
            }
        }
        
        return $utmParams;
    }
    
    /**
     * Detecta ou cria registro da página na tabela pages_visitor
     */
    private function getOrCreatePageVisitor($pageId = null, $customUrl = null, $customTitle = null) {
        $pageInfo = [
            'pages_visitor_id' => null,
            'page_url' => '',
            'page_type' => 'static',
            'page_title' => '',
            'page_category' => null
        ];
        
        // Se foi fornecido um ID de página do banco
        if ($pageId) {
            try {
                // Primeiro tenta encontrar na pages_visitor pelo page_id
                $this->db->query("SELECT * FROM pages_visitor WHERE page_id = :page_id AND is_active = 1");
                $this->db->bind(':page_id', $pageId);
                $existingPage = $this->db->single();
                
                if ($existingPage) {
                    $pageInfo['pages_visitor_id'] = $existingPage['id'];
                    $pageInfo['page_url'] = $existingPage['page_url'];
                    $pageInfo['page_type'] = $existingPage['page_type'];
                    $pageInfo['page_title'] = $existingPage['page_title'];
                    $pageInfo['page_category'] = $existingPage['page_category'];
                    
                    if ($this->debug) {
                        error_log("DEBUG: Encontrou pages_visitor existente: ID {$existingPage['id']}");
                    }
                    
                    return $pageInfo;
                }
                
                // Se não encontrou, busca na tabela pages original e cria em pages_visitor
                $this->db->query("SELECT * FROM pages WHERE id = :id AND published = 1");
                $this->db->bind(':id', $pageId);
                $page = $this->db->single();
                
                if ($page) {
                    // Cria nova entrada em pages_visitor
                    $pageUrl = '/' . ltrim($page['slug'], '/');
                    $pageVisitorId = $this->createPageVisitor(
                        $page['id'],
                        $pageUrl,
                        $page['title'],
                        'database',
                        $page['type']
                    );
                    
                    $pageInfo['pages_visitor_id'] = $pageVisitorId;
                    $pageInfo['page_url'] = $pageUrl;
                    $pageInfo['page_type'] = 'database';
                    $pageInfo['page_title'] = $page['title'];
                    $pageInfo['page_category'] = $page['type'];
                    
                    if ($this->debug) {
                        error_log("DEBUG: Criou novo pages_visitor para página do banco: ID $pageVisitorId");
                    }
                    
                    return $pageInfo;
                }
            } catch (Exception $e) {
                error_log("Erro ao buscar página: " . $e->getMessage());
            }
        }
        
        // Para páginas estáticas, usa URL customizada ou detecta automaticamente
        if ($customUrl) {
            $pageUrl = $this->cleanUrl($customUrl);
        } else {
            // Detecta URL atual
            $currentUrl = $_SERVER['REQUEST_URI'] ?? '';
            $pageUrl = $this->cleanUrl($currentUrl);
        }
        
        // Verifica se já existe em pages_visitor
        try {
            $this->db->query("SELECT * FROM pages_visitor WHERE page_url = :page_url AND is_active = 1");
            $this->db->bind(':page_url', $pageUrl);
            $existingPage = $this->db->single();
            
            if ($existingPage) {
                $pageInfo['pages_visitor_id'] = $existingPage['id'];
                $pageInfo['page_url'] = $existingPage['page_url'];
                $pageInfo['page_type'] = $existingPage['page_type'];
                $pageInfo['page_title'] = $existingPage['page_title'];
                $pageInfo['page_category'] = $existingPage['page_category'];
                
                if ($this->debug) {
                    error_log("DEBUG: Encontrou página estática existente: ID {$existingPage['id']}");
                }
                
                return $pageInfo;
            }
            
            // Se não existe, cria nova página estática
            $pageTitle = $customTitle ?: $this->detectPageTitle($pageUrl);
            $pageVisitorId = $this->createPageVisitor(
                null,
                $pageUrl,
                $pageTitle,
                'static',
                'static_page'
            );
            
            $pageInfo['pages_visitor_id'] = $pageVisitorId;
            $pageInfo['page_url'] = $pageUrl;
            $pageInfo['page_type'] = 'static';
            $pageInfo['page_title'] = $pageTitle;
            $pageInfo['page_category'] = 'static_page';
            
            if ($this->debug) {
                error_log("DEBUG: Criou nova página estática: ID $pageVisitorId");
            }
            
        } catch (Exception $e) {
            error_log("Erro ao processar página estática: " . $e->getMessage());
        }
        
        return $pageInfo;
    }
    
    /**
     * Cria novo registro na tabela pages_visitor
     */
    private function createPageVisitor($pageId, $pageUrl, $pageTitle, $pageType, $pageCategory) {
        try {
            $this->db->query("
                INSERT INTO pages_visitor (
                    page_id, page_url, page_title, page_type, page_category, 
                    auto_created, first_detected, last_activity, is_active
                ) VALUES (
                    :page_id, :page_url, :page_title, :page_type, :page_category,
                    :auto_created, NOW(), NOW(), 1
                )
            ");
            
            $this->db->bind(':page_id', $pageId);
            $this->db->bind(':page_url', $pageUrl);
            $this->db->bind(':page_title', $pageTitle);
            $this->db->bind(':page_type', $pageType);
            $this->db->bind(':page_category', $pageCategory);
            $this->db->bind(':auto_created', $pageType === 'static' ? 1 : 0);
            
            $this->db->execute();
            
            return $this->db->lastInsertId();
            
        } catch (Exception $e) {
            error_log("Erro ao criar page_visitor: " . $e->getMessage());
            return null;
        }
    }
    
    /**
     * Limpa e normaliza a URL
     */
    private function cleanUrl($url) {
        // Remove parâmetros de query
        $cleanUrl = strtok($url, '?');
        
        // Remove barras duplas e normaliza
        $cleanUrl = preg_replace('#/+#', '/', $cleanUrl);
        
        // Remove barra final se não for raiz
        if ($cleanUrl !== '/' && substr($cleanUrl, -1) === '/') {
            $cleanUrl = rtrim($cleanUrl, '/');
        }
        
        // Remove extensão .php se presente
        $cleanUrl = str_replace('.php', '', $cleanUrl);
        
        return $cleanUrl;
    }
    
    /**
     * Registra uma visita única (função principal) - CORRIGIDA
     */
    public function trackUniqueVisit($pageId = null, $customUrl = null, $customTitle = null) {
        try {
            $visitorHash = $this->generateVisitorHash();
            $pageInfo = $this->getOrCreatePageVisitor($pageId, $customUrl, $customTitle);
            $utmParams = $this->getUtmParams();
            
            if (!$pageInfo['pages_visitor_id']) {
                error_log("Não foi possível obter pages_visitor_id");
                return false;
            }
            
            if ($this->debug) {
                error_log("DEBUG: Verificando visita única para hash: $visitorHash, página: {$pageInfo['pages_visitor_id']}");
            }
            
            // CORREÇÃO: Verifica se já existe uma visita nas últimas 24 horas
            $isUniqueVisit = $this->isUniqueVisitIn24h($visitorHash, $pageInfo['pages_visitor_id']);
            
            if ($this->debug) {
                error_log("DEBUG: É visita única? " . ($isUniqueVisit ? 'SIM' : 'NÃO'));
            }
            
            if ($isUniqueVisit) {
                // Registra nova visita única
                $sessionId = $this->insertVisitorSession($visitorHash, $pageInfo, $utmParams);
                
                if ($sessionId) {
                    if ($this->debug) {
                        error_log("DEBUG: Nova sessão criada: ID $sessionId");
                    }
                    
                    // Limpa visitas antigas ocasionalmente
                    $this->cleanOldVisits();
                    
                    return true;
                } else {
                    error_log("Erro: Falha ao inserir sessão de visitante");
                    return false;
                }
            } else {
                // Atualiza última visita mesmo que não seja única
                $this->updateLastVisit($visitorHash, $pageInfo['pages_visitor_id']);
                
                if ($this->debug) {
                    error_log("DEBUG: Visita não única - atualizando última visita");
                }
                
                return false;
            }
            
        } catch (Exception $e) {
            error_log("Erro no tracking de visita única: " . $e->getMessage());
            return false;
        }
    }
    
    /**
     * Verifica se é uma visita única nas últimas 24h - CORRIGIDA
     */
    private function isUniqueVisitIn24h($visitorHash, $pagesVisitorId) {
        try {
            // CORREÇÃO: Query mais precisa para verificar visitas nas últimas 24h
            $this->db->query("
                SELECT id, created_at 
                FROM visitor_sessions 
                WHERE visitor_hash = :hash 
                AND pages_visitor_id = :pages_visitor_id 
                AND created_at >= DATE_SUB(NOW(), INTERVAL 24 HOUR)
                ORDER BY created_at DESC
                LIMIT 1
            ");
            
            $this->db->bind(':hash', $visitorHash);
            $this->db->bind(':pages_visitor_id', $pagesVisitorId);
            
            $result = $this->db->single();
            
            if ($this->debug && $result) {
                error_log("DEBUG: Encontrou visita existente: ID {$result['id']}, data: {$result['created_at']}");
            }
            
            // Se não encontrou nenhuma visita nas últimas 24h, é única
            return !$result;
            
        } catch (Exception $e) {
            error_log("Erro ao verificar visita única: " . $e->getMessage());
            // Em caso de erro, assume que é única para não bloquear
            return true;
        }
    }
    
    /**
     * Insere nova sessão de visitante - CORRIGIDA
     */
    private function insertVisitorSession($visitorHash, $pageInfo, $utmParams) {
        try {
            // Dados da sessão (device, browser, etc)
            $sessionData = [
                'ip' => $_SERVER['REMOTE_ADDR'] ?? null,
                'user_agent' => $_SERVER['HTTP_USER_AGENT'] ?? null,
                'accept_language' => $_SERVER['HTTP_ACCEPT_LANGUAGE'] ?? null,
                'screen_resolution' => $_GET['screen'] ?? null,
                'viewport_size' => $_GET['viewport'] ?? null,
                'timestamp' => time(),
                'page_info' => $pageInfo
            ];
            
            // CORREÇÃO: Query mais simples e segura
            $this->db->query("
                INSERT INTO visitor_sessions (
                    pages_visitor_id, visitor_hash, visitor_ip, user_agent, 
                    referer, session_data, utm_source, utm_medium, utm_campaign, 
                    utm_term, utm_content, gclid, fbclid, 
                    first_visit_at, last_visit_at, visit_count
                ) VALUES (
                    :pages_visitor_id, :visitor_hash, :visitor_ip, :user_agent,
                    :referer, :session_data, :utm_source, :utm_medium, :utm_campaign,
                    :utm_term, :utm_content, :gclid, :fbclid, 
                    NOW(), NOW(), 1
                )
            ");
            
            $this->db->bind(':pages_visitor_id', $pageInfo['pages_visitor_id']);
            $this->db->bind(':visitor_hash', $visitorHash);
            $this->db->bind(':visitor_ip', $_SERVER['REMOTE_ADDR'] ?? null);
            $this->db->bind(':user_agent', $_SERVER['HTTP_USER_AGENT'] ?? null);
            $this->db->bind(':referer', $_SERVER['HTTP_REFERER'] ?? null);
            $this->db->bind(':session_data', json_encode($sessionData));
            $this->db->bind(':utm_source', $utmParams['utm_source']);
            $this->db->bind(':utm_medium', $utmParams['utm_medium']);
            $this->db->bind(':utm_campaign', $utmParams['utm_campaign']);
            $this->db->bind(':utm_term', $utmParams['utm_term']);
            $this->db->bind(':utm_content', $utmParams['utm_content']);
            $this->db->bind(':gclid', $utmParams['gclid']);
            $this->db->bind(':fbclid', $utmParams['fbclid']);
            
            $this->db->execute();
            
            $sessionId = $this->db->lastInsertId();
            
            if ($this->debug) {
                error_log("DEBUG: Sessão inserida com sucesso: ID $sessionId");
            }
            
            return $sessionId;
            
        } catch (Exception $e) {
            error_log("Erro ao inserir sessão de visitante: " . $e->getMessage());
            
            if ($this->debug) {
                error_log("DEBUG: Query error details: " . print_r($this->db->debugDumpParams(), true));
            }
            
            return false;
        }
    }
    
    /**
     * Atualiza última visita para visitantes não únicos - CORRIGIDA
     */
    private function updateLastVisit($visitorHash, $pagesVisitorId) {
        try {
            $this->db->query("
                UPDATE visitor_sessions 
                SET last_visit_at = NOW(),
                    visit_count = visit_count + 1
                WHERE visitor_hash = :hash 
                AND pages_visitor_id = :pages_visitor_id 
                AND created_at >= DATE_SUB(NOW(), INTERVAL 24 HOUR)
                ORDER BY created_at DESC
                LIMIT 1
            ");
            
            $this->db->bind(':hash', $visitorHash);
            $this->db->bind(':pages_visitor_id', $pagesVisitorId);
            
            $this->db->execute();
            
            $updatedRows = $this->db->rowCount();
            
            if ($this->debug) {
                error_log("DEBUG: Atualizadas $updatedRows sessões existentes");
            }
            
        } catch (Exception $e) {
            error_log("Erro ao atualizar última visita: " . $e->getMessage());
        }
    }
    
    /**
     * Detecta título da página a partir da URL
     */
    private function detectPageTitle($url) {
        // Remove barras e converte para título
        $title = trim($url, '/');
        $title = str_replace(['-', '_'], ' ', $title);
        $title = ucwords($title);
        
        // Se estiver vazio, usa um padrão
        if (empty($title)) {
            $title = 'Página Inicial';
        } else if ($title === 'campanha pa') {
            $title = 'Cursos Gratuitos';
        }
        
        return $title;
    }
    
    /**
     * Remove visitas antigas para manter performance
     */
    private function cleanOldVisits() {
        try {
            // Remove visitas com mais de 30 dias (executa apenas ocasionalmente)
            if (rand(1, 100) <= 2) { // 2% de chance para não sobrecarregar
                $this->db->query("
                    DELETE FROM visitor_sessions 
                    WHERE created_at < DATE_SUB(NOW(), INTERVAL 30 DAY)
                ");
                $this->db->execute();
                
                $deletedRows = $this->db->rowCount();
                
                if ($deletedRows > 0) {
                    error_log("Limpeza automática: $deletedRows visitas antigas removidas");
                }
            }
        } catch (Exception $e) {
            error_log("Erro ao limpar visitas antigas: " . $e->getMessage());
        }
    }
    
    /**
     * Registra uma conversão
     */
    public function trackConversion($pagesVisitorId, $conversionType, $conversionValue = null, $conversionData = null) {
        try {
            $visitorHash = $this->generateVisitorHash();
            $utmParams = $this->getUtmParams();
            
            $this->db->query("
                INSERT INTO visitor_conversions (
                    pages_visitor_id, visitor_hash, conversion_type, conversion_value,
                    conversion_data, utm_source, utm_medium, utm_campaign, referer
                ) VALUES (
                    :pages_visitor_id, :visitor_hash, :conversion_type, :conversion_value,
                    :conversion_data, :utm_source, :utm_medium, :utm_campaign, :referer
                )
            ");
            
            $this->db->bind(':pages_visitor_id', $pagesVisitorId);
            $this->db->bind(':visitor_hash', $visitorHash);
            $this->db->bind(':conversion_type', $conversionType);
            $this->db->bind(':conversion_value', $conversionValue);
            $this->db->bind(':conversion_data', $conversionData ? json_encode($conversionData) : null);
            $this->db->bind(':utm_source', $utmParams['utm_source']);
            $this->db->bind(':utm_medium', $utmParams['utm_medium']);
            $this->db->bind(':utm_campaign', $utmParams['utm_campaign']);
            $this->db->bind(':referer', $_SERVER['HTTP_REFERER'] ?? null);
            
            $this->db->execute();
            
            // Marca a sessão como convertida
            $this->markSessionAsConverted($visitorHash, $pagesVisitorId);
            
            if ($this->debug) {
                error_log("DEBUG: Conversão registrada: $conversionType para página $pagesVisitorId");
            }
            
            return true;
            
        } catch (Exception $e) {
            error_log("Erro ao registrar conversão: " . $e->getMessage());
            return false;
        }
    }
    
    /**
     * Marca sessão como convertida
     */
    private function markSessionAsConverted($visitorHash, $pagesVisitorId) {
        try {
            $this->db->query("
                UPDATE visitor_sessions 
                SET converted = 1 
                WHERE visitor_hash = :hash 
                AND pages_visitor_id = :pages_visitor_id 
                AND created_at >= DATE_SUB(NOW(), INTERVAL 24 HOUR)
                ORDER BY created_at DESC
                LIMIT 1
            ");
            
            $this->db->bind(':hash', $visitorHash);
            $this->db->bind(':pages_visitor_id', $pagesVisitorId);
            
            $this->db->execute();
            
        } catch (Exception $e) {
            error_log("Erro ao marcar sessão como convertida: " . $e->getMessage());
        }
    }
    
    /**
     * Obtém estatísticas de visitas de uma página
     */
    public function getPageStats($pagesVisitorId) {
        try {
            $this->db->query("SELECT * FROM visitor_stats_24h WHERE id = :id");
            $this->db->bind(':id', $pagesVisitorId);
            $stats24h = $this->db->single();
            
            $this->db->query("SELECT * FROM visitor_stats_7d WHERE id = :id");
            $this->db->bind(':id', $pagesVisitorId);
            $stats7d = $this->db->single();
            
            return [
                '24h' => $stats24h,
                '7d' => $stats7d
            ];
            
        } catch (Exception $e) {
            error_log("Erro ao obter estatísticas: " . $e->getMessage());
            return null;
        }
    }
    
    /**
     * Obtém ranking de páginas mais visitadas
     */
    public function getTopPages($period = '24h', $limit = 10) {
        try {
            $view = $period === '7d' ? 'visitor_stats_7d' : 'visitor_stats_24h';
            $orderField = $period === '7d' ? 'unique_visitors_7d' : 'unique_visitors_24h';
            
            $this->db->query("
                SELECT * FROM {$view}
                ORDER BY {$orderField} DESC
                LIMIT :limit
            ");
            $this->db->bind(':limit', $limit);
            
            return $this->db->resultSet();
            
        } catch (Exception $e) {
            error_log("Erro ao obter ranking: " . $e->getMessage());
            return [];
        }
    }
    
    /**
     * Obtém páginas do banco para listagem no admin
     */
    public function getAllPages($type = 'all', $limit = 50, $offset = 0) {
        try {
            $sql = "SELECT * FROM pages_visitor WHERE is_active = 1";
            
            if ($type !== 'all') {
                $sql .= " AND page_type = :type";
            }
            
            $sql .= " ORDER BY last_activity DESC LIMIT :limit OFFSET :offset";
            
            $this->db->query($sql);
            
            if ($type !== 'all') {
                $this->db->bind(':type', $type);
            }
            
            $this->db->bind(':limit', $limit);
            $this->db->bind(':offset', $offset);
            
            return $this->db->resultSet();
            
        } catch (Exception $e) {
            error_log("Erro ao obter páginas: " . $e->getMessage());
            return [];
        }
    }
    
    /**
     * Função de debug para verificar visitas de um hash específico
     */
    public function debugVisitorSessions($visitorHash = null) {
        if (!$this->debug) {
            return false;
        }
        
        try {
            $hash = $visitorHash ?: $this->generateVisitorHash();
            
            $this->db->query("
                SELECT vs.*, pv.page_title, pv.page_url
                FROM visitor_sessions vs
                JOIN pages_visitor pv ON vs.pages_visitor_id = pv.id
                WHERE vs.visitor_hash = :hash
                ORDER BY vs.created_at DESC
            ");
            $this->db->bind(':hash', $hash);
            
            $sessions = $this->db->resultSet();
            
            error_log("DEBUG: Sessões para hash $hash:");
            foreach ($sessions as $session) {
                error_log("  - ID: {$session['id']}, Página: {$session['page_title']}, Data: {$session['created_at']}");
            }
            
            return $sessions;
            
        } catch (Exception $e) {
            error_log("Erro no debug: " . $e->getMessage());
            return false;
        }
    }
}

// Instancia global
$uniqueVisitsTracker = new UniqueVisitsTracker();