<?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\Tests;

use Apache\Ignite\Cache\CacheKeyConfiguration;
use Apache\Ignite\Cache\QueryField;
use Apache\Ignite\Cache\QueryEntity;
use Apache\Ignite\Cache\QueryIndex;
use PHPUnit\Framework\TestCase;
use Apache\Ignite\Cache\CacheInterface;
use Apache\Ignite\Cache\CacheConfiguration;
use Apache\Ignite\Exception\OperationException;
use Apache\Ignite\Exception\ClientException;

final class CacheTestCase extends TestCase
{
    const CACHE_NAME = '__php_test_cache';
    const CACHE_NAME2 = '__php_test_cache2';
    const CACHE_NAME3 = '__php_test_cache3';
    const CACHE_NAME4 = '__php_test_cache4';

    public static function setUpBeforeClass(): void
    {
        TestingHelper::init();
        self::cleanUp();
    }

    public static function tearDownAfterClass(): void
    {
        self::cleanUp();
        TestingHelper::cleanUp();
    }
    
    public function testCreateCache(): void
    {
        $client = TestingHelper::$client;
        $cache = $client->getCache(self::CACHE_NAME);
        $this->checkCache($cache, false);
        $cache = $client->createCache(self::CACHE_NAME);
        $this->checkCache($cache, true);
        $cache = $client->getCache(self::CACHE_NAME);
        $this->checkCache($cache, true);
        $client->destroyCache(self::CACHE_NAME);
    }
    
    public function testCreateCacheTwice(): void
    {
        $client = TestingHelper::$client;
        try {
            $client->getOrCreateCache(self::CACHE_NAME);
            $this->expectException(OperationException::class);
            $client->createCache(self::CACHE_NAME);
        } finally {
            $client->destroyCache(self::CACHE_NAME);
        }
    }
    
    public function testGetOrCreateCache(): void
    {
        $client = TestingHelper::$client;
        $cache = $client->getCache(self::CACHE_NAME);
        $this->checkCache($cache, false);
        $cache = $client->getOrCreateCache(self::CACHE_NAME);
        $this->checkCache($cache, true);
        $cache = $client->getCache(self::CACHE_NAME);
        $this->checkCache($cache, true);
        $client->destroyCache(self::CACHE_NAME);
    }

    public function testGetCacheNames(): void
    {
        $client = TestingHelper::$client;
        $client->getOrCreateCache(self::CACHE_NAME);
        $client->getOrCreateCache(self::CACHE_NAME2);
        $cacheNames = $client->cacheNames();
        $this->assertContains(self::CACHE_NAME, $cacheNames);
        $this->assertContains(self::CACHE_NAME2, $cacheNames);
        $client->destroyCache(self::CACHE_NAME);
        $client->destroyCache(self::CACHE_NAME2);
    }
    
    public function testDestroyCache(): void
    {
        $client = TestingHelper::$client;
        $client->getOrCreateCache(self::CACHE_NAME);
        $client->destroyCache(self::CACHE_NAME);
        
        $this->expectException(OperationException::class);
        $client->destroyCache(self::CACHE_NAME);
    }
    
