<?php

/*

 * This file is part of the Symfony package.

 *

 * (c) Fabien Potencier <fabien@symfony.com>

 *

 * For the full copyright and license information, please view the LICENSE

 * file that was distributed with this source code.

 */

namespace Symfony\Component\HttpFoundation;

use Symfony\Component\HttpFoundation\SessionStorage\NativeSessionStorage;

/**

 * Request represents an HTTP request.

 *

 * @author Fabien Potencier <fabien@symfony.com>

 *

 * @api

 */

class Request

{

    static protected $trustProxy = false;

    /**

     * @var \Symfony\Component\HttpFoundation\ParameterBag

     *

     * @api

     */

    public $attributes;

    /**

     * @var \Symfony\Component\HttpFoundation\ParameterBag

     *

     * @api

     */

    public $request;

    /**

     * @var \Symfony\Component\HttpFoundation\ParameterBag

     *

     * @api

     */

    public $query;

    /**

     * @var \Symfony\Component\HttpFoundation\ParameterBag

     *

     * @api

     */

    public $server;

    /**

     * @var \Symfony\Component\HttpFoundation\ParameterBag

     *

     * @api

     */

    public $files;

    /**

     * @var \Symfony\Component\HttpFoundation\ParameterBag

     *

     * @api

     */

    public $cookies;

    /**

     * @var \Symfony\Component\HttpFoundation\HeaderBag

     *

     * @api

     */

    public $headers;

    protected $content;

    protected $languages;

    protected $charsets;

    protected $acceptableContentTypes;

    protected $pathInfo;

    protected $requestUri;

    protected $baseUrl;

    protected $basePath;

    protected $method;

    protected $format;

    protected $session;

    static protected $formats;

    /**

     * Constructor.

     *

     * @param array  $query      The GET parameters

     * @param array  $request    The POST parameters

     * @param array  $attributes The request attributes (parameters parsed from the PATH_INFO, ...)

     * @param array  $cookies    The COOKIE parameters

     * @param array  $files      The FILES parameters

     * @param array  $server     The SERVER parameters

     * @param string $content    The raw body data

     *

     * @api

     */

    public function __construct(array $query = array(), array $request = array(), array $attributes = array(), array $cookies = array(), array $files = array(), array $server = array(), $content = null)

    {

        $this->initialize($query, $request, $attributes, $cookies, $files, $server, $content);

    }

    /**

     * Sets the parameters for this request.

     *

     * This method also re-initializes all properties.

     *

     * @param array  $query      The GET parameters

     * @param array  $request    The POST parameters

     * @param array  $attributes The request attributes (parameters parsed from the PATH_INFO, ...)

     * @param array  $cookies    The COOKIE parameters

     * @param array  $files      The FILES parameters

     * @param array  $server     The SERVER parameters

     * @param string $content    The raw body data

     *

     * @api

     */

    public function initialize(array $query = array(), array $request = array(), array $attributes = array(), array $cookies = array(), array $files = array(), array $server = array(), $content = null)

    {

        $this->request = new ParameterBag($request);

        $this->query = new ParameterBag($query);

        $this->attributes = new ParameterBag($attributes);

        $this->cookies = new ParameterBag($cookies);

        $this->files = new FileBag($files);

        $this->server = new ServerBag($server);

        $this->headers = new HeaderBag($this->server->getHeaders());

        $this->content = $content;

        $this->languages = null;

        $this->charsets = null;

        $this->acceptableContentTypes = null;

        $this->pathInfo = null;

        $this->requestUri = null;

        $this->baseUrl = null;

        $this->basePath = null;

        $this->method = null;

        $this->format = null;

    }

    /**

     * Creates a new request with values from PHP's super globals.

     *

     * @return Request A new request

     *

     * @api

     */

    static public function createFromGlobals()

    {

        $request = new static($_GET, $_POST, array(), $_COOKIE, $_FILES, $_SERVER);

        if (0 === strpos($request->server->get('CONTENT_TYPE'), 'application/x-www-form-urlencoded')

            && in_array(strtoupper($request->server->get('REQUEST_METHOD', 'GET')), array('PUT', 'DELETE'))

        ) {

            parse_str($request->getContent(), $data);

            $request->request = new ParameterBag($data);

        }

        return $request;

    }

