1:   2:   3:   4:   5:   6:   7:   8:   9:  10:  11:  12:  13:  14:  15:  16:  17:  18:  19:  20:  21:  22:  23:  24:  25:  26:  27:  28:  29:  30:  31:  32:  33:  34:  35:  36:  37:  38:  39:  40:  41:  42:  43:  44:  45:  46:  47:  48:  49:  50:  51:  52:  53:  54:  55:  56:  57:  58:  59:  60:  61:  62:  63:  64:  65:  66:  67:  68:  69:  70:  71:  72:  73:  74:  75:  76:  77:  78:  79:  80:  81:  82:  83:  84:  85:  86:  87:  88:  89:  90:  91:  92:  93:  94:  95:  96:  97:  98:  99: 100: 101: 102: 103: 104: 105: 106: 107: 108: 109: 110: 111: 112: 113: 114: 115: 116: 117: 118: 119: 120: 121: 122: 123: 124: 125: 126: 127: 128: 129: 130: 131: 132: 133: 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150: 151: 152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 162: 163: 164: 165: 166: 167: 168: 169: 170: 171: 172: 173: 174: 175: 176: 177: 178: 179: 180: 181: 182: 183: 184: 185: 186: 187: 188: 189: 190: 191: 192: 193: 194: 195: 196: 197: 198: 199: 200: 201: 202: 203: 204: 205: 206: 207: 208: 209: 210: 211: 212: 213: 214: 215: 216: 217: 218: 219: 220: 221: 222: 223: 224: 225: 226: 227: 228: 229: 230: 231: 232: 233: 234: 235: 236: 237: 238: 239: 240: 241: 242: 243: 244: 245: 246: 247: 248: 249: 250: 251: 252: 253: 254: 255: 256: 257: 258: 259: 260: 261: 262: 263: 264: 265: 266: 267: 268: 269: 270: 271: 272: 273: 274: 275: 276: 277: 278: 279: 280: 281: 282: 283: 284: 285: 286: 287: 288: 289: 290: 291: 292: 293: 294: 295: 296: 297: 298: 299: 300: 301: 302: 303: 304: 305: 306: 307: 308: 309: 310: 311: 312: 313: 314: 315: 316: 317: 318: 319: 320: 321: 322: 323: 324: 325: 326: 327: 328: 329: 330: 331: 332: 333: 334: 335: 336: 337: 338: 339: 340: 341: 342: 343: 344: 345: 346: 347: 348: 349: 350: 351: 352: 353: 354: 355: 356: 357: 358: 359: 360: 361: 362: 363: 364: 365: 366: 367: 368: 369: 370: 371: 372: 373: 374: 375: 376: 377: 378: 379: 380: 381: 382: 383: 384: 385: 386: 387: 388: 389: 390: 391: 392: 393: 394: 395: 396: 397: 398: 399: 400: 401: 402: 403: 404: 405: 406: 407: 408: 409: 410: 411: 412: 413: 414: 415: 416: 417: 418: 419: 420: 421: 422: 423: 424: 425: 426: 427: 428: 429: 430: 431: 432: 433: 434: 435: 436: 437: 438: 439: 440: 441: 442: 443: 444: 445: 446: 447: 448: 449: 450: 451: 452: 453: 454: 455: 456: 457: 458: 459: 460: 461: 462: 463: 464: 465: 466: 467: 468: 469: 470: 471: 472: 473: 474: 475: 476: 477: 478: 479: 480: 481: 482: 483: 484: 485: 486: 487: 488: 489: 490: 491: 492: 493: 494: 495: 496: 497: 498: 499: 500: 501: 502: 503: 504: 505: 506: 507: 508: 509: 510: 511: 512: 513: 514: 515: 516: 517: 518: 519: 520: 521: 522: 523: 524: 525: 526: 527: 528: 529: 530: 531: 532: 533: 534: 535: 536: 537: 538: 539: 540: 541: 542: 543: 544: 545: 546: 547: 548: 549: 550: 551: 552: 553: 554: 555: 556: 557: 558: 559: 560: 561: 562: 563: 564: 565: 566: 567: 568: 569: 570: 571: 572: 573: 574: 575: 576: 577: 578: 579: 580: 581: 582: 583: 584: 585: 586: 587: 588: 589: 590: 591: 592: 593: 594: 595: 596: 597: 598: 599: 600: 601: 602: 603: 604: 605: 606: 607: 608: 609: 610: 611: 612: 613: 614: 615: 616: 617: 618: 619: 620: 621: 622: 623: 