    public function testCreateCacheWithConfiguration(): void
    {
        $client = TestingHelper::$client;
        $cacheCfg = (new CacheConfiguration())->
            setQueryEntities(
                (new QueryEntity())->
                        setKeyTypeName('INT')->
                        setValueTypeName('Person')->
                        setTableName('Person')->
                        setKeyFieldName('id')->
                        setValueFieldName('salary')->
                        setFields(
                            (new QueryField('id', 'INT'))->setIsKeyField(true),
                            (new QueryField('firstName', 'VARCHAR'))->setIsNotNull(true),
                            (new QueryField('lastName', 'VARCHAR'))->setDefaultValue('lastName'),
                            (new QueryField('salary', 'DOUBLE'))->setPrecision(10)->setScale(10))->
                        setAliases(['id' => 'id', 'firstName' => 'firstName'])->
                        setIndexes(
                            (new QueryIndex('id_idx', QueryIndex::TYPE_SORTED))->
                                setName('id_idx')->
                                setType(QueryIndex::TYPE_SORTED)->
                                setInlineSize(10)->
                                setFields(['id' => true, 'firstName' => false])))->
            setKeyConfigurations((new CacheKeyConfiguration('Person', 'Person'))->
                setTypeName('Person')->
                setAffinityKeyFieldName('Person'));

        $cache = $client->createCache(self::CACHE_NAME3, $cacheCfg);
        $cfg = $client->getCacheConfiguration(self::CACHE_NAME3);
        $client->destroyCache(self::CACHE_NAME3);
        $keyConfig = $cfg->getKeyConfigurations()[0];
        $queryEntity = $cfg->getQueryEntities()[0];
        $queryField = $queryEntity->getFields()[0];
        $queryIndex = $queryEntity->getIndexes()[0];
        $cfg->
            setName($cfg->getName())->
            setAtomicityMode($cfg->getAtomicityMode())->
            setBackups($cfg->getBackups())->
            setCacheMode($cfg->getCacheMode())->
            setCopyOnRead($cfg->getCopyOnRead())->
            setDataRegionName($cfg->getDataRegionName())->
            setEagerTtl($cfg->getEagerTtl())->
            setStatisticsEnabled($cfg->getStatisticsEnabled())->
            setGroupName($cfg->getGroupName())->
            setDefaultLockTimeout($cfg->getDefaultLockTimeout())->
            setMaxConcurrentAsyncOperations($cfg->getMaxConcurrentAsyncOperations())->
            setMaxQueryIterators($cfg->getMaxQueryIterators())->
            setIsOnheapCacheEnabled($cfg->getIsOnheapCacheEnabled())->
            setPartitionLossPolicy($cfg->getPartitionLossPolicy())->
            setQueryDetailMetricsSize($cfg->getQueryDetailMetricsSize())->
            setQueryParallelism($cfg->getQueryParallelism())->
            setReadFromBackup($cfg->getReadFromBackup())->
            setRebalanceBatchSize($cfg->getRebalanceBatchSize())->
            setRebalanceBatchesPrefetchCount($cfg->getRebalanceBatchesPrefetchCount())->
            setRebalanceDelay($cfg->getRebalanceDelay())->
            setRebalanceMode($cfg->getRebalanceMode())->
            setRebalanceOrder($cfg->getRebalanceOrder())->
            setRebalanceThrottle($cfg->getRebalanceThrottle())->
            setRebalanceTimeout($cfg->getRebalanceTimeout())->
            setSqlEscapeAll($cfg->getSqlEscapeAll())->
            setSqlIndexInlineMaxSize($cfg->getSqlIndexInlineMaxSize())->
            setSqlSchema($cfg->getSqlSchema())->
            setWriteSynchronizationMode($cfg->getWriteSynchronizationMode())->
            setKeyConfigurations((new CacheKeyConfiguration())->
                setTypeName($keyConfig->getTypeName())->
                setAffinityKeyFieldName($keyConfig->getAffinityKeyFieldName()))->
            setQueryEntities((new QueryEntity())->
                setKeyTypeName($queryEntity->getKeyTypeName())->
                setValueTypeName($queryEntity->getValueTypeName())->
                setTableName($queryEntity->getTableName())->
                setKeyFieldName($queryEntity->getKeyFieldName())->
                setValueFieldName($queryEntity->getValueFieldName())->
                setFields(
                    (new QueryField())->
                        setName($queryField->getName())->
                        setTypeName($queryField->getTypeName())->
                        setIsKeyField($queryField->getIsKeyField())->
                        setIsNotNull($queryField->getIsNotNull())->
                        setDefaultValue($queryField->getDefaultValue())->
                        setPrecision($queryField->getPrecision())->
                        setScale($queryField->getScale()),
                    $queryEntity->getFields()[1],
                    $queryEntity->getFields()[2],
                    $queryEntity->getFields()[3])->
                setAliases($queryEntity->getAliases())->
                setIndexes((new QueryIndex())->
                    setName($queryIndex->getName())->
                    setType($queryIndex->getType())->
                    setInlineSize($queryIndex->getInlineSize())->
                    setFields($queryIndex->getFields())));
        $cache = $client->getOrCreateCache(self::CACHE_NAME4, $cfg);
        $cfg2 = $client->getCacheConfiguration(self::CACHE_NAME4);
        $client->destroyCache(self::CACHE_NAME4);
        $this->assertTrue(true);
    }
    
    public function testCreateCacheWithWrongArgs(): void
    {
        $client = TestingHelper::$client;
        $this->expectException(ClientException::class);
        $client->createCache('');
    }

    public function testGetOrCreateCacheWithWrongArgs(): void
    {
        $client = TestingHelper::$client;
        $this->expectException(ClientException::class);
        $client->getOrCreateCache('');
    }
    
    public function testGetCacheWithWrongArgs(): void
    {
        $client = TestingHelper::$client;
        $this->expectException(ClientException::class);
        $client->getCache('');
    }
    
    private function checkCache(CacheInterface $cache, bool $cacheExists): void
    {
        if (!$cacheExists) {
            $this->expectException(OperationException::class);
        }
        $cache->put(0, 0);
    }
    
    private static function cleanUp(): void
    {
        TestingHelper::destroyCache(self::CACHE_NAME);
        TestingHelper::destroyCache(self::CACHE_NAME2);
        TestingHelper::destroyCache(self::CACHE_NAME3);
        TestingHelper::destroyCache(self::CACHE_NAME4);
    }
}