<?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_Json

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

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

 * @version    $Id: Server.php 22237 2010-05-21 23:58:00Z andyfowler $

 */

/**

 * @see Zend_Server_Abstract

 */

require_once 'Zend/Server/Abstract.php';

/**

 * @category   Zend

 * @package    Zend_Json

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

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

 */

class Zend_Json_Server extends Zend_Server_Abstract

{

    /**#@+

     * Version Constants

     */

    const VERSION_1 = '1.0';

    const VERSION_2 = '2.0';

    /**#@-*/

    /**

     * Flag: whether or not to auto-emit the response

     * @var bool

     */

    protected $_autoEmitResponse = true;

    /**

     * @var bool Flag; allow overwriting existing methods when creating server definition

     */

    protected $_overwriteExistingMethods = true;

    /**

     * Request object

     * @var Zend_Json_Server_Request

     */

    protected $_request;

    /**

     * Response object

     * @var Zend_Json_Server_Response

     */

    protected $_response;

    /**

     * SMD object

     * @var Zend_Json_Server_Smd

     */

    protected $_serviceMap;

    /**

     * SMD class accessors

     * @var array

     */

    protected $_smdMethods;

    /**

     * @var Zend_Server_Description

     */

    protected $_table;

    /**

     * Attach a function or callback to the server

     *

     * @param  string|array $function Valid PHP callback

     * @param  string $namespace  Ignored

     * @return Zend_Json_Server

     */

    public function addFunction($function, $namespace = '')

    {

        if (!is_string($function) && (!is_array($function) || (2 > count($function)))) {

            require_once 'Zend/Json/Server/Exception.php';

            throw new Zend_Json_Server_Exception('Unable to attach function; invalid');

        }

        if (!is_callable($function)) {

            require_once 'Zend/Json/Server/Exception.php';

            throw new Zend_Json_Server_Exception('Unable to attach function; does not exist');

        }

        $argv = null;

        if (2 < func_num_args()) {

            $argv = func_get_args();

            $argv = array_slice($argv, 2);

        }

        require_once 'Zend/Server/Reflection.php';

        if (is_string($function)) {

            $method = Zend_Server_Reflection::reflectFunction($function, $argv, $namespace);

        } else {

            $class  = array_shift($function);

            $action = array_shift($function);

            $reflection = Zend_Server_Reflection::reflectClass($class, $argv, $namespace);

            $methods = $reflection->getMethods();

            $found   = false;

            foreach ($methods as $method) {

                if ($action == $method->getName()) {

                    $found = true;

                    break;

                }

            }

            if (!$found) {

                $this->fault('Method not found', -32601);

                return $this;

            }

        }

        $definition = $this->_buildSignature($method);

        $this->_addMethodServiceMap($definition);

        return $this;

    }

    /**

     * Register a class with the server

     *

     * @param  string $class

     * @param  string $namespace Ignored

     * @param  mixed $argv Ignored

     * @return Zend_Json_Server

     */

    public function setClass($class, $namespace = '', $argv = null)

    {

        $argv = null;

        if (3 < func_num_args()) {

            $argv = func_get_args();

            $argv = array_slice($argv, 3);

        }

        require_once 'Zend/Server/Reflection.php';

        $reflection = Zend_Server_Reflection::reflectClass($class, $argv, $namespace);

        foreach ($reflection->getMethods() as $method) {

            $definition = $this->_buildSignature($method, $class);

            $this->_addMethodServiceMap($definition);

        }

        return $this;

    }

    /**

     * Indicate fault response

     *

     * @param  string $fault

     * @param  int $code

     * @return false

     */

    public function fault($fault = null, $code = 404, $data = null)

    {

        require_once 'Zend/Json/Server/Error.php';

        $error = new Zend_Json_Server_Error($fault, $code, $data);

        $this->getResponse()->setError($error);

        return $error;

    }

    /**

     * Handle request

     *

     * @param  Zend_Json_Server_Request $request

     * @return null|Zend_Json_Server_Response

     */

    public function handle($request = false)

    {

        if ((false !== $request) && (!$request instanceof Zend_Json_Server_Request)) {

            require_once 'Zend/Json/Server/Exception.php';

            throw new Zend_Json_Server_Exception('Invalid request type provided; cannot handle');

        } elseif ($request) {

            $this->setRequest($request);

        }

        // Handle request

        $this->_handle();

        // Get response

        $response = $this->_getReadyResponse();

        // Emit response?

        if ($this->autoEmitResponse()) {

            echo $response;

            return;

        }

        // or return it?

        return $response;

    }

    /**

     * Load function definitions

     *

     * @param  array|Zend_Server_Definition $definition

     * @return void

     */

    public function loadFunctions($definition)

    {

        if (!is_array($definition) && (!$definition instanceof Zend_Server_Definition)) {

            require_once 'Zend/Json/Server/Exception.php';

            throw new Zend_Json_Server_Exception('Invalid definition provided to loadFunctions()');

        }

        foreach ($definition as $key => $method) {

            $this->_table->addMethod($method, $key);

            $this->_addMethodServiceMap($method);

        }

    }

    public function setPersistence($mode)

