/**
 * 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 "Process.hh"

#include "Properties.hh"
#include "TimeUtil.hh"
#include "AMDA-Kernel_Config.hh"

#include "Parameter.hh"

#include <algorithm>

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

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

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

using namespace std::chrono;

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);

                        AMDA::Parameters::ParameterSPtr param = _parameterManager.getParameter(paramProperties->getOriginalId());

                        AMDA::Info::ParamInfoSPtr paramInfo = AMDA::Info::ParamMgr::getInstance()->getParamInfoFromId(paramProperties->getOriginalId());

                        // adding tableParams
                        std::map<int, boost::shared_ptr<AMDA::Info::ParamTable>> tables = paramInfo->getTables();
                        if (!tables.empty())
                        {
                            for (auto table : tables)
                            {
                                if (table.second != nullptr)
                                {
                                    if (table.second->isVariable(&_parameterManager))
                                    {

                                        std::map<std::string, std::string> tableParamIds = table.second->getTableParams(&_parameterManager);
                                        if (!tableParamIds.empty())

                                            for (auto tableParamId : tableParamIds)
                                            {

                                                AMDA::Parameters::ParameterSPtr tableParam = _parameterManager.getParameter(tableParamId.second);

                                                if ((_downloadProperties.getTimeResolution() > 0) && (_downloadProperties.getOutputStructure() != ONE_FILE_PER_PARAMETER_PER_INTERVAL))
                                                {

                                                    // Use resampled table param
                                                    tableParam = _parameterManager.getSampledParameter(

                                                        tableParamId.second,
                                                        "classic",
                                                        _downloadProperties.getTimeResolution(),
                                                        tableParam->getGapThreshold(), true);

                                                }

                                                tableParam->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;
                    }
                }

            }

            void DownloadOutput::addAditionalDownloadParams(std::string paramId, bool isFullVariable)
            {

                AMDA::Parameters::ParameterSPtr pParam = _parameterManager.getParameter(paramId);

                if (pParam == NULL || _downloadProperties.getParamPropertiesFromOriginalId(paramId) != NULL)

                    return;
                AMDA::Info::ParamInfoSPtr processInfo = AMDA::Info::ParamMgr::getInstance()->getParamInfoFromId(paramId);

                if (isFullVariable || (pParam->isTableIndexParam() && processInfo->getProcessInfo().empty()))
                {
                    if ((_downloadProperties.getTimeResolution() > 0) && (_downloadProperties.getOutputStructure() != ONE_FILE_PER_PARAMETER_PER_INTERVAL))
                    {
                        // Use resampled table param

                        pParam = _parameterManager.getSampledParameter(

                            paramId,
                            "classic",
                            _downloadProperties.getTimeResolution(),
                            pParam->getGapThreshold(), true);

                    }

                    pParam->openConnection(this);

                    ParamProperties *paramProperties = new ParamProperties();

                    paramProperties->setOriginalId(paramId);

                    paramProperties->setOutputId(pParam->getId());

                    _downloadProperties.addParamProperties(paramProperties);
                    pParam->init(this, _timeIntervalList);

                }
                AMDA::Info::ParamInfoSPtr paramInfo = AMDA::Info::ParamMgr::getInstance()->getParamInfoFromId(paramId);

                const std::vector<std::string> &paramLinkedParams = paramInfo->getLinkedParamList();

                for (auto pId : paramLinkedParams)
                    addAditionalDownloadParams(pId, false);

            }

            /**
             * @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);

                        AMDA::Parameters::ParameterSPtr param = _parameterManager.getParameter(paramProperties->getOriginalId());

                        AMDA::Info::ParamInfoSPtr paramInfo = AMDA::Info::ParamMgr::getInstance()->getParamInfoFromId(paramProperties->getOriginalId());

                        // adding tableParams
                        std::map<int, boost::shared_ptr<AMDA::Info::ParamTable>> tables = paramInfo->getTables();
                        if (!tables.empty())
                        {

                            _tableParamsList.push_back(paramProperties->getOriginalId());

                            for (auto table : tables)
                            {
                                if (table.second != nullptr && table.second->isVariable(&_parameterManager))
                                {

                                    std::map<std::string, std::string> tableParamIds = table.second->getTableParams(&_parameterManager);
                                    if (!tableParamIds.empty())

                                        for (auto tableParamId : tableParamIds)
                                        {

                                            AMDA::Parameters::ParameterSPtr tableParam = _parameterManager.getParameter(tableParamId.second);
                                            if (tableParam == NULL)
                                                continue;

                                            if ((_downloadProperties.getTimeResolution() > 0) && (_downloadProperties.getOutputStructure() != ONE_FILE_PER_PARAMETER_PER_INTERVAL))
                                            {
                                                // Use resampled table param

                                                tableParam = _parameterManager.getSampledParameter(

                                                    tableParamId.second,
                                                    "classic",
                                                    _downloadProperties.getTimeResolution(),
                                                    tableParam->getGapThreshold(), true);

                                            }

                                            tableParam->init(this, _timeIntervalList);
                                            if (table.second->isFullVariable(&_parameterManager))
                                            {

                                                addAditionalDownloadParams(tableParam->getId(), true);

                                            }
                                            else
                                            {

                                                _tableParamsList.push_back(tableParam->getId());

                                            }

                                            AMDA::Info::ParamInfoSPtr tableInfo = AMDA::Info::ParamMgr::getInstance()->getParamInfoFromId(tableParam->getId());

                                            for (auto linkedParamId : tableInfo->getLinkedParamList())
                                            {

                                                addAditionalDownloadParams(linkedParamId, false);
                                            }
                                        }

                                }
                            }
                        }

                    }
                    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(

                    _downloadProperties.getSeparateInfoFile(),
                    _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(separateInfoFile, 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();

                    if (!_tableParamsList.empty())
                    {

                        std::string filePath = getTableInfoFilePath(_fileWriter->getExtension());

                        if (!_fileWriter->createNewFile(filePath))
                        {

                            LOG4CXX_ERROR(_logger, "DownloadOutput::apply : Cannot create table info file " << filePath);
                            BOOST_THROW_EXCEPTION(AMDA::Parameters::ParamOutput_exception());
                        }
                        _files.push_back(filePath);

                        // write info

                        writeAMDAInfo();

                        _fileWriter->writeTableParamsInfo(_tableParamsList, 0);
                        _fileWriter->finalize(true);

                    }

                }
                catch (...)
                {

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

            }

            /*
             * @brief Apply structure for "one-file"
             */

            void DownloadOutput::applyOneFileStructure(bool separateInfoFile, bool isFirstInterval)
            {

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

                // create a data file
                if (isFirstInterval)
                {
                    if (separateInfoFile)
                    {
                        // 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);
                    }

                    createNewDataFile();
                }

                // write data for each parameters

                for (auto paramProperties : _downloadProperties.getParamPropertiesList())
                    getParameterDataFromServer(paramProperties->getOutputId());

                // write info
                if (isFirstInterval)
                {
                    if (!separateInfoFile)
                    {
                        // write all info
                        writeInfo(true, 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::writeTableInfo()
            {

                // writeTableInfo(); comme

            }

            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);

                if (_timeIntervalList->size() > 1 && (_downloadProperties.getOutputStructure()== ONE_FILE || _downloadProperties.getOutputStructure()== ONE_FILE_REFPARAM ))

                {
                    DownloadOutput::isSeveralIntervals = true;
                    _parseTimeInterval = _timeIntervalList->end();
                    _parseTimeInterval--;
                    TimeUtil::formatTimeDateInIso(_parseTimeInterval->_stopTime, stopTime);
                }

                else

                {
                    DownloadOutput::isSeveralIntervals = false;
                    TimeUtil::formatTimeDateInIso(_currentTimeInterval->_stopTime, stopTime);
                }
                _fileWriter->writeIntervalInfo(startTime.str(), stopTime.str(), isSeveralIntervals);

            }

            void DownloadOutput::writeParamInfo()
            {

                _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(), true);
                                // 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(), true);

                                    // 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(), true);

                                        // 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);
                    _fileWriter->setTimeFormat(_downloadProperties.getTimeFormat());
                    break;
                case JSON_FILE_FORMAT:
                    _fileWriter = new FileWriter::FileWriterASCIIJson(_parameterManager);
                    _fileWriter->setTimeFormat(_downloadProperties.getTimeFormat());
                    break;
                case VOT_FILE_FORMAT:
                    _fileWriter = new FileWriter::FileWriterASCIIVOTable(_parameterManager);
                    _fileWriter->setTimeFormat(_downloadProperties.getTimeFormat());
                    break;
                case CDF_FILE_FORMAT:
                    _fileWriter = new FileWriter::FileWriterCDF(_parameterManager);
                    _fileWriter->setTimeFormat(_downloadProperties.getTimeFormat());
                    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 << "/";

                std::stringstream fileName;

                if (_downloadProperties.getFileName().empty())
                {

                    fileName << "output-";

                    // 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)
                            fileName << "_";
                        firstParam = false;

                        fileName << paramProperties->getOriginalId();

                        // add indexes
                        for (auto index : paramProperties->getIndexDefList())
                        {

                            boost::replace_all(index, "[", "");
                            boost::replace_all(index, "]", "");
                            boost::replace_all(index, "*", "x");
                            fileName << "_" << index;
                        }

                    }

                    std::stringstream fileNameSuffix;

                    if (!infoFile)
                    {

                        if ((_downloadProperties.getOutputStructure() != ONE_FILE) &&

                            (_downloadProperties.getOutputStructure() != ONE_FILE_REFPARAM) &&
                            (_parameterManager.getInputIntervals()->size() != 1))
                        {
                            // add interval index

                            fileNameSuffix << "_" << _currentTimeInterval->_ttName;

                            fileNameSuffix << "_" << _currentIntervalIndex;

                        }
                        else
                        {
                            if (_currentTimeInterval->_ttName.empty())
                            {
                                // add start time

                                double lStartTime = _currentTimeInterval->_startTime;
                                char buffer[TIMELENGTH];
                                Double2DD_Time(buffer, lStartTime);
                                fileNameSuffix << "_" << buffer;

                            }
                            else
                            {
                                // add TT name

                                fileNameSuffix << "_" << _currentTimeInterval->_ttName;
                            }

                        }

                    }
                    else

                        fileNameSuffix << "_info";

                    // check fileName size
                    if (fileName.str().size() + extension.size() + 1 + fileNameSuffix.str().size() > 100)
                    {

                        filePath << fileName.str().substr(0, 100 - extension.size() - 1 - fileNameSuffix.str().size()) << fileNameSuffix.str();

                    }
                    else
                    {

                        filePath << fileName.str() << fileNameSuffix.str();
                    }

                }
                else
                {
                    if (!infoFile)
                    {

                        if ((_downloadProperties.getOutputStructure() != ONE_FILE) &&

                            (_downloadProperties.getOutputStructure() != ONE_FILE_REFPARAM) &&
                            (_parameterManager.getInputIntervals()->size() != 1))
                        {
                            std::stringstream fileNameSuffix;
                            // add interval index
                            fileNameSuffix << _currentIntervalIndex;
                            filePath << _downloadProperties.getFileName() << fileNameSuffix.str();
                        }
                        else
                            filePath << _downloadProperties.getFileName();
                    }
                    else
                    {

                        filePath << _downloadProperties.getFileName() << "_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);
            }

            /*

             * @brief Get file info path in relation with the sequence step (only used if info is written is separate file)

             */

            std::string DownloadOutput::getTableInfoFilePath(std::string extension)
            {

                std::string suffix = "_table";

                std::string path = getInfoFilePath(extension);

                int pos = path.size() - extension.size() - 1;
                pos = std::max(pos, 0);
                path.insert(pos, suffix);

                return path;

            }

            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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

            /**
             * @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, isFirstParam);

                }

                if (_paramDataIndexInfo._nbDataToProcess > 0)
                    _fileWriter->flushData(_currentParamId, isFirstParam);

            }

        } /* namespace Download */

    }     /* namespace ParamOutputImpl */

} /* namespace AMDA */