<?php

/**

 * IRI parser/serialiser/normaliser

 *

 * @package Requests\Utilities

 */

namespace WpOrg\Requests;

use WpOrg\Requests\Exception;

use WpOrg\Requests\Exception\InvalidArgument;

use WpOrg\Requests\Ipv6;

use WpOrg\Requests\Port;

use WpOrg\Requests\Utility\InputValidator;

/**

 * IRI parser/serialiser/normaliser

 *

 * Copyright (c) 2007-2010, Geoffrey Sneddon and Steve Minutillo.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 *  * Redistributions of source code must retain the above copyright notice,

 *       this list of conditions and the following disclaimer.

 *

 *  * Redistributions in binary form must reproduce the above copyright notice,

 *       this list of conditions and the following disclaimer in the documentation

 *       and/or other materials provided with the distribution.

 *

 *  * Neither the name of the SimplePie Team nor the names of its contributors

 *       may be used to endorse or promote products derived from this software

 *       without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 *

 * @package Requests\Utilities

 * @author Geoffrey Sneddon

 * @author Steve Minutillo

 * @copyright 2007-2009 Geoffrey Sneddon and Steve Minutillo

 * @license https://opensource.org/licenses/bsd-license.php

 * @link http://hg.gsnedders.com/iri/

 *

 * @property string $iri IRI we're working with

 * @property-read string $uri IRI in URI form, {@see \WpOrg\Requests\Iri::to_uri()}

 * @property string $scheme Scheme part of the IRI

 * @property string $authority Authority part, formatted for a URI (userinfo + host + port)

 * @property string $iauthority Authority part of the IRI (userinfo + host + port)

 * @property string $userinfo Userinfo part, formatted for a URI (after '://' and before '@')

 * @property string $iuserinfo Userinfo part of the IRI (after '://' and before '@')

 * @property string $host Host part, formatted for a URI

 * @property string $ihost Host part of the IRI

 * @property string $port Port part of the IRI (after ':')

 * @property string $path Path part, formatted for a URI (after first '/')

 * @property string $ipath Path part of the IRI (after first '/')

 * @property string $query Query part, formatted for a URI (after '?')

 * @property string $iquery Query part of the IRI (after '?')

 * @property string $fragment Fragment, formatted for a URI (after '#')

 * @property string $ifragment Fragment part of the IRI (after '#')

 */

class Iri {

	/**

	 * Scheme

	 *

	 * @var string|null

	 */

	protected $scheme = null;

	/**

	 * User Information

	 *

	 * @var string|null

	 */

	protected $iuserinfo = null;

	/**

	 * ihost

	 *

	 * @var string|null

	 */

	protected $ihost = null;

	/**

	 * Port

	 *

	 * @var string|null

	 */

	protected $port = null;

	/**

	 * ipath

	 *

	 * @var string

	 */

	protected $ipath = '';

	/**

	 * iquery

	 *

	 * @var string|null

	 */

	protected $iquery = null;

	/**

	 * ifragment|null

	 *

	 * @var string

	 */

	protected $ifragment = null;

	/**

	 * Normalization database

	 *

	 * Each key is the scheme, each value is an array with each key as the IRI

	 * part and value as the default value for that part.

	 *

	 * @var array

	 */

	protected $normalization = array(

		'acap' => array(

			'port' => Port::ACAP,

		),

		'dict' => array(

			'port' => Port::DICT,

		),

		'file' => array(

			'ihost' => 'localhost',

		),

		'http' => array(

			'port' => Port::HTTP,

		),

		'https' => array(

			'port' => Port::HTTPS,

		),

	);

	/**

	 * Return the entire IRI when you try and read the object as a string

	 *

	 * @return string

	 */

	public function __toString() {

		return $this->get_iri();

	}

	/**

	 * Overload __set() to provide access via properties

	 *

	 * @param string $name Property name

	 * @param mixed $value Property value

	 */

