class.cachemanager.php

Go to the documentation of this file.

<?php
/*
 * Copyright (c) 2021-2026 Bearsampp
 * License:  GNU General Public License version 3 or later; see LICENSE.txt
 * Website: https://bearsampp.com
 * Github: https://github.com/Bearsampp
 */

class CacheManager
{
    private static $cacheDir;

    private static $enabled = true;

    private static $stats = [
        'hits'   => 0,
        'misses' => 0,
        'writes' => 0
    ];
 
    const CACHE_VERSION = '1.0';

    public static function init(string $cacheDir): void
    {
        self::$cacheDir = $cacheDir;
 
        // Create cache directory if needed
        if (!is_dir(self::$cacheDir)) {
            @mkdir(self::$cacheDir, 0755, true);
        }
 
        // Check if cache directory is writable
        if (!is_writable(self::$cacheDir)) {
            Log::warning('Cache directory not writable, caching disabled: ' . self::$cacheDir);
            self::$enabled = false;
        }
    }

    public static function load(
        string $sourcePath,
        callable $parser,
        ?string $cacheKey = null
    ) {
        if (!self::$enabled || !self::$cacheDir) {
            return call_user_func($parser, $sourcePath);
        }
 
        if ($cacheKey === null) {
            $cacheKey = md5($sourcePath);
        }
 
        $cacheFile = self::getCacheFile($cacheKey);
 
        // Try cache first (warm start optimization)
        if (self::isCacheValid($sourcePath, $cacheFile)) {
            $cached = @json_decode(file_get_contents($cacheFile), true);
            if (is_array($cached)) {
                self::$stats['hits']++;
 
                return $cached;
            }
        }
 
        // Cache miss or invalid - parse and save
        self::$stats['misses']++;
        $data = call_user_func($parser, $sourcePath);
 
        if (is_array($data)) {
            self::writeCache($cacheFile, $data);
        }
 
        return $data;
    }

    private static function isCacheValid(
        string $sourcePath,
        string $cacheFile
    ): bool {
        if (!file_exists($cacheFile) || !file_exists($sourcePath)) {
            return false;
        }
 
        // Cache valid only if newer than source
        return filemtime($cacheFile) > filemtime($sourcePath);
    }

    private static function writeCache(string $cacheFile, array $data): bool
    {
        if (!self::$enabled) {
            return false;
        }
 
        $json    = json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
        $written = @file_put_contents($cacheFile, $json);
 
        if ($written !== false) {
            self::$stats['writes']++;
 
            return true;
        }
 
        Log::warning('Failed to write cache: ' . $cacheFile);
 
        return false;
    }

    private static function getCacheFile(string $cacheKey): string
    {
        return self::$cacheDir . '/' . $cacheKey . '.cache';
    }

    public static function invalidate(string $sourcePath): void
    {
        if (!self::$enabled || !self::$cacheDir) {
            return;
        }
 
        $cacheKey  = md5($sourcePath);
        $cacheFile = self::getCacheFile($cacheKey);
 
        if (file_exists($cacheFile)) {
            @unlink($cacheFile);
        }
    }

    public static function clearAll(): int
    {
        if (!self::$enabled || !self::$cacheDir) {
            return 0;
        }
 
        // Clear in-memory caches of related classes
        if (class_exists('Module')) {
            Module::clearMemoryCache();
        }
 
        // Clear general cache if it exists
        if (class_exists('Cache')) {
            $cache = new Cache();
            $cache->clear();
        }
 
        $files   = @glob(self::$cacheDir . '/*.cache');
        $deleted = 0;
 
        if (is_array($files)) {
            foreach ($files as $file) {
                if (@unlink($file)) {
                    $deleted++;
                }
            }
        }
 
        return $deleted;
    }

    public static function getStats(): array
    {
        $files        = @glob(self::$cacheDir . '/*.cache');
        $totalSize    = 0;
        $oldestEntry  = null;
        $newestEntry  = null;
        $largestEntry = 0;
 
        if (is_array($files)) {
            foreach ($files as $file) {
                $fileSize = @filesize($file);
                if ($fileSize !== false) {
                    $totalSize += $fileSize;
                    if ($fileSize > $largestEntry) {
                        $largestEntry = $fileSize;
                    }
                }
                $fileMtime = @filemtime($file);
                if ($fileMtime !== false) {
                    if ($oldestEntry === null || $fileMtime < $oldestEntry) {
                        $oldestEntry = $fileMtime;
                    }
                    if ($newestEntry === null || $fileMtime > $newestEntry) {
                        $newestEntry = $fileMtime;
                    }
                }
            }
        }
 
        return [
            'enabled'      => self::$enabled,
            'cacheDir'     => self::$cacheDir,
            'filesCount'   => count($files ?? []),
            'totalSize'    => $totalSize,
            'oldestEntry'  => $oldestEntry,
            'newestEntry'  => $newestEntry,
            'largestEntry' => $largestEntry,
            'cacheHits'    => self::$stats['hits'],
            'cacheMisses'  => self::$stats['misses'],
            'cachewrites'  => self::$stats['writes'],
            'hitRate'      => (self::$stats['hits'] + self::$stats['misses']) > 0
                ? round((self::$stats['hits'] / (self::$stats['hits'] + self::$stats['misses'])) * 100, 2)
                : 0
        ];
    }

    public static function setEnabled(bool $enable): void
    {
        self::$enabled = $enable;
    }

    public static function isEnabled(): bool
    {
        return self::$enabled;
    }
}