<?php

//autoload configuration
function amdaintegration_autoload($class_name)
{
	$dirs = array(
			'InputOutput',
			'InputOutput/IHMImpl',
			'InputOutput/IHMImpl/Config',
			'InputOutput/IHMImpl/Params',
			'InputOutput/IHMImpl/Params/DataMiningImpl',

			'InputOutput/IHMImpl/Params/StatisticsImpl',

			'InputOutput/IHMImpl/Params/DownloadImpl',
			'InputOutput/IHMImpl/Params/PlotImpl',

			'InputOutput/IHMImpl/Params/GeneratorImpl',

			'InputOutput/IHMImpl/Process',
			'InputOutput/IHMImpl/Tools',
			'InputOutput/TestImpl',
			'Request',
			'Request/Config',
			'Request/ParamsRequestImpl',
			'Request/ParamsRequestImpl/Nodes',

			'Request/ParamsRequestImpl/Nodes/Infos',

			'Request/ParamsRequestImpl/Nodes/Params',
			'Request/ParamsRequestImpl/Nodes/Requests',
			'Request/ProcessRequestImpl',
			'Request/ProcessRequestImpl/Process'
	);

	foreach($dirs as $dir)
	{
		$file = __DIR__.'/'.$dir.'/'.$class_name.'.php';
		if (file_exists($file))
		{
			require $file;
			break;
		}
	}
}

spl_autoload_register('amdaintegration_autoload');

/**
 * @class FunctionTypeEnumClass
 * @brief Abstract class used as an enumerate for function type.
 * @details
*/
abstract class FunctionTypeEnumClass
{
	const PARAMS             = "params";

	const PARAMSGEN          = "params_gen";

	const ACTION             = "action";
	const PROCESSDELETE      = "process_delete";
	const PROCESSRUNNINGINFO = "process_running_info";
	const PROCESSGETINFO     = "process_get_info";
	const PROCESSCLEAN       = "process_clean";
	const TTMERGE            = "tt_merge";
	const TTUNION            = "tt_merge";
}

/**
 * @class ClientTypeEnumClass
 * @brief Abstract class used as an enumerate for AMDA_Integration client.
 * @details
 */
abstract class ClientTypeEnumClass
{
	const IHM  = "ihm";
	const TEST = "test";
}

/**
 * @class RequestManagerClass
 * @brief Main class to manage a request that's come from an AMDA client
 * @details
 */
Class RequestManagerClass
{
	public static $version = "1.2.0";

	/*
	 * @brief Constructor
	*/
	function __construct()
	{
	}

	/*
	 * @brief Treat a request that's come from the IHM
	*/
	public function runIHMRequest($user, $userHost, $function, $input)
	{
		return $this->runGenericRequest(ClientTypeEnumClass::IHM,$user,$userHost,$function,$input);
	}

	/*
	 * @brief Treat a request that's come from a test script
	*/
	public function runTestRequest($user, $function, $input)
	{
		$userHost = "";
		return $this->runGenericRequest(ClientTypeEnumClass::TEST,$user,$userHost,$function,$input);
	}

	/*
	 * @brief Create the request instance in relation with the function type
	*/
	private function createRequest($userHost, $function)
	{
		switch ($function)
		{
			case FunctionTypeEnumClass::PARAMS :

			case FunctionTypeEnumClass::PARAMSGEN :

			case FunctionTypeEnumClass::ACTION :
				return new ParamsRequestClass($userHost);
			case FunctionTypeEnumClass::PROCESSDELETE :
			case FunctionTypeEnumClass::PROCESSRUNNINGINFO :
			case FunctionTypeEnumClass::PROCESSGETINFO :
			case FunctionTypeEnumClass::PROCESSCLEAN :
				return new ProcessRequestClass($userHost);
			case FunctionTypeEnumClass::TTMERGE :
			case FunctionTypeEnumClass::TTUNION :
				return new TTRequestClass($userHost);
			default :
				throw new Exception('Request '.$function.' not implemented.');
		}
	}

	/*
	 * @brief Create an instance of the InputOutput interface in relation with the client
	*/
	private function createInputOutput($user,$client)
	{
		switch ($client)
		{
			case ClientTypeEnumClass::IHM :
				return new IHMInputOutputClass($user);
			case ClientTypeEnumClass::TEST :
				return new TestInputOutputClass($user);
			default :
				throw new Exception('Client '.$client.' not implemented.');
		}
	}

	/*
	 * @brief Sequence used to run a request
	*/
	private function runGenericRequest($client,$user,$userHost,$function,$input)
	{
		//create an instance of the InputOutput interface
		$inputOutput = $this->createInputOutput($user, $client);

		//get the input data from the request input data by using the InputOutput interface
		$inputdata = $inputOutput->getInputData($input,$function);

		//create an instance of the RequestClass to run the request
		$request = $this->createRequest($userHost, $function);

		if (is_array($inputdata))
		{
			$outputdata = array();
			foreach ($inputdata as $data)
				//execute the request
				$outputdata[] = $this->runSingleRequest($request,$data);
		}
		else
			$outputdata = $this->runSingleRequest($request,$inputdata);
			
		//get the request output data from the output data by using the InputOutput interface
		return $inputOutput->getOutput($outputdata);
	}

	/*
	 * @brief Run a single request
	*/
	private function runSingleRequest($request,$data)
	{
		//link the request to the input data
		$request->setData($data);

		//init the request
		if (!$request->init())
		{
			$crtData = $request->getData();
			if (isset($crtData))
				throw new Exception('Request initialization error  : '.$crtData->getLastErrorMessage());
			else
				throw new Exception('Cannot init request. Unknown error.');
		}

		//run the request
		if (!$request->run())
		{
			$crtData = $request->getData();
			if ($crtData)
				throw new Exception('Request execution error  : '.$crtData->getLastErrorMessage());
			else
				throw new Exception('Cannot run request. Unknown error.');
		}

		return $request->getData();
	}
}

?>