<?php

/**
 * MvcCore
 *
 * This source file is subject to the BSD 3 License
 * For the full copyright and license information, please view
 * the LICENSE.md file that are distributed with this source code.
 *
 * @copyright   Copyright (c) 2016 Tom Flidr (https://github.com/mvccore)
 * @license  https://mvccore.github.io/docs/mvccore/5.0.0/LICENCE.md
 */

namespace MvcCore\Route;

trait InternalInits {

    /**
     * @inheritDocs
     * @return \MvcCore\Route
     */
    public function InitAll () {
        /** @var $this \MvcCore\Route */
        if ($this->match === NULL && $this->reverse === NULL) {
            $this->initMatchAndReverse();
        } else if ($this->match !== NULL && ($this->reverseParams === NULL || $this->lastPatternParam === NULL)) {
            $this->initReverse();
        }
        return $this;
    }

    /**
     * @inheritDocs
     * @return \string[]
     */
    public function __sleep () {
        /** @var $this \MvcCore\Route */
        return static::__getPropsNames();
    }

    /**
     * @inheritDocs
     * @return void
     */
    public function __wakeup () {
        /** @var $this \MvcCore\Route */
        $this->router = \MvcCore\Application::GetInstance()->GetRouter();
    }

    /**
     * Initialize properties `match`, `reverse` and other internal properties
     * about those values, when there is necessary to prepare `pattern` value
     * for: a) PHP `preg_match_all()` route match processing, b) for `reverse`
     * value for later self URL building. This method is usually called in core
     * request routing process from `\MvcCore\Router::Matches();` method on each
     * route.
     * @throws \LogicException Route configuration property is missing.
     * @throws \InvalidArgumentException Wrong route pattern format.
     * @return void
     */
    protected function initMatchAndReverse () {
        /** @var $this \MvcCore\Route */
        if ($this->reverseSections !== NULL) return;
        if ($this->pattern === NULL)
            $this->throwExceptionIfKeyPropertyIsMissing('pattern');

        $this->lastPatternParam = NULL;
        $match = addcslashes($this->pattern, "#(){}-?!=^$.+|:*\\");
        $reverse = $this->reverse !== NULL
            ? $this->reverse
            : $this->pattern;

        list($this->reverseSections, $matchSections) = $this->initSectionsInfoForMatchAndReverse(
            $reverse, $match
        );
        $this->reverse = $reverse;
        $this->reverseParams = $this->initReverseParams(
            $reverse, $this->reverseSections, $this->constraints, $match
        );
        $this->initFlagsByPatternOrReverse($reverse);
        $this->match = $this->initMatchComposeRegex(
            $match, $matchSections, $this->reverseParams, $this->constraints
        );
    }

