<?php

/**
 * @class IHMInputOutputParamsAbstractClass
 * @brief Abstract class that's implement an InputOutputInterface used to treat input/output of a "param" (ie. download, data mining, plot, ...) request
 * @details
 */
abstract class IHMInputOutputParamsAbstractClass implements InputOutputInterface
{
	protected $paramManager      = null;
	protected $expressionManager = null;
	protected $jobsManager       = null;

	protected $paramsData        = null;
	protected $requestID         = "";
	protected $requestDirPrefix  = "";

	protected $input             = null;
	protected $sendToSamp        = FALSE;

	/*
	 * @brief Constructor
	*/
	function __construct()
	{
		$this->paramManager     = new IHMParamManagerClass();
		$this->expressionParser = new IHMExpressionParserClass();
		$this->jobsManager      = new IHMJobsManagerClass();
	}

	/*
	 * @brief Generate a unique ID for the current request
	*/
	protected function generateNewRequestId()
	{
		$this->requestID = CommonClass::generateRandomString(6);
	}

	/*
	 * @brief Get working dir name
	*/
	protected function getWorkingDirName()
	{
		return $this->requestDirPrefix.$this->requestID."_";
	}

	/*
	 * @brief Get full working dir path
	*/
	protected function getWorkingPath()
	{
		return IHMConfigClass::getRequestPath().$this->getWorkingDirName().'/';
	}

	/*
	 * @brief Unmarshall the time definition from the IHM request
	*/

	protected function unmarshallTimeDefinition($input, $requestIndex, $ttFileIndex = -1, $ttIntIndex = -1)

	{

		$requestNodes = $this->paramsData->getRequestNodes();
		$timesNode = $requestNodes[$requestIndex]->getTimesNode();

		switch ($input->timesrc)
		{
			case "TimeTable" :

				if (($ttFileIndex >= 0) && ($ttFileIndex >= count($input->timeTables)))
					throw new Exception('Try to use a non-existing Time table index in the request.');
				
				$crtIndex = 0;

				foreach ($input->timeTables as $tt)
				{

					if (($ttFileIndex >= 0 ) && ($ttFileIndex != $crtIndex))
					{
						// Do not plot this TT
						++$crtIndex;
						continue;
					}
						

					if (strpos($tt->id, "sharedtimeTable_") === 0) {
						$result = IHMSharedObjectsClass::getPath("timeTable", $tt->id);
						if (!$result['success'])
							throw new Exception($result['message']);
						$ttPath = $result['path'];
					}
					else if (strpos($tt->id, "sharedcatalog_") === 0) {
						$result = IHMSharedObjectsClass::getPath("catalog", $tt->id);
						if (!$result['success'])
							throw new Exception($result['message']);
						$ttPath = $result['path'];
					}
					else {

						$ttPath = IHMConfigClass::getUserTTPath();

						$ttPath .= ($tt->id.".xml");
					}
					
					if ((strpos($tt->id, "cat_") === 0) || (strpos($tt->id, "sharedcatalog_") === 0))

						$timesNode->addCatalog($ttPath, $tt->{'timeTableName'}, $ttIntIndex);

					else

						$timesNode->addTimeTable($ttPath, $tt->{'timeTableName'}, $ttIntIndex);
					++$crtIndex;

				}
				break;
			case "Interval" :
				date_default_timezone_set('UTC');
				$timeStamp = strtotime($input->startDate);
				$start = CommonClass::timeStampToDDTime($timeStamp);
				$timeStamp = strtotime($input->stopDate) - strtotime($input->startDate);
				$duration = CommonClass::timeStampToDDTime($timeStamp);
				$timesNode->addInterval($start, $duration);
				break;
			default :
				throw new Exception('Time source type not implemented.');
		}
	}

	/*
	 * @brief Add a job to the job manager
	*/
	protected function addToJobsFile($data,$resultKey)
	{

		$waitingResult = $data->getWaitingResult($resultKey);
		if ($this->sendToSamp && ($data->getStatus() == ProcessStatusEnumClass::DONE)) {
			$waitingResult = explode("\n", file_get_contents(IHMConfigClass::getRequestPath()."/".$this->getWorkingDirName()."/".$waitingResult));
			$waitingResult = implode(',', $waitingResult);
			$waitingResult = rtrim($waitingResult, ',');
		}

		return $this->jobsManager->addJob(
				$this->input,
				$data->getId(),
				$this->getWorkingDirName(),
				$data->getStatus() == ProcessStatusEnumClass::RUNNING,
				$data->getStart(),

				$waitingResult,

				$data->getErrorCode(),
				$data->getExecTime());

	}
	
	/*
	 * @brief Delete current working dir + delete jobs that use this working dir + delete process
	 */
	protected function deleteWorkingDir()
	{
		$res = $this->jobsManager->getJobsByWorkingDir($this->getWorkingDirName());
		
		if (!$res['success'])
			return;
		
		foreach ($res['jobs'] as $jobId)
		{
			//delete process

			$deleteData = new ProcessRequestDataClass();
			$deleteData->setManagerFilePath(IHMConfigClass::getProcessManagerFilePath());
			$deleteData->setType(ProcessTypeEnumClass::DELETE);
			$deleteData->setId($jobId);
				
			$processRequest = new ProcessRequestClass();
			$processRequest->setData($deleteData);

			if ($processRequest->init())

				$processRequest->run();
			

			//delete job and working dir

			$this->jobsManager->deleteJob($jobId);
		}
	}
	/*
	 * @brief Marshall request result for the IHM client
	*/

	protected function commonMarshallResult($data,$resultKey)
	{
		if (!$data->getSuccess())
			return array(
					'success' => false,
					'message' => $data->getLastErrorMessage());

		switch ($data->getStatus())
		{

			case ProcessStatusEnumClass::ERROR :

			case ProcessStatusEnumClass::RUNNING :

			case ProcessStatusEnumClass::DONE :

				return $this->addToJobsFile($data,$resultKey);
			default :
				return array(
				'success' => false,
				'message'   => 'Unknown Process Status');
		}

	}

	/*
	 * @brief translate input data from IHM client to AMDA_Integration module for a "param" request
	*/
	public function getInputData($input,$function,$requestId = "")
	{
		if (isset($this->paramsData))
			unset($this->paramsData);

		$this->paramsData = new ParamsRequestDataClass();
		if ($requestId == "")
		{
			$this->requestDirPrefix = "DD";
			$this->generateNewRequestId();
		}
		else
		{

			$this->requestDirPrefix = "";

			$this->requestID = $requestId;

		}
		$this->paramsData->setWorkingPath($this->getWorkingPath());
		$this->paramsData->setCompilationPath(IHMConfigClass::getCompilationPath());

		$this->paramsData->setLocalBasePath(IHMConfigClass::getLocalBasePath());

		$this->paramsData->setManagerFilePath(IHMConfigClass::getProcessManagerFilePath());

		$this->paramsData->setTask($input->nodeType);

		$this->input = $input;

		return $this->unmarshallRequest($input);
	}

	/*
	 * @brief translate output data from AMDA_Integration module to IHM client for a "param" request
	*/
	public function getOutput($data)
	{
		return $this->marshallResult($data);
	}

	/*
	 * @brief Abstract method to unmarshall a "param" request
	*/
	abstract protected function unmarshallRequest($input);

	/*
	 * @brief Abstract method to marshall the result of a "param" request
	*/
	abstract protected function marshallResult($data);
}

?>