	public function __set($name, $value) {

		if (method_exists($this, 'set_' . $name)) {

			call_user_func(array($this, 'set_' . $name), $value);

		}

		elseif (

			   $name === 'iauthority'

			|| $name === 'iuserinfo'

			|| $name === 'ihost'

			|| $name === 'ipath'

			|| $name === 'iquery'

			|| $name === 'ifragment'

		) {

			call_user_func(array($this, 'set_' . substr($name, 1)), $value);

		}

	}

	/**

	 * Overload __get() to provide access via properties

	 *

	 * @param string $name Property name

	 * @return mixed

	 */

	public function __get($name) {

		// isset() returns false for null, we don't want to do that

		// Also why we use array_key_exists below instead of isset()

		$props = get_object_vars($this);

		if (

			$name === 'iri' ||

			$name === 'uri' ||

			$name === 'iauthority' ||

			$name === 'authority'

		) {

			$method = 'get_' . $name;

			$return = $this->$method();

		}

		elseif (array_key_exists($name, $props)) {

			$return = $this->$name;

		}

		// host -> ihost

		elseif (($prop = 'i' . $name) && array_key_exists($prop, $props)) {

			$name = $prop;

			$return = $this->$prop;

		}

		// ischeme -> scheme

		elseif (($prop = substr($name, 1)) && array_key_exists($prop, $props)) {

			$name = $prop;

			$return = $this->$prop;

		}

		else {

			trigger_error('Undefined property: ' . get_class($this) . '::' . $name, E_USER_NOTICE);

			$return = null;

		}

		if ($return === null && isset($this->normalization[$this->scheme][$name])) {

			return $this->normalization[$this->scheme][$name];

		}

		else {

			return $return;

		}

	}

	/**

	 * Overload __isset() to provide access via properties

	 *

	 * @param string $name Property name

	 * @return bool

	 */

	public function __isset($name) {

		return (method_exists($this, 'get_' . $name) || isset($this->$name));

	}

	/**

	 * Overload __unset() to provide access via properties

	 *

	 * @param string $name Property name

	 */

	public function __unset($name) {

		if (method_exists($this, 'set_' . $name)) {

			call_user_func(array($this, 'set_' . $name), '');

		}

	}

	/**

	 * Create a new IRI object, from a specified string

	 *

	 * @param string|Stringable|null $iri

	 *

	 * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $iri argument is not a string, Stringable or null.

	 */

	public function __construct($iri = null) {

		if ($iri !== null && InputValidator::is_string_or_stringable($iri) === false) {

			throw InvalidArgument::create(1, '$iri', 'string|Stringable|null', gettype($iri));

		}

		$this->set_iri($iri);

	}

	/**

	 * Create a new IRI object by resolving a relative IRI

	 *

	 * Returns false if $base is not absolute, otherwise an IRI.

	 *

	 * @param \WpOrg\Requests\Iri|string $base (Absolute) Base IRI

	 * @param \WpOrg\Requests\Iri|string $relative Relative IRI

	 * @return \WpOrg\Requests\Iri|false

	 */

	public static function absolutize($base, $relative) {

		if (!($relative instanceof self)) {

			$relative = new self($relative);

		}

		if (!$relative->is_valid()) {

			return false;

		}

		elseif ($relative->scheme !== null) {

			return clone $relative;

		}

		if (!($base instanceof self)) {

			$base = new self($base);

		}

		if ($base->scheme === null || !$base->is_valid()) {

			return false;

		}

		if ($relative->get_iri() !== '') {

			if ($relative->iuserinfo !== null || $relative->ihost !== null || $relative->port !== null) {

				$target = clone $relative;

				$target->scheme = $base->scheme;

			}

			else {

				$target = new self;

				$target->scheme = $base->scheme;

				$target->iuserinfo = $base->iuserinfo;

				$target->ihost = $base->ihost;

				$target->port = $base->port;

				if ($relative->ipath !== '') {

					if ($relative->ipath[0] === '/') {

						$target->ipath = $relative->ipath;

					}

					elseif (($base->iuserinfo !== null || $base->ihost !== null || $base->port !== null) && $base->ipath === '') {

						$target->ipath = '/' . $relative->ipath;

					}

					elseif (($last_segment = strrpos($base->ipath, '/')) !== false) {

						$target->ipath = substr($base->ipath, 0, $last_segment + 1) . $relative->ipath;

					}

					else {

						$target->ipath = $relative->ipath;

					}

					$target->ipath = $target->remove_dot_segments($target->ipath);

					$target->iquery = $relative->iquery;

				}

				else {

					$target->ipath = $base->ipath;

					if ($relative->iquery !== null) {

						$target->iquery = $relative->iquery;

					}

					elseif ($base->iquery !== null) {

						$target->iquery = $base->iquery;

					}

				}

				$target->ifragment = $relative->ifragment;

			}

		}

		else {

			$target = clone $base;

			$target->ifragment = null;

		}

		$target->scheme_normalization();

		return $target;

	}

