<?php

// Own namespace
namespace Org\Mxchange\CoreFramework\Configuration;

// Import framework stuff
use Org\Mxchange\CoreFramework\Configuration\NoConfigEntryException;
use Org\Mxchange\CoreFramework\Generic\FrameworkInterface;
use Org\Mxchange\CoreFramework\Generic\UnsupportedOperationException;
use Org\Mxchange\CoreFramework\Object\BaseFrameworkSystem;
use Org\Mxchange\CoreFramework\Registry\Registerable;
use Org\Mxchange\CoreFramework\Utils\Strings\StringUtils;

// Import SPL stuff
use \InvalidArgumentException;
use \UnexpectedValueException;

/**
 * A class for the configuration stuff implemented in a singleton design pattern
 *
 * NOTE: We cannot put this in framework/main/ because it would be loaded (again) in
 * class loader. See framework/loader/class_ClassLoader.php for instance
 *
 * @see			ClassLoader
 * @author		Roland Haeder <webmaster@shipsimu.org>
 * @version		1.0.1
 * @copyright	Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2022 Core Developer Team
 * @license		GNU GPL 3.0 or any newer version
 * @link		http://www.shipsimu.org
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
class FrameworkConfiguration implements Registerable {
	// Some constants for the configuration system
	const EXCEPTION_CONFIG_KEY_IS_EMPTY = 0x130;
	const EXCEPTION_CONFIG_KEY_WAS_NOT_FOUND = 0x131;
	const EXCEPTION_CONFIG_VALUE_TYPE_UNSUPPORTED = 0x132;

	/**
	 * The framework's main configuration array which will be initialized with
	 * hard-coded configuration data and might be overwritten/extended by
	 * config data from the database.
	 */
	private static $configData = [];

	/**
	 * Call-back instance (unused)
	 */
	private $callbackInstance = NULL;

	/**
	 * Default constructor, the configuration entries are static, not the
	 * whole instance.
	 *
	 * @return	void
	 */
	public function __construct () {
		// Empty for now
	}

	/**
	 * Compatiblity method to return this class' name
	 *
	 * @return	__CLASS__	This class' name
	 */
	public function __toString () {
		return get_class($this);
	}

	/**
	 * Checks whether the given configuration key is set
	 *
	 * @param	$configKey	The configuration key we shall check
	 * @return	$isset	Whether the given configuration key is set
	 * @throws	InvalidArgumentException	If $configKey is empty
	 */
	public function isConfigurationEntrySet (string $configKey) {
		// Is it null?
		//* NOISY-DEBUG: */ printf('[%s:%d]: configKey=%s - CALLED!' . PHP_EOL, __METHOD__, __LINE__, $configKey);
		if (empty($configKey)) {
			// Entry is empty
			throw new InvalidArgumentException('Parameter "configKey" is empty', self::EXCEPTION_CONFIG_KEY_IS_EMPTY);
		}

		// Is it set?
		$isset = ((isset(self::$configData[$configKey])) || (array_key_exists($configKey, self::$configData)));

		// Return the result
		//* NOISY-DEBUG: */ printf('[%s:%d]: isset=%s - EXIT!' . PHP_EOL, __METHOD__, __LINE__, intval($isset));
		return $isset;
	}

	/**
	 * Read a configuration element.
	 *
	 * @param	$configKey		The configuration element
	 * @return	$configValue	The fetched configuration value
	 * @throws	InvalidArgumentException	If $configKey is empty
	 * @throws	NoConfigEntryException		If a configuration element was not found
	 */
	public function getConfigEntry (string $configKey) {
		// Is it null?
		//* NOISY-DEBUG: */ printf('[%s:%d]: configKey=%s - CALLED!' . PHP_EOL, __METHOD__, __LINE__, $configKey);
		if (empty($configKey)) {
			// Entry is empty
			throw new InvalidArgumentException('Parameter "configKey" is empty', self::EXCEPTION_CONFIG_KEY_IS_EMPTY);
		}

		// Convert dashes to underscore
		$configKey = StringUtils::convertDashesToUnderscores($configKey);

		// Is a valid configuration key provided?
		//* NOISY-DEBUG: */ printf('[%s:%d]: configKey=%s - AFTER!' . PHP_EOL, __METHOD__, __LINE__, $configKey);
		if (!$this->isConfigurationEntrySet($configKey)) {
			// Entry was not found!
			throw new NoConfigEntryException(array(__CLASS__, $configKey), self::EXCEPTION_CONFIG_KEY_WAS_NOT_FOUND);
		}

		// Return the requested value
		//* NOISY-DEBUG: */ printf('[%s:%d]: Returning configData[%s]=[%s]:%s - EXIT!' . PHP_EOL, __METHOD__, __LINE__, $configKey, gettype(self::$configData[$configKey]), self::$configData[$configKey]);
		return self::$configData[$configKey];
	}

	/**
	 * Set a configuration key
	 *
	 * @param	$configKey	The configuration key we want to add/change
	 * @param	$configValue	The configuration value we want to set
	 * @return	void
	 * @throws	InvalidArgumentException	If $configKey is empty
	 * @throws	InvalidArgumentException	If $configValue has an unsupported variable type
	 */
	public final function setConfigEntry (string $configKey, $configValue) {
		// Is a valid configuration key key provided?
		//* NOISY-DEBUG: */ printf('[%s:%d]: configKey=%s,configValue[]=%s' . PHP_EOL, __METHOD__, __LINE__, $configKey, gettype($configValue));
		if (empty($configKey)) {
			// Entry is empty
			throw new InvalidArgumentException('Parameter "configKey" is empty', self::EXCEPTION_CONFIG_KEY_IS_EMPTY);
		} elseif ((is_array($configValue)) || (is_object($configValue)) || (is_resource($configValue))) {
			// These cannot be set as this is not intended for configuration values, please use FrameworkArrayObject instead.
			throw new InvalidArgumentException(sprintf('configValue[]=%s for configKey=%s is not supported.', gettype($configValue), $configKey), self::EXCEPTION_CONFIG_VALUE_TYPE_UNSUPPORTED);
		}

		// Cast to string
		$configKey = StringUtils::convertDashesToUnderscores($configKey);

		// Set the configuration value
		//* NOISY-DEBUG: */ printf('[%s:%d]: configKey=%s,configValue[%s]=%s' . PHP_EOL, __METHOD__, __LINE__, $configKey, gettype($configValue), $configValue);
		self::$configData[$configKey] = $configValue;
	}

	/**
	 * Getter for whole configuration array
	 *
	 * @return	$config		Configuration array
	 */
	public final function getConfigurationArray () {
		// Return it
		//* NOISY-DEBUG: */ printf('[%s:%d]: self::configData()=%d - EXIT!' . PHP_EOL, __METHOD__, __LINE__, count(self::$configData));
		return self::$configData;
	}

	/**
	 * Sorts the configuration array, saves A LOT calls if done after all configuration files have been loaded. You should NOT
	 * set any configuration entries by your own, means outside any configuration file. If you still do so, you HAVE to call
	 * this method afterwards
	 *
	 * @return	void
	 */
	public final function sortConfigurationArray () {
		// Resort the array
		//* NOISY-DEBUG: */ printf('[%s:%d]: Sorting %d records - CALLED!' . PHP_EOL, __METHOD__, __LINE__, count(self::$configData));
		ksort(self::$configData);

		// Debug message
		//* NOISY-DEBUG: */ printf('[%s:%d]: EXIT!' . PHP_EOL, __METHOD__, __LINE__);
	}

	/**
	 * Unset a configuration key, the entry must be there or else an
	 * exception is thrown.
	 *
	 * @param	$configKey	Configuration key to unset
	 * @return	void
	 * @throws	InvalidArgumentException	If $configKey is empty
	 * @throws	NoConfigEntryException	If a configuration element was not found
	 */
	public final function unsetConfigEntry (string $configKey) {
		// Validate parameters
		//* NOISY-DEBUG: */ printf('[%s:%d]: configKey=%s - CALLED!' . PHP_EOL, __METHOD__, __LINE__, $configKey);
		if (empty($configKey)) {
			// Entry is empty
			throw new InvalidArgumentException('Parameter "configKey" is empty', self::EXCEPTION_CONFIG_KEY_IS_EMPTY);
		}

		// Convert dashes to underscore
		$configKey = StringUtils::convertDashesToUnderscores($configKey);

		// Is the configuration key there?
		//* NOISY-DEBUG: */ printf('[%s:%d]: configKey=%s - AFTER!' . PHP_EOL, __METHOD__, __LINE__, $configKey);
		if (!$this->isConfigurationEntrySet($configKey)) {
			// Entry was not found!
			throw new NoConfigEntryException(array(__CLASS__, $configKey), self::EXCEPTION_CONFIG_KEY_WAS_NOT_FOUND);
		}

		// Unset it
		//* NOISY-DEBUG: */ printf('[%s:%d]: Unsetting configKey=%s ...' . PHP_EOL, __METHOD__, __LINE__, $configKey);
		unset(self::$configData[$configKey]);

		// Debug message
		//* NOISY-DEBUG: */ printf('[%s:%d]: EXIT!' . PHP_EOL, __METHOD__, __LINE__);
	}

	/**
	 * Checks if a configuration entry is_*_enabled set to 'Y'
	 *
	 * @param	$keyPart	Configuration to expand with is_$keyPart_enabled
	 * @return	$enabled	Whether it has been set to Y or N
	 * @throws	InvalidArgumentException	If a parameter is invalid
	 * @throws	UnexpectedValueException	If a returned value is of an unexpected type or value
	 */
	public function isEnabled (string $keyPart) {
		// Validate parameters
		//* NOISY-DEBUG: */ printf('[%s:%d]: keyPart=%s - CALLED!' . PHP_EOL, __METHOD__, __LINE__, $keyPart);
		if (empty($keyPart)) {
			// Entry is empty
			throw new InvalidArgumentException('Parameter "keyPart" is empty', self::EXCEPTION_CONFIG_KEY_IS_EMPTY);
		}

		// Construct final config key
		$configKey = sprintf('is_%s_enabled', $keyPart);

		// Get value from it
		//* NOISY-DEBUG: */ printf('[%s:%d]: configKey=%s' . PHP_EOL, __METHOD__, __LINE__, $configKey);
		$isEnabled = $this->getConfigEntry($configKey);

		// Is it Y/N?
		//* NOISY-DEBUG: */ printf('[%s:%d]: isEnabled[]=%s' . PHP_EOL, __METHOD__, __LINE__, gettype($isEnabled));
		if (!is_bool($isEnabled)) {
			// Throw exception
			throw new UnexpectedValueException(sprintf('isEnabled[]=%s is unexpected', gettype($isEnabled)));
		}

		// Return it
		//* NOISY-DEBUG: */ printf('[%s:%d]: isEnabled=%d - EXIT!' . PHP_EOL, __METHOD__, __LINE__, intval($isEnabled));
		return $isEnabled;
	}

	/**
	 * Generates a code for hashes from this class
	 *
	 * @return	$hashCode	The hash code respresenting this class
	 */
	public function hashCode () {
		return crc32($this->__toString());
	}

	/**
	 * Checks whether an object equals this object. You should overwrite this
	 * method to implement own equality checks
	 *
	 * @param	$objectInstance		An instance of a FrameworkInterface object
	 * @return	$equals				Whether both objects equals
	 */
	public function equals (FrameworkInterface $objectInstance) {
		// Now test it
		$equals = ((
				$this->__toString() === $objectInstance->__toString()
				) && (
				$this->hashCode() === $objectInstance->hashCode()
				));

		// Return the result
		return $equals;
	}

	/**
	 * Setter for call-back instance
	 *
	 * @param	$callbackInstance	An instance of a FrameworkInterface class
	 * @return	void
	 */
	public function setCallbackInstance (FrameworkInterface $callbackInstance) {
		$this->callbackInstance = $callbackInstance;
	}

	/**
	 * Getter for field name
	 *
	 * @param	$fieldName		Field name which we shall get
	 * @return	$fieldValue		Field value from the user
	 * @throws	NullPointerException	If the result instance is null
	 */
	public final function getField (string $fieldName) {
		// The super interface "FrameworkInterface" requires this
		throw new UnsupportedOperationException([$this, __FUNCTION__], BaseFrameworkSystem::EXCEPTION_UNSPPORTED_OPERATION);
	}

	/**
	 * Checks if given field is set
	 *
	 * @param	$fieldName	Field name to check
	 * @return	$isSet		Whether the given field name is set
	 * @throws	NullPointerException	If the result instance is null
	 */
	public function isFieldSet (string $fieldName) {
		// The super interface "FrameworkInterface" requires this
		throw new UnsupportedOperationException([$this, __FUNCTION__], BaseFrameworkSystem::EXCEPTION_UNSPPORTED_OPERATION);
	}

}