?><option label="-"></option><?php
                                            }

                                            if ($NextFilterMetaInformation["FilterName"] == "VolumesFiltersSet") {
                                                // Обработка особенностей для фильтров по объёму - там существуют строгие фильтры, так и диапазонные
                                                echo '<optgroup label="Точный объём">';
                                            } else if ($NextFilterMetaInformation["FilterName"] == "ToughnessesFiltersSet") {

                                                uasort($NextFilterMetaInformation["FilterOptions"], function ($a, $b) {
                                                    preg_match_all('/^(\d+)\w+(?:\-(\d+))*/', $a, $a_num, PREG_SET_ORDER, 0);
                                                    preg_match_all('/^(\d+)\w+(?:\-(\d+))*/', $b, $b_num, PREG_SET_ORDER, 0);

                                                    if ($a_num && $b_num) {
                                                        if ($a_num[0][1] > $b_num[0][1]) {
                                                            return 1;
                                                        } else  if ($a_num[0][1] < $b_num[0][1]) {
                                                            return -1;
                                                        } else {
                                                            if (array_key_exists(2, $a_num[0])) {
                                                                if ($a_num[0][2] > $b_num[0][2]) {
                                                                    return 1;
                                                                } else {
                                                                    return -1;
                                                                }
                                                            }
                                                        }
                                                    } else {
                                                        if ($a > $b) {
                                                            return 1;
                                                        }
                                                        if ($a < $b) {
                                                            return -1;
                                                        }
                                                    }

                                                    return 0;
                                                });

                                            } else {
                                                asort($NextFilterMetaInformation["FilterOptions"]);

                                                        } else {
                                                            if (array_key_exists(2, $a_num[0])) {
                                                                if ($a_num[0][2] > $b_num[0][2]) {
                                                                    return 1;
                                                                } else {
                                                                    return -1;
                                                                }
                                                            }
                                                        }
                                                    } else {
                                                        if ($a > $b) {
                                                            return 1;
                                                        }
                                                        if ($a < $b) {
                                                            return -1;
                                                        }
                                                    }

                                                    return 0;
                                                });

                                            } else {
                                                asort($NextFilterMetaInformation["FilterOptions"]);
                                            }

                                            foreach ($NextFilterMetaInformation["FilterOptions"] as $FilterOptionId => $FilterOptionLabel) {

                                                //Ограничения на нечисловые объемы жидкостей
                                                if ($NextFilterMetaInformation["FilterName"] == "VolumesFiltersSet" && !is_numeric($FilterOptionId)) {
                                                    continue;
                                                }

                                                //Ограничения на запрещенных в каталоге производителей
                                                if ($NextFilterMetaInformation["FilterName"] == "LiquidBrandFiltersSet" && array_search($FilterOptionId, $RestrictedManufacturersIdentifyers) !== false) {
                                                    continue;
                                                }

                                                ?><option <?php
                                                    //Дополнительные предопределённые опции для некоторых фильтров
                                                    if ($NextFilterMetaInformation["FilterName"] == "LiquidBrandFiltersSet")

            "gccat_enginecovers"                    => "entities/catalogues/gc-enginecovers/ecview.php",              // Каталог автоодеял
            "gccat_glasses"                         => "entities/catalogues/gc-glasses/view.php",                 // Каталог стёкол
            "gccat_glasses_agc"                     => "entities/catalogues/gc-glasses/agcview.php",                 // Каталог стёкол
            "gccat_glasses_kmk"                     => "entities/catalogues/gc-glasses/kmkview.php",                 // Каталог стёкол
        );

        /**
         * Отображает указанную интерфейсную view-страницу или виджет
         * @param $ViewName
         * @param string $ViewNotFoundedCallback тип действия в случае если указанная страница не найдена
         */

        /**
         * @param $ViewName string подключаемая страница
         * @param string $ViewNotFoundedCallback
         */
        public static function GetView($ViewName, $ViewNotFoundedCallback="EXIT")
        {
            if (array_key_exists($ViewName, self::$Views))
                include __DIR__."/".self::$Views[$ViewName];
            else
                response()->httpCode(404)->redirect(404);
        }

        /**
         * Подключаем несколько интерфейсных страниц или виджетов
         * @param $ViewsList array список подключаемых страниц
         * @param string $ViewNotFoundedCallback тип действия в случае если указанная страница не найдена
         */
        public static function GetViews($ViewsList, $ViewNotFoundedCallback="EXIT") {
            foreach ($ViewsList as $Index => $ViewInclude) {
                self::GetView($ViewInclude, $ViewNotFoundedCallback);
            }
        }
    }
 

    //~Короткие ссылки на каталог масел и техжидкостей + поисковая оптимизация для регионов
    //-------------------------------------------------------------------------------------

    require_once 'template/header.php';

