<?php
/**
 * Route definition
 *
 * @author Christopher Han <xiphux@gmail.com>
 * @copyright Copyright (c) 2012 Christopher Han
 * @package GitPHP
 * @subpackage Router
 */
class GitPHP_Route
{
        /**
         * The route path
         *
         * @var string
         */
        protected $path;
 
        /**
         * The route constraints
         *
         * @var string[]
         */
        protected $constraints = array();
 
        /**
         * Additional route parameters
         *
         * @var string[]
         */
        protected $extraParameters = array();
 
        /**
         * Url parameters
         *
         * @var string[]
         */
        protected $urlParameters = array();
 
        /**
         * Used parameters
         *
         * @var string[]
         */
        protected $usedParameters = array();
 
        /**
         * Cached constraints
         *
         * @var array[]
         */
        protected $cachedConstraints;
 
        /**
         * Constructor
         *
         * @param string $path route path
         * @param string[] $constraints route constraints
         * @param string[] $extraParameters additional route parameters
         * @param GitPHP_Route $parent parent route
         */
        public function __construct($path, $constraints = array(), $extraParameters = array(), $parent = null)
        {
                if (empty($path))
                        throw new Exception('Path is required');
 
                // initialize path
                if ($parent)
                        $this->path = $parent->GetPath() . '/' . $path;
                else
                        $this->path = $path;
 
                // initialize constraints
                if ($parent)
                        $this->constraints = array_merge($parent->constraints, $constraints);
                else
                        $this->constraints = $constraints;
 
                // initialise extra parameters
                if ($parent)
                        $this->extraParameters = array_merge($parent->extraParameters, $extraParameters);
                else
                        $this->extraParameters = $extraParameters;
 
                // initialize url parameters
                $fullPath = explode('/', $this->path);
                foreach ($fullPath as $pathpiece) {
                        if (strncmp($pathpiece, ':', 1) === 0) {
                                $param = substr($pathpiece, 1);
                                $this->urlParameters[] = $param;
                        }
                }
 
                // initialize used parameters
                $this->usedParameters = array_merge($this->urlParameters, array_keys($extraParameters));
                if ($parent)
                        $this->usedParameters = array_merge($parent->GetUsedParameters(), $this->usedParameters);
                $this->usedParameters = array_unique($this->usedParameters);
        }
 
        /**
         * Get route path
         *
         * @return string $path
         */
        public function GetPath()
        {
                return $this->path;
        }
 
        /**
         * Test if this route matches the given path
         *
         * @param string $path path
         * @return array|boolean array of parameters or false if not matched
         */
        public function Match($path)
        {
                if (empty($path))
                        return false;
 
                $routepieces = explode('/', $this->GetPath());
                foreach ($routepieces as $i => $routepiece) {
                        if (strncmp($routepiece, ':', 1) === 0) {
                                $routepiece = substr($routepiece, 1);
                                if (!empty($this->constraints[$routepiece])) {
                                        $pattern = '(?P<' . $routepiece . '>' . $this->constraints[$routepiece] . ')';
                                } else {
                                        $pattern = '(?P<' . $routepiece . '>.+)';
                                }
                                $routepieces[$i] = $pattern;
                        }
                }
 
                $routepattern = implode('/', $routepieces);
 
                if (!preg_match('@^' . $routepattern . '$@', $path, $regs))
                        return false;
 
                $params = array();
                foreach ($regs as $key => $register) {
                        if (!is_string($key))
                                continue;
                        $params[$key] = $register;
                }
                if (count($this->extraParameters) > 0) {
                        $params = array_merge($params, $this->extraParameters);
                }
 
                return $params;
        }
 
        /**
         * Test if route is valid for the given parameters
         *
         * @param string[] $params parameters
         * @return boolean true if matech
         */
        public function Valid($params)
        {
                foreach ($this->constraints as $param => $constraint) {
                        if (empty($params[$param]))
                                return false;
                        $paramval = $params[$param];
                        if (!isset($this->cachedConstraints[$param][$paramval])) {
                                $this->cachedConstraints[$param][$paramval] = preg_match('@^' . $constraint . '$@', $params[$param]);
                        }
                        if (!$this->cachedConstraints[$param][$paramval])
                                return false;
                }
 
                foreach ($this->urlParameters as $param) {
                        if (empty($params[$param]))
                                return false;
                }
 
                return true;
        }
 
        /**
         * Build route from parameters
         *
         * @param string[] $params parameters
         * @return string full route
         */
        public function Build($params)
        {
                $path = $this->GetPath();
 
                $routepieces = explode('/', $path);
                foreach ($routepieces as $i => $piece) {
                        if (strncmp($piece, ':', 1) !== 0) {
                                // not a param
                                continue;
                        }
                        $paramname = substr($piece, 1);
                        $routepieces[$i] = $params[$paramname];
                }
                
                return trim(implode('/', $routepieces), '/');
        }
 
        /**
         * Get list of params used in this route
         *
         * @return string[] array of parameters
         */
        public function GetUsedParameters()
        {
                return $this->usedParameters;
        }
 
        /**
         * Compare routes for precedence
         *
         * @param GitPHP_Route $a route a
         * @param GitPHP_Route $b route b
         */
        public static function CompareRoute($a, $b)
        {
                $apath = $a->GetPath();
                $bpath = $b->GetPath();
 
                $acount = substr_count($apath, ':');
                $bcount = substr_count($bpath, ':');
 
                if ($acount == $bcount) {
                        $acount2 = substr_count($apath, '/');
                        $bcount2 = substr_count($bpath, '/');
                        if ($acount2 == $bcount2)
                                return 0;
 
                        return $acount2 < $bcount2 ? 1 : -1;
                }
 
                return $acount < $bcount ? 1 : -1;
        }
 
}