<?PHP
	NAMESPACE ILLI\Core;
	USE ILLI\Core\StaticObject\iAdapter;
	USE ILLI\Core\StaticObject\iClass;
	USE ILLI\Core\StaticObject\iFilter;
	USE ILLI\Core\StaticObject\iMethod;
	USE ILLI\Core\StaticObject\iMethodFacade;
	USE ILLI\Core\StaticObject\iMethodProto;
	USE ILLI\Core\StaticObject\iObserver;
	USE ILLI\Core\StaticObject\iSignal;
	USE ILLI\Core\StaticObject\iTo;
	USE ILLI\Core\StaticObject\tAdapter;
	USE ILLI\Core\StaticObject\tFilter;
	USE ILLI\Core\StaticObject\tInvoke;
	USE ILLI\Core\StaticObject\tObserver;
	USE ILLI\Core\StaticObject\tSignal;
	USE ILLI\Core\StaticObject\tClass;
	USE ILLI\Core\StaticObject\tTo;
	USE ILLI\Core\StaticObject\tMethod;
	USE ILLI\Core\StaticObject\tMethodFacade;
	USE ILLI\Core\StaticObject\tMethodProto;
	USE ILLI\Core\Filter;
	
	INTERFACE iStaticObject EXTENDS iAdapter, iClass, iFilter, iMethod, iMethodFacade, iMethodProto, iObserver, iSignal, iTo
	{
		public static function __load();
		
		public static function parents($__className = NULL);
		public static function traits($__className = NULL);
		
		public static function construct(array $__options = []);
		public static function __callstatic($__name, array $__parameters = []);
		
		public static function env(array $__options = []);
		public static function extend();
		public static function to($__format, array $__options = []);
	}
	
	CLASS StaticObject IMPLEMENTS iStaticObject
	{
		USE tMethodFacade
		{
			Core_StaticObject_tMethodFacade_register	AS public registerMethodFacade;
			Core_StaticObject_tMethodFacade_unregister	AS public unregisterMethodFacade;
			Core_StaticObject_tMethodFacade_exists		AS public isMethodFacade;
		}
		
		USE tAdapter
		{
			Core_StaticObject_tAdapter_register		AS public registerAdapter;
			Core_StaticObject_tAdapter_unregister		AS public unregisterAdapter;
			Core_StaticObject_tAdapter_exists		AS public isAdapter;
		}
		
		USE tClass
		{
			Core_StaticObject_tClass_register		AS public registerClass;
			Core_StaticObject_tClass_unregister		AS public unregisterClass;
			Core_StaticObject_tClass_exists			AS public isClass;
		}
		
		USE tFilter
		{
			Core_StaticObject_tFilter_register		AS public registerFilter;
			Core_StaticObject_tFilter_unregister		AS public unregisterFilter;
			Core_StaticObject_tFilter_exists		AS public isFilter;
		}
		
		USE tMethod
		{
			Core_StaticObject_tMethod_register		AS public registerMethod;
			Core_StaticObject_tMethod_unregister		AS public unregisterMethod;
			Core_StaticObject_tMethod_exists		AS public isMethod;
		}
		
		USE tObserver
		{
			Core_StaticObject_tObserver_register		AS public registerObserver;
			Core_StaticObject_tObserver_unregister		AS public unregisterObserver;
			Core_StaticObject_tObserver_exists		AS public isObserver;
		}
		
		USE tSignal
		{
			Core_StaticObject_tSignal_register		AS public registerSignal;
			Core_StaticObject_tSignal_unregister		AS public unregisterSignal;
			Core_StaticObject_tSignal_exists		AS public isSignal;
		}
		
		USE tTo
		{
			Core_StaticObject_tTo_register			AS public registerTo;
			Core_StaticObject_tTo_unregister		AS public unregisterTo;
			Core_StaticObject_tTo_exists			AS public isTo;
		}
		
		USE tMethodProto
		{
			Core_StaticObject_tMethodProto_register		AS public registerMethodProto;
			Core_StaticObject_tMethodProto_unregister	AS public unregisterMethodProto;
			Core_StaticObject_tMethodProto_exists		AS public isMethodProto;
		}
		
		USE tInvoke;
		
		protected static $__defaultConfig	= [];
		protected static $__autoConfig		= [];
		protected static $__defaultOptions	= [];
		
		protected static $__env 		= [];
		protected static $__initConfig		= [];
		
		protected static $__parentClasses	= [];
		protected static $__usedTraits		= [];
		
		private static $__baseOptions		= 
		[
			'__run'		=> TRUE,
			'__main'	=> '__main',
			'__delegate'	=> NULL,
			'__adapter'	=> [],
			'__filter'	=> [],
			'__proto'	=> [],
			'__method'	=> [],
			'__observer'	=> [],
			'__signal'	=> [],
			'__class'	=> [],
			'__to'		=>
			[
				'string'	=> 'toString',
				'array'		=> 'toArray'
			],
			'__protoprefix' => 'prototype'
		];
		
		protected static function __main()
		{
			var_dump(__METHOD__);
		}
		
		public static function __load()
		{
			$class = get_called_class();
			self::$__env[$class]		= [];
			self::$__initConfig[$class]	= [];
		}
		
		private function __construct()
		{
		}
		
		final public static function construct(array $__options = [])
		{
			$class = get_called_class();
			
			var_dump(__METHOD__);
			
			self::$__initConfig[$class] = static::extend(TRUE, self::$__baseOptions, static::$__defaultOptions, $__options);
			
			if(TRUE === self::$__initConfig[$class]['__run'])
				static::__run();
		}
		
		public static function env(array $__env = [])
		{
			$class = get_called_class();
			
			foreach(self::$__env[$class] as $passable => $val)
			{
				if(FALSE === isset($__env[$passable]))
					continue;
					
				self::$__env[$class][$passable] = is_array(self::$__env[$class][$passable]) && is_array($__env[$passable])
					? static::extend(TRUE, self::$__env[$class][$passable], $__env[$passable])
					: $__env[$passable];
				
				$key = "{$passable}";
				if(TRUE === isset(static::${$key}))
					static::${$key} = &self::$__env[$class][$passable];
			}
		}
		
		protected static function __run()
		{
			$class = get_called_class();
			
			static::__configure();
			var_dump(__METHOD__);
                        static::Core_StaticObject_tMethod_install		(self::$__initConfig[$class]['__method']);
                        static::Core_StaticObject_tMethodProto_install		(self::$__initConfig[$class]['__proto']);
                        static::Core_StaticObject_tAdapter_install		(self::$__initConfig[$class]['__delegate']);
                        static::Core_StaticObject_tAdapter_install		(self::$__initConfig[$class]['__adapter']);
                        static::Core_StaticObject_tObserver_install		(self::$__initConfig[$class]['__observer']);
                        static::Core_StaticObject_tSignal_install		(self::$__initConfig[$class]['__signal']);
                        static::Core_StaticObject_tFilter_install		(self::$__initConfig[$class]['__filter']);
                        static::Core_StaticObject_tTo_install			(self::$__initConfig[$class]['__to']);
                        static::Core_StaticObject_tClass_install		(self::$__initConfig[$class]['__class']);
			static::prototype('construct', self::$__env[$class]);
		}
		
		protected static function __configure()
		{
			var_dump(__METHOD__);
			$class = get_called_class();
			
			$defaultConfig		=& static::$__defaultConfig;
			$autoConfig		=& static::$__autoConfig;
			$initConfig		=& self::$__initConfig[$class];
			$env			=& self::$__env[$class];
			
			foreach($autoConfig as $key => $flag)
			{
				// option not given. use default value
				if(!isset($initConfig[$key])
				&& isset($defaultConfig[$key]))
				{
					$env[$key] = $defaultConfig[$key];
					continue;
				}
				
				if(!isset($initConfig[$flag])
				&& isset($defaultConfig[$flag]))
				{
					$env[$flag] = $defaultConfig[$flag];
					continue;
				}
				
				if($flag === 'merge') // initConfig + defaultConfig
				{
					if(isset($defaultConfig[$key]))
					{
						if(is_array($initConfig[$key])
						&& is_array($defaultConfig[$key]))
						{
							$env[$key] = static::extend
							(
								TRUE,
								$initConfig[$key],
								$defaultConfig[$key]
							);
						}
						else
						{
							$env[$key] =
								$initConfig[$key]
								+ $defaultConfig[$key];
						}
						
					}
					else
					{
						$env[$key] = $initConfig[$key];
					}
				}
				else // initConfig[${key}]
				if(isset($initConfig[$key]))
				{
					$env[$key] = $initConfig[$key];
				}
				else // initConfig[${flag}]
				if(isset($initConfig[$flag]))
				{
					$env[$flag] = $initConfig[$flag];
				}
				else // defaultConfig[${key}]
				if(isset($defaultConfig[$key]))
				{
					$env[$key] = $defaultConfig[$key];
				}
				else // default[${flag}]
				if(isset($defaultConfig[$flag]))
				{
					$env[$flag] = $defaultConfig[$flag];
				}
				else
				{
					$env[$flag] = NULL;
				}
			}
			
			// accessible as property
			foreach($env as $passable => &$value)
			{
				$key = "{$passable}";
				
				if(FALSE === isset(static::${$key}))
					continue;
					
				static::${$key} = &$value;
				
				if(isset($initConfig[$passable]))
					unset($initConfig[$passable]);
			}
		}
		
		protected static function prototype($__function, array $__parameters = [])
		{
			var_dump(__METHOD__);
			$__class = get_called_class();
			
			if(isset($__parameters['this']))
				unset($__parameters['this']);
			
			if(TRUE === static::Core_StaticObject_tAdapter_exists($__function))
				return static::Core_StaticObject_tAdapter_emit($__function, $__parameters);
			
			$__parameters = static::Core_StaticObject_tFilter_emit($__function, 'PARAMS', $__parameters, ['return' => $__parameters]);
			
			static::Core_StaticObject_tSignal_emit($__function, 'PRE_EVENT', [$__parameters], ['return' => $__parameters]);
			
			$__result = static::Core_StaticObject_tMethodFacade_emit($__function, $__parameters, function(array $__params) use ($__class, $__function)
			{
				$result	= NULL;
				
				if(TRUE === static::Core_StaticObject_tMethodProto_exists($__function))
				{
					$result = static::Core_StaticObject_tMethodProto_emit($__function, $params);
				}
				else
				{
					$proto = $__function === 'construct'
						? self::$__initConfig[$__class]['__main']
						: self::$__initConfig[$__class]['__protoprefix'].$__function;
				
					if($proto === $__function)
					{
					}
					else
					if(method_exists($__class, $proto))
					{
						$result = static::Core_StaticObject_tInvoke_method($proto, $__params);
					}
				}
				
				return $result;
			});
			
			$__result = static::Core_StaticObject_tFilter_emit($__function, 'RETURN', $__result, ['return' => $__result]);
			
			static::Core_StaticObject_tObserver_emit($__function, [$__result, $__parameters]);
			static::Core_StaticObject_tSignal_emit($__function, 'POST_EVENT',  [$__result, $__parameters], ['return' => $__result]);
			
			return $__result;
		}
		
		public static function parents($__className = NULL)
		{
			$parentClasses = &self::$__parentClasses;
			
			$class = NULL === $__className ? get_called_class() : $__className;
			
			if(isset($parentClasses[$class]))
				return $parentClasses[$class];
			
			$classes = [$class];
    			while($class = get_parent_class($class))
    				$classes[] = $class;
    			
    			$classes = array_reverse($classes);
    			$parentClasses[$class] = $classes;
    			
    			return $classes;
		}
		
		public static function traits($__className = NULL)
		{
			$usedTraits = &self::$__usedTraits;
			
			$class = NULL === $__className ? get_called_class() : $__className;
			$classes = self::parents($class);
			
			if(isset($usedTraits[$class]))
				return $usedTraits[$class];
			
			$traits = [];
			foreach($classes as $class)
				foreach((new \ReflectionClass($class))->getTraits() as $trait)
					$traits[] = $trait->name;
			
    			$usedTraits[$class] = $traits;
    			
    			return $traits;
		}
		
		public static function extend()
		{
			$class		= get_called_class();
			$args		= func_get_args();
			$tar		= $args[0];
			$i		= 1;
			$length		= count($args);
			$rec		= false;
			
			if($tar === true || $tar === false)
			{
				$rec = $tar;
				$tar = isset($args[1]) ? $args[1] : [];
				$i = 2;
			}
			
			if(!is_array($tar) && !is_object($tar))
				$tar = [];
				
			if($length === $i)
			{
				//if(FALSE === ($this instanceof \Iterator))
				//	throw new \Exception('Unable to iterate throw '.get_called_class());
				
				$tar = $class;
				--$i;
			}
			
			for( ; $i < $length; $i++)
			{
				if(NULL === ($opt = $args[$i]))
					continue;
				
				foreach($opt as $key => $value)
				{
					if(is_array($tar))
					{
						if(TRUE === $rec && is_array($value) && isset($tar[$key]) && is_array($tar[$key]))
						{
							$tar[$key] = static::extend($rec, $tar[$key], $value);
							continue;
						}
						
						if(is_object($value))
						{
							//$tar[$key] = TRUE === $rec ? clone $value : $value;
							$tar[$key] = $value;
							continue;
						}
						
						$tar[$key] = $opt[$key];
						continue;
					}
					
					if(is_object($tar))
					{
						if(TRUE === $rec && is_array($value) && isset($tar->$key) && is_array($tar->$key))
						{
							$tar->$key = static::extend($rec, $tar->$key, $value);
							continue;
						}
						
						if(is_object($value))
						{
							//$tar[$key] = TRUE === $rec ? clone $value : $value;
							$tar->$key = $value;
							continue;
						}
						
						$tar->$key = $opt[$key];
						continue;
					}
					
					if(is_string($tar))
					{
						if(isset(self::$__env[$class][$key]))
						{
							static::env([$key => $value]);
							continue;
						}
						
						if(TRUE === $rec && is_array($value) && isset(static::${$key}) && is_array(static::${$key}))
						{
							static::${$key} = static::extend($rec, static::${$key}, $value);
							continue;
						}
						
						if(is_object($value))
						{
							//static::${$key} = TRUE === $rec ? clone $value : $value;
							static::${$key} = $value;
							continue;
						}
						
						static::${$key} = $opt[$key];
					}
				}
			}
			
			return $tar;
		}
		
		public static function __callstatic($__name, array $__parameters = [])
		{
			if(FALSE === static::Core_StaticObject_tMethod_exists($__name))
				throw new \Exception(get_called_class().'::'.$__name.'() is not a function.');
				
			return static::Core_StaticObject_tMethod_emit($__name, $__parameters);
		}
		
		public static function to($__format, array $__options = [])
		{
			$__options +=
			[
				'handlers'	=> []
			];
			
			return static::Core_StaticObject_tTo_emit($__format, [$__options]);
		}
		
		protected static function toString(array $__options = [])
		{
			return get_called_class();
		}
		
		protected static function toArray(array $__options = [])
		{
			$__options +=
			[
				'filter'	=> function($__propertyName, $__value)
				{
					return !(substr($__propertyName, 0, 2) === '__');
				}
			];
			
			$props = [];
			$lookup = $class = get_called_class();
			
			do
			{
				foreach((new \ReflectionClass($lookup))->getStaticProperties() as $property => $value)
				{
					// normalize $space[ClassName] => $data to $space => $data
					if(isset(self::${$property})
					&& is_array(self::${$property})
					&& in_array($property, ['__initConfig', '__env'])
					&& isset(self::${$property}[$class]))
						$value = self::${$property}[$class];
					
					$props[$property] = (is_array($value) && TRUE === isset($props[$property]))
						? array_merge($value, $props[$property])
						: $value;
				}
			}
			while($lookup = get_parent_class($lookup));
			
			$result = [];
			
			foreach($props as $property => $value)
			{
				if(is_callable($__options['filter'])
				&& FALSE === $__options['filter']($property, $value))
					continue;
				
				switch(true):
					case is_array($value):
					case (!is_object($property)):
						$result[$property] = $value;
						break;
					case (isset($__options['handlers'][$class = get_class($value)])):
						$result[$property] = $__options['handlers'][$class]($value);
						break;
					case (method_exists($value, 'to')):
						$result[$property] = $value->to('array', $__options);
						break;
					case ($vars = get_object_vars($value)):
						$result[$property] = $vars;
						break;
					case (method_exists($value, '__toString')):
						$result[$property] = (string) $value;
						break;
					default:
						$result[$property] = $value;
						break;
				endswitch;
			}
			
			return [$class => $result];
		}
	}