<?php

namespace Twister;

use ArrayAccess;

/**
 *	Multi-purpose IoC/DI Container
 *	==============================
 *	This is a powerful, flexible, yet light-weight, simple and easy-to-use multi-purpose Container;
 *		it includes the ability to be a IoC/DI Container, a Service Locator,
 *		a dynamic function library, factory object builder and general purpose data/object/array storage.
 *	This Container essentially takes the place of an application `Kernel` or `App` class,
 *		all global variables/object instances, app configurations, environment variables,
 *		`microservices`, object (factory) builders etc. are all contained within it.
 *	Many of the services, capabilities and functionality are provided by the various anonymous functions contained within.
 *		Along with the closures, it also contains arrays and instanciated objects.
 *	All these capabilities are accessed in the form of a dynamic property (using __get and __set);
 *		eg. '$c->db' gives you the current database class; you can also use '$c->db()' if you prefer.
 *	Laravel Container: https://laravel.com/docs/5.4/container
 *	Symfony Container: http://symfony.com/doc/current/service_container.html
 */
class Container implements ArrayAccess
{
	/**
	 * The current globally available container instance (if any).
	 *
	 * @var static
	 */
	protected static $instance = null;

	/**
	 * The container's bindings.
	 *
	 * @var array
	 */
	protected $bindings = null;

	/**
	 * The registered type aliases.
	 *
	 * @var array
	 */
	protected $aliases = null;

	function __construct(array $c = [])
	{
		if (static::$instance)
			throw new \Exception('Cannot create another Container instance!');
		static::$instance = $this;

		$this->bindings = $c;
		if (isset($c['aliases']))
		{
			$this->aliases = $c['aliases'];
			unset($c['aliases']);
		}

		$this->bindings[self::class] = $this;
	}

	/**
	 * Get the globally available instance of the container.
	 *
	 * @return static
	 */
	public static function getInstance()
	{
		return static::$instance;
	}

	function &__call($method, $args)
	{
		if (isset($this->bindings[$method]))
			if (is_callable($this->bindings[$method]))
			{
				array_unshift($args, $this);	//	Prepend $this container to the beginning of the function call arguments!
				$result = call_user_func_array($this->bindings[$method], $args);
				return $result;
			}
			else
				return $this->bindings[$method];
		else
		{
			if (preg_match('/^([gs]et|has|isset|unset)([A-Z])(.*)$/', $method, $match))
			{
				$property = strtolower($match[2]). $match[3];
				if (isset($this->bindings[$property]))
				{
					switch($match[1])
					{
						case 'get': return $this->bindings[$property];
						case 'set': return $this->bindings[$property] = $args[0];
						case 'has': //	fallthrough vvv alias for `isset`
						case 'isset': $result = isset($this->bindings[$property]); return $result;
						case 'unset': $result = null; unset($this->bindings[$property]); return $result;
					}
				}
				throw new \InvalidArgumentException("Property {$property} doesn't exist");
			}
			throw new \InvalidArgumentException(__CLASS__ . "->{$method}() doesn't exist");
		}
	}

	/**
	 * Call the given function using the given parameters.
	 *
	 * Missing parameters will be resolved from the container.
	 *
	 * @param callable $callable   Function to call.
	 * @param array    $params     Additional parameters to use. Can be indexed by the parameter names
	 *                             or not indexed (same order as the parameters).
	 *                             The array can also contain DI definitions, e.g. DI\get().
	 *
	 * @return mixed Result of the function.
	 */
	public function call(callable $callable, array $params = null)
	{
		$reflected = new \ReflectionFunction($callable);
		return $reflected->invokeArgs($this->_buildArgList($reflected, $params));
	}

	private function _buildArgList(\ReflectionFunctionAbstract $reflected, array &$params = null)
	{
		$args	=	[];
		foreach ($reflected->getParameters() as $index => $param)
		{
			if ($param->hasType() && isset($this->bindings[$param->getType()]))
			{
				$value = &$this->bindings[$param->getType()];
				$args[] = is_callable($value) ? $value($this) : $value;
			}
			else
			{
				$name = $param->name;
				if (isset($params[$name]))
				{
					$args[] = $params[$name];
				}
				else if (isset($params[$index]))
				{
					$args[] = $params[$index];
				}
				else
				{
					if ( ! $param->isOptional())
						throw new \Exception('Unable to find NON-optional parameter `' . $param->name . ($param->hasType() ? '` of type `' . $param->getType() : null) . '` for route controller/handler: ' . var_export($this->route, true));
					$args[] = $param->getDefaultValue();
				}
			}
		}
		return $args;
	}

