<?php

/**
 * Simple File-Based Cache Helper
 *
 * Provides caching for frequently accessed data that doesn't change often,
 * such as workflow rules, user preferences, and configuration data.
 */
class CacheHelper
{
    private static ?string $cacheDir = null;
    private static array $memoryCache = [];

    /**
     * Get the cache directory path
     *
     * @return string Cache directory path
     */
    private static function getCacheDir(): string
    {
        if (self::$cacheDir === null) {
            self::$cacheDir = sys_get_temp_dir() . '/tinker_tickets_cache';
            if (!is_dir(self::$cacheDir)) {
                // 0700: only the app user may read cached data or create files.
                // mkdir mode is masked by umask, so chmod to enforce it.
                mkdir(self::$cacheDir, 0700, true);
                @chmod(self::$cacheDir, 0700);
            } elseif (!function_exists('posix_geteuid') || fileowner(self::$cacheDir) === posix_geteuid()) {
                // Existing dir we own: harden a previously world-readable dir.
                @chmod(self::$cacheDir, 0700);
            }
        }
        return self::$cacheDir;
    }

    /**
     * Generate a cache key from components
     *
     * @param string $prefix Cache prefix (e.g., 'workflow', 'user_prefs')
     * @param mixed $identifier Unique identifier
     * @return string Cache key
     */
    private static function makeKey(string $prefix, $identifier = null): string
    {
        $key = $prefix;
        if ($identifier !== null) {
            $key .= '_' . md5(serialize($identifier));
        }
        return preg_replace('/[^a-zA-Z0-9_]/', '_', $key);
    }

    /**
     * Get cached data
     *
     * @param string $prefix Cache prefix
     * @param mixed $identifier Unique identifier
     * @param int $ttl Time-to-live in seconds (default 300 = 5 minutes)
     * @return mixed|null Cached data or null if not found/expired
     */
    public static function get(string $prefix, $identifier = null, int $ttl = 300)
    {
        $key = self::makeKey($prefix, $identifier);

        // Check memory cache first (fastest)
        if (isset(self::$memoryCache[$key])) {
            $cached = self::$memoryCache[$key];
            if (time() - $cached['time'] < $ttl) {
                return $cached['data'];
            }
            unset(self::$memoryCache[$key]);
        }

        // Check file cache
        $filePath = self::getCacheDir() . '/' . $key . '.json';
        if (file_exists($filePath)) {
            $content = @file_get_contents($filePath);
            if ($content !== false) {
                $cached = json_decode($content, true);
                if ($cached && isset($cached['time']) && isset($cached['data'])) {
                    if (time() - $cached['time'] < $ttl) {
                        // Store in memory cache for faster subsequent access
                        self::$memoryCache[$key] = $cached;
                        return $cached['data'];
                    }
                }
            }
            // Expired - delete file
            @unlink($filePath);
        }

        return null;
    }

    /**
     * Store data in cache
     *
     * @param string $prefix Cache prefix
     * @param mixed $identifier Unique identifier
     * @param mixed $data Data to cache
     * @return bool Success
     */
    public static function set(string $prefix, $identifier, $data): bool
    {
        $key = self::makeKey($prefix, $identifier);
        $cached = [
            'time' => time(),
            'data' => $data
        ];

        // Store in memory cache
        self::$memoryCache[$key] = $cached;

        // Store in file cache
        $filePath = self::getCacheDir() . '/' . $key . '.json';
        $written = @file_put_contents($filePath, json_encode($cached), LOCK_EX) !== false;
        if ($written) {
            // 0600: cache may feed security-relevant reads; keep it non-readable
            // to other local users and non-poisonable by pre-created files.
            @chmod($filePath, 0600);
        }
        return $written;
    }

    /**
     * Delete cached data
     *
     * @param string $prefix Cache prefix
     * @param mixed $identifier Unique identifier (null to delete all with prefix)
     * @return bool Success
     */
    public static function delete(string $prefix, $identifier = null): bool
    {
        if ($identifier !== null) {
            $key = self::makeKey($prefix, $identifier);
            unset(self::$memoryCache[$key]);
            $filePath = self::getCacheDir() . '/' . $key . '.json';
            return !file_exists($filePath) || @unlink($filePath);
        }

        // Delete all entries for this prefix. A key is either the bare prefix or
        // prefix + '_' + md5(identifier) (32 hex chars, see makeKey). Match exactly
        // that so a prefix can't clobber a different prefix that merely shares a
        // leading substring — e.g. delete('workflow') must not wipe 'workflow_rules'.
        $safePrefix = preg_replace('/[^a-zA-Z0-9_]/', '_', $prefix);
        $keyRegex   = '/^' . preg_quote($safePrefix, '/') . '(_[0-9a-f]{32})?$/';

        $files = glob(self::getCacheDir() . '/' . $safePrefix . '*.json') ?: [];
        foreach ($files as $file) {
            if (preg_match($keyRegex, basename($file, '.json'))) {
                @unlink($file);
            }
        }

        // Clear matching memory cache entries
        foreach (array_keys(self::$memoryCache) as $key) {
            if (preg_match($keyRegex, $key)) {
                unset(self::$memoryCache[$key]);
            }
        }

        return true;
    }

    /**
     * Clear all cache
     *
     * @return bool Success
     */
    public static function clearAll(): bool
    {
        self::$memoryCache = [];

        $files = glob(self::getCacheDir() . '/*.json');
        foreach ($files as $file) {
            @unlink($file);
        }

        return true;
    }

    /**
     * Get data from cache or fetch it using a callback
     *
     * @param string $prefix Cache prefix
     * @param mixed $identifier Unique identifier
     * @param callable $callback Function to call if cache miss
     * @param int $ttl Time-to-live in seconds
     * @return mixed Cached or freshly fetched data
     */
    public static function remember(string $prefix, $identifier, callable $callback, int $ttl = 300)
    {
        $data = self::get($prefix, $identifier, $ttl);

        if ($data === null) {
            $data = $callback();
            if ($data !== null) {
                self::set($prefix, $identifier, $data);
            }
        }

        return $data;
    }

    /**
     * Clean up expired cache files (call periodically)
     *
     * @param int $maxAge Maximum age in seconds (default 1 hour)
     */
    public static function cleanup(int $maxAge = 3600): void
    {
        $files = glob(self::getCacheDir() . '/*.json');
        $now = time();

        foreach ($files as $file) {
            if ($now - filemtime($file) > $maxAge) {
                @unlink($file);
            }
        }
    }
}