<?php
/**
 * @copyright Copyright (C) 2010-2023, the Friendica project
 *
 * @license GNU AGPL version 3 or any later version
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */

namespace Friendica\Test\src\Core\Config\Cache;

use Friendica\Core\Config\ValueObject\Cache;
use Friendica\Test\MockedTest;
use ParagonIE\HiddenString\HiddenString;
use stdClass;

class CacheTest extends MockedTest
{
	public function dataTests()
	{
		return [
			'normal' => [
				'data' => [
					'system' => [
						'test' => 'it',
						'boolTrue' => true,
						'boolFalse' => false,
						'int' => 235,
						'dec' => 2.456,
						'array' => ['1', 2, '3', true, false],
					],
					'config' => [
						'a' => 'value',
					],
				]
			]
		];
	}

	private function assertConfigValues($data, Cache $configCache)
	{
		foreach ($data as $cat => $values) {
			foreach ($values as $key => $value) {
				self::assertEquals($data[$cat][$key], $configCache->get($cat, $key));
			}
		}
	}

	/**
	 * Test the loadConfigArray() method without override
	 * @dataProvider dataTests
	 */
	public function testLoadConfigArray($data)
	{
		$configCache = new Cache();
		$configCache->load($data);

		self::assertConfigValues($data, $configCache);
	}

	/**
	 * Test the loadConfigArray() method with overrides
	 * @dataProvider dataTests
	 */
	public function testLoadConfigArrayOverride($data)
	{
		$override = [
			'system' => [
				'test' => 'not',
				'boolTrue' => false,
			]
		];

		$configCache = new Cache();
		$configCache->load($data, Cache::SOURCE_DATA);
		// doesn't override - Low Priority due Config file
		$configCache->load($override, Cache::SOURCE_FILE);

		self::assertConfigValues($data, $configCache);

		// override the value - High Prio due Server Env
		$configCache->load($override, Cache::SOURCE_ENV);

		self::assertEquals($override['system']['test'], $configCache->get('system', 'test'));
		self::assertEquals($override['system']['boolTrue'], $configCache->get('system', 'boolTrue'));

		// Don't overwrite server ENV variables - even in load mode
		$configCache->load($data, Cache::SOURCE_DATA);

		self::assertEquals($override['system']['test'], $configCache->get('system', 'test'));
		self::assertEquals($override['system']['boolTrue'], $configCache->get('system', 'boolTrue'));

		// Overwrite ENV variables with ENV variables
		$configCache->load($data, Cache::SOURCE_ENV);

		self::assertConfigValues($data, $configCache);
		self::assertNotEquals($override['system']['test'], $configCache->get('system', 'test'));
		self::assertNotEquals($override['system']['boolTrue'], $configCache->get('system', 'boolTrue'));
	}

	/**
	 * Test the loadConfigArray() method with wrong/empty datasets
	 */
	public function testLoadConfigArrayWrong()
	{
		$configCache = new Cache();

		// empty dataset
		$configCache->load([]);
		self::assertEmpty($configCache->getAll());

		// wrong dataset
		$configCache->load(['system' => 'not_array']);
		self::assertEmpty($configCache->getAll());

		// incomplete dataset (key is integer ID of the array)
		$configCache->load(['system' => ['value']]);
		self::assertEquals('value', $configCache->get('system', 0));
	}

	/**
	 * Test the getAll() method
	 * @dataProvider dataTests
	 */
	public function testGetAll($data)
	{
		$configCache = new Cache();
		$configCache->load($data);

		$all = $configCache->getAll();

		self::assertContains($data['system'], $all);
		self::assertContains($data['config'], $all);
	}

	/**
	 * Test the set() and get() method
	 * @dataProvider dataTests
	 */
	public function testSetGet($data)
	{
		$configCache = new Cache();

		foreach ($data as $cat => $values) {
			foreach ($values as $key => $value) {
				$configCache->set($cat, $key, $value);
			}
		}

		self::assertConfigValues($data, $configCache);
	}

	/**
	 * Test the get() method without a value
	 */
	public function testGetEmpty()
	{
		$configCache = new Cache();

		self::assertNull($configCache->get('something', 'value'));
	}

	/**
	 * Test the get() method with a category
	 */
	public function testGetCat()
	{
		$configCache = new Cache([
			'system' => [
				'key1' => 'value1',
				'key2' => 'value2',
			],
			'config' => [
				'key3' => 'value3',
			],
		]);

		self::assertEquals([
			'key1' => 'value1',
			'key2' => 'value2',
		], $configCache->get('system'));

		// explicit null as key
		self::assertEquals([
			'key1' => 'value1',
			'key2' => 'value2',
		], $configCache->get('system', null));
	}

