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 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\Enum\KeyType;
use Olivebbs\Map\Enum\ValueType;
use Olivebbs\Map\Exception\InvalidArgumentException;
use function sprintf;

class GenericMap implements ArrayAccess, Countable
{
    protected Map $map;

    private readonly string $valueTypeValue;
    private readonly string $keyTypeValue;

    public function __construct(protected KeyType $keyType = KeyType::ANY, protected object|string $valueType = ValueType::ANY)
    {
        $this->keyTypeValue = $this->keyType->value;
        $this->valueTypeValue = is_string(value: $this->valueType) ? $this->valueType : $this->valueType->value;

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

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

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

    public function getValueType(): object|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: $offset, value: $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($this->keyType, $key) || !$this->checkType($this->valueType, $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->value, is_string($this->valueType) ? $this->valueType : $this->valueType->value));
            }
        }
        
        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 InvalidArgumentException(message: sprintf('Key should be of value %s.', $this->keyTypeValue));
        }

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

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

    private function isValidValueType(object|string $type): bool
    {
        if (is_string(value: $type) && class_exists(class: $type)) {
            return true;
        }

        return $type instanceof ValueType;
    }
}