<?php
/**
 * EZAppDotNet.php
 * Class for easy web development
 * https://github.com/jdolitsky/AppDotNetPHP
 *
 * This class does as much of the grunt work as possible in helping you to
 * access the App.net API. In theory you don't need to know anything about
 * oAuth, tokens, or all the ugly details of how it works, it should "just
 * work". 
 *
 * Note this class assumes you're running a web site, and you'll be 
 * accessing it via a web browser (it expects to be able to do things like
 * cookies and sessions). If you're not using a web browser in your App.net
 * application, or you want more fine grained control over what's being
 * done for you, use the included AppDotNet class, which does much
 * less automatically.
 */

// comment these two lines out in production
//error_reporting(E_ALL);
//ini_set('display_errors', 1);

//require_once 'EZsettings.php';
require_once 'AppDotNet.php';

// comment this out if session is started elsewhere
//session_start();

class EZAppDotNet extends AppDotNet {

	private $_callbacks = array();
	private $_autoShutdownStreams = array();

	public function __construct($clientId=null,$clientSecret=null) {
		global $app_clientId,$app_clientSecret;

		// if client id wasn't passed, and it's in the settings.php file, use it from there
		if (!$clientId && isset($app_clientId)) {

			// if it's still the default, warn them
			if ($app_clientId == 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX') {
				throw new AppDotNetException('You must change the values defined in EZsettings.php');
			}

			$clientId = $app_clientId;
			$clientSecret = $app_clientSecret;
		}

		// call the parent with the variables we have
		parent::__construct($clientId,$clientSecret);

		// set up ez streaming
		$this->registerStreamFunction(array($this,'streamEZCallback'));

		// make sure we cleanup/destroy any streams when we exit
		register_shutdown_function(array($this,'stopStreaming'));
	}

	public function getAuthUrl($redirectUri=null,$scope=null) {
		global $app_redirectUri,$app_scope;
		
		if (is_null($redirectUri)) {
			$redirectUri = $app_redirectUri;
		}
		if (is_null($scope)) {
			$scope = $app_scope;
		}
		return parent::getAuthUrl($redirectUri,$scope);
	}

	// user login
	public function setSession($cookie=0,$callback=null) {

		if (!isset($callback)) {
			global $app_redirectUri;
			$cb=$app_redirectUri;
		} else {
			$cb=$callback;
		}

		// try and set the token the original way (eg: if they're logging in)
		$token = $this->getAccessToken($cb);

		// if that didn't work, check to see if there's an existing token stored somewhere
		if (!$token) {
			$token = $this->getSession();
		}

		$_SESSION['AppDotNetPHPAccessToken']=$token;

		// if they want to stay logged in via a cookie, set the cookie
		if ($token && $cookie) {
			$cookie_lifetime = time()+(60*60*24*7);
			setcookie('AppDotNetPHPAccessToken',$token,$cookie_lifetime);
		}

		return $token;
	}

	// check if user is logged in
	public function getSession() {

		// first check for cookie
		if (isset($_COOKIE['AppDotNetPHPAccessToken']) && $_COOKIE['AppDotNetPHPAccessToken'] != 'expired') {
			$this->setAccessToken($_COOKIE['AppDotNetPHPAccessToken']);
			return $_COOKIE['AppDotNetPHPAccessToken'];
		}

		// else check the session for the token (from a previous page load)
		else if (isset($_SESSION['AppDotNetPHPAccessToken'])) {
			$this->setAccessToken($_SESSION['AppDotNetPHPAccessToken']);
			return $_SESSION['AppDotNetPHPAccessToken'];
		}

		return false;
	}

	// log the user out
	public function deleteSession() {
		// clear the session
		unset($_SESSION['AppDotNetPHPAccessToken']);

		// unset the cookie
		setcookie('AppDotNetPHPAccessToken', null, 1);

		// clear the access token
		$this->setAccessToken(null);

		// done!
		return true;
	}

	/**
	 * Registers a callback function to be called whenever an event of a certain
	 * type is received from the app.net streaming API. Your function will recieve
	 * a PHP associative array containing an app.net object. You must register at
	 * least one callback function before starting to stream (otherwise your data
	 * would simply be discarded). You can register multiple event types and even 
	 * multiple functions per event (just call this method as many times as needed).
	 * If you register multiple functions for a single event, each will be called
	 * every time an event of that type is received.
	 *
	 * Note you should not be doing any significant processing in your callback
	 * functions. Doing so could cause your scripts to fall behind the stream and
	 * risk getting disconnected. Ideally your callback functions should simply
	 * drop the data into a file or database to be collected and processed by
	 * another program.
	 * @param string $type The type of even your callback would like to recieve.
	 * At time of writing the possible options are 'post', 'star', 'user_follow'.
	 */
	public function registerStreamCallback($type,$callback) {
		switch ($type) {
			case 'post':
			case 'star':
			case 'user_follow':
				if (!array_key_exists($type,$this->_callbacks)) {
					$this->_callbacks[$type] = array();
				}
				$this->_callbacks[$type][] = $callback;
				return true;
				break;
			default:
				throw new AppDotNetException('Unknown callback type: '.$type);
		}
	}

	/**
	 * This is the easy way to start streaming. Register some callback functions
	 * using registerCallback(), then call startStreaming(). Every time the stream
	 * gets sent a type of object you have a callback for, your callback function(s)
	 * will be called with the proper data. When your script exits the streams will
	 * be cleaned up (deleted). 
	 * 
	 * Do not use this method if you want to spread out streams across multiple
	 * processes or multiple servers, since the first script that exits/crashes will
	 * delete the streams for everyone else. Instead use createStream() and openStream().
	 * @return true
	 * @see AppDotNetStream::stopStreaming()
	 * @see AppDotNetStream::createStream()
	 * @see AppDotNetStream::openStream()
	 */
	public function startStreaming() {
		// only listen for object types that we have registered callbacks for
		if (!$this->_callbacks) {
			throw new AppDotNetException('You must register at least one callback function before calling startStreaming');
		}
		// if there's already a stream running, don't allow another
		if ($this->_currentStream) {
			throw new AppDotNetException('There is already a stream being consumed, only one stream can be consumed per AppDotNetStream instance');
		}
		$stream = $this->createStream(array_keys($this->_callbacks));
		// when the script exits, delete this stream (if it's still around)
		$this->_autoShutdownStreams[] = $response['id'];
		// start consuming
		$this->openStream($response['id']);
		return true;
	}

	/**
	 * This is the easy way to stop streaming and cleans up the no longer needed stream. 
	 * This method will be called automatically if you started streaming using 
	 * startStreaming().  
	 * 
	 * Do not use this method if you want to spread out streams across multiple
	 * processes or multiple servers, since it will delete the streams for everyone 
	 * else. Instead use closeStream().
	 * @return true
	 * @see AppDotNetStream::startStreaming()
	 * @see AppDotNetStream::deleteStream()
	 * @see AppDotNetStream::closeStream()
	 */
	public function stopStreaming() {
		$this->closeStream();
		// delete any auto streams
		foreach ($this->_autoShutdownStreams as $streamId) {
			$this->deleteStream($streamId);
		}
		return true;
	}

	/**
	 * Internal function used to make your streaming easier. I hope.
	 */
	protected function streamEZCallback($type,$data) {
		// if there are defined callbacks for this object type, then...
		if (array_key_exists($type,$this->_callbacks)) {
			// loop through the callbacks notifying each one in turn
			foreach ($this->_callbacks[$type] as $callback) {
				call_user_func($callback,$data);
			}
		}
	}

}