<?php
/**
 * This class contains the connection handler.
 * It handles all the incoming and outgoing data by forwarding it
 * to the clients for the specific connection.
 * @author jpt
 * @package Client
 * @depends Connection
 * TODO: implement routing with some more detailed rules, remove hardcoded client-based routing.
 */
class Client_ClientManager {

	/**
	 * @var Connection_ConnectionPool
	 */
	protected $connectionPool;

	/**
	 * An array that contains all client instances for each connection.
	 * @var array
	 */
	protected $clientPool;

	/**
	 * An array that contains all protocols we have clients for.
	 * @var array
	 */
	protected $registeredProtocols;

	/**
	 * Contains Connection-attached configurations.
	 * @var array
	 */
	protected $configPool;


	/**
	 * Default constructor.
	 * @return void
	 */
	public function __construct() {
		$this->connectionPool = new Connection_ConnectionPool();
		$this->clientPool = array();
		$this->registeredProtocols = array();
		$this->configPool = array();
	}

	/**
	 * Default destructor. Closes connections before being killed.
	 * @return void
	 */
	public function __destruct() {
		unset($this->clientPool);
		unset($this->connectionPool);
	}

	/**
	 * @see Connection_ConnectionPool
	 * @return int
	 */
	public function countSockets() {
		return $this->connectionPool->countSockets();
	}

	/**
	 * Returns the amount of connected connection handlers.
	 * @see Connection_ConnectionPool
	 * @return int
	 */
	public function countActiveConnections() {
		return $this->connectionPool->countActiveConnections();
	}

	/**
	 * Main worker procedure.
	 * Processes incoming data, calls clients and much more.
	 * @return void
	 */
	public function work() {
			//first, create clients for connections that do NOT have one already.
		foreach($this->connectionPool->getConnectionHandlers() AS $connectionHandler) {
			if(isset($this->clientPool[$connectionHandler->getID()])) continue;
				//new connections might need a client, so we'll create one here.
			$this->addClientForConnectionHandler($connectionHandler);
				//allow client to send initial stuff right after connecting to the server.
			$this->initializeClientForConnectionHandler($connectionHandler);
		}

			//then, process all connections that have stuff to read.
		$connectionHandlers = $this->connectionPool->select();
			//nothing to do? return right now. :)
		if(isset($connectionHandlers["read"]) === FALSE || count($connectionHandlers["read"]) === 0) return;
		foreach($connectionHandlers["read"] AS $connectionHandler) {
				//handle disconnects
			if($connectionHandler->isConnected() === FALSE && $connectionHandler->isListening() === FALSE) {
					//do we need to reconnect? do it.
				if($connectionHandler->getReconnect() === TRUE) $this->handleReconnectForConnectionHandler($connectionHandler);
					//this old connectionHandler won't do much anymore - kill it.
				$this->removeClientForConnectionHandler($connectionHandler);
					//since the old connectionHandler does not exist anymore, continue.
				continue;
			}
				//handle accepted sockets, adopt them and treat them with care :-)
			if($connectionHandler->isListening() === TRUE) {
				$this->addClientForConnectionHandler($connectionHandler);
				$this->initializeClientForConnectionHandler($connectionHandler);
			}

				//prepare and get input
			$incomingData = "";
			$outgoingData = "";
			while($data = $connectionHandler->read()) $incomingData .= $data;
			unset($data);

				//call the registered client
			if(isset($this->clientPool[$connectionHandler->getID()])) $outgoingData .= $this->clientPool[$connectionHandler->getID()]->processRawData($incomingData);

				//i don't know what to do here... maybe call a connection bridge?

				//output will be sent.
			if($outgoingData !== "") $connectionHandler->write($result);
		}
			//after that, we're done here.
	}

	/**
	 * Calls ConnectionPool in order to create a simple connection.
	 * @see Connection_ConnectionPool
	 * @param string $group
	 * @param boolean $IPv6
	 * @return Connection_ConnectionHandler
	 */
	public function createTcpConnection($group = "", $protocol = "RAW", $IPv6 = FALSE) {
		return $this->connectionPool->createTcpConnection($group, $protocol, $IPv6);
	}

	/**
	 * Closes and removes the connection.
	 * @param Connection_ConnectionHandler $connectionHandler
	 * @return void
	 */
	public function removeConnection($connectionHandler) {
		unset($this->configPool[$connectionHandler->getID()]);
		unset($this->clientPool[$connectionHandler->getID()]);
		$this->connectionPool->removeConnectionHandler($connectionHandler);
	}

	/**
	 * Registers a protocol with a specific client.
	 * @param string $protocol
	 * @param string $className
	 * @return void
	 */
	public function registerProtocol($protocol, $classNamePartial) {
		$this->registeredProtocols[$protocol] = $classNamePartial;
	}

	/**
	 * Unregisters a protocol.
	 * @param string $protocol
	 * @return void
	 */
	public function unregisterProtocol($protocol) {
		unset($this->registeredProtocols[$protocol]);
	}

