<?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/ParamInfo',
			'InputOutput/IHMImpl/Tools',
			'InputOutput/IHMImpl/TimeTables',
			'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',
			'Request/TTRequestImpl',
			'RemoteDataCenter'
	);

	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_union";
	const TTCONVERT          = "tt_convert";
	const PARAMINFO          = "param_info";
}

/**
 * @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.5.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($user, $userHost, $function)
	{
		switch ($function)
		{
			case FunctionTypeEnumClass::PARAMS :
			case FunctionTypeEnumClass::PARAMSGEN :
			case FunctionTypeEnumClass::ACTION :
				return new ParamsRequestClass($user, $userHost);
			case FunctionTypeEnumClass::PROCESSDELETE :
			case FunctionTypeEnumClass::PROCESSRUNNINGINFO :
			case FunctionTypeEnumClass::PROCESSGETINFO :
			case FunctionTypeEnumClass::PROCESSCLEAN :
				return new ProcessRequestClass($user, $userHost);
			case FunctionTypeEnumClass::TTMERGE :
			case FunctionTypeEnumClass::TTUNION :
			case FunctionTypeEnumClass::TTCONVERT :
				return new TTRequestClass($user, $userHost);
			case FunctionTypeEnumClass::PARAMINFO :
				return new ParamInfoRequestClass($user, $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,$userHost = null,$client)
	{
		switch ($client)
		{
			case ClientTypeEnumClass::IHM :
				return new IHMInputOutputClass($user, $userHost);
			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, $userHost, $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($user, $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();
	}
}

?>