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: 

<?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\Router;

trait Routing {

    /**
     * @inheritDocs
     * @throws \LogicException Route configuration property is missing.
     * @throws \InvalidArgumentException Wrong route pattern format.
     * @return bool
     */
    public function Route () {
        /** @var $this \MvcCore\Router */
        $this->internalRequest = $this->request->IsInternalRequest();
        if (!$this->internalRequest) 
            if (!$this->redirectToProperTrailingSlashIfNecessary()) return FALSE;
        list($requestCtrlName, $requestActionName) = $this->routeDetectStrategy();
        if ($this->routeByQueryString) {
            $this->queryStringRouting($requestCtrlName, $requestActionName);
        } else {
            $this->rewriteRouting($requestCtrlName, $requestActionName);
        }
        if (!$this->routeProcessRouteRedirectionIfAny()) return FALSE;
        return $this->routeSetUpDefaultForHomeIfNoMatch()
                    ->routeSetUpSelfRouteNameIfAny()
                    ->canonicalRedirectIfAny();
    }
    
    /**
     * @inheritDocs
     * @param string    $controllerNamePc   Pascal case classic controller name definition.
     * @param string    $actionNamePc       Pascal case action name without `Action` suffix.
     * @param bool      $changeSelfRoute    `FALSE` by default to change self route to generate self URLs.
     * @return bool
     */
    public function RedefineRoutedTarget ($controllerNamePc = NULL, $actionNamePc = NULL, $changeSelfRoute = FALSE) {
        /** @var $this \MvcCore\Router */
        $toolClass = self::$toolClass;
        $ctrlNameDc = NULL;
        $actionNameDc = NULL;
        $currentRoute = $this->currentRoute;
        $currentRouteMatched = $currentRoute instanceof \MvcCore\IRoute;
        $matchedParams = $currentRouteMatched ? $currentRoute->GetMatchedParams() : [];
        $controllerNamePcNotNull = $controllerNamePc !== NULL;
        $actionNamePcNotNull = $actionNamePc !== NULL;
        if ($controllerNamePcNotNull) {
            $ctrlNameDc = str_replace(['\\', '_'], '/', $toolClass::GetDashedFromPascalCase($controllerNamePc));
            $matchedParams[static::URL_PARAM_CONTROLLER] = $ctrlNameDc;
            $this->request->SetControllerName($ctrlNameDc)->SetParam(static::URL_PARAM_CONTROLLER, $ctrlNameDc);
            if (isset($this->requestedParams[static::URL_PARAM_CONTROLLER])) $this->requestedParams[static::URL_PARAM_CONTROLLER] = $ctrlNameDc;
            $currentRoute->SetController($controllerNamePc);
        }
        if ($actionNamePcNotNull) {
            $actionNameDc = $toolClass::GetDashedFromPascalCase($actionNamePc);
            $matchedParams[static::URL_PARAM_ACTION] = $actionNameDc;
            $this->request->SetActionName($actionNameDc)->SetParam(static::URL_PARAM_ACTION, $ctrlNameDc);
            if (isset($this->requestedParams[static::URL_PARAM_ACTION])) $this->requestedParams[static::URL_PARAM_ACTION] = $actionNameDc;
            $currentRoute->SetAction($actionNamePc);
        }
        if ($currentRouteMatched) {
            $currentRoute->SetMatchedParams($matchedParams);
            $currentRouteName = $currentRoute->GetName();
            
            if (strpos($currentRouteName, ':') !== FALSE && ($controllerNamePcNotNull || $actionNamePcNotNull)) {
                list($ctrlPc, $actionPc) = explode(':', $currentRouteName);
                $currentRoute->SetName(
                     ($controllerNamePcNotNull ? $controllerNamePc : $ctrlPc)
                    . ':' . ($actionNamePcNotNull ? $actionNamePc : $actionPc)
                );
            }
        }
        if ($currentRouteMatched && $changeSelfRoute) {
            $this->selfRouteName = $this->anyRoutesConfigured
                ? $currentRoute->GetName()
                : $currentRoute->GetControllerAction();
            if ($controllerNamePcNotNull) 
                if (isset($this->requestedParams[static::URL_PARAM_CONTROLLER])) 
                    $this->requestedParams[static::URL_PARAM_CONTROLLER] = $ctrlNameDc;
            if ($actionNamePcNotNull)
                if (isset($this->requestedParams[static::URL_PARAM_ACTION])) 
                    $this->requestedParams[static::URL_PARAM_ACTION] = $actionNameDc;
        }
        return TRUE;
    }

