<?php

/**

 * Zend Framework

 *

 * LICENSE

 *

 * This source file is subject to the new BSD license that is bundled

 * with this package in the file LICENSE.txt.

 * It is also available through the world-wide-web at this URL:

 * http://framework.zend.com/license/new-bsd

 * If you did not receive a copy of the license and are unable to

 * obtain it through the world-wide-web, please send an email

 * to license@zend.com so we can send you a copy immediately.

 *

 * @category   Zend

 * @package    Zend_Http_UserAgent

 * @subpackage UserAgent

 * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)

 * @license    http://framework.zend.com/license/new-bsd     New BSD License

 */

/**

 * Lists of User Agent chains for testing :

 *

 * - http://www.useragentstring.com/layout/useragentstring.php

 * - http://user-agent-string.info/list-of-ua

 * - http://www.user-agents.org/allagents.xml

 * - http://en.wikipedia.org/wiki/List_of_user_agents_for_mobile_phones

 * - http://www.mobilemultimedia.be/fr/

 *

 * @category   Zend

 * @package    Zend_Http_UserAgent

 * @subpackage UserAgent

 * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)

 * @license    http://framework.zend.com/license/new-bsd     New BSD License

 */

class Zend_Http_UserAgent implements Serializable

{

    /**

     * 'desktop' by default if the sequence return false for each item or is empty

     */

    const DEFAULT_IDENTIFICATION_SEQUENCE = 'mobile,desktop';

    /**

     * Default persitent storage adapter : Session or NonPersitent

     */

    const DEFAULT_PERSISTENT_STORAGE_ADAPTER = 'Session';

    /**

     * 'desktop' by default if the sequence return false for each item

     */

    const DEFAULT_BROWSER_TYPE = 'desktop';

    /**

     * Default User Agent chain to prevent empty value

     */

