<?php
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

namespace Apache\Ignite\Cache;

use Apache\Ignite\Type\ObjectType;
use Apache\Ignite\Type\ObjectArrayType;
use Apache\Ignite\Type\ComplexObjectType;
use Apache\Ignite\Exception\ClientException;
use Apache\Ignite\Internal\Binary\MessageBuffer;
use Apache\Ignite\Internal\Binary\BinaryUtils;
use Apache\Ignite\Internal\Binary\BinaryCommunicator;
use Apache\Ignite\Internal\Utils\ArgumentChecker;

/**
 * Class representing Ignite cache configuration on a server.
 *
 * All configuration settings are optional and have defaults which are defined on a server side.
 *
 * See Apache Ignite documentation for details of every configuration setting. 
 */
class CacheConfiguration
{
    const PROP_NAME = 0;
    const PROP_CACHE_MODE = 1;
    const PROP_ATOMICITY_MODE = 2;
    const PROP_BACKUPS = 3;
    const PROP_WRITE_SYNCHRONIZATION_MODE = 4;
    const PROP_COPY_ON_READ = 5;
    const PROP_READ_FROM_BACKUP = 6;
    const PROP_DATA_REGION_NAME = 100;
    const PROP_IS_ONHEAP_CACHE_ENABLED = 101;
    const PROP_QUERY_ENTITY = 200;
    const PROP_QUERY_PARALLELISM = 201;
    const PROP_QUERY_DETAIL_METRICS_SIZE = 202;
    const PROP_SQL_SCHEMA = 203;
    const PROP_SQL_INDEX_INLINE_MAX_SIZE = 204;
    const PROP_SQL_ESCAPE_ALL = 205;
    const PROP_MAX_QUERY_ITERATORS = 206;
    const PROP_REBALANCE_MODE = 300;
    const PROP_REBALANCE_DELAY = 301;
    const PROP_REBALANCE_TIMEOUT = 302;
    const PROP_REBALANCE_BATCH_SIZE = 303;
    const PROP_REBALANCE_BATCHES_PREFETCH_COUNT = 304;
    const PROP_REBALANCE_ORDER = 305;
    const PROP_REBALANCE_THROTTLE = 306;
    const PROP_GROUP_NAME = 400;
    const PROP_CACHE_KEY_CONFIGURATION = 401;
    const PROP_DEFAULT_LOCK_TIMEOUT = 402;
    const PROP_MAX_CONCURRENT_ASYNC_OPS = 403;
    const PROP_PARTITION_LOSS_POLICY = 404;
    const PROP_EAGER_TTL = 405;
    const PROP_STATISTICS_ENABLED = 406;

    /** @name AtomicityMode
     *  @anchor AtomicityMode
     *  @{
     */
    const ATOMICITY_MODE_TRANSACTIONAL = 0;
    const ATOMICITY_MODE_ATOMIC = 1;
    /** @} */ // end of AtomicityMode

    /** @name CacheMode
     *  @anchor CacheMode
     *  @{
     */
    const CACHE_MODE_LOCAL = 0;
    const CACHE_MODE_REPLICATED = 1;
    const CACHE_MODE_PARTITIONED = 2;
    /** @} */ // end of CacheMode

    /** @name PartitionLossPolicy
     *  @anchor PartitionLossPolicy
     *  @{
     */
    const PARTITION_LOSS_POLICY_READ_ONLY_SAFE = 0;
    const PARTITION_LOSS_POLICY_READ_ONLY_ALL = 1;
    const PARTITION_LOSS_POLICY_READ_WRITE_SAFE = 2;
    const PARTITION_LOSS_POLICY_READ_WRITE_ALL = 3;
    const PARTITION_LOSS_POLICY_IGNORE = 4;
    /** @} */ // end of PartitionLossPolicy

    /** @name RebalanceMode
     *  @anchor RebalanceMode
     *  @{
     */
    const REABALANCE_MODE_SYNC = 0;
    const REABALANCE_MODE_ASYNC = 1;
    const REABALANCE_MODE_NONE = 2;
    /** @} */ // end of RebalanceMode