	/**
	 * Test the delete() method
	 * @dataProvider dataTests
	 */
	public function testDelete($data)
	{
		$configCache = new Cache($data);

		foreach ($data as $cat => $values) {
			foreach ($values as $key => $value) {
				$configCache->delete($cat, $key);
			}
		}

		self::assertEmpty($configCache->getAll());
	}

	/**
	 * Test the keyDiff() method with result
	 * @dataProvider dataTests
	 */
	public function testKeyDiffWithResult($data)
	{
		$configCache = new Cache($data);

		$diffConfig = [
			'fakeCat' => [
				'fakeKey' => 'value',
			]
		];

		self::assertEquals($diffConfig, $configCache->keyDiff($diffConfig));
	}

	/**
	 * Test the keyDiff() method without result
	 * @dataProvider dataTests
	 */
	public function testKeyDiffWithoutResult($data)
	{
		$configCache = new Cache($data);

		$diffConfig = $configCache->getAll();

		self::assertEmpty($configCache->keyDiff($diffConfig));
	}

	/**
	 * Test the default hiding of passwords inside the cache
	 */
	public function testPasswordHide()
	{
		$configCache = new Cache([
			'database' => [
				'password' => 'supersecure',
				'username' => 'notsecured',
			],
		]);

		self::assertEquals('supersecure', $configCache->get('database', 'password'));
		self::assertNotEquals('supersecure', print_r($configCache->get('database', 'password'), true));
		self::assertEquals('notsecured', print_r($configCache->get('database', 'username'), true));
	}

	/**
	 * Test disabling the hiding of passwords inside the cache
	 */
	public function testPasswordShow()
	{
		$configCache = new Cache([
			'database' => [
				'password' => 'supersecure',
				'username' => 'notsecured',
			],
		], false);

		self::assertEquals('supersecure', $configCache->get('database', 'password'));
		self::assertEquals('supersecure', print_r($configCache->get('database', 'password'), true));
		self::assertEquals('notsecured', print_r($configCache->get('database', 'username'), true));
	}

	/**
	 * Test a empty password
	 */
	public function testEmptyPassword()
	{
		$configCache = new Cache([
			'database' => [
				'password' => '',
				'username' => '',
			]
		]);

		self::assertNotEmpty($configCache->get('database', 'password'));
		self::assertInstanceOf(HiddenString::class, $configCache->get('database', 'password'));
		self::assertEmpty($configCache->get('database', 'username'));
	}

	public function testWrongTypePassword()
	{
		$configCache = new Cache([
			'database' => [
				'password' => new stdClass(),
				'username' => '',
			]
		]);

		self::assertNotEmpty($configCache->get('database', 'password'));
		self::assertEmpty($configCache->get('database', 'username'));

		$configCache = new Cache([
			'database' => [
				'password' => 23,
				'username' => '',
			]
		]);

		self::assertEquals(23, $configCache->get('database', 'password'));
		self::assertEmpty($configCache->get('database', 'username'));
	}

	/**
	 * Test the set() method with overrides
	 * @dataProvider dataTests
	 */
	public function testSetOverrides($data)
	{

		$configCache = new Cache();
		$configCache->load($data, Cache::SOURCE_DATA);

		// test with wrong override
		self::assertFalse($configCache->set('system', 'test', '1234567', Cache::SOURCE_FILE));
		self::assertEquals($data['system']['test'], $configCache->get('system', 'test'));

		// test with override (equal)
		self::assertTrue($configCache->set('system', 'test', '8910', Cache::SOURCE_DATA));
		self::assertEquals('8910', $configCache->get('system', 'test'));

		// test with override (over)
		self::assertTrue($configCache->set('system', 'test', '111213', Cache::SOURCE_ENV));
		self::assertEquals('111213', $configCache->get('system', 'test'));
	}

	/**
	 * @dataProvider dataTests
	 *
	 * @return void
	 */
	public function testSetData($data)
	{
		$configCache = new Cache();
		$configCache->load($data, Cache::SOURCE_FILE);

		$configCache->set('system', 'test_2','with_data', Cache::SOURCE_DATA);

		$this->assertEquals(['system' => ['test_2' => 'with_data']], $configCache->getDataBySource(Cache::SOURCE_DATA));
		$this->assertEquals($data, $configCache->getDataBySource(Cache::SOURCE_FILE));
	}