?>
    <div class="row">
        <div class="col-12">
            <h1 class="text-center gccat-heading">Каталог масел и технических жидкостей</h1>
        </div>
    </div>
    <div class="row">
        <div class="col-12 gccat-cell">
            <section id="gccat-liquidscat">
                <?php
                    //----------------------------------------------------
                    //Фактически подключаем страницу каталога техжидкостей
                    //----------------------------------------------------
                    DependencyBuilder::GetEntities(Array("catalogues-gccats-liquids"));
                    ViewLinker::GetView("gccat_liquids");
                ?>
            </section>
        </div>
    </div>
    <div class="row">
        <div class="col-12 gccat-bottomdisclaimer text-center">
            <section>
                <p>
                    Каталог моторных масел и техжидкостей предназначен для подбора по параметрам и техническим спецификациям.
                    В нём можно найти актуальный широкий ассортимент технических жидкостей для любого обслуживания автомобиля - это
                    моторные и трансмиссионные масла, гидравлические и охлаждающие жидкости, тормозные жидкости, герметики, смазки и спецсредства.
                    Используя кнопку "Справка о жидкости", Вы можете узнать подробности её параметров и спецификаций.
                </p>
            </section>
            <div class="gccat-bottom-copyright">Каталог создан с использованием базы <a target="_blank" href="https://getcat.net">getcat.net</a></div>
        </div>
    </div>

