<?php
/**
 * Photobucket Service API Client
 *
 */

require_once 'Zend/Service/Abstract.php';
require_once 'Zend/Oauth.php';
require_once 'Zend/Oauth/Client.php';
require_once 'Zend/Oauth/Consumer.php';
require_once 'Zend/Oauth/Token/Access.php';
require_once 'Zend/Service/Photobucket/Oauth/Client.php';
require_once 'Zend/Service/Photobucket/Exception.php';
require_once 'Zend/Uri.php';
require_once 'Zend/Json.php';
require_once 'Zend/Service/Photobucket/Methods.php';

class Zend_Service_Photobucket extends Zend_Service_Abstract
{

    /**
     * Local HTTP Client cloned from statically set client
     * @var Zend_Http_Client
     */
    protected $_localHttpClient;

    /**
     * URI of Photobucket's REST API
     * @var      string   $api
     */
    protected static $_api_url = 'http://api.photobucket.com';

    /**
     * currently logged in username
     * @var      string   $_username
     */
    protected $_username;

    /**
     * Zend_Uri of this web service
     * @var Zend_Uri_Http
     */
    protected $_uri = null;

    /**
     * Current OAuth Token
     * @var Zend_Oauth_Token_Access
     */
    protected $_token = null;

    /**
     * response type processed by the code
     * @var string
     */
    protected $_response_type = self::RESPONSE_TYPE_JSON;

    public static $baseOauthOptions = array('requestScheme' => Zend_Oauth::REQUEST_SCHEME_HEADER,
                                            'version' => '1.0',
                                            'signatureMethod' => 'HMAC-SHA1',
                                            'requestTokenUrl' => 'http://api.photobucket.com/login/request',
                                            'accessTokenUrl' => 'http://api.photobucket.com/login/access',
                                            'userAuthorizationUrl' => 'http://photobucket.com/apilogin/login',
                                           );
    protected $_oauthOptions = array();

    const RESPONSE_TYPE_JSON = 'json';
    const RESPONSE_TYPE_XML = 'xml';
    const RESPONSE_TYPE_PHP = 'php';
    const RESPONSE_TYPE_RAW = 'raw';

    const STATUS_OK = 'OK';

    /**
     * Construct
     *
     * @param string $key API key
     * @param string $secret API secret
     *
     * @return void
     */
    public function __construct(array $oauth_opts, $token = null) {
        $this->setOauthOptions($oauth_opts);

        //automatically set up http client
        $client = new Zend_Service_Photobucket_Oauth_Client($this->getOauthOptions(),
                                                            self::$_api_url);
        $client->setConfig(array('strictredirects' => true));
        $this->setLocalHttpClient($client);

        if (!$token) $token = new Zend_Oauth_Token_Access();
        $this->setToken($token);

        $this->setUri(self::$_api_url);
    }

    public function setOauthOptions(array $opts, $no_base = false) {
        if ($no_base) $this->_oauthOptions = $opts;
        else $this->_oauthOptions = array_merge(self::$baseOauthOptions, $opts);
        if (!empty($this->_oauthOptions['appId'])) {
            $this->setAppId($this->_oauthOptions['appId']);
        }
        return $this;
    }
    public function getOauthOptions() {
        return $this->_oauthOptions;
    }
    public function getOauthConsumer() {
        return new Zend_Oauth_Consumer($this->getOauthOptions());
    }

    /**
     * setLocalHttpClient
     *
     * @param Zend_Oauth_Client $client client to use
     * @return self
     */
    public function setLocalHttpClient(Zend_Oauth_Client $client) {
        $this->_localHttpClient = $client;
        return $this;
    }

    /**
     * getLocalHttpClient
     *
     * @return Zend_Oauth_Client
     */
    public function getLocalHttpClient() {
        return $this->_localHttpClient;
    }

    /**
     * set User name
     *
     * @param string $username
     * @return self
     */
    public function setUsername($username) {
        $this->_username = $username;
        return $this;
    }

    /**
     * get User name
     *
     * @return string
     */
    public function getUsername() {
        return $this->_username;
    }

    public function setToken($token = null) {
        if ($token !== null && !($token instanceof Zend_Oauth_Token_Access)) {
            throw new Zend_Service_Photobucket_Exception('Bad Token');
        }
        $this->_token = $token;
        $this->getLocalHttpClient()->setToken($token);
        return $this;
    }

    public function getToken() {
        return $this->_token;
    }

    /**
     * Set the URI to use in the request
     *
     * @param string|Zend_Uri_Http $uri URI for the web service
     * @return Zend_Rest_Client
     */
    public function setUri($uri) {
        if ($uri instanceof Zend_Uri) {
            $this->_uri = $uri;
        } else {
            $this->_uri = Zend_Uri::factory($uri);
        }

        return $this;
    }

    /**
     * Retrieve the current request URI object
     *
     * @return Zend_Uri_Http
     */
    public function getUri() {
        return $this->_uri;
    }

