<?php
/**
 * FuzeWorks ObjectStorage Component.
 *
 * The FuzeWorks PHP FrameWork
 *
 * Copyright (C) 2013-2020 i15
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * @author    i15
 * @copyright Copyright (c) 2013 - 2020, i15. (https://i15.nl)
 * @license   https://opensource.org/licenses/MIT MIT License
 *
 * @since Version 1.3.0
 *
 * @version Version 1.3.0
 */

namespace FuzeWorks\ObjectStorage\Provider;
use FuzeWorks\ObjectStorage\Exception\ObjectStorageException;
use FuzeWorks\ObjectStorage\iObjectStorageProvider;
use FuzeWorks\Core;
use Traversable;

/**
 * FileProvider
 *
 * An ObjectStorage provider which saves objects in files using the serialize() and unserialize() functions.
 * The easiest to use StorageProvider, though with its caveats. It's nimble and works on nearly everything, but
 * not particularly fast, and has some risks when multiple processes use the data at the same time.
 *
 * @todo Figure out a way to prevent indexes from clashing in multiple threads
 * @todo Find a better way to sanitize key names other than hashing them using crc32
 * @author    i15
 * @copyright Copyright (c) 2013 - 2020, i15. (https://i15.nl)
 */
class FileProvider implements iObjectStorageProvider
{

    /**
     * The directory where all objects are saved
     *
     * @var string
     */
    protected string $directory;

    /**
     * The file where the index for this provider is saved
     *
     * @var string
     */
    protected string $indexFile;

    /**
     * The index of all objects stored
     *
     * @var array
     */
    protected array $index;

    /**
     * @param array $providerConfig
     * @return bool
     * @throws ObjectStorageException
     */
    public function init(array $providerConfig): bool
    {
        // First load the directory from the providerConfig
        $directory = isset($providerConfig['storageDirectory']) ? $providerConfig['storageDirectory'] : null;

        // Check if the directory exists
        if (!file_exists($directory) || !is_dir($directory))
            throw new ObjectStorageException("Could not load FileProvider ObjectStorage. Provided storageDirectory is not a directory.");

        // Check if that directory also is writeable
        if (!Core::isReallyWritable($directory))
            throw new ObjectStorageException("Could not load FileProvider ObjectStorage. Provided storageDirectory is not writeable.");

        // Save the directory and indexFile, and load or initialize the indexFile
        $this->directory = rtrim($directory);
        $this->indexFile = $this->directory . DS . 'index.fwstorage';

        // If the index does not exist yet, load it
        if (!file_exists($this->indexFile))
        {
            if (!$this->write_file($this->indexFile, serialize(['index' => []])))
                throw new ObjectStorageException("Could not load FileProvider ObjectStorage. Could not write index.");

            chmod($this->indexFile, 0640);
        }

        // And finally, load the index
        $this->index = unserialize(file_get_contents($this->indexFile))['index'];

        return true;
    }

    public function getIndex(): array
    {
        return $this->index;
    }

    public function getItem(string $key): ?array
    {
        // Convert the key
        $file = $this->directory . DS . crc32($key) . '.fwstorage';

        // If the key could not be found in the index, return null
        if (!isset($this->index[$key]))
            return null;

        // Check if the file exists. If not, delete the indexed value
        if (!file_exists($file))
        {
            $this->deleteItem($key);
            return null;
        }

        // Otherwise try and load the metaData and contents
        $meta = $this->index[$key]['meta'];
        $data = unserialize(file_get_contents($file));

        // Return the combined data
        return ['meta' => $meta, 'data' => $data];
    }

    public function getItemMeta(string $key): ?array
    {
        // If the key could not be found in the index, return null
        if (!isset($this->index[$key]))
            return null;

        // Otherwise return the meta data
        return $this->index[$key]['meta'];
    }

    public function getItems(array $keys = []): array
    {
        $output = [];
        foreach ($keys as $key)
            $output[$key] = $this->getItem($key);

        return $output;
    }

    public function hasItem(string $key): bool
    {
        return isset($this->index[$key]);
    }

    public function clear(): bool
    {
        $keys = array_keys($this->index);
        return $this->deleteItems($keys);
    }

    public function deleteItem(string $key): bool
    {
        // Convert the key
        $file = $this->directory . DS . crc32($key) . '.fwstorage';

        // Remove the file first
        if (file_exists($file))
            unlink($file);

        // And remove it from the index
        if (isset($this->index[$key]))
            unset($this->index[$key]);

        // And commit the index
        return $this->commitIndex();
    }

    public function deleteItems(array $keys): bool
    {
        foreach ($keys as $key)
            $this->deleteItem($key);

        return true;
    }

    public function save(string $key, $value, array $metaData = []): bool
    {
        // Convert the key
        $file = $this->directory . DS . crc32($key) . '.fwstorage';

        // Remove the file if it already exists
        if (file_exists($file))
            unlink($file);

        // Write everything to the index
        $this->index[$key] = ['meta' => $metaData];
        $this->commitIndex();

        // And write the contents
        if ($this->write_file($file, serialize($value))) {
            chmod($file, 0640);
            return true;
        }

        return false;
    }

    public function commit(): bool
    {
        // TODO: Implement commit() method.
    }

    public function revert(): bool
    {
        // TODO: Implement revert() method.
    }

    private function commitIndex(): bool
    {
        if ($this->write_file($this->indexFile, serialize(['index' => $this->index]))) {
            chmod($this->indexFile, 0640);
            return true;
        }

        return false;
    }

    /**
     * Write File
     *
     * Writes data to the file specified in the path.
     * Creates a new file if non-existent.
     *
     * @param	string	$path	File path
     * @param	string	$data	Data to write
     * @param	string	$mode	fopen() mode (default: 'wb')
     * @return	bool
     */
    private function write_file(string $path, string $data, string $mode = 'wb'): bool
    {
        if ( ! $fp = @fopen($path, $mode))
            return false;

        flock($fp, LOCK_EX);

        for ($result = $written = 0, $length = strlen($data); $written < $length; $written += $result)
            if (($result = fwrite($fp, substr($data, $written))) === false)
                break;

        flock($fp, LOCK_UN);
        fclose($fp);

        return is_int($result);
    }
}