    /**

     * Creates a Request based on a given URI and configuration.

     *

     * @param string $uri        The URI

     * @param string $method     The HTTP method

     * @param array  $parameters The request (GET) or query (POST) parameters

     * @param array  $cookies    The request cookies ($_COOKIE)

     * @param array  $files      The request files ($_FILES)

     * @param array  $server     The server parameters ($_SERVER)

     * @param string $content    The raw body data

     *

     * @return Request A Request instance

     *

     * @api

     */

    static public function create($uri, $method = 'GET', $parameters = array(), $cookies = array(), $files = array(), $server = array(), $content = null)

    {

        $defaults = array(

            'SERVER_NAME'          => 'localhost',

            'SERVER_PORT'          => 80,

            'HTTP_HOST'            => 'localhost',

            'HTTP_USER_AGENT'      => 'Symfony/2.X',

            'HTTP_ACCEPT'          => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',

            'HTTP_ACCEPT_LANGUAGE' => 'en-us,en;q=0.5',

            'HTTP_ACCEPT_CHARSET'  => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',

            'REMOTE_ADDR'          => '127.0.0.1',

            'SCRIPT_NAME'          => '',

            'SCRIPT_FILENAME'      => '',

            'SERVER_PROTOCOL'      => 'HTTP/1.1',

            'REQUEST_TIME'         => time(),

        );

        $components = parse_url($uri);

        if (isset($components['host'])) {

            $defaults['SERVER_NAME'] = $components['host'];

            $defaults['HTTP_HOST'] = $components['host'];

        }

        if (isset($components['scheme'])) {

            if ('https' === $components['scheme']) {

                $defaults['HTTPS'] = 'on';

                $defaults['SERVER_PORT'] = 443;

            }

        }

        if (isset($components['port'])) {

            $defaults['SERVER_PORT'] = $components['port'];

            $defaults['HTTP_HOST'] = $defaults['HTTP_HOST'].':'.$components['port'];

        }

        if (!isset($components['path'])) {

            $components['path'] = '';

        }

        if (in_array(strtoupper($method), array('POST', 'PUT', 'DELETE'))) {

            $request = $parameters;

            $query = array();

            $defaults['CONTENT_TYPE'] = 'application/x-www-form-urlencoded';

        } else {

            $request = array();

            $query = $parameters;

            if (false !== $pos = strpos($uri, '?')) {

                $qs = substr($uri, $pos + 1);

                parse_str($qs, $params);

                $query = array_merge($params, $query);

            }

        }

        $queryString = isset($components['query']) ? html_entity_decode($components['query']) : '';

        parse_str($queryString, $qs);

        if (is_array($qs)) {

            $query = array_replace($qs, $query);

        }

        $uri = $components['path'].($queryString ? '?'.$queryString : '');

        $server = array_replace($defaults, $server, array(

            'REQUEST_METHOD'       => strtoupper($method),

            'PATH_INFO'            => '',

            'REQUEST_URI'          => $uri,

            'QUERY_STRING'         => $queryString,

        ));

        return new static($query, $request, array(), $cookies, $files, $server, $content);

    }

    /**

     * Clones a request and overrides some of its parameters.

     *

     * @param array $query      The GET parameters

     * @param array $request    The POST parameters

     * @param array $attributes The request attributes (parameters parsed from the PATH_INFO, ...)

     * @param array $cookies    The COOKIE parameters

     * @param array $files      The FILES parameters

     * @param array $server     The SERVER parameters

     *

     * @api

     */

    public function duplicate(array $query = null, array $request = null, array $attributes = null, array $cookies = null, array $files = null, array $server = null)