    public function setResponseType($type) {
        $this->_response_type = $type;
        return $this;
    }
    public function getResponseType($override = null) {
        if ($override) return $override;
        return $this->_response_type;
    }

    /**
     * Call method
     *
     * Any formal error encountered is thrown as an exception.
     *
     * @param mixed $method HTTP Method to call
     * @param array $path   path to call
     * @param array $args   Arguments to send
     * @param bool $responeseType if json or xml, will be parsed automatically
     *
     * @return string response
     */
    public function callMethod($method, $path, $args = array(), $responseType = null) {
        $this->_prepare($path);
        $args['format'] = $this->getResponseType($responseType);

        $client = $this->getLocalHttpClient();
        $client->setMethod($method);

        switch ($method) {
            case Zend_Oauth_Client::GET:
            case Zend_Oauth_Client::PUT:
            case Zend_Oauth_Client::DELETE:
                $client->setParameterGet($args);
                break;
            case Zend_Oauth_Client::POST:
                $client->setParameterPost($args);
                break;
        }

        try {
            $response = $client->request($method);
        } catch (Exception $e) {
            throw new Zend_Service_Photobucket_Exception($e->getMessage(), $e->getCode());
        }

        return $this->parseResponse($response->getBody(), $responseType);
    }

    public function callUpload($path, $files, array $args = array(), $responseType = null) {
        $this->_prepare($path);
        $args['format'] = $this->getResponseType($responseType);

        $client = $this->getLocalHttpClient();
        $client->setMethod('POST');

        $client->setParameterPost($args);
        if (!is_array($files)) {
            $files = array('uploadfile'=>$files);
        }
        foreach ($files as $name => $fn) {
            $client->setFileUpload($fn, $name);
        }

        try {
            $response = $client->request('POST');
        } catch (Exception $e) {
            throw new Zend_Service_Photobucket_Exception($e->getMessage(), $e->getCode());
        }

        return $this->parseResponse($response->getBody(), $responseType);
    }

    /**
     * parseResponse
     *
     * Parses the raw response from Myspace
     *
     * @param string $responseBody Response text unparsed
     * @param string $responseType format of response expected to parse
     *
     * @return mixed Parsed response
     */
    protected function parseResponse($responseBody, $responseType = null) {
        $responseType = $this->getResponseType($responseType);

        switch ($responseType) {
            case self::RESPONSE_TYPE_JSON:
                $result = Zend_Json::decode($responseBody, Zend_Json::TYPE_OBJECT);
                break;
            case self::RESPONSE_TYPE_XML:
                $result = simplexml_load_string($responseBody);
                break;
            case self::RESPONSE_TYPE_PHP:
                $result = unserialize($responseBody);
                break;
            case self::RESPONSE_TYPE_RAW:
                parse_str($responseBody, $result);
                break;
            default:
                //unknown type
                $result = $responseBody;
        }

        return $result;
    }

    /**
     * Update arguments
     *
     * Updates the arguments with
     * * response type
     * * URL
     *
     * @param string $method Method being called
     * @param string $path path being called
     * @param array $args  Arguments being sent
     *
     * @return self
     */
    protected function _prepare($path) {
        //set path
        $uri = $this->getUri();
        $uri->setPath(rtrim($path,'/'));
        $uri->setQuery('');

        $this->getLocalHttpClient()->resetParameters()->setUri($uri);
        return $this;
    }

    public function __get($name) {
        $name = strtolower($name);
        return $this->loadMethods($name);
    }

    protected $_knownMethodClasses = array();
    public function setMethodClass($name, Zend_Service_Photobucket_Methods $obj) {
        $name = strtolower($name);
        $this->_knownMethodClasses[$name] = $obj;
        return $this;
    }

    public function loadMethods($name) {
        $name = strtolower($name);
        if (!empty($this->_knownMethodClasses[$name])) return $this->_knownMethodClasses[$name];

        $class = $this->getMethodsClassName($name);
        require_once $this->getMethodsClassPath($name);

        return $this->_knownMethodClasses[$name] = new $class($this);
    }

    protected function getMethodsClassPath($name) {
        return dirname(__FILE__) . DIRECTORY_SEPARATOR . 'Photobucket'
            . DIRECTORY_SEPARATOR . 'Methods'
            . DIRECTORY_SEPARATOR . ucfirst($name) . '.php';
    }

    protected function getMethodsClassName($name) {
        return __CLASS__ . '_Methods_' . ucfirst($name);
    }

    public function ping(array $params = array(), $method = 'GET') {
        return $this->callMethod($method, '/ping', $params);
    }
    public function time() {
        $client = $this->getLocalHttpClient();
        $client->setMethod(Zend_Oauth_Client::GET);

        try {
            $response = $client->request(Zend_Oauth_Client::GET);
        } catch (Exception $e) {
            throw new Zend_Service_Photobucket_Exception($e->getMessage(), $e->getCode());
        }

        return $response->getBody();
    }
}