not a joke

<?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
    {
        USE \ILLI\Core\Proto\T_Boot;

        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 = [];

        public function __construct(array $__options = [])
        {
            $__boot =
            [
                I_Proto::PROP_DEFINE_DEFAULTS =>
                [
                    I_Boot::ON_LOOKUP => function(array $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::DEFAULT_VALUE => $v
                            ];

                            $value = &$c[$p][I_Proto::DEFAULT_VALUE];

                            if(isset($value)
                            && is_array($value)
                            && is_array($v)
                            && in_array($p, ['class'])) // I_Object namespaces
                                $value = $this->extend(TRUE, $v, $value);
                        });

                        return $c;
                    },
                    I_Boot::ON_INIT => function(array $c)
                    {
                        array_walk($c, function($s, $p)
                        {
                            $this->__initConfig[$p] = $s[I_Proto::DEFAULT_VALUE];
                        });

                        return $c;
                    }
                ],
                I_Proto::PROP_DEFINE_ASP =>
                [
                    I_Boot::ON_LOOKUP => function(array $c, $n, array $l)
                    {
                        $d =
                        [
                            I_Proto::ASP_TYPE_DEF   => [I_Proto::ASP_FN_PRFX_SET, I_Proto::ASP_FN_PRFX_RESTORE],
                            I_Proto::ASP_TYPE_OBJ   => [I_Proto::ASP_FN_PRFX_SET, I_Proto::ASP_FN_PRFX_RESTORE],
                            I_Proto::ASP_TYPE_ARR   => [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::ASP_AVAIL  => $a = is_string($u = is_bool($v)
                                                ? I_Proto::ASP_TYPE_DEF : $v) ? isset($d[$u]) ? $d[$u] : explode('|', $u) : $u,
                                I_Proto::ASP_USE    => !isset($a[0]) ? isset($d[$u]) ? $d[$u][0] : I_Proto::ASP_FN_PRFX_SET : $a[0],
                                I_Proto::ASP_HANDLE => is_string($v) ? TRUE : $v
                            ];
                        });

                        return $c;
                    },
                    I_Boot::ON_COMPLETE => function(array $c)
                    {
                        array_walk($c, function(&$s, $p)
                        {
                            if(FALSE === $s[I_Boot::EXISTS]
                            || FALSE === $s[I_Proto::ASP_HANDLE])
                                return;

                            array_walk($s[I_Proto::ASP_AVAIL], function($a) use (&$s, $p)
                            {
                                $m = String::insert(I_Proto::TPL_ASP_FN_NAME, [
                                    'aspFnPrfx' => Inflector::camelize($a),
                                    'propertyName'  => Inflector::camelize($p)]);

                                $s += [I_Proto::ASP_ACCESS_ALL.$a => $m];
                                $s += [(($e = method_exists($this, $m))
                                    ? I_Proto::ASP_ACCESS_ASP : I_Proto::ASP_ACCESS_DIR).$a => ($e ? $m : $p)];
                            });
                        });

                        return $c;
                    }
                ],
                I_Proto::PROP_DEFINE_CONFIGURABLE =>
                [
                    I_Boot::ON_LOOKUP => function(array $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::CONFIG_HANDLE => $v
                            ];
                        });

                        return $c;
                    }
                ]
            ];

            $__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()]);
                }
                : function($p, $v)
                {
                    $a = self::$__Core_Proto_T_Boot_Static[get_called_class()][I_Proto::PROP_DEFINE_ASP];

                    if(!isset($a[$p]))
                        return $this->$p = $v;

                    $s = $a[$p];

                    if(FALSE === $s[I_Proto::ASP_HANDLE])
                        return $this->$p = $v;

                    $u = &$s[I_Proto::ASP_USE];

                    if(!isset($u))
                        throw new Exception('The default handle is "set". No handler found.');

                    $d = &$s[I_Proto::ASP_ACCESS_DIR.$u];
                    $m = &$s[I_Proto::ASP_ACCESS_ASP.$u];

                    if(isset($d))
                        return $this->$p = $v;

                    if(isset($m))
                        return $this->$m($v);

                    $m = I_Proto::ASP_ACCESS_ASP.$u;
                    throw new Exception('Setter {:m} not avail.', compact('m'));
                };

            $__exec = isset($__options[I_Proto::DI_BOOT_EXEC]) && is_callable($__options[I_Proto::DI_BOOT_EXEC])
                ? function() use ($__init, $__options)
                {
                    $__options[I_Proto::DI_BOOT_EXEC]($__init, self::$__Core_Proto_T_Boot_Static[get_called_class()]);

                    $this->__initConfig[I_Proto::DI_RUN] = TRUE;
                    unset($this->__initConfig[I_Proto::DI_BOOT_EXEC]);
                }
                : function() use ($__init)
                {
                    $_ = self::$__Core_Proto_T_Boot_Static[get_called_class()];
                    $c = $_[I_Proto::PROP_DEFINE_CONFIGURABLE];
                    $d = $_[I_Proto::PROP_DEFINE_DEFAULTS];
                    $i = &$this->__initConfig;
                    $t = [];

                    array_walk($d, function($s, $p) use (&$t)
                    {
                        if(FALSE === $s[I_Boot::EXISTS])
                            return;

                        $t[$p] = &$s[I_Proto::DEFAULT_VALUE];
                    });

                    array_walk($c, function($s, $p) use (&$i, &$t)
                    {
                        if(FALSE === isset($i[$p]))
                            return;

                        $value = $i[$p];

                        if(FALSE === $s[I_Boot::EXISTS])
                            return;

                        switch(TRUE):
                            case is_array($value) && is_array($this->$p):
                                switch($s[I_Boot::CONFIG_HANDLE]):
                                    case I_Proto::CONFIG_HANDLE_ARR_ADD:
                                        $value = $this->$p + $value;
                                        break;
                                    case I_Proto::CONFIG_HANDLE_ARR_EXTEND:
                                        $value = $this->extend($this->$p, $value);
                                        break;
                                    case I_Proto::CONFIG_HANDLE_ARR_MERGE:
                                        $value = array_merge($this->$p, $value);
                                        break;
                                    case I_Proto::CONFIG_HANDLE_ARR_RECURSIVE:
                                        $value = $this->extend(TRUE, $this->$p, $value);
                                        break;
                                endswitch;
                                break;
                            case is_string($value) && is_string($this->$p):
                                switch($s[I_Boot::CONFIG_HANDLE]):
                                    case I_Proto::CONFIG_HANDLE_STR_APPEND:
                                        $value = $this->$p.$value;
                                        break;
                                    case I_Proto::CONFIG_HANDLE_STR_PREPEND:
                                        $value = $value.$this->$p;
                                        break;
                                endswitch;
                                break;
                        endswitch;

                        $t[$p] = &$value;
                    });

                    array_walk($t, function(&$v, $p) use (&$i, $__init)
                    {
                        unset($i[$p]);
                        $__init($p, $v);
                    });

                    $this->__initConfig[I_Proto::DI_RUN] = TRUE;
                    unset($this->__initConfig[I_Proto::DI_BOOT_EXEC]);
                };

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

            unset($__boot);
            unset($__init);
            unset($__exec);
        }

        public function run()
        {
            if(isset($this->__initConfig[I_Proto::DI_BOOT_EXEC]))
                $this->__initConfig[I_Proto::DI_BOOT_EXEC]();

            return $this;
        }

        public function propertySet($property, $value)
        {
            $_ = self::$__Core_Proto_T_Boot_Static[get_called_class()];
            $c = $_[I_Proto::PROP_DEFINE_CONFIGURABLE];

            if(!isset($c[$property]))
                throw new Exception('{:property} is not public.', compact('property'));

            $this->$property = $value;
            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;
        }

        public function dump()
        {
            return self::$__Core_Proto_T_Boot_Static;
        }
    }