WP Options Factory

<?PHP
    NAMESPACE tri4m\Wp\Wtf;
    USE tri4m\Wp\__const_Action;
    USE tri4m\Wp\__const_Filter;
    USE tri4m\Wp\__type_Action;
    USE tri4m\Wp\__type_Call;
    USE tri4m\Wp\__type_Filter;
    USE tri4m\Wp\Inv;
    USE tri4m\Wp\Theme;
    USE tri4m\Wp\Wtf\__type_Settings;
    USE tri4m\Wp\Wtf\Settings\__type_Messages;
    USE tri4m\Wp\Wtf\Settings\__type_Field;
    USE tri4m\Wp\Wtf\Settings\__type_Section;
    USE tri4m\Wp\Wtf\Settings\__type_Page;
    USE tri4m\Wp\Wtf\__type_SubMenuPage;
    USE tri4m\Wp\Wtf\SubMenuPage;
    USE ILLI\Core\Std\Def\__const_Type;
    USE ILLI\Core\Std\Invoke;
    USE ILLI\Core\Util\Inflector;
    USE ILLI\Core\Util\String;

    CLASS Settings EXTENDS \tri4m\Wp\Wtf
    {
        protected $__Page   = [];
        protected $__pageHook   = NULL;
        protected $__cache  = [];

        protected $__actions    =
        [
            __const_Action::ADMIN_INIT => NULL,
            __const_Action::ADMIN_MENU => NULL
        ];

        function __construct(__type_Settings $__Setup)
        {
            static $__STATIC_fnI, $__STATIC_fnV, $__STATIC_fnF, $__STATIC_fnS, $__STATIC_fnR, $__STATIC_fnP;

            isset($__STATIC_fnI) ?: $__STATIC_fnI = function(__type_Call $T)
            {
                switch(TRUE):
                    case $T->isVal($T::fn, __const_Type::SPL_CLOSURE):  return Invoke::emitCallable($T->fn, $T->arguments);
                    case $T->isVal($T::fn, __const_Type::SPL_FUNCTION): return Invoke::emitFunction($T->fn, $T->arguments);
                    case $T->isVal($T::fn, __const_Type::SPL_METHOD):   return Invoke::emit($T->fn[0], $T->fn[1], $T->arguments);
                endswitch;
            };

            isset($__STATIC_fnV) ?: $__STATIC_fnV = function(__type_Settings $__Setup, array $__cache, array $__input)
            {
                if(FALSE === isset($_POST['action']))
                    return;

                $result = [];

                switch($_POST['action']):
                    case 'reset':

                        if($__Setup->messages instanceOf __type_Messages)
                            Inv::addSettingsError($__Setup->id, 'restore_defaults', $__Setup->messages->resetComplete, 'updated fade');

                        if(TRUE === $__Setup->deep)
                        {
                            foreach($__cache as $sid => &$fields)
                                foreach($fields as $fid => &$Field)
                                    $result[$sid][$fid] = $Field->std;
                        }
                        else
                        {
                            foreach($__cache as $id => &$Field)
                                $result[$id] = $Field->std;
                        }

                        break;

                    case 'import':

                        if($result = unserialize(stripslashes(trim($_POST['import']))))
                        {
                            if($__Setup->messages instanceOf __type_Messages)
                                Inv::addSettingsError($__Setup->id, 'import', $__Setup->messages->importComplete, 'updated fade');
                            break;
                        }

                        if($__Setup->messages instanceOf __type_Messages)
                            Inv::addSettingsError($__Setup->id, 'import', $__Setup->messages->importError, 'updated fade');
                        break;

                    case 'update':

                        $v = function(__type_Field $Field, $i)
                        {
                            if(FALSE === isset($i))
                                return $Field->std;

                            if(NULL !== ($_ = $Field->fn))
                                return $_($i, $Field);

                            //if(Inv::hasFilter('tri4m_sanitize_'.$Field->type))
                            //  $result[$id] = Inv::applyFilters('tri4m_sanitize_' . $Field->type, $__input[$id], $Field);
                                return $i;

                            return $Field->std;
                        };

                        if(TRUE === $__Setup->deep)
                        {
                            foreach($__cache as $sid => &$fields)
                                foreach($fields as $fid => &$Field)
                                {
                                    $i = &$__input[$sid][$fid];
                                    $result[$sid][$fid] = $v($Field, $i);
                                }
                        }
                        else
                        {
                            foreach($__cache as $id => &$Field)
                            {
                                $i = &$__input[$id];
                                $result[$id] = $v($Field, $i);
                            }
                        }

                        break;
                endswitch;

                return [] === $result ? NULL : $result;
            };

            isset($__STATIC_fnS) ?: $__STATIC_fnS = function(__type_Settings $__Setup, __type_Section $__Section) use (&$__STATIC_fnI)
            {
                Inv::addSettingsSection
                (
                    $__Section->id,
                    $__Section->title,
                    function() use (&$__Section, &$__STATIC_fnI)
                    {
                        switch(TRUE):
                            case is_string($c = $__Section->content):
                                print $c;
                                break;

                            case is_array($c = $__Section->content):
                                print implode(PHP_EOL, $c);
                                break;

                            case ($c = $__Section->content) instanceOf __type_Call:
                                print is_array($c = $__STATIC_fnI($c)) ? implode(PHP_EOL, $c) : $c;
                                break;
                        endswitch;
                    },
                    $__Setup->id
                );
            };

            isset($__STATIC_fnF) ?: $__STATIC_fnF = function(__type_Settings $__Setup, __type_Section $__Section, __type_Field $__Field)
            {
                Inv::addSettingsField
                (
                    $__Field->id,
                    $__Field->title,
                    function() use (&$__Setup, &$__Section, &$__Field)
                    {
                        if(TRUE === $__Setup->deep)
                        {
                            if(FALSE === ($options = Inv::getOption($__Setup->id))
                            || FALSE === isset($options[$__Section->id][$__Field->id]))
                                $options[$__Section->id][$__Field->id] = $__Field->std;
                        }
                        else
                        {
                            if(FALSE === ($options = Inv::getOption($__Setup->id))
                            || FALSE === isset($options[$__Field->id]))
                                $options[$__Field->id] = $__Field->std;
                        }

                        $pattern = [
                            'id'        => '{:setupId}_{:sectionId}_{:fieldId}',
                            'name'      => TRUE === $__Setup->deep
                                        ? '{:setupId}[{:sectionId}][{:fieldId}]'
                                        : '{:setupId}[{:fieldId}]',
                            'type'      => '{:type}',
                            'value'     => '{:value}'
                        ];

                        $config = [
                            'fieldId'   => $__Field->id,
                            'sectionId'     => $__Section->id,
                            'setupId'   => $__Setup->id,
                            'value'     => TRUE === $__Setup->deep
                                        ? $options[$__Section->id][$__Field->id]
                                        : $options[$__Field->id],
                            'type'      => $__Field->type
                        ];

                        foreach($pattern as &$_)
                            $_ = String::insert($_, $config);

                        print String::insert('<input {:attr} />', ['attr' => String::attribute($pattern, ['delimeter' => ' '])]);
                    },
                    $__Setup->id,
                    $__Section->id,
                    [
                        'type'      => $__Field->type,
                        'desc'      => $__Field->desc,
                        'id'        => String::insert('{:setupId}_{:fieldId}', ['setupId' => $__Setup->id, 'fieldId' => $__Field->id]),
                        'label_for' => String::insert('{:setupId}_{:fieldId}', ['setupId' => $__Setup->id, 'fieldId' => $__Field->id]),
                        'choices'   => $__Field->choices,
                        'std'       => $__Field->std,
                        'class'     => $__Field->cssClass
                    ]
                );
            };

            isset($__STATIC_fnR) ?: $__STATIC_fnR = function(__type_Settings $__Setup, array &$__cache) use (&$__STATIC_fnV)
            {
                Inv::registerSetting
                (
                    $__Setup->id,
                    $__Setup->id,
                    NULL === $__Setup->fn
                        ? function($__input) use (&$__Setup, &$__cache, &$__STATIC_fnV)
                        {
                            return $__STATIC_fnV($__Setup, $__cache, $__input);
                        }
                        : $__Setup->fn
                );
            };

            isset($__STATIC_fnP) ?: $__STATIC_fnP = function(__type_Settings $__Setup)
            {
                print $__Setup->page->beforeForm;
                settings_fields($__Setup->id);
                do_settings_sections($__Setup->id);
                print $__Setup->page->beforeCtrl;
                print $__Setup->page->submit;
                print $__Setup->page->reset;
                print $__Setup->page->afterCtrl;
                print $__Setup->page->afterForm;
            };

            $id         = $__Setup->id;
            $this->__Setup      = $__Setup;
            $this->__Setup->id  = Theme::slug(Inflector::variablize(Inflector::underscore($this->__Setup->id)));

            if($this->__Setup->page instanceOf __type_Page)
            {
                $config = [];

                foreach([
                    __type_Page::parentId       => __type_SubMenuPage::parentId,
                    __type_Page::title      => __type_SubMenuPage::title,
                    __type_Page::menuTitle      => __type_SubMenuPage::menuTitle,
                    __type_Page::cssClass       => __type_SubMenuPage::cssClass,
                    __type_Page::capability     => __type_SubMenuPage::capability,
                    __type_Page::icon       => __type_SubMenuPage::icon
                ] as $i => $k)
                    $config[$k] = $this->__Setup->page->get()->toArray()[$i];

                $config[__type_SubMenuPage::id]     = $id;
                $config[__type_SubMenuPage::content]    = new __type_Call([
                    __type_Call::fn     => function() use (&$__STATIC_fnP)
                    {
                        $__STATIC_fnP($this->__Setup);
                    }
                ]);

                $this->__Page = new SubMenuPage(new __type_SubMenuPage($config));
            }

            $this->__actions[__const_Action::ADMIN_INIT] = new __type_Action([
                __type_Action::argsNum  => 0,
                __type_Action::priority => 101,
                __type_Action::fn   => function() use (&$__STATIC_fnV, &$__STATIC_fnF, &$__STATIC_fnS, &$__STATIC_fnR)
                {
                    $__STATIC_fnR($this->__Setup, $this->__cache);

                    foreach($this->__Setup->sections->get() as $Section)
                    {
                        $Section->id = Inflector::variablize(Inflector::underscore($Section->id));

                        $__STATIC_fnS($this->__Setup, $Section);

                        foreach($Section->fields->get() as $Field)
                        {
                            $Field->id = Inflector::variablize(Inflector::underscore($Field->id));

                            TRUE === $this->__Setup->deep
                                ? $this->__cache[$Section->id][$Field->id]  = $Field
                                : $this->__cache[$Field->id]            = $Field;

                            $__STATIC_fnF($this->__Setup, $Section, $Field);
                        }
                    }


                }
            ]);

            /*
            $this->__actions[__const_Action::ADMIN_MENU] = new __type_Action([
                __type_Action::argsNum  => 0,
                __type_Action::priority => 100,
                __type_Action::fn   => function() use (&$__STATIC_fnP)
                {
                    $this->__pageHook = $__STATIC_fnP($this->__Setup);
                }
            ]);
            /*
            $this->__actions[String::insert(__const_Action::LOAD_PAGE_HOOK__, ['pageHook' => $this->__pageHook])] = new __type_Action([
                __type_Action::argsNum  => 2,
                __type_Action::priority => 105,
                __type_Action::fn   => function($__pageNow, $__WPScreen)
                {
                    wp_register_style('admin', get_bloginfo('template_url') . '/styles.css');
                    wp_enqueue_style( 'admin' );
                }
            ]);
            */
        }

        public function install()
        {
            $this->__Page instanceOf SubMenuPage
                ? parent::install()->__Page->install()
                : parent::install();

            return $this;
        }

    }