    /** @name WriteSynchronizationMode
     *  @anchor WriteSynchronizationMode
     *  @{
     */
    const WRITE_SYNC_MODE_FULL_SYNC = 0;
    const WRITE_SYNC_MODE_FULL_ASYNC = 1;
    const WRITE_SYNC_MODE_PRIMARY_SYNC = 2;
    /** @} */ // end of WriteSynchronizationMode

    private $properties;
    private static $propInfo;

    /**
     * Public CacheConfiguration constructor.
     */
    public function __construct()
    {
        $this->properties = [];
    }

    /**
     *
     *
     * @param string $name
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setName(string $name): CacheConfiguration
    {
        $this->properties[self::PROP_NAME] = $name;
        return $this;
    }

    /**
     *
     *
     * @return string|null
     */
    public function getName(): ?string
    {
        return $this->getProperty(self::PROP_NAME);
    }

    /**
     *
     *
     * @param int $atomicityMode one of @ref AtomicityMode constants.
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     *
     * @throws ClientException if error.
     */
    public function setAtomicityMode(int $atomicityMode): CacheConfiguration
    {
        ArgumentChecker::hasValueFrom(
            $atomicityMode, 'atomicityMode', false, [self::ATOMICITY_MODE_TRANSACTIONAL, self::ATOMICITY_MODE_ATOMIC]);
        $this->properties[self::PROP_ATOMICITY_MODE] = $atomicityMode;
        return $this;
    }

    /**
     *
     *
     * @return int|null
     */
    public function getAtomicityMode(): ?int
    {
        return $this->getProperty(self::PROP_ATOMICITY_MODE);
    }

    /**
     *
     *
     * @param int $backups
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setBackups(int $backups): CacheConfiguration
    {
        $this->properties[self::PROP_BACKUPS] = $backups;
        return $this;
    }

    /**
     *
     *
     * @return int|null
     */
    public function getBackups(): ?int
    {
        return $this->getProperty(self::PROP_BACKUPS);
    }

    /**
     *
     *
     * @param int $cacheMode one of @ref CacheMode constants.
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     *
     * @throws ClientException if error.
     */
    public function setCacheMode(int $cacheMode): CacheConfiguration
    {
        ArgumentChecker::hasValueFrom(
            $cacheMode,
            'cacheMode',
            false,
            [self::CACHE_MODE_LOCAL, self::CACHE_MODE_REPLICATED, self::CACHE_MODE_PARTITIONED]);
        $this->properties[self::PROP_CACHE_MODE] = $cacheMode;
        return $this;
    }

    /**
     *
     *
     * @return int|null
     */
    public function getCacheMode(): ?int
    {
        return $this->getProperty(self::PROP_CACHE_MODE);
    }

    /**
     *
     *
     * @param bool $copyOnRead
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setCopyOnRead(bool $copyOnRead): CacheConfiguration
    {
        $this->properties[self::PROP_COPY_ON_READ] = $copyOnRead;
        return $this;
    }

    /**
     *
     *
     * @return bool|null
     */
    public function getCopyOnRead(): ?bool
    {
        return $this->getProperty(self::PROP_COPY_ON_READ);
    }

    /**
     *
     *
     * @param string|null $dataRegionName
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setDataRegionName(?string $dataRegionName): CacheConfiguration
    {
        $this->properties[self::PROP_DATA_REGION_NAME] = $dataRegionName;
        return $this;
    }

    /**
     *
     *
     * @return string|null
     */
    public function getDataRegionName(): ?string
    {
        return $this->getProperty(self::PROP_DATA_REGION_NAME);
    }

    /**
     *
     *
     * @param bool $eagerTtl
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setEagerTtl(bool $eagerTtl): CacheConfiguration
    {
        $this->properties[self::PROP_EAGER_TTL] = $eagerTtl;
        return $this;
    }

    /**
     *
     *
     * @return bool|null
     */
    public function getEagerTtl(): ?bool
    {
        return $this->getProperty(self::PROP_EAGER_TTL);
    }

    /**
     *
     *
     * @param bool $statisticsEnabled
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setStatisticsEnabled(bool $statisticsEnabled): CacheConfiguration
    {
        $this->properties[self::PROP_STATISTICS_ENABLED] = $statisticsEnabled;
        return $this;
    }

    /**
     *
     *
     * @return bool|null
     */
    public function getStatisticsEnabled(): ?bool
    {
        return $this->getProperty(self::PROP_STATISTICS_ENABLED);
    }

