<?PHP
	NAMESPACE ILLI\Core;
	USE ILLI\Core\Exception;
	USE ILLI\Util\Inflector;
	USE ILLI\Util\String;
	USE ILLI\Core\Proto\I_Boot;
	
	CLASS Proto EXTENDS \ILLI\Core\A_Proto IMPLEMENTS \ILLI\Core\I_Proto
	{
		private static $__defaultOptions =
		[
			I_Proto::DI_RUN			=> TRUE,
			I_Proto::DI_MAIN		=> '__main',
			I_Proto::DI_CLASS		=> [],
			I_Proto::DI_DELEGATE		=> [],
			I_Proto::DI_FILTER		=> [],
			I_Proto::DI_METHOD		=> [],
			I_Proto::DI_OBSERVER		=> [],
			I_Proto::DI_METHOD_PROTO	=> [],
			I_Proto::DI_SIGNAL		=> [],
			I_Proto::DI_TO =>
			[
				'string'		=> 'toString',
				'array'			=> 'toArray'
			]
		];
		
		protected $__initConfig = [];
		
		USE \ILLI\Core\Proto\T_Boot;
		
		/**
		 * bootstrap static protected vars and store default class-setup in a static dict
		 * default strapping:
		 *	::$propertyConfigurable: a list of accessible/configurable properties including constructor-options
		 *	::$propertyDefaults: the default Values of defined class-properties
		 *	::$propertyAspectable: a list of injectable class-properties (observer, signal, facade, strategy etc.)
		 *
		 * @discus: diff for constructor-configurable and runtime-configurable:
		 *		unset from whitelist on @__exec() ??
		 */
		final public function __construct(array $__options = [])
		{
			// $obj->$prop not exist:
			// 	bypass property... public $obj->$commonProp is evil: the value is avail in __initConfig and never modifiable from outside
			
			// modify prop:
			//	not defined as CONFIGURABLE -> not public -> not modifiable
			
			// __construct(array $__options):
			//	not defined as CONFIGURABLE: $__options[prop] is stored in __initConfig[prop] -> bypass $obj->$prop
			
			// DEFAULT VALUE, construct $__options, modify prop:
			//	not defined as ASPECTABLE: use direct access
			
			// @__boot
			//	ON_LOOKUP | ON_COMPLETE => static results
			//	ON_INIT $obj::__construct-event
			$__boot = 
			[
				// DEFAULT VALUE
				//	the default values
				// static $obj::$__DEFINE_propDef
				I_Proto::DEFINE_DEFAULTS =>
				[
					// merge DEF -> value: called class overwrites base-class except $__defaultOptions (extend)
					// write $c to static cache
					I_Boot::ON_LOOKUP => function($c, $n, array $l)
					{
						array_walk($l, function($v, $p) use (&$c, $n)
						{
							$c[$p] = $this->Core_Proto_T_Boot_handleLookup($p, $n, $c) +
							[
								I_Proto::BOOT_IDX_DEFAULT_VALUE => $v
							];
							
							$m = &$c[$p][I_Proto::BOOT_IDX_DEFAULT_VALUE];
							
							if(isset($m)
							&& isset(self::$__defaultOptions[$p])
							&& is_array($m)
							&& is_array($v))
								$m = $this->extend(TRUE, $v, $m);
						});
						
						return $c;
					},
					// load $c from static cache
					// save merged defaults in __initConfig on __construct()
					I_Boot::ON_INIT => function($c)
					{
						array_walk($c, function($s, $p)
						{
							$this->__initConfig[$p] = $s[I_Proto::BOOT_IDX_DEFAULT_VALUE];
						});
						
						return $c;
					}
				],
				// ASPECTABLE PROP
				//	aspProperty is injectable
				// 	[$prop => false] overwrites parent::$prop to bypass asp
				// 	[$prop => flag] overwrites parent::$prop: 'array', 'property' OR ['myFunc1', 'myFunc2'] OR 'myFunc1|myFunc2'
				//	inject-accessor is the camelized version of property-name + event-name: aspectable{:Event}{:Property}() -> aspectableSetParam
				//	protected accessor is property({:event}, {:property}[, {:value}])
				//	public accessor is property{:Event}([{:property}, {:value}]) @see CONFIGURABLE
				//	to apply asp-events for DEFAULT-values register all events before calling @__exec()! ($__option[__run] = FALSE)
				// static $obj::$__DEFINE_propAsp
				I_Proto::DEFINE_ASPECTABLE =>
				[
					// merge ASP -> flag: called class extends base-class
					// write $c to static cache
					I_Boot::ON_LOOKUP => function($c, $n, $l)
					{
						$d =
						[
							I_Proto::ASP_TYPE_PROP	=> [I_Proto::ASP_FN_PRFX_SET, I_Proto::ASP_FN_PRFX_RESTORE],
							I_Proto::ASP_TYPE_ARRAY	=> [I_Proto::ASP_FN_PRFX_SET, I_Proto::ASP_FN_PRFX_RESTORE, I_Proto::ASP_FN_PRFX_ADD, I_Proto::ASP_FN_PRFX_REMOVE, I_Proto::ASP_FN_PRFX_CLEAR],
						];
						
						array_walk($l, function($v, $p) use (&$c, $n, $d)
						{
							if(is_integer($p))
							{
								$p = $v;
								$v = TRUE;
							}
							
							$c[$p] = $this->Core_Proto_T_Boot_handleLookup($p, $n, $c) +
							[
								I_Proto::BOOT_IDX_ASP_ENABLED		=> is_string($v) ? TRUE : $v,
								I_Proto::BOOT_IDX_ASP_DI_LIST		=> $a = is_string($u = is_bool($v) ? I_Proto::ASP_TYPE_PROP : $v) ? isset($d[$u]) ? $d[$u] : explode('|', $u) : $u,
								I_Proto::BOOT_IDX_ASP_DI_INIT_NAME	=> !isset($a[0]) ? isset($d[$u]) ? $d[$u][0] : I_Proto::ASP_FN_PRFX_SET : $a[0],
								I_Proto::BOOT_IDX_ASP_DI_NAMES		=> [],
								I_Proto::BOOT_IDX_ASP_DI_DISABLED	=> [],
								I_Proto::BOOT_IDX_ASP_DI_ENABLED	=> []
							];
						});
						
						return $c;
					},
					// create accessor tuplet
					// write $c to static cache
					I_Boot::ON_COMPLETE => function($c)
					{
						array_walk($c, function(&$s, $p)
						{
							if(FALSE === $s[I_Boot::BOOT_IDX_EXISTS]
							|| FALSE === $s[I_Proto::BOOT_IDX_ASP_ENABLED])
								return;
							
							array_walk($s[I_Proto::BOOT_IDX_ASP_DI_LIST], function($a) use (&$s, $p)
							{
								$s[I_Proto::BOOT_IDX_ASP_DI_NAMES] += [$a => $m = String::insert(I_Proto::ASP_TPL_FN_NAME, ['aspFnPrefix' => Inflector::camelize($a), 'propertyName' => Inflector::camelize($p)])];
								$s[(($e = method_exists($this, $m)) ? I_Proto::BOOT_IDX_ASP_DI_ENABLED : I_Proto::BOOT_IDX_ASP_DI_DISABLED)] += [$a => ($e ? $m : $p)];
							});
						});
						
						return $c;
					}
				],
				// CONFIGURABLE
				//	comProperty is a runtimeProperty
				//	accessible from public scope
				//	accessibble from __construct
				// 	[$prop => flag] overwrites parent::$prop: behavior (merge, extend...)
				//	public accessor is property{:Event}([{:property}, {:value}])
				// static $obj::$__DEFINE_propCom
				I_Proto::DEFINE_CONFIGURABLE =>
				[
					// merge CONFIGURABLE -> flag: called class extends base-class
					// write $c to static cache
					I_Boot::ON_LOOKUP => function($c, $n, array $l)
					{
						array_walk($l, function($v, $p) use (&$c, $n)
						{
							if(is_integer($p))
							{
								$p = $v;
								$v = FALSE;
							}
							
							$c[$p] = $this->Core_Proto_T_Boot_handleLookup($p, $n, $c) +
							[
								I_Proto::BOOT_IDX_CONFIG_FLAG => $v
							];
						});
						
						return $c;
					}
				]
			];
			
			// @__dest
			//	finalizer
			$__dest = function()
			{
				$this->__initConfig[I_Proto::DI_RUN] = TRUE;
				unset($this->__initConfig[I_Proto::DI_BOOT_EXEC]);
			};
			
			// @__init
			// 	write property-value
			$__init = isset($__options[I_Proto::DI_BOOT_INIT]) && is_callable($__options[I_Proto::DI_BOOT_INIT])
				? function($p, $v) use ($__options)
				{
					$__options[I_Proto::DI_BOOT_INIT]($p, $v, self::$__Core_Proto_T_Boot_Static[get_called_class()]);
				}
				// write $obj->$prop when prop is not defined as ASP
				// write $obj->$prop when prop is defined as direct-access
				// write $obj->$prop when prop ASP is disabled
				// delegate to $obj->property{:Event}($value)
				: function($p, $v)
				{
					$a = self::$__Core_Proto_T_Boot_Static[get_called_class()][I_Proto::DEFINE_ASPECTABLE];
					
					if(!isset($a[$p]))
						return $this->$p = $v;
					
					$s = $a[$p];
					
					if(FALSE === $s[I_Proto::BOOT_IDX_ASP_ENABLED])
						return $this->$p = $v;
					
						
					if(!isset($s[I_Proto::BOOT_IDX_ASP_DI_INIT_NAME]))
						throw new Exception('The default handle is "set". No handler found.');
					
					$u = $s[I_Proto::BOOT_IDX_ASP_DI_INIT_NAME];
					
					if(isset($s[I_Proto::BOOT_IDX_ASP_DI_DISABLED][$u]))
						return $this->$p = $v;
						
					if(isset($s[I_Proto::BOOT_IDX_ASP_DI_ENABLED][$u]))
						return $this->$s[I_Proto::BOOT_IDX_ASP_DI_ENABLED][$u]($v);
						
					throw new Exception('Setter {:u} not avail.', compact('u'));
				};
			
			// @__exec
			// 	load default property-values from DEFAULTS
			//	load accessible properties from CONFIGURABLE 
			//	handle data by CONFIGURABLE-flag
			//	write initial property-values using @__init
			//	unset accessible properties from __initConfig
			$__exec = isset($__options[I_Proto::DI_BOOT_EXEC]) && is_callable($__options[I_Proto::DI_BOOT_EXEC])
				? function() use ($__init, $__dest, $__options)
				{
					$__options[I_Proto::DI_BOOT_EXEC]($__init, self::$__Core_Proto_T_Boot_Static[get_called_class()]);
					$__dest();
				}
				: function() use ($__init, $__dest)
				{
					$_ = self::$__Core_Proto_T_Boot_Static[get_called_class()];
					$c = $_[I_Proto::DEFINE_CONFIGURABLE];
					$d = $_[I_Proto::DEFINE_DEFAULTS];
					$i = &$this->__initConfig;
					$t = [];
			
					// load DEFAULT VALUE when prop exists as $obj->$prop
					array_walk($d, function($s, $p) use (&$t)
					{
						if(FALSE === $s[I_Boot::BOOT_IDX_EXISTS])
							return;
							
						$t[$p] = $s[I_Proto::BOOT_IDX_DEFAULT_VALUE];
					});
					
					// load CONFIGURABLE when prop exists in __initConfig
					// load CONFIGURABLE when prop exists as $obj->$prop
					// handle __initConfig[prop] by CONFIGURABLE-flag
					array_walk($c, function($s, $p) use (&$i, &$t)
					{
						if(FALSE === isset($i[$p])
						|| FALSE === $s[I_Boot::BOOT_IDX_EXISTS])
							return;
							
						$v = $i[$p];
						
						switch(TRUE):
							case is_array($v) && is_array($this->$p):
								switch($s[I_Proto::BOOT_IDX_CONFIG_FLAG]):
									case I_Proto::CONFIG_HANDLE_ARR_ADD:
										$v = $this->$p + $v;
										break;
									case I_Proto::CONFIG_HANDLE_ARR_EXTEND:
										$v = $this->extend($this->$p, $v);
										break;
									case I_Proto::CONFIG_HANDLE_ARR_MERGE:
										$v = array_merge($this->$p, $v);
										break;
									case I_Proto::CONFIG_HANDLE_ARR_RECURSIVE:
										$v = $this->extend(TRUE, $this->$p, $v);
										break;
								endswitch;
								break;
							case is_string($v) && is_string($this->$p):
								switch($s[I_Proto::BOOT_IDX_CONFIG_FLAG]):
									case I_Proto::CONFIG_HANDLE_STR_APPEND:
										$v = $this->$p.$v;
										break;
									case I_Proto::CONFIG_HANDLE_STR_PREPEND:
										$v = $v.$this->$p;
										break;
								endswitch;
								break;
						endswitch;
						
						$t[$p] = &$v;
					});
					
					// $__init()
					array_walk($t, function(&$v, $p) use (&$i, $__init)
					{
						unset($i[$p]);
						$__init($p, $v);
					});
					
					$__dest();
				};
				
			// *magic*
			
			$this->Core_Proto_T_Boot_emit($this->extend(TRUE, (isset($__options[I_Proto::DI_BOOT_LOAD]) ? $__options[I_Proto::DI_BOOT_LOAD] : []), $__boot));
			
			unset($__options[I_Proto::DI_BOOT_LOAD]);
			unset($__options[I_Proto::DI_BOOT_EXEC]);
			unset($__options[I_Proto::DI_BOOT_INIT]);
			
			$this->__initConfig = $this->extend(TRUE, $this->__initConfig, self::$__defaultOptions, $__options);
			
			TRUE === $this->__initConfig[I_Proto::DI_RUN]
				? $__exec()
				: $this->__initConfig[I_Proto::DI_BOOT_EXEC] = $__exec; // @see ::run()
			
			unset($__boot);
			unset($__init);
			unset($__exec);
			unset($__dest);
		}
		
		public function run()
		{
			if(isset($this->__initConfig[I_Proto::DI_BOOT_EXEC]))
				$this->__initConfig[I_Proto::DI_BOOT_EXEC]();
				
			return $this;
		}
		
		public function extend()
		{
			$a = func_get_args();
			$t = $a[0];
			$i = 1;
			$l = count($a);
			$r = FALSE;
			
			if(is_bool($t))
			{
				$r = $t;
				$t = isset($a[1]) ? $a[1] : [];
				$i = 2;
			}
			
			if(FALSE === is_array($t)
			&& FALSE === is_object($t)
			&& FALSE === is_string($t))
				$t = [];
				
			if($l === $i)
			{
				$t = $this;
				--$i;
			}
			
			for( ; $i < $l; $i++)
			{
				if(NULL === ($o = $a[$i]))
					continue;
				
				foreach($o as $p => $v)
				{
					switch(TRUE):
						case is_array($t):
							$t[$p] = (TRUE === $r && is_array($v) && isset($t[$p]) && is_array($t[$p]))
								? $this->extend($r, $t[$p], $v)
								: $v;
							break;
						case is_object($t):
							$t->$p = (TRUE === $r && is_array($v) && isset($t->$p) && is_array($t->$p))
								? $this->extend($r, $t->$p, $v)
								: $v;
							break;
						case is_string($t):
							if(FALSE === class_exists($t))
								throw new Exception('Class {:t} not found.', compact('t'));
								
							if(FALSE === property_exists($t, $p))
								throw new Exception('Property {:t}::${:p} not found.', compact('t', 'p'));
								
							$t::$$p = (TRUE === $r && is_array($v) && is_array($t::${$p}))
								? $this->extend($r, $t::$$p, $v)
								: $v;
							break;
						default:
							throw new Exception('Target not writable.');
					endswitch;
				}
			}
			
			return $t;
		}
		
		// test
		public function propertySet($property, $value)
		{
			$_ = self::$__Core_Proto_T_Boot_Static[get_called_class()];
			$c = $_[I_Proto::DEFINE_CONFIGURABLE];
			
			if(!isset($c[$property]))
				throw new Exception('{:property} is not public.', compact('property'));
				
			$this->$property = $value; // stub
			return $this;
		}
		
		public function dump()
		{
			return self::$__Core_Proto_T_Boot_Static;
		}
	}