    const DEFAULT_HTTP_USER_AGENT = 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)';

    /**

     * Default Http Accept param to prevent empty value

     */

    const DEFAULT_HTTP_ACCEPT = "application/xhtml+xml";

    /**

     * Default markup language

     */

    const DEFAULT_MARKUP_LANGUAGE = "xhtml";

    /**

     * Browser type

     *

     * @var string

     */

    protected $_browserType;

    /**

     * Browser type class

     *

     * Map of browser types to classes.

     *

     * @var array

     */

    protected $_browserTypeClass = array();

    /**

     * Array to store config

     *

     * Default values are provided to ensure specific keys are present at

     * instantiation.

     *

     * @var array

     */

    protected $_config = array(

        'identification_sequence' => self::DEFAULT_IDENTIFICATION_SEQUENCE,

        'storage'                 => array(

            'adapter'             => self::DEFAULT_PERSISTENT_STORAGE_ADAPTER,

        ),

    );

    /**

     * Identified device

     *

     * @var Zend_Http_UserAgent_Device

     */

    protected $_device;

    /**

     * Whether or not this instance is immutable.

     *

     * If true, none of the following may be modified:

     * - $_server

     * - $_browserType

     * - User-Agent (defined in $_server)

     * - HTTP Accept value (defined in $_server)

     * - $_storage

     *

     * @var bool

     */

    protected $_immutable = false;

    /**

     * Plugin loaders

     * @var array

     */

    protected $_loaders = array();

    /**

     * Valid plugin loader types

     * @var array

     */

    protected $_loaderTypes = array('storage', 'device');

    /**

     * Trace of items matched to identify the browser type

     *

     * @var array

     */

    protected $_matchLog = array();

    /**

     * Server variable

     *

     * @var array

     */

    protected $_server;

    /**

     * Persistent storage handler

     *

     * @var Zend_Http_UserAgent_Storage

     */

    protected $_storage;

    /**

     * Constructor

     *

     * @param  null|array|Zend_Config|ArrayAccess $options

     * @return void

     */

    public function __construct($options = null)

    {

        if (null !== $options) {

            $this->setOptions($options);

        }

    }

    /**

     * Serialized representation of the object

     *

     * @return string

     */

    public function serialize()

    {

        $device = $this->getDevice();

        $spec = array(

            'browser_type' => $this->_browserType,

            'config'       => $this->_config,

            'device_class' => get_class($device),

            'device'       => $device->serialize(),

            'user_agent'   => $this->getServerValue('http_user_agent'),

            'http_accept'  => $this->getServerValue('http_accept'),

        );

        return serialize($spec);

    }

    /**

     * Unserialize a previous representation of the object

     *

     * @param  string $serialized

     * @return void

     */

    public function unserialize($serialized)

    {

        $spec = unserialize($serialized);

        $this->setOptions($spec);

        // Determine device class and ensure the class is loaded

        $deviceClass          = $spec['device_class'];

        if (!class_exists($deviceClass)) {

            $this->_getUserAgentDevice($this->getBrowserType());

        }

        // Get device specification and instantiate

        $deviceSpec            = unserialize($spec['device']);

        $deviceSpec['_config'] = $this->getConfig();

        $deviceSpec['_server'] = $this->getServer();

        $this->_device = new $deviceClass($deviceSpec);

    }

    /**

     * Configure instance

     *

     * @param  array|Zend_Config|ArrayAccess $options

     * @return Zend_Http_UserAgent

     */

    public function setOptions($options)

    {

        if ($options instanceof Zend_Config) {

            $options = $options->toArray();

        }

        if (!is_array($options)

            && !$options instanceof ArrayAccess

            && !$options instanceof Traversable

        ) {

            require_once 'Zend/Http/UserAgent/Exception.php';

            throw new Zend_Http_UserAgent_Exception(sprintf(

                'Invalid argument; expected array, Zend_Config object, or object implementing ArrayAccess and Traversable; received %s',

                (is_object($options) ? get_class($options) : gettype($options))

            ));

        }

        // Set $_SERVER first

        if (isset($options['server'])) {

            $this->setServer($options['server']);

            unset($options['server']);

        }

        // Get plugin loaders sorted

        if (isset($options['plugin_loader'])) {

            $plConfig = $options['plugin_loader'];

            if (is_array($plConfig) || $plConfig instanceof Traversable) {

                foreach ($plConfig as $type => $class) {

                    $this->setPluginLoader($type, $class);

                }

            }

            unset($plConfig, $options['plugin_loader']);

        }

        // And then loop through the remaining options

        $config = array();

        foreach ($options as $key => $value) {

            switch (strtolower($key)) {

                case 'browser_type':

                    $this->setBrowserType($value);

                    break;

                case 'http_accept':

                    $this->setHttpAccept($value);

                    break;

                case 'user_agent':

                    $this->setUserAgent($value);

                    break;

                default:

                    // Cache remaining options for $_config

                    $config[$key] = $value;

                    break;

            }

        }

        $this->setConfig($config);

        return $this;

    }

    /**

     * Comparison of the UserAgent chain and browser signatures.

     *

     * The comparison is case-insensitive : the browser signatures must be in lower

     * case

     *

     * @param  string $deviceClass Name of class against which a match will be attempted

     * @return bool

     */

    protected function _match($deviceClass)

    {

        // Validate device class

        $r = new ReflectionClass($deviceClass);

        if (!$r->implementsInterface('Zend_Http_UserAgent_Device')) {

            throw new Zend_Http_UserAgent_Exception(sprintf(

                'Invalid device class provided ("%s"); must implement Zend_Http_UserAgent_Device',

                $deviceClass

            ));

        }

        $userAgent = $this->getUserAgent();

        // Call match method on device class

        return call_user_func(

            array($deviceClass, 'match'),

            $userAgent,

            $this->getServer()

        );

    }

    /**

     * Loads class for a user agent device

     *

     * @param  string $browserType Browser type

     * @return string

     * @throws Zend_Loader_PluginLoader_Exception if unable to load UA device

     */

    protected function _getUserAgentDevice($browserType)

    {

        $browserType = strtolower($browserType);

        if (isset($this->_browserTypeClass[$browserType])) {

            return $this->_browserTypeClass[$browserType];

        }

        if (isset($this->_config[$browserType])

            && isset($this->_config[$browserType]['device'])

        ) {

            $deviceConfig = $this->_config[$browserType]['device'];

            if (is_array($deviceConfig) && isset($deviceConfig['classname'])) {

                $device = (string) $deviceConfig['classname'];

                if (!class_exists($device)) {

                    require_once 'Zend/Http/UserAgent/Exception.php';

                    throw new Zend_Http_UserAgent_Exception(sprintf(

                        'Invalid classname "%s" provided in device configuration for browser type "%s"',

                        $device,

                        $browserType

                    ));

                }

            } elseif (is_array($deviceConfig) && isset($deviceConfig['path'])) {

                $loader = $this->getPluginLoader('device');

                $path   = $deviceConfig['path'];

                $prefix = isset($deviceConfig['prefix']) ? $deviceConfig['prefix'] : 'Zend_Http_UserAgent';

                $loader->addPrefixPath($prefix, $path);

                $device = $loader->load($browserType);

            } else {

                $loader = $this->getPluginLoader('device');

                $device = $loader->load($browserType);

            }

        } else {

            $loader = $this->getPluginLoader('device');

            $device = $loader->load($browserType);

        }

        $this->_browserTypeClass[$browserType] = $device;

        return $device;

    }

    /**

     * Returns the User Agent value

     *

     * If $userAgent param is null, the value of $_server['HTTP_USER_AGENT'] is

     * returned.

     *

     * @return string

     */

    public function getUserAgent()

    {

        if (null === ($ua = $this->getServerValue('http_user_agent'))) {

            $ua = self::DEFAULT_HTTP_USER_AGENT;

            $this->setUserAgent($ua);

        }

        return $ua;

    }

    /**

     * Force or replace the UA chain in $_server variable

     *

     * @param  string $userAgent Forced UserAgent chain

     * @return Zend_Http_UserAgent

     */

    public function setUserAgent($userAgent)

    {

        $this->setServerValue('http_user_agent', $userAgent);

        return $this;

    }

    /**

     * Returns the HTTP Accept server param

     *

     * @param  string $httpAccept (option) forced HTTP Accept chain

     * @return string

     */

    public function getHttpAccept($httpAccept = null)

    {

        if (null === ($accept = $this->getServerValue('http_accept'))) {

            $accept = self::DEFAULT_HTTP_ACCEPT;

            $this->setHttpAccept($accept);

        }

        return $accept;

    }

    /**

     * Force or replace the HTTP_ACCEPT chain in self::$_server variable

     *

     * @param  string $httpAccept Forced HTTP Accept chain

     * @return Zend_Http_UserAgent

     */

    public function setHttpAccept($httpAccept)

    {

        $this->setServerValue('http_accept', $httpAccept);

        return $this;

    }

    /**

     * Returns the persistent storage handler

     *

     * Session storage is used by default unless a different storage adapter

     * has been set via the "persistent_storage_adapter" key. That key should

     * contain either a fully qualified class name, or a short name that

     * resolves via the plugin loader.

     *

     * @param  string $browser Browser identifier (User Agent chain)

     * @return Zend_Http_UserAgent_Storage

     */

    public function getStorage($browser = null)

    {

        if (null === $browser) {

            $browser = $this->getUserAgent();

        }

        if (null === $this->_storage) {

            $config  = $this->_config['storage'];

            $adapter = $config['adapter'];

            if (!class_exists($adapter)) {

                $loader = $this->getPluginLoader('storage');

                $adapter = $loader->load($adapter);

                $loader = $this->getPluginLoader('storage');

            }

            $options = array('browser_type' => $browser);

            if (isset($config['options'])) {

                $options = array_merge($options, $config['options']);

            }

            $this->setStorage(new $adapter($options));

        }

        return $this->_storage;

    }

    /**