/**
 * DownloadOutput.hh
 *
 *  Created on: 02 oct. 2014
 *      Author: AKKA
 */

#ifndef PARAMOUTPUTASCIIFILE_HH_
#define PARAMOUTPUTASCIIFILE_HH_

#include "ParamOutput.hh"
#include "DownloadProperties.hh"
#include "DownloadLogger.hh"
#include "FileWriter.hh"
#include "ParameterIndexesTool.hh"
#include "StatisticProcess.hh"
#include "Catalog.hh"

#include <memory>

namespace AMDA
{
	namespace ParamOutputImpl

	{

		namespace Download
		{

			/**
			 * @class DownloadOutput
			 * @brief Implementation of a ParamOutput to download data.
			 * @details
			 */
			class DownloadOutput : public AMDA::Parameters::VisitorOfParamData,
								   public AMDA::Parameters::ParamOutput
			{
			public:
				DownloadOutput(AMDA::Parameters::ParameterManager &pParameterManager);

				virtual ~DownloadOutput();

				/**
				 * @overload DataClient::establishConnection()
				 */
				virtual void establishConnection();

				/**
				 * @overload VisitorOfParamData::visit()
				 */
				virtual void visit(AMDA::Parameters::ParamDataScalaireShort *);

				/**
				 * @overload VisitorOfParamData::visit()
				 */
				virtual void visit(AMDA::Parameters::ParamDataScalaireFloat *);

				/**
				 * @overload VisitorOfParamData::visit()
				 */
				virtual void visit(AMDA::Parameters::ParamDataScalaireDouble *);

				/**
				 * @overload VisitorOfParamData::visit()
				 */
				virtual void visit(AMDA::Parameters::ParamDataScalaireLongDouble *);

				/**
				 * @overload VisitorOfParamData::visit()
				 */
				virtual void visit(AMDA::Parameters::ParamDataScalaireInt *);

				/**
				 * @overload VisitorOfParamData::visit()
				 */
				virtual void visit(AMDA::Parameters::ParamDataLogicalData *);

				/**
				 * @overload VisitorOfParamData::visit()
				 */
				virtual void visit(AMDA::Parameters::ParamDataTab1DShort *);

				/**
				 * @overload VisitorOfParamData::visit()
				 */
				virtual void visit(AMDA::Parameters::ParamDataTab1DFloat *);

				/**
				 * @overload VisitorOfParamData::visit()
				 */
				virtual void visit(AMDA::Parameters::ParamDataTab1DDouble *);

				/**
				 * @overload VisitorOfParamData::visit()
				 */
				virtual void visit(AMDA::Parameters::ParamDataTab1DLongDouble *);

				/**
				 * @overload VisitorOfParamData::visit()
				 */
				virtual void visit(AMDA::Parameters::ParamDataTab1DInt *);

				/**
				 * @overload VisitorOfParamData::visit()
				 */
				virtual void visit(AMDA::Parameters::ParamDataTab1DLogicalData *);

				/**
				 * @overload VisitorOfParamData::visit(ParamDataTab2DShort *)
				 */
				virtual void visit(AMDA::Parameters::ParamDataTab2DShort *);

				/**
				 * @overload VisitorOfParamData::visit(ParamDataTab2DFloat *)
				 */
				virtual void visit(AMDA::Parameters::ParamDataTab2DFloat *);

				/**
				 * @overload VisitorOfParamData::visit(ParamDataTab2DDouble *)
				 */
				virtual void visit(AMDA::Parameters::ParamDataTab2DDouble *);

				/**
				 * @overload VisitorOfParamData::visit(ParamDataTab2DLongDouble *)
				 */
				virtual void visit(AMDA::Parameters::ParamDataTab2DLongDouble *);

				/**
				 * @overload VisitorOfParamData::visit(ParamDataTab2DInt *)
				 */
				virtual void visit(AMDA::Parameters::ParamDataTab2DInt *);

				/**
				 * @overload VisitorOfParamData::visit(ParamDataTab2DLogicalData *)
				 */
				virtual void visit(AMDA::Parameters::ParamDataTab2DLogicalData *);

				/*
				 * @brief Get Download request properties
				 */
				DownloadProperties &getDownloadProperties()
				{
					return _downloadProperties;
				}

				/*
				 * @brief Set Download request properties
				 */
				void setDownloadProperties(const DownloadProperties &downloadProperties)
				{
					_downloadProperties = downloadProperties;
				}
				/*
				 * @brief add semi-variable and fully variable table indexes to the current download
				 */
				void addAditionalDownloadParams(std::string paramId, bool isFullVariable);

			protected:
				/**
				 * @overload ParamOutput::init()
				 */
				virtual void init();

				/**
				 * @overload ParamOutput::apply()
				 */
				virtual void apply();

				/*
				 * @brief write information in file
				 */

				void writeInfo(bool isWriteIntervalInfo, bool isWriteOnlyIntervalInfo,
							   bool isFinalizeInfoFile);

				/*
				 * @brief write Table information in file
				 */
				void writeTableInfo();

				/*
				 * @brief write AMDA information
				 */
				void writeAMDAInfo(void);

				/*
				 * @brief write request information
				 */
				void writeRequestInfo(void);

				/*
				 * @brief write param information
				 */
				void writeParamInfo(void);

				/*
				 * @brief write current interval information
				 */
				void writeIntervalInfo();

				/*
				 * @overload ParamOutput::terminate - Terminate output: Write too small intervals file
				 */
				virtual void terminate(void);

				/*
				 * @brief Create a new data file
				 */
				void createNewDataFile(void);

				/*
				 * @brief Create parameters in relation with the download properties
				 */
				void createParameters(void);

				/*
				 * @brief create file writer associated to the requested file format
				 */
				void createFileWriter(void);

				/*
				 * @brief Get file path in relation with the sequence step
				 */
				std::string getFilePath(std::string extension, bool infoFile = false);

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

				/*
				 * @brief Get file table info path in relation with the sequence step (only used if info constant or variable but finite table)
				 */
				std::string getTableInfoFilePath(std::string extension);

				/*
				 * @brief Apply structure for "one-file"
				 */
				void applyOneFileStructure(bool separateInfoFile, bool isFirstInterval);

				/*
				 * @brief Apply structure for "one-file-per-interval"
				 */
				void applyOneFilePerInterval(bool separateInfoFile, bool isFirstInterval);

				/*
				 * @brief Apply structure for "one-file-per-parameter-per-interval"
				 */
				void applyOneFilePerParameterPerInterval(bool separateInfoFile, bool isFirstInterval);

				/*
				 * @brief Get parameter from server and write it
				 */
				void getParameterDataFromServer(std::string paramId);

				/*
				 * @brief Add the parameter definition in the current file if needed
				 */
				void addParameterInFile(std::string paramId, FileWriter::FileDataType type, bool isFirstParam, int dim1Size = 1, int dim2Size = 1);

				/*
				 * @brief Get parameter indexes
				 */
				void buildParamIndexes(std::string paramId, int dim1Size = 1, int dim2Size = 1);

				/*
				 * @brief To know if we need to create a too small interval file
				 */
				bool isNeedToGenerateTooSmallIntervalFile(void);

				/*
				 * @brief Build a too small interval file
				 */
				void buildTooSmallIntervalCatalog(void);

				/*
				 * @brief Init mean processes for small interval treatments
				 */
				void initMeanProcessMapForSmallInterval(std::map<std::string, std::shared_ptr<AMDA::Parameters::StatisticProcess>> &meanProcessMap);

				/*
				 * @brief list of tables
				 */
				std::vector<std::string> _tableParamsList;
				/*
				 * @brief Furkan
				 */
				bool isSeveralIntervals;

			private:
				/**
				 * Download properties
				 */
				DownloadProperties _downloadProperties;

				/*
				 * File writer
				 */
				FileWriter::FileWriter *_fileWriter;

				/**
				 * @brief id of current output parameter.
				 */
				std::string _currentParamId;

				/**
				 * @brief id of the first output parameter.
				 */
				std::string _firstParamId;

				/**
				 * @brief list of indexes list for all output parameters (build during the first visit of each parameters)
				 */
				std::map<std::string, AMDA::Common::ParameterIndexComponentList> _paramsIndexList;

				/*
				 * @brief map to know if a parameter is already added in the current file
				 */
				std::map<std::string, bool> _paramDefinedInFile;

				/*
				 * @brief map of mean statistic processes for too small intervals
				 */
				std::map<std::string, std::shared_ptr<AMDA::Parameters::StatisticProcess>> _tooSmallIntervalProcessMap;

				/*
				 * @brief Index of current interval
				 */
				int _currentIntervalIndex;

				/*
				 * @brief Catalog for too small time intervals
				 */
				TimeTableCatalog::Catalog _smallIntervalsCatalog;
				;
			};

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

} /* namespace AMDA */

#endif /* PARAMOUTPUTASCIIFILE_HH_ */