    /**
     * @inheritDocs
     * @param string $routeName Always as `default`, `error` or `not_found`, by constants:
     *                       `\MvcCore\IRouter::DEFAULT_ROUTE_NAME`
     *                       `\MvcCore\IRouter::DEFAULT_ROUTE_NAME_ERROR`
     *                       `\MvcCore\IRouter::DEFAULT_ROUTE_NAME_NOT_FOUND`
     * @param string $controllerPc Controller name in pascal case.
     * @param string $actionPc Action name with pascal case without ending `Action` substring.
     * @param bool $fallbackCall `FALSE` by default. If `TRUE`, this function is called from error rendering fallback, self route name is not changed.
     * @return \MvcCore\Route
     */
    public function SetOrCreateDefaultRouteAsCurrent ($routeName, $controllerPc, $actionPc, $fallbackCall = FALSE) {
        /** @var $this \MvcCore\Router */
        $controllerPc = strtr($controllerPc, '/', '\\');
        $ctrlActionRouteName = $controllerPc.':'. $actionPc;
        $request = $this->request;
        if (isset($this->routes[$ctrlActionRouteName])) {
            $defaultRoute = $this->routes[$ctrlActionRouteName];
        } else if (isset($this->routes[$routeName])) {
            $defaultRoute = $this->routes[$routeName];
        } else {
            $routeClass = self::$routeClass;
            $pathParamName = static::URL_PARAM_PATH;
            $defaultRoute = $routeClass::CreateInstance()
                ->SetMatch("#/(?<{$pathParamName}>.*)#")
                ->SetReverse("/<{$pathParamName}>")
                ->SetName($routeName)
                ->SetController($controllerPc)
                ->SetAction($actionPc)
                ->SetDefaults([
                    $pathParamName                  => NULL,
                    static::URL_PARAM_CONTROLLER    => NULL,
                    static::URL_PARAM_ACTION        => NULL,
                ]);
            $anyRoutesConfigured = $this->anyRoutesConfigured;
            $this->AddRoute($defaultRoute, NULL, TRUE, FALSE);
            $this->anyRoutesConfigured = $anyRoutesConfigured;
            if (!$request->IsInternalRequest()) 
                $request->SetParam(static::URL_PARAM_PATH, ($request->HasParam(static::URL_PARAM_PATH)
                    ? $request->GetParam(static::URL_PARAM_PATH, '.*')
                    : $request->GetPath())
                );
        }
        $toolClass = self::$toolClass;
        $request
            ->SetControllerName(str_replace('\\', '/', 
                $toolClass::GetDashedFromPascalCase($defaultRoute->GetController())
            ))
            ->SetActionName(
                $toolClass::GetDashedFromPascalCase($defaultRoute->GetAction())
            );
        $this->currentRoute = $defaultRoute;
        if (!$fallbackCall) $this->selfRouteName = $routeName;
        return $defaultRoute;
    }

    /**
     * Detect and set up route strategy to complete requested controller and action.
     * Return strategy to complete those values by query string if:
     * - If there is controller and also action, both defined in query string.
     * - Or if requested path is `/` (or `/index.php`) and there is defined 
     *   controller or action in query string.
     * Else then choose strategy to complete controller and action by rewrite routes.
     * Return array with possible query string controller name and action.
     * @return \string[]
     */
    protected function routeDetectStrategy () {
        /** @var $this \MvcCore\Router */
        $request = $this->request;
        $requestCtrlName = $request->GetControllerName();
        $requestActionName = $request->GetActionName();
        if ($this->routeByQueryString === NULL) {
            list($reqScriptName, $reqPath) = [$request->GetScriptName(), $request->GetPath(TRUE)];
            $requestCtrlNameNotNull = $requestCtrlName !== NULL;
            $requestActionNameNotNull = $requestActionName !== NULL;
            $requestCtrlAndAlsoAction = $requestCtrlNameNotNull && $requestActionNameNotNull;
            $requestCtrlOrAction = $requestCtrlNameNotNull || $requestActionNameNotNull;
            $this->routeByQueryString = (
                $this->anyRoutesConfigured !== TRUE ||
                $requestCtrlAndAlsoAction ||
                ($requestCtrlOrAction && (
                    $reqScriptName === $reqPath || 
                    trim($reqPath, '/') === ''
                ))
            );
        }
        return [$requestCtrlName, $requestActionName];
    }