    /**
     * Process together given `match` and `reverse` value and complete two
     * arrays with sections info about those two given values. Also change the
     * given `match` and `reverse` string references and remove all brackets
     * `[]` defining variable section(s). Every result array with this sections
     * info, with those statistics contains for each fixed section or variable
     * section defined with brackets `[]` info about it's type (fixed or
     * variable), about start position, end position and length. Those
     * statistics are always used to build URL later.
     * @param string $match     A match string prepared from `pattern` property.
     * @param string $reverse   A reverse string value, directly from `reverse`
     *                          property or from `pattern` property if `reverse`
     *                          property is empty.
     * @return \stdClass[][] Two arrays with array with `\stdClass` objects.
     */
    protected function initSectionsInfoForMatchAndReverse (& $match, & $reverse) {
        /** @var $this \MvcCore\Route */
        $matchInfo = [];
        $reverseInfo = [];
        $reverseIndex = 0;
        $matchIndex = 0;
        $reverseLength = mb_strlen($reverse);
        $matchLength = mb_strlen($match);
        $matchOpenPos = FALSE;
        $matchClosePos = FALSE;
        while ($reverseIndex < $reverseLength) {
            $reverseOpenPos = mb_strpos($reverse, '[', $reverseIndex);
            $reverseClosePos = FALSE;
            if ($reverseOpenPos !== FALSE) {
                $reverseClosePos = mb_strpos($reverse, ']', $reverseOpenPos);
                $matchOpenPos = mb_strpos($match, '[', $matchIndex);
                $matchClosePos = mb_strpos($match, ']', $matchOpenPos);
            }
            if ($reverseClosePos === FALSE) {
                $reverseInfo[] = (object) [
                    'fixed'=>TRUE, 'start'=>$reverseIndex, 'end'=>$reverseLength,
                    'length' => $reverseLength - $reverseIndex
                ];
                $matchInfo[]   = (object) [
                    'fixed' => TRUE, 'start'=>$matchIndex, 'end'=>$matchLength,
                    'length' => $matchLength - $matchIndex
                ];
                break;
            } else {
                if ($reverseIndex < $reverseOpenPos) {
                    $reverseInfo[]  = (object) [
                        'fixed'=> TRUE,         'start'=> $reverseIndex,
                        'end'=> $reverseOpenPos,
                        'length' => $reverseOpenPos - $reverseIndex
                    ];
                    $matchInfo[]    = (object) [
                        'fixed'=> TRUE,
                        'start'=> $matchIndex,
                        'end'=> $matchOpenPos,
                        'length'=> $matchOpenPos - $matchIndex];
                }
                $reverseOpenPosPlusOne = $reverseOpenPos + 1;
                $reverseLocalLength = $reverseClosePos - $reverseOpenPosPlusOne;
                $reverse = mb_substr($reverse, 0, $reverseOpenPos) . mb_substr(
                    $reverse, $reverseOpenPosPlusOne, $reverseLocalLength
                    ) . mb_substr($reverse, $reverseClosePos + 1);
                $reverseLength -= 2;
                $reverseClosePos -= 1;
                $reverseInfo[] = (object) [
                    'fixed' => FALSE,               'start' => $reverseOpenPos,
                    'end'   => $reverseClosePos,    'length'=> $reverseLocalLength
                ];
                $matchOpenPosPlusOne = $matchOpenPos + 1;
                $matchLocalLength = $matchClosePos - $matchOpenPosPlusOne;
                $match = mb_substr($match, 0, $matchOpenPos)
                    . mb_substr($match, $matchOpenPosPlusOne, $matchLocalLength)
                    . mb_substr($match, $matchClosePos + 1);
                $matchLength -= 2;
                $matchClosePos -= 1;
                $matchInfo[] = (object) [
                    'fixed' => FALSE,           'start' => $matchOpenPos,
                    'end'   => $matchClosePos,  'length'=> $matchLocalLength
                ];
            }
            $reverseIndex = $reverseClosePos;
            $matchIndex = $matchClosePos;
        }
        return [$matchInfo, $reverseInfo];
    }