    /**
     *
     *
     * @param string|null $groupName
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setGroupName(?string $groupName): CacheConfiguration
    {
        $this->properties[self::PROP_GROUP_NAME] = $groupName;
        return $this;
    }

    /**
     *
     *
     * @return string|null
     */
    public function getGroupName(): ?string
    {
        return $this->getProperty(self::PROP_GROUP_NAME);
    }

    /**
     *
     *
     * @param float $lockTimeout
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setDefaultLockTimeout(float $lockTimeout): CacheConfiguration
    {
        $this->properties[self::PROP_DEFAULT_LOCK_TIMEOUT] = $lockTimeout;
        return $this;
    }

    /**
     *
     *
     * @return float|null
     */
    public function getDefaultLockTimeout(): ?float
    {
        return $this->getProperty(self::PROP_DEFAULT_LOCK_TIMEOUT);
    }

    /**
     *
     *
     * @param int $maxConcurrentAsyncOperations
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setMaxConcurrentAsyncOperations(int $maxConcurrentAsyncOperations): CacheConfiguration
    {
        $this->properties[self::PROP_MAX_CONCURRENT_ASYNC_OPS] = $maxConcurrentAsyncOperations;
        return $this;
    }

    /**
     *
     *
     * @return int|null
     */
    public function getMaxConcurrentAsyncOperations(): ?int
    {
        return $this->getProperty(self::PROP_MAX_CONCURRENT_ASYNC_OPS);
    }

    /**
     *
     *
     * @param int $maxQueryIterators
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setMaxQueryIterators(int $maxQueryIterators): CacheConfiguration
    {
        $this->properties[self::PROP_MAX_QUERY_ITERATORS] = $maxQueryIterators;
        return $this;
    }

    /**
     *
     *
     * @return int|null
     */
    public function getMaxQueryIterators(): ?int
    {
        return $this->getProperty(self::PROP_MAX_QUERY_ITERATORS);
    }

    /**
     *
     *
     * @param bool $isOnheapCacheEnabled
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setIsOnheapCacheEnabled(bool $isOnheapCacheEnabled): CacheConfiguration
    {
        $this->properties[self::PROP_IS_ONHEAP_CACHE_ENABLED] = $isOnheapCacheEnabled;
        return $this;
    }

    /**
     *
     *
     * @return bool|null
     */
    public function getIsOnheapCacheEnabled(): ?bool
    {
        return $this->getProperty(self::PROP_IS_ONHEAP_CACHE_ENABLED);
    }

    /**
     *
     *
     * @param int $partitionLossPolicy one of @ref PartitionLossPolicy constants.
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     *
     * @throws ClientException if error.
     */
    public function setPartitionLossPolicy(int $partitionLossPolicy): CacheConfiguration
    {
        ArgumentChecker::hasValueFrom(
            $partitionLossPolicy,
            'partitionLossPolicy',
            false,
            [
                self::PARTITION_LOSS_POLICY_READ_ONLY_SAFE,
                self::PARTITION_LOSS_POLICY_READ_ONLY_ALL,
                self::PARTITION_LOSS_POLICY_READ_WRITE_SAFE,
                self::PARTITION_LOSS_POLICY_READ_WRITE_ALL,
                self::PARTITION_LOSS_POLICY_IGNORE
            ]);
        $this->properties[self::PROP_PARTITION_LOSS_POLICY] = $partitionLossPolicy;
        return $this;
    }

    /**
     *
     *
     * @return int|null
     */
    public function getPartitionLossPolicy(): ?int
    {
        return $this->getProperty(self::PROP_PARTITION_LOSS_POLICY);
    }

    /**
     *
     *
     * @param int $queryDetailMetricsSize
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setQueryDetailMetricsSize(int $queryDetailMetricsSize): CacheConfiguration
    {
        $this->properties[self::PROP_QUERY_DETAIL_METRICS_SIZE] = $queryDetailMetricsSize;
        return $this;
    }

    /**
     *
     *
     * @return int|null
     */
    public function getQueryDetailMetricsSize(): ?int
    {
        return $this->getProperty(self::PROP_QUERY_DETAIL_METRICS_SIZE);
    }