	/**
	 * @dataProvider dataTests
	 */
	public function testMerge($data)
	{
		$configCache = new Cache();
		$configCache->load($data, Cache::SOURCE_FILE);

		$configCache->set('system', 'test_2','with_data', Cache::SOURCE_DATA);
		$configCache->set('config', 'test_override','with_another_data', Cache::SOURCE_DATA);
		$configCache->set('old_category', 'test_45','given category', Cache::SOURCE_DATA);

		$newCache = new Cache();
		$newCache->set('config', 'test_override','override it again', Cache::SOURCE_DATA);
		$newCache->set('system', 'test_3','new value', Cache::SOURCE_DATA);
		$newCache->set('new_category', 'test_23','added category', Cache::SOURCE_DATA);

		$mergedCache = $configCache->merge($newCache);

		self::assertEquals('with_data', $mergedCache->get('system', 'test_2'));
		self::assertEquals('override it again', $mergedCache->get('config', 'test_override'));
		self::assertEquals('new value', $mergedCache->get('system', 'test_3'));
		self::assertEquals('given category', $mergedCache->get('old_category', 'test_45'));
		self::assertEquals('added category', $mergedCache->get('new_category', 'test_23'));
	}

	/**
	 * @dataProvider dataTests
	 */
	public function testDiff($data)
	{
		$configCache = new Cache();
		$configCache->load($data, Cache::SOURCE_FILE);

		$configCache->set('system', 'test_2','with_data', Cache::SOURCE_DATA);
		$configCache->set('config', 'test_override','with_another_data', Cache::SOURCE_DATA);

		$newCache = new Cache();
		$newCache->set('config', 'test_override','override it again', Cache::SOURCE_DATA);
		$newCache->set('system', 'test_3','new value', Cache::SOURCE_DATA);

		$mergedCache = $configCache->diff($newCache);

		print_r($mergedCache);

		self::assertEquals('with_data', $mergedCache->get('system', 'test_2'));
		// existing entry was dropped
		self::assertNull($mergedCache->get('config', 'test_override'));
		// the newCache entry wasn't set, because we Diff
		self::assertNull($mergedCache->get('system', 'test_3'));
	}

	public function dataTestCat()
	{
		return [
			'test_with_hashmap'     => [
				'data'      => [
					'test_with_hashmap' => [
						'notifyall' => [
							'last_update' => 1671051565,
							'admin'       => true,
						],
						'blockbot'  => [
							'last_update' => 1658952852,
							'admin'       => true,
						],
					],
					'config'            => [
						'register_policy' => 2,
						'register_text'   => '',
						'sitename'        => 'Friendica Social Network23',
						'hostname'        => 'friendica.local',
						'private_addons'  => false,
					],
					'system'            => [
						'dbclean_expire_conversation' => 90,
					],
				],
				'cat'       => 'test_with_hashmap',
				'assertion' => [
					'notifyall' => [
						'last_update' => 1671051565,
						'admin'       => true,
					],
					'blockbot'  => [
						'last_update' => 1658952852,
						'admin'       => true,
					],
				],
			],
			'test_with_keys'        => [
				'data'      => [
					'test_with_keys' => [
						[
							'last_update' => 1671051565,
							'admin'       => true,
						],
						[
							'last_update' => 1658952852,
							'admin'       => true,
						],
					],
					'config'            => [
						'register_policy' => 2,
						'register_text'   => '',
						'sitename'        => 'Friendica Social Network23',
						'hostname'        => 'friendica.local',
						'private_addons'  => false,
					],
					'system'            => [
						'dbclean_expire_conversation' => 90,
					],
				],
				'cat'       => 'test_with_keys',
				'assertion' => [
					[
						'last_update' => 1671051565,
						'admin'       => true,
					],
					[
						'last_update' => 1658952852,
						'admin'       => true,
					],
				],
			],
			'test_with_inner_array' => [
				'data'      => [
					'test_with_inner_array' => [
						'notifyall' => [
							'last_update' => 1671051565,
							'admin'       => [
								'yes' => true,
								'no'  => 1.5,
							],
						],
						'blogbot'   => [
							'last_update' => 1658952852,
							'admin'       => true,
						],
					],
					'config'                => [
						'register_policy' => 2,
						'register_text'   => '',
						'sitename'        => 'Friendica Social Network23',
						'hostname'        => 'friendica.local',
						'private_addons'  => false,
					],
					'system'                => [
						'dbclean_expire_conversation' => 90,
					],
				],
				'cat'       => 'test_with_inner_array',
				'assertion' => [
					'notifyall' => [
						'last_update' => 1671051565,
						'admin'       => [
							'yes' => true,
							'no'  => 1.5,
						],
					],
					'blogbot'   => [
						'last_update' => 1658952852,
						'admin'       => true,
					],
				],
			],
		];
	}

	/**
	 * Tests that the Cache can return a whole category at once
	 *
	 * @dataProvider dataTestCat
	 */
	public function testGetCategory(array $data, string $category, array $assertion)
	{
		$cache = new Cache($data);

		self::assertEquals($assertion, $cache->get($category));
	}
}