    /**
     * Initialize property `reverse` and other internal properties about this
     * value, when there is necessary to prepare it for: a) URL building, b) for
     * request routing, when there is configured `match` property directly
     * an when is necessary to initialize route flags from `reverse` to complete
     * correctly subject to match.
     * @throws \LogicException Route configuration property is missing.
     * @throws \InvalidArgumentException Wrong route pattern format.
     * @return void
     */
    protected function initReverse () {
        /** @var $this \MvcCore\Route */
        if ($this->reverseSections !== NULL) return;
        $reverse = NULL;
        if ($this->reverse !== NULL) {
            $reverse = $this->reverse;
        } else if ($this->pattern !== NULL) {
            $reverse = $this->pattern;
        } else/* if ($this->pattern === NULL)*/ {
            if ($this->redirect !== NULL)
                return $this->initFlagsByPatternOrReverse(
                    $this->pattern !== NULL
                        ? $this->pattern
                        : str_replace(['\\', '(?', ')?', '/?'], '', $this->match)
                );
            $this->throwExceptionIfKeyPropertyIsMissing('reverse', 'pattern');
        }

        $this->lastPatternParam = NULL;

        $this->reverseSections = $this->initSectionsInfo($reverse);
        $this->reverse = $reverse;

        $match = NULL;
        $this->reverseParams = $this->initReverseParams(
            $reverse, $this->reverseSections, $this->constraints, $match
        );

        $this->initFlagsByPatternOrReverse($reverse);
    }

    /**
     * Process given `reverse` value and complete array with sections info about
     * this given value. Also change the given `reverse` string reference and
     * remove all brackets `[]` defining variable section(s). The result array
     * with sections info, with this statistic contains for each fixed section
     * or variable section defined with brackets `[]` info about it's type
     * (fixed or variable), about start position, end position and length. This
     * statistic is always used to build URL later.
     * @param string $pattern A reverse string value, directly from `reverse`
     *                        property or from `pattern` property if `reverse`
     *                        property is empty.
     * @return \stdClass[][] An array with `\stdClass` objects.
     */
    protected function & initSectionsInfo (& $pattern) {
        /** @var $this \MvcCore\Route */
        $result = [];
        $index = 0;
        $length = mb_strlen($pattern);
        while ($index < $length) {
            $openPos = mb_strpos($pattern, '[', $index);
            $closePos = FALSE;
            if ($openPos !== FALSE)
                $closePos = mb_strpos($pattern, ']', $openPos);
            if ($closePos === FALSE) {
                $result[] = (object) [
                    'fixed' => TRUE,    'start'     => $index,
                    'end'   => $length, 'length'    => $length - $index
                ];
                break;
            } else {
                if ($index < $openPos)
                    $result[] = (object) [
                    'fixed' => TRUE,        'start'     => $index,
                    'end'   => $openPos,    'length'    => $openPos - $index
                ];
                $openPosPlusOne = $openPos + 1;
                $lengthLocal = $closePos - $openPosPlusOne;
                $pattern = mb_substr($pattern, 0, $openPos)
                    . mb_substr($pattern, $openPosPlusOne, $lengthLocal)
                    . mb_substr($pattern, $closePos + 1);
                $length -= 2;
                $closePos -= 1;
                $result[] = (object) [
                    'fixed' => FALSE,       'start'     => $openPos,
                    'end'   => $closePos,   'length'    => $lengthLocal
                ];
            }
            $index = $closePos;
        }
        return $result;
    }

