<?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  = "";
	private   $input             = null;

	/*
	 * @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)
	{
		$timesNode = $this->paramsData->getRequestNodes()[$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, "sharedtt_") === 0)
						$ttPath = IHMConfigClass::getSharedTTPath();
					else
						$ttPath = IHMConfigClass::getUserTTPath();
					$ttPath .= ($tt->id.".xml");
					if (strpos($tt->id, "cat_") === 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)
	{
		return $this->jobsManager->addJob(
				$this->input,
				$data->getId(),
				$this->getWorkingDirName(),
				$data->getStatus() == ProcessStatusEnumClass::RUNNING,
				$data->getStart(),
				$data->getWaitingResult($resultKey),
				$data->getErrorCode());
	}
	
	/*
	 * @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->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);
}

?>