    /**
     *
     *
     * @param int $queryParallelism
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setQueryParallelism(int $queryParallelism): CacheConfiguration
    {
        $this->properties[self::PROP_QUERY_PARALLELISM] = $queryParallelism;
        return $this;
    }

    /**
     *
     *
     * @return int|null
     */
    public function getQueryParallelism(): ?int
    {
        return $this->getProperty(self::PROP_QUERY_PARALLELISM);
    }

    /**
     *
     *
     * @param bool $readFromBackup
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setReadFromBackup(bool $readFromBackup): CacheConfiguration
    {
        $this->properties[self::PROP_READ_FROM_BACKUP] = $readFromBackup;
        return $this;
    }

    /**
     *
     *
     * @return bool|null
     */
    public function getReadFromBackup(): ?bool
    {
        return $this->getProperty(self::PROP_READ_FROM_BACKUP);
    }

    /**
     *
     *
     * @param int $rebalanceBatchSize
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setRebalanceBatchSize(int $rebalanceBatchSize): CacheConfiguration
    {
        $this->properties[self::PROP_REBALANCE_BATCH_SIZE] = $rebalanceBatchSize;
        return $this;
    }

    /**
     *
     *
     * @return int|null
     */
    public function getRebalanceBatchSize(): ?int
    {
        return $this->getProperty(self::PROP_REBALANCE_BATCH_SIZE);
    }

    /**
     *
     *
     * @param float $rebalanceBatchesPrefetchCount
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setRebalanceBatchesPrefetchCount(float $rebalanceBatchesPrefetchCount): CacheConfiguration
    {
        $this->properties[self::PROP_REBALANCE_BATCHES_PREFETCH_COUNT] = $rebalanceBatchesPrefetchCount;
        return $this;
    }

    /**
     *
     *
     * @return float|null
     */
    public function getRebalanceBatchesPrefetchCount(): ?float
    {
        return $this->getProperty(self::PROP_REBALANCE_BATCHES_PREFETCH_COUNT);
    }

    /**
     *
     *
     * @param float $rebalanceDelay
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setRebalanceDelay(float $rebalanceDelay): CacheConfiguration
    {
        $this->properties[self::PROP_REBALANCE_DELAY] = $rebalanceDelay;
        return $this;
    }

    /**
     *
     *
     * @return float|null
     */
    public function getRebalanceDelay(): ?float
    {
        return $this->getProperty(self::PROP_REBALANCE_DELAY);
    }

    /**
     *
     *
     * @param int $rebalanceMode one of @ref RebalanceMode constants.
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     *
     * @throws ClientException if error.
     */
    public function setRebalanceMode(int $rebalanceMode): CacheConfiguration
    {
        ArgumentChecker::hasValueFrom(
            $rebalanceMode,
            'rebalanceMode',
            false,
            [self::REABALANCE_MODE_SYNC, self::REABALANCE_MODE_ASYNC, self::REABALANCE_MODE_NONE]);
        $this->properties[self::PROP_REBALANCE_MODE] = $rebalanceMode;
        return $this;
    }

    /**
     *
     *
     * @return int|null
     */
    public function getRebalanceMode(): ?int
    {
        return $this->getProperty(self::PROP_REBALANCE_MODE);
    }

    /**
     *
     *
     * @param int $rebalanceOrder
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setRebalanceOrder(int $rebalanceOrder): CacheConfiguration
    {
        $this->properties[self::PROP_REBALANCE_ORDER] = $rebalanceOrder;
        return $this;
    }

    /**
     *
     *
     * @return int|null
     */
    public function getRebalanceOrder(): ?int
    {
        return $this->getProperty(self::PROP_REBALANCE_ORDER);
    }

    /**
     *
     *
     * @param float $rebalanceThrottle
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setRebalanceThrottle(float $rebalanceThrottle): CacheConfiguration
    {
        $this->properties[self::PROP_REBALANCE_THROTTLE] = $rebalanceThrottle;
        return $this;
    }

    /**
     *
     *
     * @return float|null
     */
    public function getRebalanceThrottle(): ?float
    {
        return $this->getProperty(self::PROP_REBALANCE_THROTTLE);
    }