    /**
     * Initialize reverse params info array. Each item in completed array is
     * `\stdClass` object with records about founded parameter place: `name`,
     * `greedy`, `sectionIndex`, `reverseStart`, `reverseEnd`. Records
     * `matchStart` and `matchEnd` could be values `-1` when function argument
     * `$match` is `NULL`, because this function is used to complete `match` and
     * `reverse` properties together and also to complete `reverse` property
     * separately and only. Result array is always used as `reverseParams`
     * property to complete URL rewrite params inside result `reverse` string.
     * @param string        $reverse                A reverse string with `<param>`s.
     * @param \stdClass[]   $reverseSectionsInfo    Reverse sections statistics with
     *                                              fixed and variable sections.
     * @param array         $constraints            Route constraints array.
     * @param string|NULL   $match                  A match string, could be `NULL`.
     * @throws \InvalidArgumentException Wrong route pattern format.
     * @return array        An array with keys as param names and values as
     *                      `\stdClass` objects with data about each reverse param.
     */
    protected function & initReverseParams (& $reverse, & $reverseSectionsInfo, & $constraints, & $match = NULL) {
        /** @var $this \MvcCore\Route */
        $result = [];
        $completeMatch = $match !== NULL;
        $reverseIndex = 0;
        $matchIndex = 0;
        $sectionIndex = 0;
        $section = $reverseSectionsInfo[$sectionIndex];
        $reverseLength = mb_strlen($reverse);
        $greedyCaught = FALSE;
        $matchOpenPos = -1;
        $matchClosePos = -1;
        $this->lastPatternParam = '';
        while ($reverseIndex < $reverseLength) {
            $reverseOpenPos = mb_strpos($reverse, '<', $reverseIndex);
            $reverseClosePos = FALSE;
            if ($reverseOpenPos !== FALSE) {
                $reverseClosePos = mb_strpos($reverse, '>', $reverseOpenPos);
                if ($completeMatch) {
                    $matchOpenPos = mb_strpos($match, '<', $matchIndex);
                    $matchClosePos = mb_strpos($match, '>', $matchOpenPos) + 1;
                }}
            if ($reverseClosePos === FALSE) break;// no other param caught
            // check if param belongs to current section
            // and if not, move to next (or next...) section
            $reverseClosePos += 1;
            if ($reverseClosePos > $section->end) {
                $reverseSectionsInfoCountMinusOne = count($reverseSectionsInfo) - 1;
                while ($sectionIndex < $reverseSectionsInfoCountMinusOne) {
                    $nextSection = $reverseSectionsInfo[$sectionIndex + 1];
                    if ($reverseClosePos > $nextSection->end) {
                        $sectionIndex += 1;
                    } else {
                        $sectionIndex += 1;
                        $section = $reverseSectionsInfo[$sectionIndex];
                        break;
                    }}}
            // complete param section length and param name
            $paramLength = $reverseClosePos - $reverseOpenPos;
            $paramName = mb_substr($reverse, $reverseOpenPos + 1, $paramLength - 2);
            list ($greedyFlag, $sectionIsLast) = $this->initReverseParamsGetGreedyInfo(
                $reverseSectionsInfo, $constraints,
                $paramName, $sectionIndex, $greedyCaught
            );
            if ($greedyFlag && $sectionIsLast) {
                $lastSectionChar = mb_substr(
                    $reverse, $reverseClosePos, $reverseSectionsInfo[$sectionIndex]->end - $reverseClosePos
                );
                if ($lastSectionChar == '/') {
                    $lastSectionChar = '';
                    $reverseSectionsInfo[$sectionIndex]->end -= 1;
                }
                if ($lastSectionChar === '')
                    $this->lastPatternParam = $paramName;
            }
            $result[$paramName] = (object) [
                'name'          => $paramName,
                'greedy'        => $greedyFlag,
                'sectionIndex'  => $sectionIndex,
                    'length'        => $paramLength,
                'reverseStart'  => $reverseOpenPos,
                'reverseEnd'    => $reverseClosePos,
                'matchStart'    => $matchOpenPos,
                'matchEnd'      => $matchClosePos,
            ];
            $reverseIndex = $reverseClosePos;
            $matchIndex = $matchClosePos;
        }
        return $result;
    }