<?php
    require_once 'template/footer.php';

    SimpleRouter::match(['get', 'head'],'login', function() {require_once "pages/3.0/billing-login.php";});
    SimpleRouter::match(['get', 'head'],'logout', function() {require_once "pages/3.0/billing-logout.php";});
    SimpleRouter::match(['get', 'head'],'account/{SubpartitionCode?}', function($SubpartitionCode = null) {require_once "pages/3.0/billing-account-index.php";});
    SimpleRouter::match(['get', 'head'],'register', function() {require_once "pages/3.0/billing-register.php";});
    SimpleRouter::match(['get', 'head'],'rmpassword/{state?}/{userid?}{token?}/{useremail?}', function($state = "initial", $userid = "", $token = "", $useremail = "") {require_once "pages/3.0/billing-passrecovery.php";},['defaultParameterRegex' => '[\@\%\.\w\p{L}\s-]+']);
    SimpleRouter::match(['get', 'head'],'manufacturers', function() {require_once "pages/3.0/mfrlist.php";});
    SimpleRouter::match(['get', 'head'],'manufacturers/{mnkey}', function($mnkey) {require_once "pages/3.0/mfrinfo.php";},['defaultParameterRegex' => '[&\.\w\|\%\p{L}\s-]+']);
    SimpleRouter::match(['get', 'head'],'select_department', function() {require_once "pages/3.0/changeoffice.php";});
    SimpleRouter::match(['get', 'head'],'changeoffice', function() {require_once "pages/3.0/changeoffice.php";});
    SimpleRouter::match(['get', 'head'],'whereismyorder', function() {require_once "pages/3.0/whereismyorder.php";});
    SimpleRouter::match(['get', 'head'],'pricing', function() {require_once "pages/3.0/pricing.php";});
    SimpleRouter::match(['get', 'head'],'actionmapreply', function() {require_once "pages/3.0/promo-actionreply-maps.php";});
    SimpleRouter::match(['get', 'head'],'dspecial', function() {require_once "pages/3.0/deptwidgetpage.php";});
    SimpleRouter::match(['get', 'head'],'protectionscat', function() {require_once "pages/3.0/cats-gccats-protection.php";});
    SimpleRouter::match(['get', 'head'],'hitchcat', function() {require_once "pages/3.0/cats-gccats-hitch.php";});
    SimpleRouter::match(['get', 'head'],'unevixcat', function() {require_once "pages/3.0/cats-gccats-unevix.php";});
    SimpleRouter::match(['get', 'head'],'carpetscat', function() {require_once "pages/3.0/cats-gccats-carpets.php";});
    SimpleRouter::match(['get', 'head'],'enginecoverscat', function() {require_once "pages/3.0/cats-gccats-enginecovers.php";});
    SimpleRouter::match(['get', 'head'],'glassescat', function() {require_once "pages/3.0/cats-gccats-glasses.php";});
    SimpleRouter::match(['get', 'head'],'liquidscat/{liquidgenesis?}', function($liquidgenesis = "") {$_GET["lqgenush"] = ArgProtect::StringProtect($liquidgenesis); $_GET["genesis"] = ArgProtect::StringProtect($liquidgenesis); require_once "pages/3.0/cats-gccats-liquids.php";});
    SimpleRouter::match(['get', 'head'],'electricscat{genesis?}', function($genesis = "") {$_GET["lqgenush"] = ArgProtect::StringProtect($genesis); $_GET["genesis"] = ArgProtect::StringProtect($genesis); require_once "pages/3.0/cats-gccats-electrics.php";});
    SimpleRouter::match(['get', 'head'],'toolscat/{genesis?}', function($genesis) {$_GET["lqgenush"] = ArgProtect::StringProtect($genesis); $_GET["genesis"] = ArgProtect::StringProtect($genesis); require_once "pages/3.0/cats-gccats-tools.php";});
    SimpleRouter::match(['get', 'head'],'wheelscat', function() {require_once "pages/3.0/cats-gccats-wheels.php";});
    SimpleRouter::match(['get', 'head'],'wiperscat2', function() {require_once "pages/3.0/cats-gccats-wipers.php";});
    SimpleRouter::match(['get', 'head'],'accessoirescat', function() {require_once "pages/3.0/cats-gccats-accessoires.php";});
    SimpleRouter::match(['get', 'head'],'maintenancecat_brands', function() {require_once "pages/3.0/cats-gccats-maintenance-brands.php";});
    SimpleRouter::match(['get', 'head'],'maintenancecat', function() {require_once "pages/3.0/cats-gccats-maintenance-brands.php";});
    SimpleRouter::match(['get', 'head'],'maintenancecat/{brandkey}', function($brandkey) {require_once "pages/3.0/cats-gccats-maintenance-modifications.php";})->setFilterEmptyParams(false);
    SimpleRouter::match(['get', 'head'],'maintenancecat/{brandkey}/{modificationkey}', function($brandkey, $modificationkey) {require_once "pages/3.0/cats-gccats-maintenance-vehicles.php";})->setFilterEmptyParams(false);
    SimpleRouter::match(['get', 'head'],'maintenancecat/{brandkey}/{modificationkey}/{vehiclekey}', function($brandkey, $modificationkey, $vehiclekey) {require_once "pages/3.0/cats-gccats-maintenance-vehicleparts.php";})->setFilterEmptyParams(false);
    SimpleRouter::match(['get', 'head'],'maintenance_modifications', function() {require_once "pages/3.0/cats-gccats-maintenance-modifications.php";});
    SimpleRouter::match(['get', 'head'],'maintenance_vehicles', function() {require_once "pages/3.0/cats-gccats-maintenance-vehicles.php";});
    SimpleRouter::match(['get', 'head'],'maintenance_vehicleparts', function() {require_once "pages/3.0/cats-gccats-maintenance-vehicleparts.php";});
    SimpleRouter::match(['get', 'head'],'pcarscats/{brand}/{model}', function($brand, $model) {require_once "pages/3.0/cats-hotlinks-popularcars.php";})->setMatch('/pcarscats\/(\w+)\/((?:\w|%20)+)/')->where(['brand'=>'\w+', 'model'=>'[\%\.\w\p{L}\s-]+']);
    SimpleRouter::match(['get', 'head'],'originalcats', function() {require_once "pages/3.0/cats-originalcats.php";});
    SimpleRouter::match(['get', 'head'],'tspccats', function() {require_once "pages/3.0/cats-tspcvincats.php";});
    SimpleRouter::match(['get', 'head'],'originalcat', function() {require_once "pages/3.0/cats-tspcvincats.php";});
    SimpleRouter::match(['get', 'head'],'tspdecodevinbybrand', function() {require_once "pages/3.0/cats-tspcvincats-searchvin.php";});
    SimpleRouter::match(['get', 'head'],'originalcat/{brand}', function($brand) {require_once "pages/3.0/cats-tspcvincats-searchvin.php";});
    SimpleRouter::match(['get', 'head'],'bank-client-payments', function() {require_once "pages/3.0/bank-client-payments.php";});

     * @param object $class
     * @param string $method
     * @param array $parameters
     * @return string
     */
    public function loadClassMethod($class, string $method, array $parameters): string
    {
        return (string)call_user_func_array([$class, $method], array_values($parameters));
    }
 
    /**
     * Load closure
     *
     * @param Callable $closure
     * @param array $parameters
     * @return string
     */
    public function loadClosure(callable $closure, array $parameters): string
    {
        return (string)call_user_func_array($closure, array_values($parameters));
    }
 
}

     * @param object $class
     * @param string $method
     * @param array $parameters
     * @return string
     */
    public function loadClassMethod($class, string $method, array $parameters): string
    {
        return (string)call_user_func_array([$class, $method], array_values($parameters));
    }
 
    /**
     * Load closure
     *
     * @param Callable $closure
     * @param array $parameters
     * @return string
     */
    public function loadClosure(callable $closure, array $parameters): string
    {
        return (string)call_user_func_array($closure, array_values($parameters));
    }
 
}

 
        /* Filter parameters with null-value */
        if ($this->filterEmptyParams === true) {
            $parameters = array_filter($parameters, static function ($var): bool {
                return ($var !== null);
            });
        }
 
        /* Render callback function */
        if (is_callable($callback) === true) {
            $router->debug('Executing callback');
 
            /* Load class from type hinting */
            if (is_array($callback) === true && isset($callback[0], $callback[1]) === true) {
                $callback[0] = $router->getClassLoader()->loadClass($callback[0]);
            }
 
            /* When the callback is a function */
 
            return $router->getClassLoader()->loadClosure($callback, $parameters);
        }
 
        $controller = $this->getClass();
        $method = $this->getMethod();
 
        $namespace = $this->getNamespace();
        $className = ($namespace !== null && $controller[0] !== '\\') ? $namespace . '\\' . $controller : $controller;
 
        $router->debug('Loading class %s', $className);
        $class = $router->getClassLoader()->loadClass($className);
 
        if ($method === null) {
            $controller[1] = '__invoke';
        }
 
        if (method_exists($class, $method) === false) {
            throw new ClassNotFoundHttpException($className, $method, sprintf('Method "%s" does not exist in class "%s"', $method, $className), 404, null);
        }
 
        $router->debug('Executing callback %s -> %s', $className, $method);

                        'route' => $route,
                        'middlewares' => $route->getMiddlewares(),
                    ]);
 
                    $route->loadMiddleware($this->request, $this);
 
                    $output = $this->handleRouteRewrite($key, $url);
                    if ($output !== null) {
                        return $output;
                    }
 
                    $methodNotAllowed = false;
 
                    $this->request->addLoadedRoute($route);
 
                    $this->fireEvents(EventHandler::EVENT_RENDER_ROUTE, [
                        'route' => $route,
                    ]);
 
                    $routeOutput = $route->renderRoute($this->request, $this);
 
                    if ($this->renderMultipleRoutes === true) {
                        if ($routeOutput !== '') {
                            return $routeOutput;
                        }
 
                        $output = $this->handleRouteRewrite($key, $url);
                        if ($output !== null) {
                            return $output;
                        }
                    } else {
                        $output = $this->handleRouteRewrite($key, $url);
 
                        return $output ?? $routeOutput;
                    }
                }
            }
 
        } catch (Exception $e) {
            return $this->handleException($e);

 
        $this->fireEvents(EventHandler::EVENT_INIT);
 
        $this->loadRoutes();
 
        if ($this->csrfVerifier !== null) {
 
            $this->fireEvents(EventHandler::EVENT_RENDER_CSRF, [
                'csrfVerifier' => $this->csrfVerifier,
            ]);
 
            try {
                /* Verify csrf token for request */
                $this->csrfVerifier->handle($this->request);
            } catch (Exception $e) {
                return $this->handleException($e);
            }
        }
 
        $output = $this->routeRequest();
 
        $this->fireEvents(EventHandler::EVENT_LOAD, [
            'loadedRoutes' => $this->getRequest()->getLoadedRoutes(),
        ]);
 
        $this->debug('Routing complete');
 
        return $output;
    }
 
    /**
     * Routes the request
     *
     * @return string|null
     * @throws HttpException
     * @throws Exception
     */
    public function routeRequest(): ?string
    {
        $this->debug('Routing request');

     * @var Router
     */
    protected static ?Router $router = null;
 
    /**
     * Start routing
     *
     * @throws \Pecee\SimpleRouter\Exceptions\NotFoundHttpException
     * @throws \Pecee\Http\Middleware\Exceptions\TokenMismatchException
     * @throws HttpException
     * @throws Exception
     */
    public static function start(): void
    {
        // Set default namespaces
        foreach (static::router()->getRoutes() as $route) {
            static::addDefaultNamespace($route);
        }
 
        echo static::router()->start();
    }
 
    /**
     * Start the routing an return array with debugging-information
     *
     * @return array
     */
    public static function startDebug(): array
    {
        $routerOutput = null;
 
        try {
            ob_start();
            static::router()->setDebugEnabled(true)->start();
            $routerOutput = ob_get_clean();
        } catch (Exception $e) {
 
        }
 
        // Try to parse library version

    if($actualException->getCode() < 500 && $actualException->getCode() > 399)
        G5Log::File("access.log",$actualException->getMessage(), "CODE:".$actualException->getCode()." UA: ".request()->getUserAgent().", IP: ".getVisitorIPAddress());
    if($actualException->getCode() > 499)
        G5Log::File("errors.log",$actualException->getMessage(),"CODE:".$actualException->getCode()." UA: ".request()->getUserAgent().", IP: ".getVisitorIPAddress() );
    if($actualException->getCode() == 404)
    {
        require_once "pages/3.0/page404.php";
        exit();
    }

    response()->httpCode((int)$actualException->getCode());
    require_once "pages/3.0/page500.php";
    throw $actualException;
});

CommonDataStorage::Initialize();

//Auth::fromCookie()->impersonateAsUserName("admin");
//Запускаем роутинг
SimpleRouter::start();