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 function class_exists;
use Countable;
use Ds\Map;
use function enum_exists;
use function in_array;
use function is_array;
use function is_callable;
use function is_int;
use function is_object;
use function is_string;
use function mb_strlen;
use Olivebbs\Map\Exception\InvalidArgumentException;
use function sprintf;
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 ENUM = 'enum';
    public const ANY = 'any';

    protected Map $map;

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

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

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

        if (!$this->isValidValueType(type: $this->valueType)) {
            throw new InvalidArgumentException(message: 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(mixed $offset): bool
    {
        $this->checkTypes(offset: $offset);

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

    /**
     * @inheritDoc
     */
    public function offsetGet(mixed $offset): mixed
    {
        $this->checkTypes(offset: $offset);

        if (!$this->map->offsetExists(offset: $offset)) {
            return null;
        }

        return $this->map->offsetGet(offset: $offset);
    }

    /**
     * @inheritDoc
     */
    public function offsetSet(mixed $offset, mixed $value): void
    {
        $this->checkTypes($offset, $value);

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

    /**
     * @inheritDoc
     */
    public function offsetUnset(mixed $offset): void
    {
        $this->checkTypes(offset: $offset);

        $this->map->offsetUnset(offset: $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(type: $this->keyType, var: $key) || !$this->checkType(type: $this->valueType, var: $value)) {
                throw new InvalidArgumentException(message: sprintf('Invalid types for map [%s => %s], they should be [%s => %s]', get_debug_type(value: $key), get_debug_type(value: $value), $this->keyType, $this->valueType));
            }
        }
        
        return true;
    }

    private function checkTypes(mixed $offset, mixed $value = null): void
    {
        if (is_array(value: $offset) || is_object(value: $offset)) {
            throw new InvalidArgumentException(message: 'Map keys cannot be objects or arrays');
        }

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

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

    /**
     * @codeCoverageIgnore
     * @param string $type
     * @param mixed  $var
     *
     * @return bool
     */
    private function checkType(string $type, mixed $var): bool
    {
        return match ($type) {
            self::OBJECT => is_object(value: $var),
            self::CALLABLE => is_callable(value: $var),
            self::ARRAY => is_array(value: $var),
            self::INT, self::INTEGER => is_int(value: $var),
            self::STRING => is_string(value: $var),
            self::CHAR => is_string(value: $var) && (function_exists('mb_strlen') ? mb_strlen(string: $var) === 1 : strlen(string: $var) === 1),
            self::ENUM => is_object(value: $var) && enum_exists(enum: $var::class),
            self::ANY => true,
            default => $var instanceof $type,
        };
    }

    private function isValidKeyType(string $type): bool
    {
        return in_array(needle: $type, haystack: [
            self::INT,
            self::INTEGER,
            self::STRING,
            self::CHAR,
            self::ANY,
        ], strict: true);
    }

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

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