    /**
     * Get if founded param place is greedy or not. If it's greedy, check if it
     * is only one greedy param in whole pattern string and if it is the last
     * param between other params. Get also if given section index belongs to
     * the last section info in line.
     * @param \stdClass[]   $reverseSectionsInfo    Whole sections info array ref.
     *                                              with `\stdClass` objects.
     * @param array         $constraints            Route params constraints.
     * @param string        $paramName              Route parsed params.
     * @param int           $sectionIndex           Currently checked section index.
     * @param bool          $greedyCaught           Boolean about if param is checked as greedy.
     * @throws \InvalidArgumentException Wrong route pattern format.
     * @return \bool[]      Array with two boolean values. First is greedy flag
     *                      and second is about if section is last or not. The
     *                      second could be `NULL`
     */
    protected function initReverseParamsGetGreedyInfo (& $reverseSectionsInfo, & $constraints, & $paramName, & $sectionIndex, & $greedyCaught) {
        /** @var $this \MvcCore\Route */
        // complete greedy flag by star character inside param name
        $greedyFlag = mb_strpos($paramName, '*') !== FALSE;
        $sectionIsLast = NULL;
        // check greedy param specifics
        if ($greedyFlag) {
            if ($greedyFlag && $greedyCaught) 
                throw new \InvalidArgumentException(
                    "[".get_class()."] Route pattern definition can have only one greedy `<param_name*>` "
                    ." with star (to include everything - all characters and slashes . `.*`) ({$this})."
                );
            $reverseSectionsCount = count($reverseSectionsInfo);
            $sectionIndexPlusOne = $sectionIndex + 1;
            if (// next section is optional
                $sectionIndexPlusOne < $reverseSectionsCount &&
                !($reverseSectionsInfo[$sectionIndexPlusOne]->fixed)
            ) {
                // check if param is really greedy or not
                $constraintDefined = isset($constraints[$paramName]);
                $constraint = $constraintDefined ? $constraints[$paramName] : NULL ;
                $greedyReal = !$constraintDefined || ($constraintDefined && (
                    mb_strpos($constraint, '.*') !== FALSE || mb_strpos($constraint, '.+') !== FALSE
                ));
                if ($greedyReal) 
                    throw new \InvalidArgumentException(
                        "[".get_class()."] Route pattern definition can not have greedy `<param_name*>` with star "
                        ."(to include everything - all characters and slashes . `.*`) immediately before optional "
                        ."section ({$this})."
                    );
            }
            $greedyCaught = TRUE;
            $paramName = str_replace('*', '', $paramName);
            $sectionIsLast = $sectionIndexPlusOne === $reverseSectionsCount;
        }
        return [$greedyFlag, $sectionIsLast];
    }

    /**
     * Initialize three route integer flags. About if and what scheme definition
     * is contained in given pattern, if and what domain parts are contained in
     * given pattern and if given pattern contains any part of query string.
     * Given pattern is `reverse` and if reverse is empty, it's `pattern` prop.
     * @param string $pattern
     * @return void
     */
    protected function initFlagsByPatternOrReverse ($pattern) {
        /** @var $this \MvcCore\Route */
        $scheme = static::FLAG_SCHEME_NO;
        if (mb_strpos($pattern, '//') === 0) {
            $scheme = static::FLAG_SCHEME_ANY;
        } else if (mb_strpos($pattern, 'http://') === 0) {
            $scheme = static::FLAG_SCHEME_HTTP;
        } else if (mb_strpos($pattern, 'https://') === 0) {
            $scheme = static::FLAG_SCHEME_HTTPS;
        }
        $host = static::FLAG_HOST_NO;
        if ($scheme) {
            if (mb_strpos($pattern, static::PLACEHOLDER_HOST) !== FALSE) {
                $host = static::FLAG_HOST_HOST;
            } else if (mb_strpos($pattern, static::PLACEHOLDER_DOMAIN) !== FALSE) {
                $host = static::FLAG_HOST_DOMAIN;
            } else {
                if (mb_strpos($pattern, static::PLACEHOLDER_TLD) !== FALSE)
                    $host += static::FLAG_HOST_TLD;
                if (mb_strpos($pattern, static::PLACEHOLDER_SLD) !== FALSE)
                    $host += static::FLAG_HOST_SLD;
            }
            if (mb_strpos($pattern, static::PLACEHOLDER_BASEPATH) !== FALSE)
                $host += static::FLAG_HOST_BASEPATH;
        }
        $queryString = mb_strpos($pattern, '?') !== FALSE
            ? static::FLAG_QUERY_INCL
            : static::FLAG_QUERY_NO;
        $this->flags = [$scheme, $host, $queryString];
    }