    /**
     *
     *
     * @param float $rebalanceTimeout
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setRebalanceTimeout(float $rebalanceTimeout): CacheConfiguration
    {
        $this->properties[self::PROP_REBALANCE_TIMEOUT] = $rebalanceTimeout;
        return $this;
    }

    /**
     *
     *
     * @return float|null
     */
    public function getRebalanceTimeout(): ?float
    {
        return $this->getProperty(self::PROP_REBALANCE_TIMEOUT);
    }

    /**
     *
     *
     * @param bool $sqlEscapeAll
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setSqlEscapeAll(bool $sqlEscapeAll): CacheConfiguration
    {
        $this->properties[self::PROP_SQL_ESCAPE_ALL] = $sqlEscapeAll;
        return $this;
    }

    /**
     *
     *
     * @return bool|null
     */
    public function getSqlEscapeAll(): ?bool
    {
        return $this->getProperty(self::PROP_SQL_ESCAPE_ALL);
    }

    /**
     *
     *
     * @param int $sqlIndexInlineMaxSize
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setSqlIndexInlineMaxSize(int $sqlIndexInlineMaxSize): CacheConfiguration
    {
        $this->properties[self::PROP_SQL_INDEX_INLINE_MAX_SIZE] = $sqlIndexInlineMaxSize;
        return $this;
    }

    /**
     *
     *
     * @return int|null
     */
    public function getSqlIndexInlineMaxSize(): ?int
    {
        return $this->getProperty(self::PROP_SQL_INDEX_INLINE_MAX_SIZE);
    }

    /**
     *
     *
     * @param string|null $sqlSchema
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setSqlSchema(?string $sqlSchema): CacheConfiguration
    {
        $this->properties[self::PROP_SQL_SCHEMA] = $sqlSchema;
        return $this;
    }

    /**
     *
     *
     * @return string|null
     */
    public function getSqlSchema(): ?string
    {
        return $this->getProperty(self::PROP_SQL_SCHEMA);
    }

    /**
     *
     *
     * @param int $writeSynchronizationMode one of @ref WriteSynchronizationMode constants.
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     *
     * @throws ClientException if error.
     */
    public function setWriteSynchronizationMode(int $writeSynchronizationMode): CacheConfiguration
    {
        ArgumentChecker::hasValueFrom(
            $writeSynchronizationMode,
            'writeSynchronizationMode',
            false,
            [self::WRITE_SYNC_MODE_FULL_SYNC, self::WRITE_SYNC_MODE_FULL_ASYNC, self::WRITE_SYNC_MODE_PRIMARY_SYNC]);
        $this->properties[self::PROP_WRITE_SYNCHRONIZATION_MODE] = $writeSynchronizationMode;
        return $this;
    }

    /**
     *
     *
     * @return int|null
     */
    public function getWriteSynchronizationMode(): ?int
    {
        return $this->getProperty(self::PROP_WRITE_SYNCHRONIZATION_MODE);
    }

    /**
     *
     *
     * @param CacheKeyConfiguration ...$keyConfigurations
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setKeyConfigurations(CacheKeyConfiguration ...$keyConfigurations): CacheConfiguration
    {
        $this->properties[self::PROP_CACHE_KEY_CONFIGURATION] = $keyConfigurations;
        return $this;
    }

    /**
     *
     *
     * @return CacheKeyConfiguration[]|null
     */
    public function getKeyConfigurations(): ?array
    {
        return $this->getProperty(self::PROP_CACHE_KEY_CONFIGURATION);
    }

    /**
     *
     *
     * @param QueryEntity ...$queryEntities
     *
     * @return CacheConfiguration the same instance of the CacheConfiguration.
     */
    public function setQueryEntities(QueryEntity ...$queryEntities): CacheConfiguration
    {
        $this->properties[self::PROP_QUERY_ENTITY] = $queryEntities;
        return $this;
    }

    /**
     *
     *
     * @return QueryEntity[]|null
     */
    public function getQueryEntities(): ?array
    {
        return $this->getProperty(self::PROP_QUERY_ENTITY);
    }

    private function getProperty(int $prop)
    {
        if (array_key_exists($prop, $this->properties)) {
            return $this->properties[$prop];
        }
        return null;
    }

