map/src/Olivebbs/Map/GenericMap.php

<?php declare(strict_types=1);

/*
 * Copyright (c) 2020  https://rewiv.com sikofitt@gmail.com
 *
 * This file is a part of Olive BBS
 *
 * This Source Code Form is subject to the
 * terms of the Mozilla Public License, v. 2.0.
 *
 * If a copy of the MPL was not distributed with this file,
 * You can obtain one at https://mozilla.org/MPL/2.0/.
 *
 *         ___                   ___    ___
 *        (   ).-.              (   )  (   )
 *    .--. | |( __)___  ___ .--. | |.-. | |.-.     .--.
 *   /    \| |(''"(   )(   /    \| /   \| /   \  /  _  \
 *  |  .-. | | | | | |  | |  .-. |  .-. |  .-. |. .' `. ;
 *  | |  | | | | | | |  | |  | | | |  | | |  | || '   | |
 *  | |  | | | | | | |  | |  |/  | |  | | |  | |_\_`.(___)
 *  | |  | | | | | | |  | |  ' _.| |  | | |  | (   ). '.
 *  | '  | | | | | ' '  ; |  .'.-| '  | | '  | || |  `\ |
 *  '  `-' | | | |  \ `' /'  `-' ' `-' ;' `-' ; ; '._,' '
 *   `.__.(___(___)  '_.'  `.__.' `.__.  `.__.   '.___.'
 *
 */

namespace Olivebbs\Map;

use ArrayAccess;
use Countable;
use Ds\Map;
use function is_array;
use function is_callable;
use function is_int;
use function is_object;
use function is_string;
use Olivebbs\Map\Exception\InvalidArgumentException;

use function strtolower;
use TypeError;
use ValueError;

class GenericMap implements ArrayAccess, Countable
{
    public const OBJECT = 'object';
    public const CALLABLE = 'callable';
    public const ARRAY = 'array';
    public const INT = 'int';
    public const INTEGER = 'integer';
    public const STRING = 'string';
    public const CHAR = 'char';
    public const ANY = 'any';

    protected Map $map;
    protected string $keyType;
    protected string $valueType;

    public function __construct(string $keyType = self::ANY, string $valueType = self::ANY)
    {
        $this->keyType = strtolower($keyType);

        $this->valueType = class_exists($valueType) ? $valueType : strtolower($valueType);

        if (!$this->isValidKeyType($this->keyType)) {
            throw new InvalidArgumentException(sprintf('Invalid key type (%s)', $this->keyType));
        }

        if (!$this->isValidValueType($this->valueType)) {
            throw new InvalidArgumentException(sprintf('Invalid value type (%s)', $this->valueType));
        }

        $this->map = new Map();
    }

    public function getKeyType(): string
    {
        return $this->keyType;
    }

    public function getValueType(): string
    {
        return $this->valueType;
    }

    /**
     * @inheritDoc
     */
    public function offsetExists($offset): bool
    {
        if (is_array($offset) || is_object($offset)) {
            throw new InvalidArgumentException('Map keys cannot be objects or arrays');
        }

        if (!$this->checkType($this->keyType, $offset)) {
            throw new TypeError(sprintf('Key should be of value %s.', $this->keyType));
        }

        return $this->map->offsetExists($offset);
    }

    /**
     * @inheritDoc
     */
    public function offsetGet($offset)
    {
        if (is_array($offset) || is_object($offset)) {
            throw new InvalidArgumentException('Map keys cannot be objects or arrays');
        }

        if (!$this->checkType($this->keyType, $offset)) {
            throw new TypeError(sprintf('Key should be of value %s.', $this->keyType));
        }
        if (!$this->map->offsetExists($offset)) {
            return null;
        }
        return $this->map->offsetGet($offset);
    }

    /**
     * @inheritDoc
     */
    public function offsetSet($offset, $value): void
    {
        if (is_array($offset) || is_object($offset)) {
            throw new InvalidArgumentException('Map keys cannot be objects or arrays');
        }

        if (!$this->checkType($this->keyType, $offset)) {
            throw new TypeError(sprintf('Key should be of value %s.', $this->keyType));
        }

        if (!$this->checkType($this->valueType, $value)) {
            throw new ValueError(sprintf('Value should be of type %s.', $this->valueType));
        }

        $this->map->offsetSet($offset, $value);
    }

    /**
     * @inheritDoc
     */
    public function offsetUnset($offset): void
    {
        if (is_array($offset) || is_object($offset)) {
            throw new InvalidArgumentException('Map keys cannot be objects or arrays');
        }

        if (!$this->checkType($this->keyType, $offset)) {
            throw new TypeError(sprintf('Key should be of value %s.', $this->keyType));
        }

        $this->map->offsetUnset($offset);
    }

    /**
     * Count elements of an object
     *
     * @link https://php.net/manual/en/countable.count.php
     * @return int The custom count as an integer.
     * </p>
     * <p>
     * The return value is cast to an integer.
     */
    public function count(): int
    {
        return $this->map->count();
    }

    public function toArray(): array
    {
        return $this->map->toArray();
    }

    protected function assertInitialValues(array $initialValues): bool
    {
        foreach ($initialValues as $key => $value) {
            if (!$this->checkType($this->keyType, $key) || !$this->checkType($this->valueType, $value)) {
                throw new InvalidArgumentException(sprintf('Invalid types for map [%s => %s], they should be [%s => %s]', get_debug_type($key), get_debug_type($value), $this->keyType, $this->valueType));
            }
        }
        
        return true;
    }

    /**
     * @codeCoverageIgnore
     * @param string $type
     * @param        $var
     *
     * @return bool
     */
    private function checkType(string $type, $var): bool
    {
        switch ($type) {
            case self::OBJECT:
                return is_object($var);
            case self::CALLABLE:
                return is_callable($var);
            case self::ARRAY:
                return is_array($var);
            case self::INT:
            case self::INTEGER:
                return is_int($var);
            case self::STRING:
                return is_string($var);
            case self::CHAR:
                return is_string($var) && \mb_strlen($var) === 1;
            case self::ANY:
                return true;
            default:
                return $var instanceof $type;
        }
    }
    private function isValidKeyType(string $type): bool
    {
        return in_array($type, [
            self::INT,
            self::INTEGER,
            self::STRING,
            self::CHAR,
            self::ANY,
        ], true);
    }

    private function isValidValueType(string $type): bool
    {
        if (class_exists($type)) {
            return true;
        }

        return in_array($type, [
          self::OBJECT,
          self::CALLABLE,
          self::ARRAY,
          self::INT,
          self::INTEGER,
          self::STRING,
          self::CHAR,
          self::ANY,
        ], true);
    }
}