<?php

define ("DOWNLOAD_RESULT_FILE_KEY","download");

/**
 * @class IHMInputOutputParamsDownloadClass
 * @brief Implementation of IHMInputOutputParamsAbstractClass to treat download request
 * @details
*/
class IHMInputOutputParamsDownloadClass extends IHMInputOutputParamsAbstractClass
{
	/*
	 * @brief method to unmarshall a download request
	*/
	protected function unmarshallRequest($input)
	{
		//{"nodeType":"download","type":"Download","downloadSrc":"0","structure":"2","sampling":600,"output":"",
		// "header":"0","timesrc":"TimeTable","timeTables":[{"timeTableName":"rzerzer","id":"tt_1"},{"timeTableName":"sqsdq","id":"tt_0"}],
		//"list":["dst"],"milli":false,"fileformat":"ASCII","timeformat":"YYYY-MM-DDThh:mm:ss","compression":"tar+gzip","leaf":true}

		$requestNode = $this->paramsData->addRequestNode();
		
		$paramsNode = $requestNode->getParamsNode();

		//unmarshall time definition
		$this->unmarshallTimeDefinition($input, 0);

		//unmarshall download output definition
		$outputsNode = $requestNode->getOutputsNode();
		$downloadNode = $outputsNode->addNewOutput(RequestOutputTypeEnum::DOWNLOAD);

		//timeformatData    : [['Y-m-dTH:i:s', 'YYYY-MM-DDThh:mm:ss'], ['DD Time', 'DD Time'], ['Timestamp', 'Timestamp']],
		switch ($input->timeformat)
		{
			case 'YYYY-MM-DDThh:mm:ss' :
				$downloadNode->setTimeFormat(RequestOutputDownloadTimeFormatEnum::ISO);
				break;
			case 'DD Time' :
				$downloadNode->setTimeFormat(RequestOutputDownloadTimeFormatEnum::DDTIME);
				break;
			case 'Timestamp' :
				$downloadNode->setTimeFormat(RequestOutputDownloadTimeFormatEnum::TIMESTAMP);
				break;
			default :
				throw new Exception('Time format not implemented.');
		}

		//formatData    : [['ASCII', 'ASCII'],['vot', 'VOTable'],['cdf', 'CDF'],['json', 'JSON']],
		switch ($input->fileformat)
		{
			case "ASCII" :
				$downloadNode->setFileFormat(RequestOutputDownloadFileFormatEnum::ASCII);
				$formatExtension = ".txt";
				break;
			case "vot" :				
			case "VOT" :
				$downloadNode->setFileFormat(RequestOutputDownloadFileFormatEnum::VOTABLE);
				$formatExtension = ".vot";
				break;
			case "cdf" :
				$downloadNode->setFileFormat(RequestOutputDownloadFileFormatEnum::CDF);
				$formatExtension = ".cdf";
				break;
			case "json" :
				$downloadNode->setFileFormat(RequestOutputDownloadFileFormatEnum::JSON);
				$formatExtension = ".json";
				break;
			default :
				throw new Exception('File format '.$input->fileformat.' not implemented.');
		}

		if ($input->fileprefix != "")
			$downloadNode->setFileName($input->fileprefix);

		//add params to output
		foreach ($input->list as $param)
		{
			$paramInfo = $this->paramManager->addExistingParam($param->paramid, $this->paramsData, $param->template_args);
			switch ($param->type) {
				case 0:
					//scalar - nothing to do
					break;
				case 1:
					//Tab1D
					if ($param->{'dim1-is-range'}) {
						$template_args = array(
							'paramid' => $paramInfo['id'],
							'min' => $param->{'dim1-min-range'},
							'max' => $param->{'dim1-max-range'},
							'relateddim' => 0
						);
						$paramInfo = $this->paramManager->addExistingParam('sum_into_table_range', $this->paramsData, $template_args);
					}
					else {
						if (($param->{'dim1-index'} != '*') && ($param->{'dim1-index'} != '')) {
							$paramInfo['indexes'] = array();
							$paramInfo['indexes'][] = $param->{'dim1-index'};
						}
					}
					
					if ($param->{'dim2-is-range'}) {
						$template_args = array(
							'paramid' => $paramInfo['id'],
							'min' => $param->{'dim2-min-range'},
							'max' => $param->{'dim2-max-range'},
							'relateddim' => 1
						);
						$paramInfo = $this->paramManager->addExistingParam('sum_into_table_range', $this->paramsData, $template_args);
					}
					else {
						if (($param->{'dim2-index'} != '*') && ($param->{'dim2-index'} != '')) {
							$paramInfo['indexes'] = array();
							$paramInfo['indexes'][] = $param->{'dim2-index'};
						}
					}
					break;
				case 2:
					if (($param->{'dim1-index'} != '*') || ($param->{'dim2-index'} != '*')) {
						$paramInfo['indexes'] = array();
						$paramInfo['indexes'][] = "[".$param->{'dim1-index'}.",".$param->{'dim2-index'}."]";
					}
					break;
			}
			$downloadNode->addParam($paramInfo['id'],$paramInfo['indexes'],$paramInfo['calib_infos']);
			$paramsNode->addParam($paramInfo['id']);
		}

		//filestructureData : [['0','All In One File'], ['1','One File Per Time Interval'], ['2','One File Per Param/Interval']],
		switch ($input->structure)
		{
			case "0" :
				if (!$input->refparamSampling)
				{
					$downloadNode->setSamplingTime($input->sampling);
					$downloadNode->setStructure(RequestOutputDownloadStructureEnum::ONE_FILE);
				}
				else
					$downloadNode->setStructure(RequestOutputDownloadStructureEnum::ONE_FILE_REFPARAM);
				break;
			case "1" :
				if (!$input->refparamSampling)
				{
					$downloadNode->setSamplingTime($input->sampling);
					$downloadNode->setStructure(RequestOutputDownloadStructureEnum::ONE_FILE_PER_INTERVAL);
				}
				else
					$downloadNode->setStructure(RequestOutputDownloadStructureEnum::ONE_FILE_PER_INTERVAL_REFPARAM);
				break;
			case "2" :
				$downloadNode->setStructure(RequestOutputDownloadStructureEnum::ONE_FILE_PER_PARAMETER_PER_INTERVAL);
				break;
			default :
				throw new Exception('Structure type not implemented.');
		}

		//filecompressData  : [['zip', 'zip'], ['tar+gzip', 'tar+gzip']],
		$extension = "";
		$resultFilePrefix = "";
		switch ($input->compression)
		{
			case "zip" :
				$extension = ".zip";
				$downloadNode->addPostProcessing(RequestOutputPostProcessingEnumClass::ZIP);
				$resultFilePrefix = "download_";
				break;
			case "tar+gzip" :
				$extension = ".tar.gz";
				$downloadNode->addPostProcessing(RequestOutputPostProcessingEnumClass::TAR);
				$downloadNode->addPostProcessing(RequestOutputPostProcessingEnumClass::GZIP);
				$resultFilePrefix = "download_";
				break;
			case "gzip" :
				$extension = $formatExtension.".gz";
				$downloadNode->addPostProcessing(RequestOutputPostProcessingEnumClass::GZIP);
				if ($input->fileprefix)
					$resultFilePrefix = $input->fileprefix;
				else
					$resultFilePrefix = "output-";
				break;
			case "" :
				$extension = $formatExtension;
				if ($input->fileprefix)
					$resultFilePrefix = $input->fileprefix;
				else
					$resultFilePrefix = "output-";
				break;
			default :
				throw new Exception('Compression type not implemented.');
		}

		$resultFile = "result_".$this->requestID;
		$this->paramsData->addWaitingResult(DOWNLOAD_RESULT_FILE_KEY, $resultFile);

		$postProcessCmd  = "mv ".$resultFilePrefix."*";
		
		$postProcessCmd .= $extension;
		$postProcessCmd .= " ".$resultFile.$extension;

		$this->paramsData->setPostCmd($postProcessCmd);
		
		if (isset($input->disablebatch))
			$this->paramsData->setBatchEnable(!$input->disablebatch);

		return $this->paramsData;
	}

	/*
	 * @brief method to marshall the result of a download request
	*/
	protected function marshallResult($data)
	{
		return $this->commonMarshallResult($data,DOWNLOAD_RESULT_FILE_KEY);
	}
}
?>