    {

    }

    /**

     * Set request object

     *

     * @param  Zend_Json_Server_Request $request

     * @return Zend_Json_Server

     */

    public function setRequest(Zend_Json_Server_Request $request)

    {

        $this->_request = $request;

        return $this;

    }

    /**

     * Get JSON-RPC request object

     *

     * @return Zend_Json_Server_Request

     */

    public function getRequest()

    {

        if (null === ($request = $this->_request)) {

            require_once 'Zend/Json/Server/Request/Http.php';

            $this->setRequest(new Zend_Json_Server_Request_Http());

        }

        return $this->_request;

    }

    /**

     * Set response object

     *

     * @param  Zend_Json_Server_Response $response

     * @return Zend_Json_Server

     */

    public function setResponse(Zend_Json_Server_Response $response)

    {

        $this->_response = $response;

        return $this;

    }

    /**

     * Get response object

     *

     * @return Zend_Json_Server_Response

     */

    public function getResponse()

    {

        if (null === ($response = $this->_response)) {

            require_once 'Zend/Json/Server/Response/Http.php';

            $this->setResponse(new Zend_Json_Server_Response_Http());

        }

        return $this->_response;

    }

    /**

     * Set flag indicating whether or not to auto-emit response

     *

     * @param  bool $flag

     * @return Zend_Json_Server

     */

    public function setAutoEmitResponse($flag)

    {

        $this->_autoEmitResponse = (bool) $flag;

        return $this;

    }

    /**

     * Will we auto-emit the response?

     *

     * @return bool

     */

    public function autoEmitResponse()

    {

        return $this->_autoEmitResponse;

    }

    // overloading for SMD metadata

    /**

     * Overload to accessors of SMD object

     *

     * @param  string $method

     * @param  array $args

     * @return mixed

     */

    public function __call($method, $args)

    {

        if (preg_match('/^(set|get)/', $method, $matches)) {

            if (in_array($method, $this->_getSmdMethods())) {

                if ('set' == $matches[1]) {

                    $value = array_shift($args);

                    $this->getServiceMap()->$method($value);

                    return $this;

                } else {

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

                }

            }

        }

        return null;

    }

    /**

     * Retrieve SMD object

     *

     * @return Zend_Json_Server_Smd

     */

    public function getServiceMap()

    {

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

            require_once 'Zend/Json/Server/Smd.php';

            $this->_serviceMap = new Zend_Json_Server_Smd();

        }

        return $this->_serviceMap;

    }

    /**

     * Add service method to service map

     *

     * @param  Zend_Server_Reflection_Function $method

     * @return void

     */

    protected function _addMethodServiceMap(Zend_Server_Method_Definition $method)

    {

        $serviceInfo = array(

            'name'   => $method->getName(),

            'return' => $this->_getReturnType($method),

        );

        $params = $this->_getParams($method);

        $serviceInfo['params'] = $params;

        $serviceMap = $this->getServiceMap();

        if (false !== $serviceMap->getService($serviceInfo['name'])) {

            $serviceMap->removeService($serviceInfo['name']);

        }

        $serviceMap->addService($serviceInfo);

    }

    /**

     * Translate PHP type to JSON type

     *

     * @param  string $type

     * @return string

     */

    protected function _fixType($type)

    {

        return $type;

    }

    /**

     * Get default params from signature

     *

     * @param  array $args

     * @param  array $params

     * @return array

     */

    protected function _getDefaultParams(array $args, array $params)

    {

        $defaultParams = array_slice($params, count($args));

        foreach ($defaultParams as $param) {

            $value = null;

            if (array_key_exists('default', $param)) {

                $value = $param['default'];

            }

            array_push($args, $value);

        }

        return $args;

    }

    /**

     * Get method param type

     *

     * @param  Zend_Server_Reflection_Function_Abstract $method

     * @return string|array

     */

    protected function _getParams(Zend_Server_Method_Definition $method)

    {

        $params = array();

        foreach ($method->getPrototypes() as $prototype) {

            foreach ($prototype->getParameterObjects() as $key => $parameter) {

                if (!isset($params[$key])) {

                    $params[$key] = array(

                        'type'     => $parameter->getType(),

                        'name'     => $parameter->getName(),

                        'optional' => $parameter->isOptional(),

                    );

                    if (null !== ($default = $parameter->getDefaultValue())) {

                        $params[$key]['default'] = $default;

                    }

                    $description = $parameter->getDescription();

                    if (!empty($description)) {

                        $params[$key]['description'] = $description;

                    }

                    continue;

                }

                $newType = $parameter->getType();

                if (!is_array($params[$key]['type'])) {

                    if ($params[$key]['type'] == $newType) {

                        continue;

                    }

                    $params[$key]['type'] = (array) $params[$key]['type'];

                } elseif (in_array($newType, $params[$key]['type'])) {

                    continue;

                }

                array_push($params[$key]['type'], $parameter->getType());

            }

        }

        return $params;

    }

    /**

     * Set response state

     *

     * @return Zend_Json_Server_Response

     */

    protected function _getReadyResponse()

    {

        $request  = $this->getRequest();

        $response = $this->getResponse();