	/**
	 * Attaches a configuration to a connection.
	 * Will overwrite the existing configuration for the connection.
	 * @param array $config
	 * @param Connection_ConnectionHandler $connectionHandler
	 * @return void
	 */
	public function attachConfig($config, $connectionHandler) {
		$this->configPool[$connectionHandler->getID()] = $config;
	}

	/**
	 * Calls Connection_Pool
	 * @see Connection_ConnectionPool
	 * @param int $id
	 * @param string $data
	 * @return void
	 */
	public function sendToID($id, $data) {
		return $this->connectionPool->writeToID($id, $data);
	}

	/**
	 * Returns a list of available connection IDs.
	 * @return array
	 */
	public function getIDs() {
		$list = array();
		foreach($this->connectionPool->getConnectionHandlers() AS $connectionHandler) $list[] = $connectionHandler->getID();
		return $list;
	}

	/**
	 * Returns a list of available connection groups.
	 * @return array
	 */
	public function getGroups() {
		$list = array();
		foreach($this->connectionPool->getConnectionHandlers() AS $connectionHandler) $list[] = $connectionHandler->getGroup();
		return $list;
	}

	/**
	 * Calls Connection_Pool
	 * @see Connection_ConnectionPool
	 * @param string $group
	 * @param string $data
	 * @return void
	 */
	public function sendToGroup($group, $data) {
		return $this->connectionPool->writeToGroup($group, $data);
	}

	/**
	 * Searches for the registered client for the given protocol.
	 * Returns a client instance or void.
	 * @param string $protocol
	 * @return mixed
	 * @throws Exception_GeneralException
	 */
	protected function createClientForProtocol($protocol) {
			//look for the protocol
		if(!in_array($protocol, $this->registeredProtocols)) {
			throw new Exception_GeneralException("No client registered for protocol: '" . $protocol . "'!", 1290271651);
		}
		$className = "Client_" . $protocol . "Client";
			//look for the class
		if(class_exists($className)) {
				//TODO: This looks ugly and wrong. Ideas, anyone?
			$client = new $className();
			if(!$client instanceof Client_AbstractClient) throw new Exception_GeneralException("Class '" . $className . "' does not implement the AbstractClient-API!", 1294837055);
			return $client;
		} else {
			throw new Exception_GeneralException("Registered class name '" . $className . "' does not exist for protocol: '" . $protocol . "'!", 1290271773);
		}
	}

	/**
	 * Initializes the client of a given connectionHandler.
	 * This should be done after establishing a connection.
	 * @param Connection_ConnectionHandler $connectionHandler
	 * @return void
	 */
	protected function initializeClientForConnectionHandler($connectionHandler) {
		$this->clientPool[$connectionHandler->getID()]->initializeConnection();
			//after initializing, have it process an empty string in order to get stuff to write. >.<
		$result = $this->clientPool[$connectionHandler->getID()]->processRawData("");
		if($result !== "") $connectionHandler->write($result);
	}

	/**
	 * Creates a new connectionHandler, resets the clients connection status,
	 * copies the old config and assigns the new connectionHandler to the client.
	 * @param Connection_ConnectionHandler $connectionHandler
	 * @return void
	 */
	protected function handleReconnectForConnectionHandler($connectionHandler) {
			//have the connectionHandler do the reconnect.
		$newConnectionHandler = $connectionHandler->reconnect();
			//get the client and reset it.
		$client = $this->clientPool[$connectionHandler->getID()];
		$client->resetConnectionStatus();
			//assign the client to the new connectionHandler.
		$this->clientPool[$newConnectionHandler->getID()] = $client;
			//get the config and assign it to the new connectionHandler, too.
		$config = $this->configPool[$connectionHandler->getID()];
		$this->configPool[$newConnectionHandler->getID()] = $config;
			//re-initialize the client
		$this->initializeClientForConnectionHandler($newConnectionHandler);
			//remove old connection
		$this->removeConnection($connectionHandler);
	}

	/**
	 * Adds a client to our client pool.
	 * @param Connection_ConnectionHandler $connectionHandler
	 * @return void
	 */
	protected function addClientForConnectionHandler($connectionHandler) {
		$protocol = $this->registeredProtocols[$connectionHandler->getProtocol()];
			//do not try this for raw connections
		if($protocol === "RAW") return;
		$client = $this->createClientForProtocol($protocol);
		if(isset($this->configPool[$connectionHandler->getID()])) {
			$client->loadConfig($this->configPool[$connectionHandler->getID()]);
		}
		$client->injectClientManager($this);
		$protocolHandlerClass = "Protocol_".$protocol."ProtocolHandler";
			//TODO: This looks ugly, too. Is there a better way?
		$protocolHandler = new $protocolHandlerClass();
		$client->injectProtocolHandler($protocolHandler);
		$client->setID($connectionHandler->getID());
		$client->setGroup($connectionHandler->getGroup());
		$this->clientPool[$connectionHandler->getID()] = $client;
	}

	/**
	 * Removes a client from our client pool.
	 * @param Connection_ConnectionHandler $connectionHandler
	 * @return void
	 */
	protected function removeClientForConnectionHandler($connectionHandler) {
		unset($this->clientPool[$connectionHandler->getID()]);
		$this->connectionPool->removeConnectionHandler($connectionHandler);
	}

}
?>