<?php
/**
 * A resolver for resolving controllers locally
 *
 * @author		Roland Haeder <webmaster@ship-simu.org>
 * @version		0.0.0
 * @copyright	Copyright (c) 2007, 2008 Roland Haeder, 2009 Core Developer Team
 * @license		GNU GPL 3.0 or any newer version
 * @link		http://www.ship-simu.org
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
class ConsoleControllerResolver extends BaseControllerResolver implements ControllerResolver {
	/**
	 * Last successfull resolved controller (name)
	 */
	private $lastControllerName = '';

	/**
	 * Last successfull resolved controller (instance)
	 */
	private $lastControllerInstance = null;

	/**
	 * Protected constructor
	 *
	 * @return	void
	 */
	protected function __construct () {
		// Call parent constructor
		parent::__construct(__CLASS__);

		// Set prefix to "Console"
		$this->setControllerPrefix("Console");
	}

	/**
	 * Creates an instance of a resolver class with a given command
	 *
	 * @param	$controllerName				The controller we shall resolve
	 * @param	$appInstance				An instance of a manageable application helper class
	 * @return	$resolverInstance			The prepared controller resolver instance
	 * @throws	EmptyVariableException		Thrown if default command is not set
	 * @throws	InvalidControllerException	Thrown if default controller is invalid
	 */
	public final static function createConsoleControllerResolver ($controllerName, ManageableApplication $appInstance) {
		// Create the new instance
		$resolverInstance = new ConsoleControllerResolver();

		// Is the variable $controllerName set and the command is valid?
		if (empty($controllerName)) {
			// Then thrown an exception here
			throw new EmptyVariableException(array($resolverInstance, 'commandName'), self::EXCEPTION_UNEXPECTED_EMPTY_STRING);
		} elseif ($resolverInstance->isControllerValid($controllerName) === false) {
			// Invalid command found
			throw new InvalidControllerException(array($resolverInstance, $controllerName), self::EXCEPTION_INVALID_CONTROLLER);
		}

		// Set the application instance
		$resolverInstance->setApplicationInstance($appInstance);

		// Set command name
		$resolverInstance->setControllerName($controllerName);

		// Return the prepared instance
		return $resolverInstance;
	}

	/**
	 * Resolves the default controller of the given command
	 *
	 * @return	$controllerInstance		A controller instance for the default
	 *									command
	 * @throws	InvalidControllerInstanceException	Thrown if $controllerInstance
	 *												is invalid
	 */
	public function resolveController () {
		// Init variables
		$controllerName = '';
		$controllerInstance = null;

		// Get the command name 
		$controllerName = $this->getControllerName();

		// Get the command
		$controllerInstance = $this->loadController($controllerName);

		// And validate it
		if ((!is_object($controllerInstance)) || (!$controllerInstance instanceof Controller)) {
			// This command has an invalid instance!
			throw new InvalidControllerInstanceException(array($this, $controllerName), self::EXCEPTION_INVALID_CONTROLLER);
		} // END - if

		// Set last controller
		$this->lastControllerInstance = $controllerInstance;

		// Return the maybe resolved instance
		return $controllerInstance;
	}

	/**
	 * "Loads" a given controller and instances it if not yet cached. If the
	 * controller was not found one of the default controllers will be used
	 * depending on wether news shall be displayed.
	 *
	 * @param	$controllerName			A controller name we shall look for
	 * @return	$controllerInstance		A loaded controller instance
	 * @throws	InvalidControllerException	Thrown if even the requested
	 *										controller class is missing (bad!)
	 */
	private function loadController ($controllerName) {
		// Cache default command
		$defaultController = $this->getConfigInstance()->readConfig('default_console_command');

		// Init controller instance
		$controllerInstance = null;

		// Default controller
		$this->setClassName('ConsoleDefaultController');

		// Generate the class name
		//* DEBUG: */ echo __METHOD__.": Controller=".$controllerName;
		if ($controllerName != $defaultController) {
			// Create controller class name
			$className = 'Console' . $this->convertToClassName($controllerName) . 'Controller';

			// ... and set it
			$this->setClassName($className);
		} elseif ($this->getConfigInstance()->readConfig('page_with_news') == $this->getApplicationInstance()->getRequestInstance()->getRequestElement('command')) {
			// Yes, display news in home then set default controller with news
			$this->setClassName('ConsoleDefaultNewsController');
		} else {
			// No news at home page or non-news page
			$this->setClassName('ConsoleDefaultController');
		}
		//* DEBUG: */ echo ", controller=".$this->getClassName()."<br />\n";

		// Is this class loaded?
		if (!class_exists($this->getClassName())) {
			// Throw an exception here
			throw new InvalidControllerException(array($this, $controllerName), self::EXCEPTION_INVALID_CONTROLLER);
		} // END - if

		// Set default resolver config name
		$resolverConfigEntry = '';

		// Try to read a config entry for our resolver including controller name... ;-)
		try {
			// Create the resolver name
			$resolverConfigEntry = sprintf("console_cmd_%s_resolver_class", strtolower($controllerName));

			// Get the config, this will throw an exception if there is no special command resolver
			$resolverClass = $this->getConfigInstance()->readConfig($resolverConfigEntry);
		} catch (ConfigEntryNotFoundException $e) {
			// Use default resolver entry
			// @TODO Maybe we need to log this?
			$resolverConfigEntry = 'console_cmd_resolver_class';
		}

		// Initiate the resolver and controller
		$resolverInstance = ObjectFactory::createObjectByConfiguredName(
			$resolverConfigEntry,
			array(
				$controllerName,
				$this->getApplicationInstance()
			)
		);
		$controllerInstance = ObjectFactory::createObjectByName(
			$this->getClassName(),
			array($resolverInstance)
		);

		// Return the result
		return $controllerInstance;
	}
}

// [EOF]
?>