<?php

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

// Import framework stuff
use Org\Mxchange\CoreFramework\Generic\FrameworkInterface;
use Org\Mxchange\CoreFramework\Generic\NullPointerException;
use Org\Mxchange\CoreFramework\Generic\UnsupportedOperationException;
use Org\Mxchange\CoreFramework\Object\BaseFrameworkSystem;
use Org\Mxchange\CoreFramework\Registry\Registerable;

// Import SPL stuff
use \InvalidArgumentException;

/**
 * A class for the configuration stuff implemented in a singleton design paddern
 *
 * 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 - 2017 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 {

	/**
	 * 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 $config = array();

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

	// 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;

	/**
	 * 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	NullPointerException	If $configKey is NULL
	 * @throws	InvalidArgumentException	If $configKey is empty
	 */
	public function isConfigurationEntrySet ($configKey) {
		// Is it null?
		if (is_null($configKey)) {
			// Throw NPE
			throw new NullPointerException($this, BaseFrameworkSystem::EXCEPTION_IS_NULL_POINTER);
		} elseif (!is_string($configKey)) {
			// Is not a string
			throw new InvalidArgumentException(sprintf('configKey[]=%s is not a string', gettype($configKey)), self::EXCEPTION_CONFIG_KEY_IS_EMPTY);
		} elseif ((is_string($configKey)) && (empty($configKey))) {
			// Entry is empty
			throw new InvalidArgumentException('configKey is empty', self::EXCEPTION_CONFIG_KEY_IS_EMPTY);
		}

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

		// Return the result
		return $isset;
	}

	/**
	 * Read a configuration element.
	 *
	 * @param	$configKey		The configuration element
	 * @return	$configValue	The fetched configuration value
	 * @throws	NullPointerException	If $configKey is NULL
	 * @throws	InvalidArgumentException	If $configKey is empty
	 * @throws	NoConfigEntryException		If a configuration element was not found
	 */
	public function getConfigEntry ($configKey) {
		// Is it null?
		if (is_null($configKey)) {
			// Throw NPE
			throw new NullPointerException($this, BaseFrameworkSystem::EXCEPTION_IS_NULL_POINTER);
		} elseif (!is_string($configKey)) {
			// Is not a string
			throw new InvalidArgumentException(sprintf('configKey[]=%s is not a string', gettype($configKey)), self::EXCEPTION_CONFIG_KEY_IS_EMPTY);
		} elseif ((is_string($configKey)) && (empty($configKey))) {
			// Entry is empty
			throw new InvalidArgumentException('configKey is empty', self::EXCEPTION_CONFIG_KEY_IS_EMPTY);
		}

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

		// Is a valid configuration key provided?
		if (!$this->isConfigurationEntrySet($configKey)) {
			// Entry was not found!
			throw new NoConfigEntryException(array(__CLASS__, $configKey), self::EXCEPTION_CONFIG_KEY_WAS_NOT_FOUND);
		} // END - if

		// Return the requested value
		return self::$config[$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	NullPointerException	If $configKey is NULL
	 * @throws	InvalidArgumentException	If $configKey is empty
	 * @throws	InvalidArgumentException	If $configValue has an unsupported variable type
	 */
	public final function setConfigEntry ($configKey, $configValue) {
		// Is a valid configuration key key provided?
		if (is_null($configKey)) {
			// Configuration key is null
			throw new NullPointerException($this, BaseFrameworkSystem::EXCEPTION_IS_NULL_POINTER);
		} elseif (!is_string($configKey)) {
			// Is not a string
			throw new InvalidArgumentException(sprintf('configKey[]=%s is not a string', gettype($configKey)), self::EXCEPTION_CONFIG_KEY_IS_EMPTY);
		} elseif ((is_string($configKey)) && (empty($configKey))) {
			// Entry is empty
			throw new InvalidArgumentException('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 = BaseFrameworkSystem::convertDashesToUnderscores($configKey);

		// Set the configuration value
		//* NOISY-DEBUG: */ print(__METHOD__ . ':configEntry=' . $configKey . ',configValue[' . gettype($configValue) . ']=' . $configValue . PHP_EOL);
		self::$config[$configKey] = $configValue;

		// Resort the array
		ksort(self::$config);
	}

	/**
	 * Getter for whole configuration array
	 *
	 * @return	$config		Configuration array
	 */
	public final function getConfigurationArray () {
		// Return it
		return self::$config;
	}

	/**
	 * Unset a configuration key, the entry must be there or else an
	 * exception is thrown.
	 *
	 * @param	$configKey	Configuration key to unset
	 * @return	void
	 * @throws	NullPointerException	If $configKey is NULL
	 * @throws	InvalidArgumentException	If $configKey is empty
	 * @throws	NoConfigEntryException	If a configuration element was not found
	 */
	public final function unsetConfigEntry ($configKey) {
		// Validate parameters
		if (is_null($configKey)) {
			// Configuration key is null
			throw new NullPointerException($this, BaseFrameworkSystem::EXCEPTION_IS_NULL_POINTER);
		} elseif (!is_string($configKey)) {
			// Entry is empty
			throw new InvalidArgumentException(sprintf('configKey[]=%s is not a string', gettype($configKey)), self::EXCEPTION_CONFIG_KEY_IS_EMPTY);
		} elseif ((is_string($configKey)) && (empty($configKey))) {
			// Entry is empty
			throw new InvalidArgumentException('configKey is empty', self::EXCEPTION_CONFIG_KEY_IS_EMPTY);
		}

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

		// Is the configuration key there?
		if (!$this->isConfigurationEntrySet($configKey)) {
			// Entry was not found!
			throw new NoConfigEntryException(array(__CLASS__, $configKey), self::EXCEPTION_CONFIG_KEY_WAS_NOT_FOUND);
		} // END - if

		// Unset it
		unset(self::$config[$configKey]);
	}

	/**
	 * 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 ($fieldName) {
		// The super interface "FrameworkInterface" requires this
		throw new UnsupportedOperationException(array($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 ($fieldName) {
		// The super interface "FrameworkInterface" requires this
		throw new UnsupportedOperationException(array($this, __FUNCTION__), BaseFrameworkSystem::EXCEPTION_UNSPPORTED_OPERATION);
	}

	/**
	 * 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;
	}

}