	/**

	 * Parse an IRI into scheme/authority/path/query/fragment segments

	 *

	 * @param string $iri

	 * @return array

	 */

	protected function parse_iri($iri) {

		$iri = trim($iri, "\x20\x09\x0A\x0C\x0D");

		$has_match = preg_match('/^((?P<scheme>[^:\/?#]+):)?(\/\/(?P<authority>[^\/?#]*))?(?P<path>[^?#]*)(\?(?P<query>[^#]*))?(#(?P<fragment>.*))?$/', $iri, $match);

		if (!$has_match) {

			throw new Exception('Cannot parse supplied IRI', 'iri.cannot_parse', $iri);

		}

		if ($match[1] === '') {

			$match['scheme'] = null;

		}

		if (!isset($match[3]) || $match[3] === '') {

			$match['authority'] = null;

		}

		if (!isset($match[5])) {

			$match['path'] = '';

		}

		if (!isset($match[6]) || $match[6] === '') {

			$match['query'] = null;

		}

		if (!isset($match[8]) || $match[8] === '') {

			$match['fragment'] = null;

		}

		return $match;

	}

	/**

	 * Remove dot segments from a path

	 *

	 * @param string $input

	 * @return string

	 */

	protected function remove_dot_segments($input) {

		$output = '';

		while (strpos($input, './') !== false || strpos($input, '/.') !== false || $input === '.' || $input === '..') {

			// A: If the input buffer begins with a prefix of "../" or "./",

			// then remove that prefix from the input buffer; otherwise,

			if (strpos($input, '../') === 0) {

				$input = substr($input, 3);

			}

			elseif (strpos($input, './') === 0) {

				$input = substr($input, 2);

			}

			// B: if the input buffer begins with a prefix of "/./" or "/.",

			// where "." is a complete path segment, then replace that prefix

			// with "/" in the input buffer; otherwise,

			elseif (strpos($input, '/./') === 0) {

				$input = substr($input, 2);

			}

			elseif ($input === '/.') {

				$input = '/';

			}

			// C: if the input buffer begins with a prefix of "/../" or "/..",

			// where ".." is a complete path segment, then replace that prefix

			// with "/" in the input buffer and remove the last segment and its

			// preceding "/" (if any) from the output buffer; otherwise,

			elseif (strpos($input, '/../') === 0) {

				$input = substr($input, 3);

				$output = substr_replace($output, '', (strrpos($output, '/') ?: 0));

			}

			elseif ($input === '/..') {

				$input = '/';

				$output = substr_replace($output, '', (strrpos($output, '/') ?: 0));

			}

			// D: if the input buffer consists only of "." or "..", then remove

			// that from the input buffer; otherwise,

			elseif ($input === '.' || $input === '..') {

				$input = '';

			}

			// E: move the first path segment in the input buffer to the end of

			// the output buffer, including the initial "/" character (if any)

			// and any subsequent characters up to, but not including, the next

			// "/" character or the end of the input buffer

			elseif (($pos = strpos($input, '/', 1)) !== false) {

				$output .= substr($input, 0, $pos);

				$input = substr_replace($input, '', 0, $pos);

			}

			else {

				$output .= $input;

				$input = '';

			}

		}

		return $output . $input;

	}

	/**

	 * Replace invalid character with percent encoding

	 *

	 * @param string $text Input string

	 * @param string $extra_chars Valid characters not in iunreserved or

	 *                            iprivate (this is ASCII-only)