<?PHP
	NAMESPACE ILLI\Core\Proto;
	USE ILLI\Core\Exception;
	USE ILLI\Core\Proto\I_Boot;
	USE SplFixedArray;
	
	TRAIT T_Boot
	{
		private static $__Core_Proto_T_Boot_Static = [];
		
		protected function Core_Proto_T_Boot_handleLookup($propertyName, $lookupClassName, $classCache)
		{
			if(FALSE === isset($classCache[$propertyName]))
				return
				[
					I_Boot::BOOT_IDX_EXISTS		=> isset($this->$propertyName) || property_exists($this, $propertyName),
					I_Boot::BOOT_IDX_DEFINED	=> $lookupClassName,
					I_Boot::BOOT_IDX_REDEFINED	=> FALSE,
					I_Boot::BOOT_IDX_INSPECT	=> $lookupClassName.'::$'.$propertyName
				];
				
			$r = $classCache[$propertyName];
			
			if(FALSE === $r[I_Boot::BOOT_IDX_REDEFINED])
			{
				$r[I_Boot::BOOT_IDX_REDEFINED]	= $r[I_Boot::BOOT_IDX_DEFINED];
				$r[I_Boot::BOOT_IDX_INSPECT]	= $r[I_Boot::BOOT_IDX_DEFINED].'::$'.$propertyName;
			}
			
			$r[I_Boot::BOOT_IDX_DEFINED] = $lookupClassName;
			
			return $r;
		}
		
		protected function Core_Proto_T_Boot_emit(array $__lookupTable = [])
		{
			array_walk($__lookupTable, function($t, $p)
			{
				if(is_integer($p))
				{
					$p = $t;
					$t = [];
				}
				
				$l = get_called_class();
				$s = &self::$__Core_Proto_T_Boot_Static[$l][$p];
				
				if(isset($s))
					goto _init;
					
				$c = [];
				
				do
				{
					if(FALSE === isset($l::$$p))
						continue;
						
					$c = is_callable($h = isset($t[I_Boot::ON_LOOKUP]) ? $t[I_Boot::ON_LOOKUP] : NULL)
						? $h($c, $l, $l::$$p)
						: $l::$$p;
				}
				while($l = get_parent_class($l));
				
				$c = is_callable($h = isset($t[I_Boot::ON_COMPLETE]) ? $t[I_Boot::ON_COMPLETE] : NULL)
					? $h($c)
					: $c;
				
				array_walk($c, function($v, $p) use (&$s)
				{
					$s[$p] = SplFixedArray::fromArray($v, TRUE);
				});
				
				_init:
				
				if(is_callable($h = isset($t[I_Boot::ON_INIT]) ? $t[I_Boot::ON_INIT] : NULL))
					$h($s);
			});
			
			return $this;
		}
	}