    {

        $dup = clone $this;

        if ($query !== null) {

            $dup->query = new ParameterBag($query);

        }

        if ($request !== null) {

            $dup->request = new ParameterBag($request);

        }

        if ($attributes !== null) {

            $dup->attributes = new ParameterBag($attributes);

        }

        if ($cookies !== null) {

            $dup->cookies = new ParameterBag($cookies);

        }

        if ($files !== null) {

            $dup->files = new FileBag($files);

        }

        if ($server !== null) {

            $dup->server = new ServerBag($server);

            $dup->headers = new HeaderBag($dup->server->getHeaders());

        }

        $this->languages = null;

        $this->charsets = null;

        $this->acceptableContentTypes = null;

        $this->pathInfo = null;

        $this->requestUri = null;

        $this->baseUrl = null;

        $this->basePath = null;

        $this->method = null;

        $this->format = null;

        return $dup;

    }

    /**

     * Clones the current request.

     *

     * Note that the session is not cloned as duplicated requests

     * are most of the time sub-requests of the main one.

     */

    public function __clone()

    {

        $this->query      = clone $this->query;

        $this->request    = clone $this->request;

        $this->attributes = clone $this->attributes;

        $this->cookies    = clone $this->cookies;

        $this->files      = clone $this->files;

        $this->server     = clone $this->server;

        $this->headers    = clone $this->headers;

    }

    /**

     * Returns the request as a string.

     *

     * @return string The request

     */

    public function __toString()

    {

        return

            sprintf('%s %s %s', $this->getMethod(), $this->getRequestUri(), $this->server->get('SERVER_PROTOCOL'))."\r\n".

            $this->headers."\r\n".

            $this->getContent();

    }

    /**

     * Overrides the PHP global variables according to this request instance.

     *

     * It overrides $_GET, $_POST, $_REQUEST, $_SERVER, $_COOKIE, and $_FILES.

     *

     * @api

     */

    public function overrideGlobals()

    {

        $_GET = $this->query->all();

        $_POST = $this->request->all();

        $_SERVER = $this->server->all();

        $_COOKIE = $this->cookies->all();

        // FIXME: populate $_FILES

        foreach ($this->headers->all() as $key => $value) {

            $key = strtoupper(str_replace('-', '_', $key));

            if (in_array($key, array('CONTENT_TYPE', 'CONTENT_LENGTH'))) {

                $_SERVER[$key] = implode(', ', $value);

            } else {

                $_SERVER['HTTP_'.$key] = implode(', ', $value);

            }

        }

        // FIXME: should read variables_order and request_order

        // to know which globals to merge and in which order

        $_REQUEST = array_merge($_GET, $_POST);

    }

    /**

     * Trusts $_SERVER entries coming from proxies.

     *

     * You should only call this method if your application

     * is hosted behind a reverse proxy that you manage.

     *

     * @api

     */

    static public function trustProxyData()

    {

        self::$trustProxy = true;

    }

    /**

     * Gets a "parameter" value.

     *

     * This method is mainly useful for libraries that want to provide some flexibility.

     *

     * Order of precedence: GET, PATH, POST, COOKIE

     * Avoid using this method in controllers:

     *  * slow

     *  * prefer to get from a "named" source

     *

     * @param string    $key        the key

     * @param mixed     $default    the default value

     * @param type      $deep       is parameter deep in multidimensional array

     *

     * @return mixed

     */

    public function get($key, $default = null, $deep = false)

    {

        return $this->query->get($key, $this->attributes->get($key, $this->request->get($key, $default, $deep), $deep), $deep);

    }

    /**

     * Gets the Session.

     *

     * @return Session|null The session

     *

     * @api

     */

    public function getSession()

    {

        return $this->session;

    }

    /**

     * Whether the request contains a Session which was started in one of the

     * previous requests.

     *

     * @return boolean

     *

     * @api

     */

    public function hasPreviousSession()

    {

        // the check for $this->session avoids malicious users trying to fake a session cookie with proper name

        return $this->cookies->has(session_name()) && null !== $this->session;

    }

    /**

     * Whether the request contains a Session object.

     *

     * @return boolean

     *

     * @api

     */

    public function hasSession()

    {

        return null !== $this->session;

    }