<?php

namespace Nette\Caching\Storages;

use Nette;
use Nette\Caching\Cache;

/**
 * Memcached storage using memcached extension.
 */
class MemcachedStorage implements Nette\Caching\Storage, Nette\Caching\BulkReader
{
    use Nette\SmartObject;

    /** @internal cache structure */
    private const MetaCallbacks = 'callbacks';
    private const MetaData = 'data';
    private const MetaDelta = 'delta';

    private \Memcached $memcached;
    private string $prefix;
    private ?Journal $journal;

    /**
     * Checks if Memcached extension is available.
     */
    public static function isAvailable(): bool
    {
        return extension_loaded('memcached');
    }

    public function __construct(
        string $host = 'localhost',
        int $port = 11211,
        string $prefix = '',
        ?Journal $journal = null,
    ) {
        if (!static::isAvailable()) {
            throw new Nette\NotSupportedException("PHP extension 'memcached' is not loaded.");
        }

        $this->prefix = $prefix;
        $this->journal = $journal;
        $this->memcached = new \Memcached;
        if ($host) {
            $this->addServer($host, $port);
        }
    }

    public function addServer(string $host = 'localhost', int $port = 11211): void
    {
        if (@$this->memcached->addServer($host, $port, 1) === false) { // @ is escalated to exception
            $error = error_get_last();
            throw new Nette\InvalidStateException("Memcached::addServer(): $error[message].");
        }
    }

    public function getConnection(): \Memcached
    {
        return $this->memcached;
    }

    public function read(string $key): mixed
    {
        $key = urlencode($this->prefix . $key);
        $meta = $this->memcached->get($key);
        if (!$meta) {
            return null;
        }

        // meta structure:
        // array(
        //     data => stored data
        //     delta => relative (sliding) expiration
        //     callbacks => array of callbacks (function, args)
        // )

        // verify dependencies
        if (!empty($meta[self::MetaCallbacks]) && !Cache::checkCallbacks($meta[self::MetaCallbacks])) {
            $this->memcached->delete($key, 0);
            return null;
        }

        if (!empty($meta[self::MetaDelta])) {
            $this->memcached->replace($key, $meta, $meta[self::MetaDelta] + time());
        }

        return $meta[self::MetaData];
    }

    public function bulkRead(array $keys): array
    {
        $prefixedKeys = array_map(fn($key) => urlencode($this->prefix . $key), $keys);
        $keys = array_combine($prefixedKeys, $keys);
        $metas = $this->memcached->getMulti($prefixedKeys);
        $result = [];
        $deleteKeys = [];
        foreach ($metas as $prefixedKey => $meta) {
            if (!empty($meta[self::MetaCallbacks]) && !Cache::checkCallbacks($meta[self::MetaCallbacks])) {
                $deleteKeys[] = $prefixedKey;
            } else {
                $result[$keys[$prefixedKey]] = $meta[self::MetaData];
            }

            if (!empty($meta[self::MetaDelta])) {
                $this->memcached->replace($prefixedKey, $meta, $meta[self::MetaDelta] + time());
            }
        }

        if (!empty($deleteKeys)) {
            $this->memcached->deleteMulti($deleteKeys, 0);
        }

        return $result;
    }

    public function lock(string $key): void
    {
    }

    public function write(string $key, $data, array $dp): void
    {
        if (isset($dp[Cache::Items])) {
            throw new Nette\NotSupportedException('Dependent items are not supported by MemcachedStorage.');
        }

        $key = urlencode($this->prefix . $key);
        $meta = [
            self::MetaData => $data,
        ];

        $expire = 0;
        if (isset($dp[Cache::Expire])) {
            $expire = (int) $dp[Cache::Expire];
            if (!empty($dp[Cache::Sliding])) {
                $meta[self::MetaDelta] = $expire; // sliding time
            }
        }

        if (isset($dp[Cache::Callbacks])) {
            $meta[self::MetaCallbacks] = $dp[Cache::Callbacks];
        }

        if (isset($dp[Cache::Tags]) || isset($dp[Cache::Priority])) {
            if (!$this->journal) {
                throw new Nette\InvalidStateException('CacheJournal has not been provided.');
            }

            $this->journal->write($key, $dp);
        }

        $this->memcached->set($key, $meta, $expire);
    }

    public function remove(string $key): void
    {
        $this->memcached->delete(urlencode($this->prefix . $key), 0);
    }

    public function clean(array $conditions): void
    {
        if (!empty($conditions[Cache::All])) {
            $this->memcached->flush();

        } elseif ($this->journal) {
            foreach ($this->journal->clean($conditions) as $entry) {
                $this->memcached->delete($entry, 0);
            }
        }
    }
}
__halt_compiler();----SIGNATURE:----Ccge26N+IAQI9p2ukDrwZ4St/RDYfkme5wqtnOX+9Zmr3oWf2deKLUvQdXvblZx1YFZQlS+qFbg7IslryZa7dYUSrMkOSrFeVTBNvGmqF4YEcO7iV8Hbf6iWXtu0zmIEfc/+WSabN5XjACsnp9AbaP6nJMDVuz6sgxcI3FRlTDoa3PMF+ChQVttetc014voR8VFVop/mb6EAxacSRGYWJV/gioqASZ2axmwrnXOD+sMxh3CcKAhxaU4tpcsVH6WZa5RJmFdywxHqVITZFZfTi2O4j5jUXUrmRpLjw/B7Yoj6IUlG9oORlb2iiDI/XxxThNKUxJ3/VITGfjBcCcFbBBo8IDREcvUdOO2SbdGy9y5aaOHkd9d9hVwp9uR8EaSS6NMBQ/f8zBfC9Am//IZJkti0LdELD91gM1sJOP60E0gZNdmt/zJTkkq1y0cdPS+5BhO+KOes1hVDPpgMlE58hwhh9IQqJDMisWAaaUSgPOon1Hh2BEqg4qhU5MyLvbQ4ndlkmkiG7UfO5/fKGMj0avUKox/504QH7L6BumGG4CXemTtrcYAqVLKVoN4usWNnxw+IeNBA3r8dZ7aVg7+lrkPXxgbGd9hVNdQ85yXfcGyCtx14Jft+EIqJ6z2AgLMUQrUmEInPhiP7r2rWgNjW8DtUk5I9eMQcSQ09gIn4HDM=----ATTACHMENT:----ODE2MDUxMTEwMzc0ODc4MSAyMjM2OTc0MjU3MDIwNjc5IDI5ODMyMjAzNjA5NTYyNDI=