/**
 * DownloadOutput.cc
 *
 *  Created on: 03 oct. 2014
 *      Author: AKKA
 */

#include "DownloadOutput.hh"
#include "FileWriterASCIITabular.hh"
#include "FileWriterASCIIJson.hh"
#include "FileWriterASCIIVOTable.hh"
#include "FileWriterCDF.hh"
#include "Helper.hh"
#include "Properties.hh"
#include "TimeUtil.hh"
#include "AMDA-Kernel_Config.hh"

#include "TimeTable.hh"
#include "TimeTableCatalogFactory.hh"

#include "ServicesServer.hh"
#include "TimeInterval.hh"

#include <boost/filesystem/path.hpp>
#include <boost/filesystem.hpp>

namespace AMDA {
namespace ParamOutputImpl {

/**
 * @brief Implement ParamOutput to download parameters data in files.
 */
namespace Download {

DownloadOutput::DownloadOutput(AMDA::Parameters::ParameterManager& pParameterManager) :
			VisitorOfParamData(),
			ParamOutput(pParameterManager),
			_downloadProperties(),
			_fileWriter(NULL),
			_currentParamId(""),
			_firstParamId(""),
			_currentIntervalIndex(0)
{

}

DownloadOutput::~DownloadOutput()
{
	if (_fileWriter != NULL)
		delete _fileWriter;
}

/**
 * @overload DataClient::establishConnection()
 */
void DownloadOutput::establishConnection()
{
	LOG4CXX_DEBUG(_logger,"DownloadOutput::establishConnection");

	//Create the file writer
	createFileWriter();

	//create all needed parameters
	try {
		_currentTimeInterval = _parameterManager.getInputIntervals()->begin();
		createParameters();
	} catch (...) {
		LOG4CXX_ERROR(_logger, "DownloadOutput::establishConnection - It's impossible to create parameters");
		throw;
	}

	//open connection for all needed parameters
	for (auto paramProperties : _downloadProperties.getParamPropertiesList())
	{
		LOG4CXX_DEBUG(_logger,"DownloadOutput::establishConnection - " << paramProperties->getOutputId());

		try {
			_parameterManager.getParameter(paramProperties->getOutputId())->openConnection(this);
		} catch (...) {
			LOG4CXX_ERROR(_logger, "DownloadOutput::establishConnection - It's impossible to open connection for " << paramProperties->getOutputId());
			std::string filePath = getFilePath(_fileWriter->getExtension());
			if (_fileWriter->createNewFile(filePath))
				_fileWriter->writeError("EstablishConnection Error.\nIt's impossible to create  the parameter: \""
							+ paramProperties->getOriginalId() + "\".");
			throw;
		}
	}
}

/**
 * @overload ParamOutput::init()
 */
void DownloadOutput::init()
{
	LOG4CXX_DEBUG(_logger,"DownloadOutput::init");

	//init too small intervals process map
	if (isNeedToGenerateTooSmallIntervalFile())
	{
		for (auto paramProperties : _downloadProperties.getParamPropertiesList())
		{
			//get original parameter pointer
			AMDA::Parameters::ParameterSPtr param = _parameterManager.getParameter(paramProperties->getOriginalId());

			//get mean statistic process associated to this parameter
			AMDA::Parameters::StatisticProcess* process = AMDA::Parameters::ServicesServer::getInstance()->getStatisticProcess(
					"mean", *param.get(), -1);

			//establish connection
			process->establishConnection();

			//push process to the map
			_tooSmallIntervalProcessMap[paramProperties->getOriginalId()].reset(process);
		}
	}

	//init all needed parameters
	for (auto paramProperties : _downloadProperties.getParamPropertiesList())
	{
		try {
			//init parameter
			LOG4CXX_DEBUG(gLogger,"DownloadOutput::init - " << paramProperties->getOutputId());
			_parameterManager.getParameter(paramProperties->getOutputId())->init(this, _timeIntervalList);
		} catch (...) {

			LOG4CXX_ERROR(_logger, "DownloadOutput::init : Error to init parameter " <<
					paramProperties->getOutputId());
			std::string filePath = getFilePath(_fileWriter->getExtension());
			if (_fileWriter->createNewFile(filePath))
				_fileWriter->writeError("Init Error.\nIt's impossible to initialize parameter: \""
						+ paramProperties->getOriginalId() + "\".");
			throw;
		}
	}

	//init processes for too small intervals
	if (isNeedToGenerateTooSmallIntervalFile())
	{
		for (auto process : _tooSmallIntervalProcessMap)
		{
			process.second->init(_timeIntervalListTooSmall);
		}
	}
}

/**
 * @overload ParamOutput::apply()
 */
void DownloadOutput::apply()
{
	LOG4CXX_DEBUG(_logger,"DownloadOutput::apply");

	if (_fileWriter == NULL)
	{
		LOG4CXX_ERROR(_logger, "DownloadOutput::apply : No file writer defined");
		BOOST_THROW_EXCEPTION(AMDA::Parameters::ParamOutput_exception());
	}

	//Working flags
	bool separateInfoFile = _fileWriter->isInfoInSeparateFile(
			_timeIntervalList->size() == 1,
			_downloadProperties.getOutputStructure());

	try {
		bool isFirstInterval = true;
		//Intervals loop
		while (_currentTimeInterval != _timeIntervalList->end())
		{
			_currentParamId = "";
			_currentIntervalIndex = _currentTimeInterval->_index;
			//apply sequence in relation to the output structure
			switch (_downloadProperties.getOutputStructure())
			{
			case ONE_FILE :
			case ONE_FILE_REFPARAM :
				applyOneFileStructure(isFirstInterval);
				break;
			case ONE_FILE_PER_INTERVAL :
			case ONE_FILE_PER_INTERVAL_REFPARAM :
				applyOneFilePerInterval(separateInfoFile, isFirstInterval);
				break;
			case ONE_FILE_PER_PARAMETER_PER_INTERVAL :
				applyOneFilePerParameterPerInterval(separateInfoFile, isFirstInterval);
				break;
			}

			isFirstInterval = false;
			++_currentTimeInterval;
			//Finalize the data write in the case of a ONE_FILE or ONE_FILE_REFPARAM structure when last interval is treated
			if ((_currentTimeInterval == _timeIntervalList->end()) &&
					((_downloadProperties.getOutputStructure() == ONE_FILE) ||
					 (_downloadProperties.getOutputStructure() == ONE_FILE_REFPARAM)))
				_fileWriter->finalize();
		}
		_fileWriter->closeFile();

		//build too small interval file if needed
		if (isNeedToGenerateTooSmallIntervalFile())
			buildTooSmallIntervalCatalog();

	} catch (...) {
		_fileWriter->closeFile();
		LOG4CXX_ERROR(_logger, "DownloadOutput::apply : Error to apply output");
		throw;
	}
}

/*
 * @brief Apply structure for "one-file"
 */
void DownloadOutput::applyOneFileStructure(bool isFirstInterval)
{
	LOG4CXX_DEBUG(_logger,"DownloadOutput::applyOneFileStructure");
	//create a data file
	if (isFirstInterval)
		createNewDataFile();
	//write data for each parameters
	for (auto paramProperties : _downloadProperties.getParamPropertiesList())
		getParameterDataFromServer(paramProperties->getOutputId());
	//write info
	if (isFirstInterval)
		writeInfo(false,false,false);
}

/*
 * @brief Apply structure for "one-file-per-interval"
 */
void DownloadOutput::applyOneFilePerInterval(bool separateInfoFile, bool isFirstInterval)
{
	LOG4CXX_DEBUG(_logger,"DownloadOutput::applyOneFilePerInterval");
	//create new output file
	createNewDataFile();
	for (auto paramProperties : _downloadProperties.getParamPropertiesList())
		getParameterDataFromServer(paramProperties->getOutputId());

	_currentParamId = "";
	if (separateInfoFile)
	{
		//write only interval info
		writeInfo(true,true,false);
	}
	else
	{
		//write all info
		writeInfo(true,false,false);
	}

	//finalize data write
	_fileWriter->finalize();

	if (separateInfoFile && isFirstInterval)
	{
		//create info file
		std::string filePath = getInfoFilePath(_fileWriter->getExtension());
		if (!_fileWriter->createNewFile(filePath))
		{
			LOG4CXX_ERROR(_logger, "DownloadOutput::applyOneFilePerInterval : Cannot create info file " << filePath);
			BOOST_THROW_EXCEPTION(AMDA::Parameters::ParamOutput_exception());
		}
		_files.push_back(filePath);

		//write info
		writeInfo(false,false,true);
	}
}

/*
 * @brief Apply structure for "one-file-per-parameter-per-interval"
 */
void DownloadOutput::applyOneFilePerParameterPerInterval(bool separateInfoFile, bool isFirstInterval)
{
	LOG4CXX_DEBUG(_logger,"DownloadOutput::applyOneFilePerParameterPerInterval");
	for (auto paramProperties : _downloadProperties.getParamPropertiesList())
	{
		_currentParamId = paramProperties->getOutputId();
		//create output file
		createNewDataFile();
		//force first parameter id
		_firstParamId = paramProperties->getOutputId();

		//write data
		getParameterDataFromServer(paramProperties->getOutputId());

		if (separateInfoFile)
		{
			//write only interval info
			writeInfo(true,true,false);
		}
		else
		{
			//write all info
			writeInfo(true,false,false);
		}

		//finalize data write
		_fileWriter->finalize();

		if (separateInfoFile && isFirstInterval)
		{
			//create info file
			std::string filePath = getInfoFilePath(_fileWriter->getExtension());
			if (!_fileWriter->createNewFile(filePath))
			{
				LOG4CXX_ERROR(_logger, "DownloadOutput::applyOneFilePerParameterPerInterval : Cannot create info file " << filePath);
				BOOST_THROW_EXCEPTION(AMDA::Parameters::ParamOutput_exception());
			}
			_files.push_back(filePath);

			//write info
			writeInfo(false,false,true);
		}
	}
}

void DownloadOutput::writeInfo(bool isWriteIntervalInfo,
		bool isWriteOnlyIntervalInfo,
		bool isFinalizeInfoFile)
{
	char *hideHeader;
	if((hideHeader = getenv("HIDE_HEADER_FILE")) != NULL)
		if (strcmp(hideHeader,"true") == 0)
			return; //hide header for validation tests

	if (!isWriteOnlyIntervalInfo)
	{
		writeAMDAInfo();
		writeRequestInfo();
		writeParamInfo();
	}
	if (isWriteIntervalInfo)
		writeIntervalInfo();

	if (isFinalizeInfoFile)
		_fileWriter->finalize(true);
}

void DownloadOutput::writeAMDAInfo(void)
{
	std::string version = AMDA_Kernel_VERSION;

	char *hideVersion;
	if((hideVersion = getenv("HIDE_VERSION")) != NULL)
		if (strcmp(hideVersion,"true") == 0)
			version = "none-for-test"; //hide version number for tests

	AMDA::helpers::Properties lProperties("amda.properties");

	std::string createdby = lProperties["createdby"];
	std::string acknowledgement = lProperties["acknowledgement"];

	_fileWriter->writeAMDAInfo(version, createdby, acknowledgement);
}

void DownloadOutput::writeRequestInfo(void)
{
	std::string structure = ouputStructureToStr[_downloadProperties.getOutputStructure()];
	std::string timeFormat = ouputFormatTimeToStr[_downloadProperties.getTimeFormat()];

	std::stringstream outputParams;
	bool firstParam = true;
	for (auto paramProperties : _downloadProperties.getParamPropertiesList())
	{
		if (!firstParam)
			outputParams << ",";
		firstParam = false;
		outputParams << paramProperties->getOriginalId();
	}

	_fileWriter->writeRequestInfo(structure,timeFormat,_downloadProperties.getTimeResolution(),
			outputParams.str(),_currentTimeInterval->_ttName);
}

void DownloadOutput::writeIntervalInfo(void)
{
	std::stringstream startTime, stopTime;
	TimeUtil::formatTimeDateInIso(_currentTimeInterval->_startTime, startTime);
	TimeUtil::formatTimeDateInIso(_currentTimeInterval->_stopTime, stopTime);

	_fileWriter->writeIntervalInfo(startTime.str(),stopTime.str());
}

void DownloadOutput::writeParamInfo(void)
{
	_fileWriter->writeParamsInfo(_downloadProperties.getParamPropertiesList(),
			_downloadProperties.getOutputStructure(), _currentParamId);
}

bool DownloadOutput::isNeedToGenerateTooSmallIntervalFile()
{
	return (_timeIntervalListTooSmall->empty() == false);
}

void DownloadOutput::buildTooSmallIntervalCatalog(void)
{
	if (!isNeedToGenerateTooSmallIntervalFile())
		return;

	LOG4CXX_DEBUG(_logger,"DownloadOutput::buildTooSmallIntervalCatalog");

	//build small intervals catalog file name
	std::ostringstream catalogName;
	catalogName << _timeIntervalListTooSmall->begin()->_ttName << "_" << _samplingValue	<< "_smallIntervals";

	//create small intervals catalog file

	_smallIntervalsCatalog._name = catalogName.str();

	if(getenv("HIDE_AMDA_DATE") != NULL)
		_smallIntervalsCatalog._creationDate = 0;
	else
		_smallIntervalsCatalog._creationDate = std::time(0);

	std::ostringstream description;
	description << "Time intervals are less than requested timeResolution (" << _samplingValue << ")";
	_smallIntervalsCatalog._description.push_back(description.str());

	//add interval index description
	TimeTableCatalog::ParameterDescription indexDesc(
		"index",
		"Interval index",
		"1",
		TimeTableCatalog::ParameterDescription::ParameterType::Integer,
		"",
		"Interval index in input TimeTable",
		"meta.number",
		""
	);
	_smallIntervalsCatalog.addParameterDescription(indexDesc);

	//compute mean processes for each small inetrvals and store results in the catalog file
	AMDA::Parameters::TimeIntervalList::iterator currentTooSmallTimeInterval = _timeIntervalListTooSmall->begin();
	while (currentTooSmallTimeInterval != _timeIntervalListTooSmall->end())
	{
		TimeTableCatalog::TimeInterval crtInterval(currentTooSmallTimeInterval->_startTime,currentTooSmallTimeInterval->_stopTime);

		//push index for this time interval
		std::vector<std::string> crtIndex;
		crtIndex.push_back(std::to_string(currentTooSmallTimeInterval->_index));
		crtInterval.addParameterData(std::string("index"), crtIndex);

		for (auto process : _tooSmallIntervalProcessMap)
		{
			std::vector<std::string> crtResult;
			std::vector<std::string> crtCoverage;
			//compute the mean
			process.second->compute(crtResult,crtCoverage);

			if (currentTooSmallTimeInterval == _timeIntervalListTooSmall->begin())
			{
				//add mean processes description to the catalog
				std::string name = "mean(";
				name += process.first;
				name += ")";

				TimeTableCatalog::ParameterDescription desc(
					process.first,
					name,
					process.second->getResultDimDefinition(),
					TimeTableCatalog::ParameterDescription::ParameterType::Double,
					"",
					"Mean of the parameter in the interval",
					process.second->getUCD(),
					""
				);
				_smallIntervalsCatalog.addParameterDescription(desc);
			}

			//push result for this time interval
			crtInterval.addParameterData(process.first, crtResult);
		}

		//add interval to the catalog
		_smallIntervalsCatalog.addInterval(crtInterval);

		//go to the next too small interval
		++currentTooSmallTimeInterval;
	}
}

void DownloadOutput::terminate(void)
{
	//write the catalog file

	if (isNeedToGenerateTooSmallIntervalFile())
	{
		std::string ttPath = _timeIntervalList->begin()->_ttPath;
		_smallIntervalsCatalog.write(_workPath,
				TimeTableCatalog::TimeTableCatalogFactory::getInstance().getReaderType(ttPath));
		//add the catalog file to the output files list
		boost::filesystem::path ttp(ttPath);
		_files.push_back(_smallIntervalsCatalog._name + ttp.extension().string());
	}

	ParamOutput::terminate();
}

void DownloadOutput::createNewDataFile(void)
{
	std::string filePath = getFilePath(_fileWriter->getExtension());
	if (!_fileWriter->createNewFile(filePath))
	{
		LOG4CXX_ERROR(_logger, "DownloadOutput::createNewDataFile : Cannot create output file " << filePath);
		BOOST_THROW_EXCEPTION(AMDA::Parameters::ParamOutput_exception());
	}
	_files.push_back(filePath);
	_paramDefinedInFile.clear();
}

/*
 * @brief Create parameters in relation with the download properties
 */
void DownloadOutput::createParameters(void)
{
	LOG4CXX_DEBUG(_logger,"DownloadOutput::createParameters");

	switch (_downloadProperties.getOutputStructure())
	{
	case ONE_FILE :
	case ONE_FILE_REFPARAM :
	case ONE_FILE_PER_INTERVAL :
	case ONE_FILE_PER_INTERVAL_REFPARAM :
		if (_downloadProperties.getParamPropertiesList().size() == 1)
		{
			//only one paramter defined in the request
			try {
				//get original parameter
				AMDA::Parameters::ParameterSPtr originalParam = _parameterManager.getParameter(
						_downloadProperties.getParamPropertiesList()[0]->getOriginalId());

				if (_downloadProperties.getTimeResolution() == 0)
				{
					//only one parameter and no time resolution defined => keep original parameter
					_downloadProperties.getParamPropertiesList()[0]->setOutputId(
							_downloadProperties.getParamPropertiesList()[0]->getOriginalId());
					_firstParamId = _downloadProperties.getParamPropertiesList()[0]->getOriginalId();
				}
				else
				{
					//only one parameter but time resolution defined => resample the parameter
					AMDA::Parameters::ParameterSPtr resampledParam = _parameterManager.getSampledParameter(
												originalParam->getId(),
												"classic",
												_downloadProperties.getTimeResolution(),
												originalParam->getGapThreshold());
					//set the resampled parameter id
					_downloadProperties.getParamPropertiesList()[0]->setOutputId(resampledParam->getId());
					_firstParamId = resampledParam->getId();
					_samplingValue = _downloadProperties.getTimeResolution();
				}

			} catch (...) {
				std::string filePath = getFilePath(_fileWriter->getExtension());
				if (_fileWriter->createNewFile(filePath))
					_fileWriter->writeError("EstablishConnection Error.\nIt's impossible to create  the parameter: \""
							+ _downloadProperties.getParamPropertiesList()[0]->getOriginalId() + "\".");
				throw;
			}
		}
		else
		{
			double samplingTime = _downloadProperties.getTimeResolution();
			if ((samplingTime == 0) &&
				((_downloadProperties.getOutputStructure() == ONE_FILE) ||
				 (_downloadProperties.getOutputStructure() == ONE_FILE_PER_INTERVAL)))
			{
				//no time resolution defined with outputStructure ONE_FILE or ONE_FILE_PER_PARAMETER_PER_INTERVAL
				//=> get max parameters sampling time
				for (auto paramProperties : _downloadProperties.getParamPropertiesList())
				{
					try {
						AMDA::Parameters::ParameterSPtr originalParam = _parameterManager.getParameter(paramProperties->getOriginalId());
						samplingTime = std::max(samplingTime,getSamplingInTreeParameter(originalParam));
					} catch (...) {
						std::string filePath = getFilePath(_fileWriter->getExtension());
						if (_fileWriter->createNewFile(filePath))
							_fileWriter->writeError("EstablishConnection Error.\nIt's impossible to create  the parameter: \""
													+ paramProperties->getOriginalId() + "\".");
						throw;
					}
				}
			}

			_samplingValue = samplingTime;

			//create resampled parameters for all parameters defined in the request
			bool isFirstParam = true;
			AMDA::Parameters::ParameterSPtr firstParam;
			for (auto paramProperties : _downloadProperties.getParamPropertiesList())
			{
				try {
					//get original parameter
					AMDA::Parameters::ParameterSPtr originalParam = _parameterManager.getParameter(paramProperties->getOriginalId());

					//Create resampled parameter
					AMDA::Parameters::ParameterSPtr resampledParam;
					if (_samplingValue > 0)
					{
						resampledParam = _parameterManager.getSampledParameter(
								paramProperties->getOriginalId(),
								"classic",
								samplingTime,
								originalParam->getGapThreshold());

						//set the resampled parameter id
						paramProperties->setOutputId(resampledParam->getId());

						if (isFirstParam)
						{
							_firstParamId = resampledParam->getId();
							firstParam = resampledParam;
						}
					}
					else
					{
						//use resampled parameter under first parameter time definition
						if (isFirstParam)
						{
							//first parameter => no resampling
							//set the original parameter id
							paramProperties->setOutputId(paramProperties->getOriginalId());
							_firstParamId = paramProperties->getOriginalId();
							firstParam = originalParam;
						}
						else
						{
							resampledParam = _parameterManager.getSampledParameterUnderRefParam(
								originalParam->getId(),
								firstParam->getId());

							//set the resampled parameter id
							paramProperties->setOutputId(resampledParam->getId());
						}
					}
					isFirstParam = false;
				} catch (...) {
					std::string filePath = getFilePath(_fileWriter->getExtension());
					if (_fileWriter->createNewFile(filePath))
						_fileWriter->writeError("EstablishConnection Error.\nIt's impossible to create  the parameter: \""
								+ paramProperties->getOriginalId() + "\".");
					throw;
				}
			}
		}
		break;
	case ONE_FILE_PER_PARAMETER_PER_INTERVAL :
	{
		bool isFirstParam = true;
		for (auto paramProperties : _downloadProperties.getParamPropertiesList())
		{
			try {
				//get original parameter
				AMDA::Parameters::ParameterSPtr originalParam = _parameterManager.getParameter(paramProperties->getOriginalId());

				paramProperties->setOutputId(paramProperties->getOriginalId());
				if (isFirstParam)
					_firstParamId = paramProperties->getOriginalId();
				isFirstParam = false;
			} catch (...) {
				std::string filePath = getFilePath(_fileWriter->getExtension());
				if (_fileWriter->createNewFile(filePath))
					_fileWriter->writeError("EstablishConnection Error.\nIt's impossible to create  the parameter: \""
							+ paramProperties->getOriginalId() + "\".");
				throw;
			}
		}
	}
	break;
	default :
		LOG4CXX_ERROR(_logger, "DownloadOutput::createParameters : Output structure not implemented");
		BOOST_THROW_EXCEPTION(AMDA::Parameters::ParamOutput_exception());
	}
}

/*
* @brief create file writer associated to the requested file format
 */
void DownloadOutput::createFileWriter(void)
{
	if (_fileWriter != NULL)
		delete _fileWriter;

	switch (_downloadProperties.getFileFormat())
	{
	case ASCII_FILE_FORMAT :
		_fileWriter = new FileWriter::FileWriterASCIITabular(_parameterManager);
		break;
	case JSON_FILE_FORMAT :
			_fileWriter = new FileWriter::FileWriterASCIIJson(_parameterManager);
			break;
	case VOT_FILE_FORMAT :
			_fileWriter = new FileWriter::FileWriterASCIIVOTable(_parameterManager);
			break;
	case CDF_FILE_FORMAT :
		_fileWriter = new FileWriter::FileWriterCDF(_parameterManager);
		break;
	default:
		LOG4CXX_ERROR(_logger, "DownloadOutput::createFileWriter : File format not implemented");
		BOOST_THROW_EXCEPTION(AMDA::Parameters::ParamOutput_exception());
	}
}

/*
 * @brief Get file path in relation with the sequence step
 */
std::string DownloadOutput::getFilePath(std::string extension, bool infoFile)
{
	//create workspace dir if needed
	int ret = AMDA::Helpers::Helper::mkdir(_workPath.c_str());
	if (ret)
	{
		const size_t buflen = 250;
		char buf[250];
		LOG4CXX_ERROR(_logger,
				"Create working directory \"" << _workPath <<"\"error : " << strerror_r(ret, buf, buflen));
		BOOST_THROW_EXCEPTION(AMDA::Parameters::ParamOutput_exception());
	}

	//create full file path
	std::stringstream filePath;
	filePath << _workPath;

	filePath << "/";

	if (_downloadProperties.getFileName().empty())
		filePath << "output-";
	else
		filePath << _downloadProperties.getFileName() << "-";

	//add parameters ids
	bool firstParam = true;
	for (auto paramProperties : _downloadProperties.getParamPropertiesList())
	{
		if (!_currentParamId.empty())
		{
			//add only current parameter id
			if (_currentParamId != paramProperties->getOutputId())
				continue;
		}

		if (!firstParam)
			filePath << "_";
		firstParam = false;

		filePath << paramProperties->getOriginalId();

		//add indexes
		for (auto index : paramProperties->getIndexDefList())
		{
			boost::replace_all(index, "[", "");
			boost::replace_all(index, "]", "");
			boost::replace_all(index, "*", "x");
			filePath << "_" << index;
		}
	}

	if (!infoFile)
	{
		if ((_downloadProperties.getOutputStructure() != ONE_FILE) &&
			(_downloadProperties.getOutputStructure() != ONE_FILE_REFPARAM) &&
				(_parameterManager.getInputIntervals()->size() != 1))
		{
			//add interval index
			filePath << "_" <<  _currentTimeInterval->_ttName;
			filePath << "_" << _currentIntervalIndex;
		}
		else
		{
			if (_currentTimeInterval->_ttName.empty())
			{
				//add start time
				double lStartTime = _currentTimeInterval->_startTime;
				char buffer[TIMELENGTH];
				Double2DD_Time(buffer, lStartTime);
				filePath << "_" << buffer;
			}
			else
			{
				//add TT name
				filePath << "_" <<  _currentTimeInterval->_ttName;
			}
		}
	}
	else
		filePath << "_info";

	//add extension
	filePath << ".";
	filePath << extension;

	return filePath.str();
}

/*
 * @brief Get file info path in relation with the sequence step (only used if info is written is separate file)
 */
std::string DownloadOutput::getInfoFilePath(std::string extension)
{
	return getFilePath(extension, true);
}

void DownloadOutput::getParameterDataFromServer(std::string paramId)
{
	try {
		_currentParamId = paramId;
		do {
			try {
				_paramDataIndexInfo = _parameterManager.getParameter(paramId)->getAsync(this).get();
			} catch (...) {
				BOOST_THROW_EXCEPTION(AMDA::Parameters::ParamOutput_exception());
				throw;
			}
			if (_paramDataIndexInfo._nbDataToProcess > 0) {
				try {
					_parameterManager.getParameter(paramId)->getParamData(this)->accept(*this);
				} catch (AMDA::AMDA_exception & e) {
					e << AMDA::errno_code(AMDA_PARAM_OUTPUT_ERR);
					throw;
				}
			}
		} while(!_paramDataIndexInfo._noMoreTimeInt && !_paramDataIndexInfo._timeIntToProcessChanged);
	}catch (...) {
		_fileWriter->writeError("apply Error.\nIt's impossible to get or write data of  parameter: \""
								+ paramId + "\".");
		throw;
	}
}

void DownloadOutput::addParameterInFile(std::string paramId,
		FileWriter::FileDataType type, bool isFirstParam, int dim1Size, int dim2Size)
{
	if (!_paramDefinedInFile[paramId])
	{
		ParamProperties* prop = _downloadProperties.getParamPropertiesFromOutputId(paramId);
		_fileWriter->addParameter(prop,_paramsIndexList[paramId], type, isFirstParam, dim1Size, dim2Size);
	}
	_paramDefinedInFile[paramId] = true;
}

void DownloadOutput::buildParamIndexes(std::string paramId, int dim1Size, int dim2Size)
{
	_paramsIndexList[paramId].clear();
	for (auto paramProp : _downloadProperties.getParamPropertiesList())
	{
		if (paramProp->getOutputId() == paramId)
		{
			for (auto indexDef : paramProp->getIndexDefList())
			{
				if (!AMDA::Common::ParameterIndexesTool::parse(indexDef,dim1Size,dim2Size,_paramsIndexList[paramId]))
				{
					ERROR_EXCEPTION(
							"DownloadOutput of: '" << paramId << "' index: " << indexDef << " out of range");
				}
			}
			break;
		}
	}

	if (_paramsIndexList[paramId].empty())
		AMDA::Common::ParameterIndexesTool::parse("",dim1Size,dim2Size,_paramsIndexList[paramId]);
}

/***************************** VISITORS ********************************/

/**
 * @overload VisitorOfParamData::visit()
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataScalaireShort *pParamData)
{
	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_SHORT, isFirstParam);

	for (unsigned int index = _paramDataIndexInfo._startIndex;
				index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		_fileWriter->writeShortData(_currentParamId,0,pParamData->get(index), _downloadProperties.getPrecision());
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit()
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataScalaireFloat *pParamData)
{
	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_FLOAT, isFirstParam);

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		_fileWriter->writeFloatData(_currentParamId,0,pParamData->get(index), _downloadProperties.getPrecision());
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit()
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataScalaireDouble *pParamData)
{
	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_DOUBLE, isFirstParam);

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		_fileWriter->writeDoubleData(_currentParamId,0,pParamData->get(index), _downloadProperties.getPrecision());
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit()
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataScalaireLongDouble *pParamData)
{
	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_LONGDOUBLE, isFirstParam);

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		_fileWriter->writeLongDoubleData(_currentParamId,0,pParamData->get(index), _downloadProperties.getPrecision());
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit()
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataScalaireInt *pParamData)
{
	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_INT, isFirstParam);

	for (unsigned int index = _paramDataIndexInfo._startIndex;
				index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		_fileWriter->writeIntData(_currentParamId,0,pParamData->get(index), _downloadProperties.getPrecision());
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit()
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataLogicalData *pParamData)
{
	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_LOGICAL, isFirstParam);

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		_fileWriter->writeLogicalData(_currentParamId,0,pParamData->get(index), _downloadProperties.getPrecision());
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit()
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataTab1DShort *pParamData)
{
	if (_paramsIndexList[_currentParamId].empty())
		buildParamIndexes(_currentParamId, pParamData->get(_paramDataIndexInfo._startIndex).size());

	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_SHORT, isFirstParam, pParamData->get(_paramDataIndexInfo._startIndex).size());

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		int varIndex = 0;
		for (auto component : _paramsIndexList[_currentParamId])
		{
			_fileWriter->writeShortData(_currentParamId,varIndex,pParamData->get(index)[component.getDim1Index()], _downloadProperties.getPrecision());
			++varIndex;
		}
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit()
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataTab1DFloat *pParamData)
{
	if (_paramsIndexList[_currentParamId].empty())
		buildParamIndexes(_currentParamId, pParamData->get(_paramDataIndexInfo._startIndex).size());

	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_FLOAT, isFirstParam, pParamData->get(_paramDataIndexInfo._startIndex).size());

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		int varIndex = 0;
		for (auto component : _paramsIndexList[_currentParamId])
		{
			_fileWriter->writeFloatData(_currentParamId,varIndex,pParamData->get(index)[component.getDim1Index()], _downloadProperties.getPrecision());
			++varIndex;
		}
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit()
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataTab1DDouble *pParamData)
{
	if (_paramsIndexList[_currentParamId].empty())
		buildParamIndexes(_currentParamId, pParamData->get(_paramDataIndexInfo._startIndex).size());

	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_DOUBLE, isFirstParam, pParamData->get(_paramDataIndexInfo._startIndex).size());

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		int varIndex = 0;
		for (auto component : _paramsIndexList[_currentParamId])
		{
			_fileWriter->writeDoubleData(_currentParamId,varIndex,pParamData->get(index)[component.getDim1Index()], _downloadProperties.getPrecision());
			++varIndex;
		}
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit()
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataTab1DLongDouble *pParamData)
{
	if (_paramsIndexList[_currentParamId].empty())
		buildParamIndexes(_currentParamId, pParamData->get(_paramDataIndexInfo._startIndex).size());

	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_LONGDOUBLE, isFirstParam, pParamData->get(_paramDataIndexInfo._startIndex).size());

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		int varIndex = 0;
		for (auto component : _paramsIndexList[_currentParamId])
		{
			_fileWriter->writeLongDoubleData(_currentParamId,varIndex,pParamData->get(index)[component.getDim1Index()], _downloadProperties.getPrecision());
			++varIndex;
		}
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit()
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataTab1DInt *pParamData)
{
	if (_paramsIndexList[_currentParamId].empty())
		buildParamIndexes(_currentParamId, pParamData->get(_paramDataIndexInfo._startIndex).size());

	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_INT, isFirstParam, pParamData->get(_paramDataIndexInfo._startIndex).size());

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		int varIndex = 0;
		for (auto component : _paramsIndexList[_currentParamId])
		{
			_fileWriter->writeIntData(_currentParamId,varIndex,pParamData->get(index)[component.getDim1Index()], _downloadProperties.getPrecision());
			++varIndex;
		}
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit()
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataTab1DLogicalData *pParamData)
{
	if (_paramsIndexList[_currentParamId].empty())
		buildParamIndexes(_currentParamId, pParamData->get(_paramDataIndexInfo._startIndex).size());

	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_LOGICAL, isFirstParam, pParamData->get(_paramDataIndexInfo._startIndex).size());

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		int varIndex = 0;
		for (auto component : _paramsIndexList[_currentParamId])
		{
			_fileWriter->writeLogicalData(_currentParamId,varIndex,pParamData->get(index)[component.getDim1Index()], _downloadProperties.getPrecision());
			++varIndex;
		}
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab2DShort *)
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataTab2DShort *pParamData) {
	if (_paramsIndexList[_currentParamId].empty())
		buildParamIndexes(_currentParamId, pParamData->get(_paramDataIndexInfo._startIndex).getDim1Size(), pParamData->get(_paramDataIndexInfo._startIndex).getDim2Size());

	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_SHORT, isFirstParam, pParamData->get(_paramDataIndexInfo._startIndex).getDim1Size(), pParamData->get(_paramDataIndexInfo._startIndex).getDim2Size());

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		int varIndex = 0;
		for (auto component : _paramsIndexList[_currentParamId])
		{
			short val = (pParamData->get(index))[component.getDim1Index()][component.getDim2Index()];
			_fileWriter->writeShortData(_currentParamId,varIndex,val, _downloadProperties.getPrecision());
			++varIndex;
		}
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab2DFloat *)
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataTab2DFloat *pParamData) {
	if (_paramsIndexList[_currentParamId].empty())
		buildParamIndexes(_currentParamId, pParamData->get(_paramDataIndexInfo._startIndex).getDim1Size(), pParamData->get(_paramDataIndexInfo._startIndex).getDim2Size());

	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_FLOAT, isFirstParam, pParamData->get(_paramDataIndexInfo._startIndex).getDim1Size(), pParamData->get(_paramDataIndexInfo._startIndex).getDim2Size());

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		int varIndex = 0;
		for (auto component : _paramsIndexList[_currentParamId])
		{
			float val = (pParamData->get(index))[component.getDim1Index()][component.getDim2Index()];
			_fileWriter->writeFloatData(_currentParamId,varIndex,val, _downloadProperties.getPrecision());
			++varIndex;
		}
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab2DDouble *)
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataTab2DDouble *pParamData) {
	if (_paramsIndexList[_currentParamId].empty())
		buildParamIndexes(_currentParamId, pParamData->get(_paramDataIndexInfo._startIndex).getDim1Size(), pParamData->get(_paramDataIndexInfo._startIndex).getDim2Size());

	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_DOUBLE, isFirstParam, pParamData->get(_paramDataIndexInfo._startIndex).getDim1Size(), pParamData->get(_paramDataIndexInfo._startIndex).getDim2Size());

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		int varIndex = 0;
		for (auto component : _paramsIndexList[_currentParamId])
		{
			double val = (pParamData->get(index))[component.getDim1Index()][component.getDim2Index()];
			_fileWriter->writeDoubleData(_currentParamId,varIndex,val, _downloadProperties.getPrecision());
			++varIndex;
		}
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab2DLongDouble *)
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataTab2DLongDouble *pParamData) {
	if (_paramsIndexList[_currentParamId].empty())
		buildParamIndexes(_currentParamId, pParamData->get(_paramDataIndexInfo._startIndex).getDim1Size(), pParamData->get(_paramDataIndexInfo._startIndex).getDim2Size());

	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_LONGDOUBLE, isFirstParam, pParamData->get(_paramDataIndexInfo._startIndex).getDim1Size(), pParamData->get(_paramDataIndexInfo._startIndex).getDim2Size());

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		int varIndex = 0;
		for (auto component : _paramsIndexList[_currentParamId])
		{
			long double val = (pParamData->get(index))[component.getDim1Index()][component.getDim2Index()];
			_fileWriter->writeLongDoubleData(_currentParamId,varIndex,val, _downloadProperties.getPrecision());
			++varIndex;
		}
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab2DInt *)
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataTab2DInt *pParamData) {
	if (_paramsIndexList[_currentParamId].empty())
			buildParamIndexes(_currentParamId, pParamData->get(_paramDataIndexInfo._startIndex).getDim1Size(), pParamData->get(_paramDataIndexInfo._startIndex).getDim2Size());

	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_INT, isFirstParam, pParamData->get(_paramDataIndexInfo._startIndex).getDim1Size(), pParamData->get(_paramDataIndexInfo._startIndex).getDim2Size());

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		int varIndex = 0;
		for (auto component : _paramsIndexList[_currentParamId])
		{
			int val = (pParamData->get(index))[component.getDim1Index()][component.getDim2Index()];
			_fileWriter->writeIntData(_currentParamId,varIndex,val, _downloadProperties.getPrecision());
			++varIndex;
		}
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab2DLogicalData *)
 */
void DownloadOutput::visit(AMDA::Parameters::ParamDataTab2DLogicalData *pParamData) {
	if (_paramsIndexList[_currentParamId].empty())
		buildParamIndexes(_currentParamId, pParamData->get(_paramDataIndexInfo._startIndex).getDim1Size(), pParamData->get(_paramDataIndexInfo._startIndex).getDim2Size());

	bool isFirstParam = (_currentParamId == _firstParamId);

	addParameterInFile(_currentParamId, FileWriter::FileDataType::DT_LOGICAL, isFirstParam, pParamData->get(_paramDataIndexInfo._startIndex).getDim1Size(), pParamData->get(_paramDataIndexInfo._startIndex).getDim2Size());

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index < _paramDataIndexInfo._nbDataToProcess + _paramDataIndexInfo._startIndex; ++index)
	{
		if (pParamData->getTime(index) > _currentTimeInterval->_stopTime)
			return;
		_fileWriter->writeTimeData(_currentParamId, pParamData->getTime(index), _downloadProperties.getTimeFormat(), isFirstParam);
		int varIndex = 0;
		for (auto component : _paramsIndexList[_currentParamId])
		{
			AMDA::Parameters::LogicalData val = (pParamData->get(index))[component.getDim1Index()][component.getDim2Index()];
			_fileWriter->writeLogicalData(_currentParamId,varIndex,val, _downloadProperties.getPrecision());
			++varIndex;
		}
		_fileWriter->goToNextRecord(_currentParamId);
	}
}

} /* namespace Download */
} /* namespace ParamOutputImpl */
} /* namespace AMDA */