<?php

define ("DOWNLOAD_RESULT_FILE_KEY","download");

define ("DOWNLOAD_SAMP_RESULT_FILE_KEY","download-samp");

/**
 * @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","filestructure":"2","sampling":600,"separateInfoFile":false,"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(0);

		
		$paramsNode = $requestNode->getParamsNode();

		//Send to SAMP
		$this->sendToSamp = isset($input->sendToSamp) ? $input->sendToSamp : FALSE;
		if ($this->sendToSamp) {

			$input->disablebatch = TRUE;

			$input->timeformat = 'YYYY-MM-DDThh:mm:ss';
			$input->fileformat = 'vot';
			$input->compression = '';
			$input->fileprefix = 'amda-samp';
		}

		//unmarshall time definition

		$this->unmarshallTimeDefinition($input, 0);

		//unmarshall download output definition

		$outputsNode = $requestNode->getOutputsNode();

		$downloadNode = $outputsNode->addNewOutput(RequestOutputTypeEnum::DOWNLOAD);

		if (isset($input->scientificformat) && $input->scientificformat) {
			$downloadNode->setPrecision("true");
		}

		//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 'DOY TIME' :

				$downloadNode->setTimeFormat(RequestOutputDownloadTimeFormatEnum::DOYTIME);

				break;
			case 'Timestamp' :
				$downloadNode->setTimeFormat(RequestOutputDownloadTimeFormatEnum::TIMESTAMP);
				break;

                        case 'Timestamp-with-milliseconds' :
                                $downloadNode->setTimeFormat(RequestOutputDownloadTimeFormatEnum::MS);
                                break;
                        case 'YYYY MM DD hh mm ss' :
                                $downloadNode->setTimeFormat(RequestOutputDownloadTimeFormatEnum::SPACES);
                                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 "cdf-istp":
				$downloadNode->setFileFormat(RequestOutputDownloadFileFormatEnum::CDF_ISTP);
				$downloadNode->setTimeFormat(RequestOutputDownloadTimeFormatEnum::TT2000);
				$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);

			$paramInfo['indexes'] = array();
			$this->paramManager->applyRangesAndIndexes($this->paramsData, $param, FALSE, $paramInfo);

                                                            $this->paramManager->applyFilter($this->paramsData, $param,$paramInfo);

			$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->filestructure)

		{
			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.');
		}

		//separateInfoFile
                $downloadNode->setSeparateInfoFile(isset($input->separateInfoFile) ? $input->separateInfoFile : FALSE);

		//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.');
		}

		if (!$this->sendToSamp) {
			$resultFile = "result_".$this->requestID;
			$this->paramsData->addWaitingResult(DOWNLOAD_RESULT_FILE_KEY, $resultFile);

			$postProcessCmd  = "mv ".$resultFilePrefix."*";

			$postProcessCmd .= $extension;
			$postProcessCmd .= " ".$resultFile.$extension;
		}
		else {
			$resultFile = $input->fileprefix.".list";
			$this->paramsData->addWaitingResult(DOWNLOAD_SAMP_RESULT_FILE_KEY, $resultFile);

			$postProcessCmd  = "ls ".$input->fileprefix."* > ".$resultFile;
		}

		$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)
	{

		if ($this->sendToSamp)
			return $this->commonMarshallResult($data,DOWNLOAD_SAMP_RESULT_FILE_KEY);
		else
			return $this->commonMarshallResult($data,DOWNLOAD_RESULT_FILE_KEY);

	}
}

?>