<?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 PHPUnit\Framework\TestCase;
use Apache\Ignite\Exception\ClientException;
use Apache\Ignite\Cache\CacheEntry;
use Apache\Ignite\Cache\CacheConfiguration;
use Apache\Ignite\Cache\CacheInterface;

final class CacheKeyValueOpsTestCase extends TestCase
{
    const CACHE_NAME = '__php_test_cache';

    public static function setUpBeforeClass(): void
    {
        TestingHelper::init();
        self::cleanUp();
        TestingHelper::$client->getOrCreateCache(self::CACHE_NAME);
    }

    public static function tearDownAfterClass(): void
    {
        self::cleanUp();
        TestingHelper::cleanUp();
    }
    
    public function testCacheGet(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $value = $cache->get(1);
            $this->assertEquals($value, null);
            $cache->put(1, 2);
            $value = $cache->get(1);
            $this->assertEquals($value, 2);
        } finally {
            $cache->removeAll();
        }
    }
    
    public function cacheWrongKeys(): array
    {
        return array(
            array(null)
        );
    }

    /**
     * @dataProvider cacheWrongKeys
     */
    public function testCacheGetWrongArgs($cacheKey): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->get($cacheKey);
        } finally {
            $cache->removeAll();
        }
    }
    
    public function testCacheGetAll(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            for ($i = 0; $i < 5; $i++) {
                $cache->put($i, $i * 2);
            }
            $entries = $cache->getAll([3, 4, 5, 6, 7]);
            $this->assertCount(2, $entries);
            foreach ($entries as $entry) {
                $this->assertTrue($entry->getKey() === 3 || $entry->getKey() === 4);
                $this->assertEquals($entry->getValue(), $entry->getKey() * 2);
            }
            $entries = $cache->getAll([6, 7, 8]);
            $this->assertCount(0, $entries);
        } finally {
            $cache->removeAll();
        }
    }
    
    public function cacheGetAllWrongKeys(): array
    {
        return array(
            array([])
        );
    }

    /**
     * @dataProvider cacheGetAllWrongKeys
     */
    public function testCacheGetAllWrongArgs($keys): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->getAll($keys);
        } finally {
            $cache->removeAll();
        }
    }

    public function testCachePut(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $value = $cache->get(1);
            $this->assertEquals($value, null);
            $cache->put(1, 2);
            $value = $cache->get(1);
            $this->assertEquals($value, 2);
            $cache->put(1, 4);
            $value = $cache->get(1);
            $this->assertEquals($value, 4);
        } finally {
            $cache->removeAll();
        }
    }

    public function cacheWrongKeyValues(): array
    {
        return array(
            array(null, 1),
            array(1, null),
            array(null, null)
        );
    }

    /**
     * @dataProvider cacheWrongKeyValues
     */
    public function testCachePutWrongArgs($key, $value): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->put($key, $value);
        } finally {
            $cache->removeAll();
        }
    }

    public function testCachePutAll(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $cacheEntries = array();
            for ($i = 0; $i < 5; $i++) {
                array_push($cacheEntries, new CacheEntry($i, $i * 2));
            }
            $cache->putAll($cacheEntries);
            $entries = $cache->getAll([3, 4, 5, 6, 7]);
            $this->assertCount(2, $entries);
            foreach ($entries as $entry) {
                $this->assertTrue($entry->getKey() === 3 || $entry->getKey() === 4);
                $this->assertEquals($entry->getValue(), $entry->getKey() * 2);
            }
            $entries = $cache->getAll([-2, -1, 0, 1, 2, 3, 4, 5, 6, 7]);
            $this->assertCount(5, $entries);
            foreach ($entries as $entry) {
                $this->assertTrue($entry->getKey() >= 0 && $entry->getKey() <= 4);
                $this->assertEquals($entry->getValue(), $entry->getKey() * 2);
            }
            $entries = $cache->getAll([6, 7, 8]);
            $this->assertCount(0, $entries);
        } finally {
            $cache->removeAll();
        }
    }
    
    public function cachePutAllWrongArgs(): array
    {
        return array(
            array([]),
            array([new CacheConfiguration])
        );
    }

    /**
     * @dataProvider cachePutAllWrongArgs
     */
    public function testCachePutAllWrongArgs($entries): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->putAll($entries);
        } finally {
            $cache->removeAll();
        }
    }
    
    public function testContainsKey(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $result = $cache->containsKey(1);
            $this->assertFalse($result);
            $cache->put(1, 2);
            $result = $cache->containsKey(1);
            $this->assertTrue($result);
        } finally {
            $cache->removeAll();
        }
    }
    
    /**
     * @dataProvider cacheWrongKeys
     */
    public function testContainsKeyWrongArgs($cacheKey): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->containsKey($cacheKey);
        } finally {
            $cache->removeAll();
        }
    }
  
    public function testCacheContainsKeys(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $result = $cache->containsKeys([1, 2, 3]);
            $this->assertFalse($result);
            $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4)]);
            $result = $cache->containsKeys([1, 2, 3]);
            $this->assertFalse($result);
            $cache->put(3, 6);
            $result = $cache->containsKeys([1, 2, 3]);
            $this->assertTrue($result);
        } finally {
            $cache->removeAll();
        }
    }
    
    /**
     * @dataProvider cacheGetAllWrongKeys
     */
    public function testCacheContainsKeysWrongArgs($keys): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->containsKeys($keys);
        } finally {
            $cache->removeAll();
        }
    }
    
    public function testCacheGetAndPut(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $value = $cache->getAndPut(1, 2);
            $this->assertEquals($value, null);
            $value = $cache->getAndPut(1, 4);
            $this->assertEquals($value, 2);
            $cache->put(1, 6);
            $value = $cache->getAndPut(1, 8);
            $this->assertEquals($value, 6);
            $value = $cache->get(1);
            $this->assertEquals($value, 8);

        } finally {
            $cache->removeAll();
        }
    }

    /**
     * @dataProvider cacheWrongKeyValues
     */
    public function testCacheGetAndPutWrongArgs($key, $value): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->getAndPut($key, $value);
        } finally {
            $cache->removeAll();
        }
    }

    public function testCacheGetAndReplace(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $value = $cache->getAndReplace(1, 2);
            $this->assertEquals($value, null);
            $cache->put(1, 4);
            $value = $cache->getAndReplace(1, 6);
            $this->assertEquals($value, 4);
            $value = $cache->get(1);
            $this->assertEquals($value, 6);
        } finally {
            $cache->removeAll();
        }
    }

    /**
     * @dataProvider cacheWrongKeyValues
     */
    public function testCacheGetAndReplaceWrongArgs($key, $value): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->getAndReplace($key, $value);
        } finally {
            $cache->removeAll();
        }
    }
    
    public function testCacheGetAndRemove(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $value = $cache->getAndRemove(1);
            $this->assertEquals($value, null);
            $cache->put(1, 2);
            $value = $cache->getAndRemove(1);
            $this->assertEquals($value, 2);
            $value = $cache->get(1);
            $this->assertEquals($value, null);
        } finally {
            $cache->removeAll();
        }
    }
    
    /**
     * @dataProvider cacheWrongKeys
     */
    public function testCacheGetAndRemoveWrongArgs($cacheKey): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->getAndRemove($cacheKey);
        } finally {
            $cache->removeAll();
        }
    }

    public function testCachePutIfAbsent(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $result = $cache->putIfAbsent(1, 2);
            $this->assertTrue($result);
            $value = $cache->get(1);
            $this->assertEquals($value, 2);
            $result = $cache->putIfAbsent(1, 4);
            $this->assertFalse($result);
            $value = $cache->get(1);
            $this->assertEquals($value, 2);
        } finally {
            $cache->removeAll();
        }
    }

    /**
     * @dataProvider cacheWrongKeyValues
     */
    public function testCachePutIfAbsentWrongArgs($key, $value): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->putIfAbsent($key, $value);
        } finally {
            $cache->removeAll();
        }
    }
  
    public function testCacheGetAndPutIfAbsent(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $value = $cache->getAndPutIfAbsent(1, 2);
            $this->assertEquals($value, null);
            $value = $cache->get(1);
            $this->assertEquals($value, 2);
            $value = $cache->getAndPutIfAbsent(1, 4);
            $this->assertEquals($value, 2);
            $value = $cache->get(1);
            $this->assertEquals($value, 2);

        } finally {
            $cache->removeAll();
        }
    }

    /**
     * @dataProvider cacheWrongKeyValues
     */
    public function testCacheGetAndPutIfAbsentWrongArgs($key, $value): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->getAndPutIfAbsent($key, $value);
        } finally {
            $cache->removeAll();
        }
    }

    public function testCacheReplace(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $result = $cache->replace(1, 2);
            $this->assertFalse($result);
            $value = $cache->get(1);
            $this->assertEquals($value, null);
            $cache->put(1, 1);
            $result = $cache->replace(1, 4);
            $this->assertTrue($result);
            $value = $cache->get(1);
            $this->assertEquals($value, 4);

        } finally {
            $cache->removeAll();
        }
    }

    /**
     * @dataProvider cacheWrongKeyValues
     */
    public function testCacheReplaceWrongArgs($key, $value): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->replace($key, $value);
        } finally {
            $cache->removeAll();
        }
    }
    
    public function testCacheReplaceIfEquals(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $result = $cache->replaceIfEquals(1, 2, 3);
            $this->assertFalse($result);
            $cache->put(1, 4);
            $result = $cache->replaceIfEquals(1, 2, 3);
            $this->assertFalse($result);
            $value = $cache->get(1);
            $this->assertEquals($value, 4);
            $result = $cache->replaceIfEquals(1, 4, 3);
            $this->assertTrue($result);
            $value = $cache->get(1);
            $this->assertEquals($value, 3);
        } finally {
            $cache->removeAll();
        }
    }

    public function cacheWrongReplaceIfEqualsArgs(): array
    {
        return array(
            array(null, 1, 1),
            array(null, 1, null),
            array(1, null, 1),
            array(1, null, null),
            array(null, null, null)
        );
    }

    /**
     * @dataProvider cacheWrongReplaceIfEqualsArgs
     */
    public function testCacheReplaceIfEqualsWrongArgs($key, $value, $newValue): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->replaceIfEquals($key, $value, $newValue);
        } finally {
            $cache->removeAll();
        }
    }
  
    public function testCacheClear(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $cache->clear();
            $result = $cache->getSize();
            $this->assertEquals($result, 0);
            $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
            $result = $cache->getSize();
            $this->assertEquals($result, 3);
            $cache->clear();
            $result = $cache->getSize();
            $this->assertEquals($result, 0);
            $entries = $cache->getAll([1, 2, 3]);
            $this->assertCount(0, $entries);
        } finally {
            $cache->removeAll();
        }
    }

    public function testCacheClearKeys(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $cache->clearKeys([1, 2, 3]);
            $result = $cache->getSize();
            $this->assertEquals($result, 0);
            $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
            $result = $cache->getSize();
            $this->assertEquals($result, 3);
            $cache->clearKeys([1, 2, 7, 8]);
            $result = $cache->getSize();
            $this->assertEquals($result, 1);
            $value = $cache->get(3);
            $this->assertEquals($value, 6);
        } finally {
            $cache->removeAll();
        }
    }
    
    /**
     * @dataProvider cacheGetAllWrongKeys
     */
    public function testCacheClearKeysWrongArgs($keys): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->clearKeys($keys);
        } finally {
            $cache->removeAll();
        }
    }

    public function testCacheClearKey(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $cache->clearKey(1);
            $result = $cache->getSize();
            $this->assertEquals($result, 0);
            $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
            $result = $cache->getSize();
            $this->assertEquals($result, 3);
            $cache->clearKey(1);
            $result = $cache->getSize();
            $this->assertEquals($result, 2);
            $value = $cache->get(2);
            $this->assertEquals($value, 4);
            $value = $cache->get(3);
            $this->assertEquals($value, 6);
        } finally {
            $cache->removeAll();
        }
    }
    
    /**
     * @dataProvider cacheWrongKeys
     */
    public function testCacheClearKeyWrongArgs($cacheKey): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->clearKey($cacheKey);
        } finally {
            $cache->removeAll();
        }
    }

    public function testCacheRemoveKey(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $result = $cache->removeKey(1);
            $this->assertFalse($result);
            $result = $cache->getSize();
            $this->assertEquals($result, 0);
            $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
            $result = $cache->getSize();
            $this->assertEquals($result, 3);
            $result = $cache->removeKey(1);
            $this->assertTrue($result);
            $result = $cache->removeKey(1);
            $this->assertFalse($result);
            $result = $cache->getSize();
            $this->assertEquals($result, 2);
            $value = $cache->get(2);
            $this->assertEquals($value, 4);
            $value = $cache->get(3);
            $this->assertEquals($value, 6);
        } finally {
            $cache->removeAll();
        }
    }
    
    /**
     * @dataProvider cacheWrongKeys
     */
    public function testCacheRemoveKeyWrongArgs($cacheKey): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->removeKey($cacheKey);
        } finally {
            $cache->removeAll();
        }
    }
    
    public function testRemoveIfEquals(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $result = $cache->removeIfEquals(1, 2);
            $this->assertFalse($result);
            $cache->put(1, 4);
            $result = $cache->removeIfEquals(1, 2);
            $this->assertFalse($result);
            $result = $cache->removeIfEquals(1, 4);
            $this->assertTrue($result);
            $value = $cache->get(1);
            $this->assertEquals($value, null);
        } finally {
            $cache->removeAll();
        }
    }

    /**
     * @dataProvider cacheWrongKeyValues
     */
    public function testRemoveIfEqualsWrongArgs($key, $value): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->removeIfEquals($key, $value);
        } finally {
            $cache->removeAll();
        }
    }
    
    public function testCacheRemoveKeys(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $cache->removeKeys([1, 2, 3]);
            $result = $cache->getSize();
            $this->assertEquals($result, 0);
            $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
            $result = $cache->getSize();
            $this->assertEquals($result, 3);
            $cache->removeKeys([1, 2, 7, 8]);
            $result = $cache->getSize();
            $this->assertEquals($result, 1);
            $value = $cache->get(3);
            $this->assertEquals($value, 6);
        } finally {
            $cache->removeAll();
        }
    }
    
    /**
     * @dataProvider cacheGetAllWrongKeys
     */
    public function testCacheRemoveKeysWrongArgs($keys): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->removeKeys($keys);
        } finally {
            $cache->removeAll();
        }
    }

    public function testCacheRemoveAll(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $cache->removeAll();
            $result = $cache->getSize();
            $this->assertEquals($result, 0);
            $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
            $result = $cache->getSize();
            $this->assertEquals($result, 3);
            $cache->removeAll();
            $result = $cache->getSize();
            $this->assertEquals($result, 0);
            $entries = $cache->getAll([1, 2, 3]);
            $this->assertCount(0, $entries);
        } finally {
            $cache->removeAll();
        }
    }
    
    public function testCacheGetSize(): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $result = $cache->getSize();
            $this->assertEquals($result, 0);
            $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
            $result = $cache->getSize();
            $this->assertEquals($result, 3);
            $result = $cache->getSize(CacheInterface::PEEK_MODE_ALL);
            $this->assertEquals($result, 3);
            $result = $cache->getSize(CacheInterface::PEEK_MODE_ALL, CacheInterface::PEEK_MODE_ALL);
            $this->assertEquals($result, 3);
        } finally {
            $cache->removeAll();
        }
    }
    
    public function getSizeWrongArgs(): array
    {
        return array(
            array(-1, -2),
            array(4, 5, 6, 0)
        );
    }

    /**
     * @dataProvider getSizeWrongArgs
     */
    public function testCacheGetSizeWrongArgs($modes): void
    {
        $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
        try {
            $this->expectException(ClientException::class);
            $cache->getSize($modes);
        } finally {
            $cache->removeAll();
        }
    }
    
    private static function cleanUp(): void
    {
        TestingHelper::destroyCache(self::CACHE_NAME);
    }
}