    static function init(): void
    {
        self::$propInfo = array(
            self::PROP_NAME => ObjectType::STRING,
            self::PROP_CACHE_MODE => ObjectType::INTEGER,
            self::PROP_ATOMICITY_MODE => ObjectType::INTEGER,
            self::PROP_BACKUPS => ObjectType::INTEGER,
            self::PROP_WRITE_SYNCHRONIZATION_MODE => ObjectType::INTEGER,
            self::PROP_COPY_ON_READ => ObjectType::BOOLEAN,
            self::PROP_READ_FROM_BACKUP => ObjectType::BOOLEAN,
            self::PROP_DATA_REGION_NAME => ObjectType::STRING,
            self::PROP_IS_ONHEAP_CACHE_ENABLED => ObjectType::BOOLEAN,
            self::PROP_QUERY_ENTITY => new ObjectArrayType((new ComplexObjectType())->setPhpClassName(QueryEntity::class)),
            self::PROP_QUERY_PARALLELISM => ObjectType::INTEGER,
            self::PROP_QUERY_DETAIL_METRICS_SIZE => ObjectType::INTEGER,
            self::PROP_SQL_SCHEMA => ObjectType::STRING,
            self::PROP_SQL_INDEX_INLINE_MAX_SIZE => ObjectType::INTEGER,
            self::PROP_SQL_ESCAPE_ALL => ObjectType::BOOLEAN,
            self::PROP_MAX_QUERY_ITERATORS => ObjectType::INTEGER,
            self::PROP_REBALANCE_MODE => ObjectType::INTEGER,
            self::PROP_REBALANCE_DELAY => ObjectType::LONG,
            self::PROP_REBALANCE_TIMEOUT => ObjectType::LONG,
            self::PROP_REBALANCE_BATCH_SIZE => ObjectType::INTEGER,
            self::PROP_REBALANCE_BATCHES_PREFETCH_COUNT => ObjectType::LONG,
            self::PROP_REBALANCE_ORDER => ObjectType::INTEGER,
            self::PROP_REBALANCE_THROTTLE => ObjectType::LONG,
            self::PROP_GROUP_NAME => ObjectType::STRING,
            self::PROP_CACHE_KEY_CONFIGURATION => new ObjectArrayType((new ComplexObjectType())->setPhpClassName(CacheKeyConfiguration::class)),
            self::PROP_DEFAULT_LOCK_TIMEOUT => ObjectType::LONG,
            self::PROP_MAX_CONCURRENT_ASYNC_OPS => ObjectType::INTEGER,
            self::PROP_PARTITION_LOSS_POLICY => ObjectType::INTEGER,
            self::PROP_EAGER_TTL => ObjectType::BOOLEAN,
            self::PROP_STATISTICS_ENABLED => ObjectType::BOOLEAN
        );
    }

    // This is not the public API method, is not intended for usage by an application.
    public function write(BinaryCommunicator $communicator, MessageBuffer $buffer, string $name): void
    {
        $this->setName($name);

        $startPos = $buffer->getPosition();
        $buffer->setPosition($startPos +
            BinaryUtils::getSize(ObjectType::INTEGER) +
            BinaryUtils::getSize(ObjectType::SHORT));

        foreach ($this->properties as $propertyCode => $property) {
            $this->writeProperty($communicator, $buffer, $propertyCode, $property);
        }

        $length = $buffer->getPosition() - $startPos;
        $buffer->setPosition($startPos);

        $buffer->writeInteger($length);
        $buffer->writeShort(count($this->properties));
    }

    private function writeProperty(BinaryCommunicator $communicator, MessageBuffer $buffer, int $propertyCode, $property): void
    {
        $buffer->writeShort($propertyCode);
        $propertyType = self::$propInfo[$propertyCode];
        switch (BinaryUtils::getTypeCode($propertyType)) {
            case ObjectType::INTEGER:
            case ObjectType::LONG:
            case ObjectType::BOOLEAN:
                $communicator->writeObject($buffer, $property, $propertyType, false);
                return;
            case ObjectType::STRING:
                $communicator->writeObject($buffer, $property, $propertyType);
                return;
            case ObjectType::OBJECT_ARRAY:
                $length = $property ? count($property) : 0;
                $buffer->writeInteger($length);
                foreach ($property as $prop) {
                    $prop->write($communicator, $buffer);
                }
                return;
            default:
                BinaryUtils::internalError();
        }
    }