    /**
     * Compose regular expression pattern to match incoming request or not.
     * This method is called in route matching process, when it's necessary to
     * complete route `match` property from `pattern` property. The result
     * regular expression is always composed to match trailing slash or missing
     * trailing slash and any fixed and variable sections defined by `pattern`.
     * @param string        $match              A pattern string with escaped all special regular
     *                                          expression special characters except `<>` chars.
     * @param \stdClass[]   $matchSectionsInfo  Match sections info about fixed or variable
     *                                          section, param name, start, end and length.
     * @param array         $reverseParams      An array with keys as param names and values as
     *                                          `\stdClass` objects with data about reverse params.
     * @param array         $constraints        Route params regular expression constraints
     *                                          Defining which value each param could contain or not.
     *                                          If there is no constraint for param, there is used
     *                                          default constraint defined in route static property.
     * @return string
     */
    protected function initMatchComposeRegex (& $match, & $matchSectionsInfo, & $reverseParams, & $constraints) {
        /** @var $this \MvcCore\Route */
        $sections = [];
        $paramIndex = 0;
        $reverseParamsKeys = array_keys($reverseParams);
        $paramsCount = count($reverseParamsKeys);
        $anyParams = $paramsCount > 0;
        $defaultPathConstraint = static::$defaultPathConstraint;
        $defaultDomainConstraint = static::$defaultDomainConstraint;
        $schemeFlag = $this->flags[0];
        $matchIsAbsolute = (bool) $schemeFlag;
        $firstPathSlashPos = 0;
        if ($matchIsAbsolute) {
            $matchIsAbsolute = TRUE;
            $defaultConstraint = $defaultDomainConstraint;
            // if scheme flag is `http://` or `https://`, there is necessary to increase
            // `mb_strpos()` index by one, because there is always backslash in match pattern
            // before `:` - like `http\://` or `https\://`
            $firstPathSlashPos = mb_strpos($match, '/', $schemeFlag + ($schemeFlag > static::FLAG_SCHEME_ANY ? 1 : 0));
        } else {
            $defaultConstraint = $defaultPathConstraint;
        }
        $pathFixedSectionsCount = 0;
        $lastPathFixedSectionIndex = 0;
        $trailingSlash = '?';
        $one = $matchIsAbsolute ? 0 : 1;
        $sectionsCountMinusOne = count($matchSectionsInfo) - 1;
        foreach ($matchSectionsInfo as $sectionIndex => $section) {
            $sectionEnd = $section->end;
            if ($anyParams) {
                $sectionOffset = $section->start;
                $sectionResult = '';
                while ($paramIndex < $paramsCount) {
                    $paramKey = $reverseParamsKeys[$paramIndex];
                    $param = $reverseParams[$paramKey];
                    if ($param->sectionIndex !== $sectionIndex) break;
                    $paramStart = $param->matchStart;
                    if ($matchIsAbsolute && $paramStart > $firstPathSlashPos)
                        $defaultConstraint = $defaultPathConstraint;
                    if ($sectionOffset < $paramStart)
                        $sectionResult .= mb_substr($match, $sectionOffset, $paramStart - $sectionOffset);
                    $paramName = $param->name;
                    $customConstraint = isset($constraints[$paramName]);
                    if (!$customConstraint && $param->greedy) $defaultConstraint = '.*';
                    if ($customConstraint) {
                        $constraint = $constraints[$paramName];
                    } else {
                        $constraint = $defaultConstraint;
                    }
                    $sectionResult .= '(?<' . $paramName . '>' . $constraint . ')';
                    $paramIndex += 1;
                    $sectionOffset = $param->matchEnd;
                }
                if ($sectionOffset < $sectionEnd)
                    $sectionResult .= mb_substr($match, $sectionOffset, $sectionEnd - $sectionOffset);
            } else {
                $sectionResult = mb_substr($match, $section->start, $section->length);
            }
            if ($matchIsAbsolute && $sectionEnd > $firstPathSlashPos) $one = 1;
            if ($section->fixed) {
                $pathFixedSectionsCount += $one;
                $lastPathFixedSectionIndex = $sectionIndex;
            } else {
                $sectionResult = '(' . $sectionResult . ')?';
            }
            $sections[] = $sectionResult;
        }
        if ($pathFixedSectionsCount > 0) {
            $lastFixedSectionContent = & $sections[$lastPathFixedSectionIndex];
            if ($sectionsCountMinusOne == 0 && $lastPathFixedSectionIndex == 0 &&
                $lastFixedSectionContent === '/'
            ) {
                $trailingSlash = ''; // homepage -> `/`
            } else {
                $lastCharIsSlash = mb_substr($lastFixedSectionContent, -1, 1) == '/';
                if ($lastPathFixedSectionIndex == $sectionsCountMinusOne) {// last section is fixed section
                    if (!$lastCharIsSlash) $trailingSlash = '/?';
                } else {// last section is optional section or sections
                    $lastFixedSectionContent .= ($lastCharIsSlash ? '' : '/') . '?';
                    $trailingSlash = '/?';
                }}}
        // always add UTF-8 modifier to match UTF-8 request paths
        return '#^' . implode('', $sections) . $trailingSlash . '$#u';
    }