    /**
     * If there is chosen query string routing strategy, create new route by 
     * controller and action directly assigned from request and if controller or 
     * action values are missing, assign there default controller and action values.
     * Set up also default and request params by request object.
     * 
     * Request params are necessary to complete any `self` URL, to route request
     * properly, to complete canonical URL and to process possible route redirection.
     * 
     * Default params are necessary to handle route filtering in and out and to
     * complete URL by any other route name for case, when some required param 
     * is not presented in second `$params` argument in Url() method (then the
     * param is assigned from default params).
     * @param string|NULL $requestCtrlName      Possible controller name value or `NULL` assigned directly 
     *                                          from request object in `\MvcCore\router::routeDetectStrategy();`
     * @param string|NULL $requestActionName    Possible action name value or `NULL` assigned directly 
     *                                          from request object in `\MvcCore\router::routeDetectStrategy();`
     * @return void
     */
    protected function queryStringRouting ($requestCtrlName, $requestActionName) {
        /** @var $this \MvcCore\Router */
        $toolClass = self::$toolClass;
        list($ctrlDfltName, $actionDfltName) = $this->application->GetDefaultControllerAndActionNames();
        $this->SetOrCreateDefaultRouteAsCurrent(
            \MvcCore\IRouter::DEFAULT_ROUTE_NAME,
            $toolClass::GetPascalCaseFromDashed($requestCtrlName ?: $ctrlDfltName),
            $toolClass::GetPascalCaseFromDashed($requestActionName ?: $actionDfltName)
        );
        // default params are merged with previous default params to have 
        // possibility to add domain params by extended module router
        $this->defaultParams = array_merge([], $this->defaultParams, $this->request->GetParams(FALSE));
        $this->requestedParams = array_merge([], $this->defaultParams);
    }

    /**
     * After route matching process is done and there is completed current route 
     * object, check if current route object contains redirect configuration.
     * If route contains redirection to another route, redirect request to target 
     * URL, which is completed by standard `Url()` router method by target route
     * name and by given request params. Redirect with code 301 - Moved permanently.
     * If there was necessary to redirect, return `FALSE`, else return `TRUE`.
     * @return bool
     */
    protected function routeProcessRouteRedirectionIfAny () {
        /** @var $this \MvcCore\Router */
        if ($this->currentRoute instanceof \MvcCore\IRoute) {
            $redirectRouteName = $this->currentRoute->GetRedirect();
            if ($redirectRouteName !== NULL) {
                $redirectUrl = $this->Url($redirectRouteName, $this->requestedParams);
                $this->redirect(
                    $redirectUrl, 
                    \MvcCore\IResponse::MOVED_PERMANENTLY,
                    'Redirection route '
                );
                return FALSE;
            }
        }
        return TRUE;
    }

    /**
     * After routing is done, check if there is any current route.
     * If there is no current route found by any strategy, there is possible to
     * create default route object into current object automatically newly created
     * by default configured values. It is necessary to check if request is 
     * targeting homepage or if router is configured to route request to default 
     * controller and action. If those two conditions are OK, create new route 
     * with default controller and action and set this new route as current route 
     * to process default controller and action even if there is no route for it.
     * @return \MvcCore\Router
     */
    protected function routeSetUpDefaultForHomeIfNoMatch () {
        /** @var $this \MvcCore\Router */
        if ($this->currentRoute === NULL) {
            $request = $this->request;
            if ($this->routeToDefaultIfNotMatch) {
                $requestIsHome = (
                    trim($request->GetPath(), '/') == '' || 
                    $request->GetPath() == $request->GetScriptName()
                );
                if ($requestIsHome) {
                    list($dfltCtrl, $dftlAction) = $this->application->GetDefaultControllerAndActionNames();
                    $this->SetOrCreateDefaultRouteAsCurrent(
                        static::DEFAULT_ROUTE_NAME, $dfltCtrl, $dftlAction
                    );
                    // set up requested params from query string if there are any 
                    // (and path if there is path from previous function)
                    $requestParams = array_merge([], $this->request->GetParams(FALSE));
                    unset($requestParams[static::URL_PARAM_CONTROLLER], $requestParams[static::URL_PARAM_ACTION]);
                    $this->requestedParams = & $requestParams;
                }
            }
        }
        return $this;
    }

    /**
     * After routing is done, check if there is any current route and set up
     * property `$this->selfRouteName` about currently matched route name
     * to complete any time later `self` url.
     * @return \MvcCore\Router
     */
    protected function routeSetUpSelfRouteNameIfAny () {
        /** @var $this \MvcCore\Router */
        if ($this->currentRoute instanceof \MvcCore\IRoute) 
            $this->selfRouteName = $this->anyRoutesConfigured
                ? $this->currentRoute->GetName()
                : $this->currentRoute->GetControllerAction();
        return $this;
    }
}