<?PHP
	NAMESPACE ILLI\Core\Proto;

	INTERFACE I_Boot
	{
		// offsets in SplFixedArray
		CONST BOOT_IDX_EXISTS		= 0;
		CONST BOOT_IDX_DEFINED		= 1;
		CONST BOOT_IDX_REDEFINED	= 2;
		CONST BOOT_IDX_INSPECT		= 3;
		
		// events
		CONST ON_LOOKUP			= 'ILLI\Core\Proto\I_Boot::ON_LOOKUP';
		CONST ON_COMPLETE		= 'ILLI\Core\Proto\I_Boot::ON_COMPLETE';
		CONST ON_INIT			= 'ILLI\Core\Proto\I_Boot::ON_INIT';
	}

<?PHP
	NAMESPACE ILLI\Core;

	INTERFACE I_Proto
	{
		// offsets in SplFixedArray
		CONST BOOT_IDX_ASP_DI_LIST		= 4;
		CONST BOOT_IDX_ASP_ENABLED		= 5;
		CONST BOOT_IDX_ASP_DI_INIT_NAME		= 6;
		CONST BOOT_IDX_ASP_DI_NAMES		= 7;
		CONST BOOT_IDX_ASP_DI_DISABLED		= 8;
		CONST BOOT_IDX_ASP_DI_ENABLED		= 9;
		CONST BOOT_IDX_CONFIG_FLAG		= 4;
		CONST BOOT_IDX_DEFAULT_VALUE		= 4;
		
		// bootstrapping properties
		CONST DEFINE_ASPECTABLE			= '__DEFINE_propAsp';
		CONST DEFINE_CONFIGURABLE		= '__DEFINE_propCom';
		CONST DEFINE_DEFAULTS			= '__DEFINE_propDef';
		
		// default options
		CONST DI_BOOT_LOAD			= 'ILLI\Core\I_Proto::DI_BOOT_LOAD';
		CONST DI_BOOT_INIT			= 'ILLI\Core\I_Proto::DI_BOOT_INIT';
		CONST DI_BOOT_EXEC			= 'ILLI\Core\I_Proto::DI_BOOT_EXEC';
		CONST DI_RUN				= 'ILLI\Core\I_Proto::DI_RUN';
		CONST DI_MAIN				= 'ILLI\Core\I_Proto::DI_MAIN';
		CONST DI_CLASS				= 'ILLI\Core\I_Proto::DI_CLASS';
		CONST DI_DELEGATE			= 'ILLI\Core\I_Proto::DI_DELEGATE';
		CONST DI_FILTER				= 'ILLI\Core\I_Proto::DI_FILTER';
		CONST DI_METHOD				= 'ILLI\Core\I_Proto::DI_METHOD';
		CONST DI_METHOD_FACADE			= 'ILLI\Core\I_Proto::DI_METHOD_FACADE';
		CONST DI_METHOD_PROTO			= 'ILLI\Core\I_Proto::DI_METHOD_PROTO';
		CONST DI_OBSERVER			= 'ILLI\Core\I_Proto::DI_OBSERVER';
		CONST DI_SIGNAL				= 'ILLI\Core\I_Proto::DI_SIGNAL';
		CONST DI_TO				= 'ILLI\Core\I_Proto::DI_TO';
		
		// asp type handle def
		CONST ASP_TYPE_ARRAY			= 'ILLI\Core\I_Proto::ASP_TYPE_ARRAY';
		CONST ASP_TYPE_PROP			= 'ILLI\Core\I_Proto::ASP_TYPE_PROP';
		
		// asp method handle names
		CONST ASP_FN_PRFX_ADD			= 'add';
		CONST ASP_FN_PRFX_CLEAR			= 'clear';
		CONST ASP_FN_PRFX_GET			= 'get';
		CONST ASP_FN_PRFX_REMOVE		= 'remove';
		CONST ASP_FN_PRFX_RESTORE		= 'restore';
		CONST ASP_FN_PRFX_SET			= 'set';
		
		// default aspectable method name
		CONST ASP_TPL_FN_NAME			= 'aspectable{:aspFnPrefix}{:propertyName}';
		
		// config flag handle names
		CONST CONFIG_HANDLE_ARR_ADD		= 'ILLI\Core\I_Proto::CONFIG_HANDLE_ARR_ADD';
		CONST CONFIG_HANDLE_ARR_EXTEND		= 'ILLI\Core\I_Proto::CONFIG_HANDLE_ARR_EXTEND';
		CONST CONFIG_HANDLE_ARR_MERGE		= 'ILLI\Core\I_Proto::CONFIG_HANDLE_ARR_MERGE';
		CONST CONFIG_HANDLE_ARR_RECURSIVE	= 'ILLI\Core\I_Proto::CONFIG_HANDLE_ARR_RECURSIVE';
		CONST CONFIG_HANDLE_STR_APPEND		= 'ILLI\Core\I_Proto::CONFIG_HANDLE_STR_APPEND';
		CONST CONFIG_HANDLE_STR_PREPEND		= 'ILLI\Core\I_Proto::CONFIG_HANDLE_STR_PREPEND';
	}