    /**
     * Thrown a logic exception about missing key property in route object to
     * parse `pattern` or `reverse`. Those properties are necessary to complete
     * correctly `match` property to route incoming request or to complete
     * correctly `reverse` property to build URL address.
     * @throws \LogicException Route configuration property is missing.
     * @param \string[] $propsNames,... Missing properties names.
     * @return void
     */
    protected function throwExceptionIfKeyPropertyIsMissing ($propsNames) {
        /** @var $this \MvcCore\Route */
        $propsNames = func_get_args();
        throw new \LogicException(
            "[".get_class()."] Route configuration property/properties is/are"
            ." missing: `" . implode("`, `", $propsNames) . "`, to parse and"
            ." complete key properties `match` and/or `reverse` to route"
            ." or build URL correctly ({$this})."
        );
    }

    /**
     * This method serve only for debug and development purposes. It renders all
     * instance properties values into string, to print whole route in logic
     * exception message about what property is missing.
     * @return string
     */
    public function __toString () {
        /** @var $this \MvcCore\Route */
        $type = new \ReflectionClass($this);
        $allProps = $type->getProperties(
            \ReflectionProperty::IS_PUBLIC |
            \ReflectionProperty::IS_PROTECTED |
            \ReflectionProperty::IS_PRIVATE
        );
        $result = [];
        /** @var $prop \ReflectionProperty */
        foreach ($allProps as $prop) {
            if ($prop->isStatic()) continue;
            if ($prop->isPrivate()) $prop->setAccessible(TRUE);
            $value = NULL;
            try {
                $value = $prop->getValue($this);
            } catch (\Exception $e) { // backward compatibility
            } catch (\Throwable $e) {
            };
            $result[] = '"' . $prop->getName() . '":"' . ($value === NULL ? 'NULL' : var_export($value)) . '"';
        }
        return '{'.implode(', ', $result) . '}';
    }

    /**
     * Return property names to be serialized.
     * @return \string[]
     */
    private static function __getPropsNames () {
        /** @var $this \MvcCore\Route */
        static $__propsNames = NULL;
        if ($__propsNames == NULL) {
            $props = (new \ReflectionClass(get_called_class()))->getProperties(
                \ReflectionProperty::IS_PUBLIC |
                \ReflectionProperty::IS_PROTECTED |
                \ReflectionProperty::IS_PRIVATE
            );
            $__propsNames = [];
            foreach ($props as $prop)
                if (
                    !$prop->isStatic() &&
                    !isset(static::$protectedProperties[$prop->name])
                )
                    $__propsNames[] = $prop->name;
        }
        return $__propsNames;
    }
}