    // This is not the public API method, is not intended for usage by an application.
    public function read(BinaryCommunicator $communicator, MessageBuffer $buffer): void
    {
        //length
        $buffer->readInteger();
        $this->readProperty($communicator, $buffer, self::PROP_ATOMICITY_MODE);
        $this->readProperty($communicator, $buffer, self::PROP_BACKUPS);
        $this->readProperty($communicator, $buffer, self::PROP_CACHE_MODE);
        $this->readProperty($communicator, $buffer, self::PROP_COPY_ON_READ);
        $this->readProperty($communicator, $buffer, self::PROP_DATA_REGION_NAME);
        $this->readProperty($communicator, $buffer, self::PROP_EAGER_TTL);
        $this->readProperty($communicator, $buffer, self::PROP_STATISTICS_ENABLED);
        $this->readProperty($communicator, $buffer, self::PROP_GROUP_NAME);
        $this->readProperty($communicator, $buffer, self::PROP_DEFAULT_LOCK_TIMEOUT);
        $this->readProperty($communicator, $buffer, self::PROP_MAX_CONCURRENT_ASYNC_OPS);
        $this->readProperty($communicator, $buffer, self::PROP_MAX_QUERY_ITERATORS);
        $this->readProperty($communicator, $buffer, self::PROP_NAME);
        $this->readProperty($communicator, $buffer, self::PROP_IS_ONHEAP_CACHE_ENABLED);
        $this->readProperty($communicator, $buffer, self::PROP_PARTITION_LOSS_POLICY);
        $this->readProperty($communicator, $buffer, self::PROP_QUERY_DETAIL_METRICS_SIZE);
        $this->readProperty($communicator, $buffer, self::PROP_QUERY_PARALLELISM);
        $this->readProperty($communicator, $buffer, self::PROP_READ_FROM_BACKUP);
        $this->readProperty($communicator, $buffer, self::PROP_REBALANCE_BATCH_SIZE);
        $this->readProperty($communicator, $buffer, self::PROP_REBALANCE_BATCHES_PREFETCH_COUNT);
        $this->readProperty($communicator, $buffer, self::PROP_REBALANCE_DELAY);
        $this->readProperty($communicator, $buffer, self::PROP_REBALANCE_MODE);
        $this->readProperty($communicator, $buffer, self::PROP_REBALANCE_ORDER);
        $this->readProperty($communicator, $buffer, self::PROP_REBALANCE_THROTTLE);
        $this->readProperty($communicator, $buffer, self::PROP_REBALANCE_TIMEOUT);
        $this->readProperty($communicator, $buffer, self::PROP_SQL_ESCAPE_ALL);
        $this->readProperty($communicator, $buffer, self::PROP_SQL_INDEX_INLINE_MAX_SIZE);
        $this->readProperty($communicator, $buffer, self::PROP_SQL_SCHEMA);
        $this->readProperty($communicator, $buffer, self::PROP_WRITE_SYNCHRONIZATION_MODE);
        $this->readProperty($communicator, $buffer, self::PROP_CACHE_KEY_CONFIGURATION);
        $this->readProperty($communicator, $buffer, self::PROP_QUERY_ENTITY);
    }

    private function readProperty(BinaryCommunicator $communicator, MessageBuffer $buffer, int $propertyCode): void
    {
        $propertyType = self::$propInfo[$propertyCode];
        switch (BinaryUtils::getTypeCode($propertyType)) {
            case ObjectType::INTEGER:
            case ObjectType::LONG:
            case ObjectType::BOOLEAN:
                $this->properties[$propertyCode] = $communicator->readTypedObject($buffer, $propertyType);
                return;
            case ObjectType::STRING:
                $this->properties[$propertyCode] = $communicator->readObject($buffer, $propertyType);
                return;
            case ObjectType::OBJECT_ARRAY:
                $length = $buffer->readInteger();
                $properties = [];
                for ($i = 0; $i < $length; $i++) {
                    $propClassName = $propertyType->getElementType()->getPhpClassName();
                    $property = new $propClassName();
                    $property->read($communicator, $buffer);
                    array_push($properties, $property);
                }
                $this->properties[$propertyCode] = $properties;
                return;
            default:
                BinaryUtils::internalError();
        }
    }
}

CacheConfiguration::init();