	/**
	 * Build an entry of the container by its name.
	 *
	 * This method behaves like get() except resolves the entry again every time.
	 * For example if the entry is a class then a new instance will be created each time.
	 *
	 * This method makes the container behave like a factory.
	 *
	 * @param string $name       Entry name or a class name.
	 * @param array  $parameters Optional parameters to use to build the entry.
	 *                           Use this to force specific parameters to specific values.
	 *                           Parameters not defined in this array will be resolved using the container.
	 *
	 * @throws InvalidArgumentException The name parameter must be of type string.
	 * @throws DependencyException Error while resolving the entry.
	 * @throws NotFoundException No entry found for the given name.
	 * @return mixed
	 */
	public function make(string $name, array $parameters = null)
	{
		$definition = $this->definitionSource->getDefinition($name);
		if (! $definition) {
			// If the entry is already resolved we return it
			if (array_key_exists($name, $this->resolvedEntries)) {
				return $this->resolvedEntries[$name];
			}

			throw new NotFoundException("No entry or class found for '$name'");
		}

		return $this->resolveDefinition($definition, $parameters);
	}

	/**
	 * Define an object or a value in the container.
	 *
	 * @param string $name Entry name
	 * @param mixed|DefinitionHelper $value Value, use definition helpers to define objects
	 */
	public function set(string $name, $value)
	{
		if ($value instanceof DefinitionHelper) {
			$value = $value->getDefinition($name);
		} elseif ($value instanceof \Closure) {
			$value = new FactoryDefinition($name, $value);
		}

		if ($value instanceof Definition) {
			$this->setDefinition($name, $value);
		} else {
			$this->resolvedEntries[$name] = $value;
		}
	}



	function set($key, $value)				//	alias for __set()
	{
		return $this->__set($key, $value);
	}
	function &get($key, $default = null)	//	similar to __get()
	{
		return $this->bindings[$key] ?? $default;
	}
	function has($key)						//	alias for __isset()
	{
		return isset($this->bindings[$key]);
	}
	function &merge($key, array $arr)		//	we need this function because we cannot (re)`set` the arrays to new values without unsetting the old values first! ie. __set() will fail because it already exists!
	{
		//	TODO: Add is_array() checks to the container, and add variable number of array inputs!
		$this->bindings[$key] = array_merge($this->bindings[$key], $arr);
		return $this->bindings[$key];
	}
	function remove($key)					//	alias for __unset()
	{
		unset($this->bindings[$key]);
	}




	/**
	 * Determine if a given offset exists.
	 *
	 * @param  string  $key
	 * @return bool
	 */
	public function offsetExists($key)
	{
		return isset($this->bindings[$key]);
	}

	/**
	 * Get the value at a given offset.
	 *
	 * @param  string  $key
	 * @return mixed
	 */
	public function offsetGet($key)
	{
		return $this->__get($key);
	}

	/**
	 * Set the value at a given offset.
	 *
	 * @param  string  $key
	 * @param  mixed   $value
	 * @return void
	 */
	public function offsetSet($key, $value)
	{
		$this->__set($key, $value);
	}

	/**
	 * Unset the value at a given offset.
	 *
	 * @param  string  $key
	 * @return void
	 */
	public function offsetUnset($key)
	{
		unset($this->bindings[$key]);
	}

	/**
	 * Dynamically access container services.
	 *
	 * @param  string  $key
	 * @return mixed
	 */
	public function __get($key)
	{
		if (isset($this->bindings[$key]))
		{
			$value = $this->bindings[$key];
			return is_callable($value) ? $value($this) : $value;	//	$value instanceof Closure
		}

		/**
		 *	Examples of official PHP error messages when a property cannot be found
		 *		Notice: Undefined index: config in C:\...\app.php on line 34
		 *		Undefined property: Container::$config in <b>C:\...\app.php</b> on line <b>111</b><br />
		 */
		$trace = debug_backtrace();
		trigger_error('Undefined container property: ' . __CLASS__ . "->{$key} in <b>{$trace[0]['file']}</b> on line <b>{$trace[0]['line']}</b>; thrown", E_USER_ERROR);
		return null;
	}

	/**
	 * Dynamically set container services.
	 *
	 * @param  string  $key
	 * @param  mixed   $value
	 * @return void
	 */
	public function __set($key, $value)
	{
		/**
		 *	do we really need to stop the variables from being set???
		 *	currently we are protecting anything that is not a callable function.
		 *		the reason why I don't protect a callable, is because many of the callables
		 *		will set the same value to an instantaited object. It just saves us using `unset()` first
		 *	The alternative is to do something like Symfony or other frameworks,
		 *		where we call a `protect()` or `singleton()` methods etc.
		 *	I just hate calling yet another method for every occasion or fringe case!
		 */
		if (isset($this->bindings[$key]) && ! is_callable($this->bindings[$key]))
		{
			$trace = debug_backtrace();
			trigger_error(__CLASS__ . " container property `{$key}` has already been set and cannot be changed in {$trace[0]['file']} on line {$trace[0]['line']}. Please unset() and re-set the value!", E_USER_ERROR);
		}
		else
			return $this->bindings[$key] = $value;
	}

	function __isset($key)
	{
		return isset($this->bindings[$key]);
	}

	function __unset($key)
	{
		unset($this->bindings[$key]);
	}

}