/*
 * PlotOutput.cc
 *
 *  Created on: 28 oct. 2013
 *      Author: CS
 */

#include "PlotOutput.hh"
#include "PlotLogger.hh"
#include <fstream>
#include "PlotLogger.hh"
#include "LayoutAuto.hh"
#include "LayoutVertical.hh"

namespace plot {

PlotOutput::PlotOutput(AMDA::Parameters::ParameterManager& pParameterManager) :
		AMDA::Parameters::VisitorOfParamData(), ParamOutput(pParameterManager),
		_currentParamId(""), _outputStructure(OutputStructure::ONE_FILE_PER_INTERVAL) {

}

PlotOutput::~PlotOutput()
{

}

/**
 * @overload DataClient::establishConnection()
 */
void PlotOutput::establishConnection()
{
	LOG4CXX_DEBUG(gLogger,"PlotOutput::establishConnection");
	//create all needed parameters
	for (auto plot : _plots)
		plot->createParameters(_usedParametersId);

	//open connection for all needed parameters
	for (auto paramId : _usedParametersId)
	{
		LOG4CXX_DEBUG(gLogger,"PlotOutput::establishConnection - " << paramId);
		_parameterManager.getParameter(paramId)->openConnection(this);
	}
}

/**
 * @overload ParamOutput::init()
 */
void PlotOutput::init()
{
	LOG4CXX_DEBUG(gLogger,"PlotOutput::init");
	//init all needed parameters
	for (auto paramId : _usedParametersId)
	{
		try {
			//init parameter
			LOG4CXX_DEBUG(gLogger,"PlotOutput::init - " << paramId);
			_parameterManager.getParameter(paramId)->init(this, _timeIntervalList);
		} catch (...) {
			LOG4CXX_ERROR(_logger,
					"PlotOutput::init parameter : \""<< paramId <<"\" Error");
			throw;
		}
	}
}

/**
 * Gets parameter value from server and stores them into dedicated
 * structure.
 */
void PlotOutput::getDataFromServer()
{
	LOG4CXX_DEBUG(gLogger,"PlotOutput::getDataFromServer");
	// request data from server
	// get data and call visitor to store them into dedicated structure
	for (auto paramId : _usedParametersId)
	{
		try {
			_currentParamId = paramId;

			LOG4CXX_DEBUG(gLogger,"PlotOutput::getDataFromServer - " << paramId);

			_paramDataIndexInfo = _parameterManager.getParameter(paramId)->getAsync(this).get();

			while (_paramDataIndexInfo._nbDataToProcess > 0)
			{
				_parameterManager.getParameter(paramId)->getParamData(this)->accept(*this);

				if (_paramDataIndexInfo._timeIntToProcessChanged)
					break;

				_paramDataIndexInfo = _parameterManager.getParameter(paramId)->getAsync(this).get();
			}
		}catch (...) {
			LOG4CXX_ERROR(gLogger,
				"apply Error.\nCannot get or write data for parameter: \""
					+ paramId + "\".");
			throw;
		}
	}
}

/**
 * @overload ParamOutput::apply()
 */
void PlotOutput::apply() {
	LOG4CXX_DEBUG(gLogger,"PlotOutput::apply");
	_currentTimeInterval = _timeIntervalList->begin();

	_files.clear();

	if (_timeIntervalList->empty())
	{
		LOG4CXX_DEBUG(gLogger,"PlotOutput::apply - Nothing to plot");
		return;
	}

	//set time intervals list to each plot
	for (auto plot : _plots)
		plot->setTimeIntervalListPtr(_timeIntervalList.get());

	if (_page->_superposeMode == false)
		drawOneIntervalByPage();
	else
		drawAllIntervalsInOnePage();

	_pls.reset();

	// reset iterator on intervals
	_currentTimeInterval = _timeIntervalList->begin();
}

/**
 * @brief Init new page - Create also the new file if necessary
 */
void PlotOutput::initNewPage(int intervalIndex)
{
	LOG4CXX_DEBUG(gLogger,"PlotOutput::initNewPage");
	std::stringstream plotFilePrefix;

	//create new plplot stream for new file :
	// * if ONE_FILE : one file for all time interval
	// * if ONE_FILE_PER_INTERVAL : one file for one time interval
	bool newFile = ((_pls == nullptr) || (_outputStructure == OutputStructure::ONE_FILE_PER_INTERVAL));
	if (newFile)
		_pls.reset(new plstream());

	//set file prefix
	plotFilePrefix.str("");
	if ((_timeIntervalList->size() > 1) &&
		(_outputStructure == OutputStructure::ONE_FILE_PER_INTERVAL) &&
		!_page->_superposeMode)
		plotFilePrefix << "plot_" << intervalIndex << "_";
	else
		plotFilePrefix << "plot_";

	//draw page
	_page->draw(_pls, newFile, plotFilePrefix.str().c_str());
}

/*
 * @brief Sequence to draw one interval by page
 */
void PlotOutput::drawOneIntervalByPage()
{
	LOG4CXX_DEBUG(gLogger,"PlotOutput::drawOneIntervalByPage");
	while (_currentTimeInterval != _timeIntervalList->end())
	{
		//get parameters data
		getDataFromServer();

		//init the page
		initNewPage(_currentTimeInterval->_index);

		// Compute panel position depending on the page layout
		computePanelBounds();

		// Initialize panel plot
		for (auto plot : _plots) {
			// set current plplot stream for plot,
			plot->setPlStream(_pls);
			// set link to parameters data
			plot->setParameterValues(&_parameterValues);
			// prepare plot area for each panel
			plot->preparePlotArea(_currentTimeInterval->_startTime, _currentTimeInterval->_stopTime, _currentTimeInterval->_index);
		}

		// Compute and set panel plot area position depending on the panel constraints
		computePanelPlotAreaBounds();

		// Compute and set left axis tickmark width depending on the panel constraints
		computePanelLegendPosition();

		//Draw all PanelPlot -
		for (auto plot : _plots) {
			//draw the panel plot output
			plot->draw(
					_currentTimeInterval->_startTime,
					_currentTimeInterval->_stopTime,
					_currentTimeInterval->_index,
					//is first intervals?
					_currentTimeInterval == _timeIntervalList->begin(),
					//is second intervals?
					_currentTimeInterval == std::prev(_timeIntervalList->end()));
			//prepare for the next time interval
			plot->reset();
		}

		//reset all data
		for (auto paramId : _usedParametersId)
			_parameterValues[paramId].reset();

		//add file to file list for post processing
		_files.push_back(_page->_fileName);

		//go to next interval
		++_currentTimeInterval;
	}
}

void PlotOutput::drawAllIntervalsInOnePage()
{
	LOG4CXX_DEBUG(gLogger,"PlotOutput::drawAllIntervalsInOnePage");
	/*
	 * First step : init page, panel and plot area
	 */

	double globalStartTime = _timeIntervalList->front()._startTime;
	double globalStopTime  = _timeIntervalList->back()._stopTime;

	//get all data for all intervals
	while (_currentTimeInterval != _timeIntervalList->end())
	{
		//get parameters data
		getDataFromServer();

		//go to next interval
		++_currentTimeInterval;
	}

	//init the page
	initNewPage(0);

	//Compute panel position depending on the page layout
	computePanelBounds();

	//Initialize panel plot
	for (auto plot : _plots)
	{
		// set current plplot stream for plot,
		plot->setPlStream(_pls);
		// set link to parameters data
		plot->setParameterValues(&_parameterValues);
		// prepare plot area for each panel
		plot->preparePlotArea(globalStartTime, globalStopTime, 0);
	}

	// Compute and set panel plot area position depending on the panel constraints
	computePanelPlotAreaBounds();

	// Compute and set left axis tickmark width depending on the panel constraints
	computePanelLegendPosition();

	/*
	 * Second step : Draw plot for each intervals
	 */
	_currentTimeInterval = _timeIntervalList->begin();

	while (_currentTimeInterval != _timeIntervalList->end())
	{
		//Draw all PanelPlot -
		for (auto plot : _plots)
		{
			//draw the panel plot output
			plot->draw(
					_currentTimeInterval->_startTime,
					_currentTimeInterval->_stopTime,
					_currentTimeInterval->_index,
					//is first interval?
					_currentTimeInterval == _timeIntervalList->begin(),
					//is second interval?
					_currentTimeInterval == std::prev(_timeIntervalList->end()));
		}

		//go to next interval
		++_currentTimeInterval;
	}

	/*
	 * Third step : reset plots and data and prepare for post processing
	 */
	for (auto plot : _plots)
		plot->reset();

	//reset all data
	for (auto paramId : _usedParametersId)
		_parameterValues[paramId].reset();

	//add file to file list for post processing
	_files.push_back(_page->_fileName);
}

/**
 * @brief Gets a list of plots on the same panel
 */
std::vector<boost::shared_ptr<PanelPlotOutput>> PlotOutput::getPlots(Panel* panel_){
	std::vector<boost::shared_ptr<PanelPlotOutput>> plots;
	for(auto plot : _plots){
		if(plot->_panel->_id == panel_->_id){
			plots.push_back(plot);
		}
	}
	return plots;
}

void PlotOutput::computePanelBounds(void) {
	// Nothing to plot -> nothing to compute !
	// Nothing to compute if layout type is manual
	if ((_plots.empty() == true) ||
		(_page->_layoutProperties.getType() == LayoutType::MANUAL))	{
		return;
	}

	LOG4CXX_DEBUG(gLogger,"PlotOutput::computePanelBounds...");

	// Compute page XY ratio
	std::tuple<float, float> pageSizeInMm = _page->getSizeInMm();

	double xyRatio 	= (std::get<0>(pageSizeInMm) * (1.0 - 2.0 * _page->_xMargin))
					/ (std::get<1>(pageSizeInMm) * (1.0 - 2.0 * _page->_yMargin));

	// Build a new layout depending on the layout type
	Layout *pLayout;
	if (_page->_layoutProperties.getType() == LayoutType::AUTO) {
		pLayout = new LayoutAuto (
					_page->_layoutProperties.getPanelHeight(),
					_page->_layoutProperties.getPanelSpacing(),
					_page->_layoutProperties.getFirstPanelHeightFactor(),
					_page->_layoutProperties.isExpand(),
					xyRatio);
	} else {
		pLayout = new LayoutVertical (
					_page->_layoutProperties.getPanelHeight(),
					_page->_layoutProperties.getPanelSpacing(),
					_page->_layoutProperties.getFirstPanelHeightFactor(),
					_page->_layoutProperties.isExpand(),
					xyRatio);
	}

	// Add panels constraint to the layout
	for (auto plot : _plots) {
		pLayout->addPanel ( plot->getLayoutConstraint(),
							plot->_panel->_preferedWidth,
							plot->_panel->_preferedHeight);
	}

	// Reset layout
	pLayout->reset();

	// Compute panel bounds depending on the constraints
	for (auto plot : _plots) {
		plot->_panel->_bounds = pLayout->getNextBounds (plot->getLayoutConstraint());
	}

	delete pLayout;
}

void PlotOutput::computePanelPlotAreaBounds(void) {
	// Nothing to plot -> nothing to compute !
	// Nothing to compute if layout type is manual
	if ((_plots.empty() == true) ||
		(_page->_layoutProperties.getType() == LayoutType::MANUAL))	{
		return;
	}

	LOG4CXX_DEBUG(gLogger,"PlotOutput::computePanelPlotAreaBounds...");

	// Retrieve plotarea minimal dimensions for each (MaxWidth constraint) panels

	double plotAreaMinX = 0.0, plotAreaMaxX = 1.0;
	Bounds plotAreaBounds;
	for (auto plot : _plots) {
		if (plot->getLayoutConstraint() == PanelConstraint::MaxWidth) {
			plot->getPlotAreaBounds(plotAreaBounds);

			if (plotAreaBounds._x > plotAreaMinX)
				plotAreaMinX = plotAreaBounds._x;

			if ((plotAreaBounds._x + plotAreaBounds._width) < plotAreaMaxX)
				plotAreaMaxX = (plotAreaBounds._x + plotAreaBounds._width);
		}
	}

	// Force plot area position for panels with MaxWidth constraint
	for (auto plot : _plots) {
		if (plot->getLayoutConstraint() == PanelConstraint::MaxWidth) {
			plot->forcePlotAreaPosAndWidth(plotAreaMinX, plotAreaMaxX - plotAreaMinX);
		}
	}
}

void PlotOutput::computePanelLegendPosition(void) {
	// Nothing to plot -> nothing to compute !
	// Nothing to compute if layout type is manual
	if ((_plots.empty() == true) ||
		(_page->_layoutProperties.getType() == LayoutType::MANUAL))	{
		return;
	}

	LOG4CXX_DEBUG(gLogger,"PlotOutput::computePanelLegendPosition...");

	// Retrieve left axis tickmark size for each (MaxWidth constraint) panels

	int maxLeftAxisTickMarkWitdh = 0;
	int leftAxisTickMarkWitdh = 0;
	for (auto plot : _plots) {
		if (plot->getLayoutConstraint() == PanelConstraint::MaxWidth) {
			leftAxisTickMarkWitdh = plot->getLeftAxisTickMarkWidth();

			if (leftAxisTickMarkWitdh > maxLeftAxisTickMarkWitdh)
				maxLeftAxisTickMarkWitdh = leftAxisTickMarkWitdh;
		}
	}

	// Force plot left axis tickmark max width for panels with MaxWidth constraint
	for (auto plot : _plots) {
		if (plot->getLayoutConstraint() == PanelConstraint::MaxWidth) {
			plot->forceLeftAxisTickMarkWidth(maxLeftAxisTickMarkWitdh);
		}
	}
}

/**
 * @brief Get the list of indexes used for a vector parameter
 */
template<typename Type>
std::vector<AMDA::Common::ParameterIndexComponent> PlotOutput::getParamUsedIndexes(std::string paramId, AMDA::Parameters::ParamDataSpec<std::vector<Type>>* pParamData)
{
	std::vector<AMDA::Common::ParameterIndexComponent> indexes;

	for (auto plot : _plots) {
		std::vector<AMDA::Common::ParameterIndexComponent> plotIndexes =
				plot->getParamUsedIndexes(paramId,pParamData->get(_paramDataIndexInfo._startIndex).size());

		for (auto index : plotIndexes)
		{
			//push indexes
			if (std::find(indexes.begin(),indexes.end(),index) != indexes.end())
				continue;
			indexes.push_back(index);
		}
	}

	if (indexes.empty())
		indexes.push_back(AMDA::Common::ParameterIndexComponent(-1,-1));

	if (std::find(indexes.begin(),indexes.end(),AMDA::Common::ParameterIndexComponent(-1,-1)) != indexes.end())
	{
		indexes.clear();
		for (unsigned int i = 0; i < pParamData->get(_paramDataIndexInfo._startIndex).size(); ++i)
			indexes.push_back(AMDA::Common::ParameterIndexComponent(i));
	}

	_parameterValues[paramId].setDim1Size(pParamData->get(_paramDataIndexInfo._startIndex).size());

	return indexes;
}

/**
 * @brief Get the list of indexes used for a Tab2D parameter
 */
template<typename Type>
std::vector<AMDA::Common::ParameterIndexComponent> PlotOutput::getParamUsedIndexes(std::string paramId, AMDA::Parameters::ParamDataSpec<AMDA::Parameters::Tab2DData<Type>>* pParamData)
{
	std::vector<AMDA::Common::ParameterIndexComponent> indexes;

	for (auto plot : _plots) {
		std::vector<AMDA::Common::ParameterIndexComponent> plotIndexes = plot->getParamUsedIndexes(paramId,
				pParamData->get(_paramDataIndexInfo._startIndex).getDim1Size(),
				pParamData->get(_paramDataIndexInfo._startIndex).getDim2Size());

		for (auto index : plotIndexes)
		{
			if (std::find(indexes.begin(),indexes.end(),index) != indexes.end())
				continue;
			indexes.push_back(index);
		}
	}

	if (indexes.empty())
		indexes.push_back(AMDA::Common::ParameterIndexComponent(-1,-1));

	if (std::find(indexes.begin(),indexes.end(),AMDA::Common::ParameterIndexComponent(-1,-1)) != indexes.end())
	{
		indexes.clear();
		for (int i = 0; i < pParamData->get(_paramDataIndexInfo._startIndex).getDim1Size(); ++i)
			for (int j = 0; j < pParamData->get(_paramDataIndexInfo._startIndex).getDim2Size(); ++j)
				indexes.push_back(AMDA::Common::ParameterIndexComponent(i,j));
	}

	_parameterValues[paramId].setDim1Size(pParamData->get(_paramDataIndexInfo._startIndex).getDim1Size());
	_parameterValues[paramId].setDim2Size(pParamData->get(_paramDataIndexInfo._startIndex).getDim2Size());

	return indexes;
}

/**
 * @brief Get the list of indexes used for a parameter
 */
template<class ParamData>
double PlotOutput::getParamGapSize(std::string paramId, ParamData* pParamData)
{
	try {
		AMDA::Parameters::ParameterSPtr crtParam = _parameterManager.getParameter(paramId);
		return _parameterManager.getComputedGapSize(crtParam->getGapThreshold(),
			pParamData->getMinSampling());
	} catch(...) {
		LOG4CXX_ERROR(gLogger,
				"apply Error.\nCannot get parameter gap size: \""
					+ paramId + "\".");
		throw;
	}
}

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

/**
 * @overload VisitorOfParamData::visit(ParamDataScalaireShort *)
 */
void PlotOutput::visit(
		AMDA::Parameters::ParamDataScalaireShort * pParamData) {
	double gapSize = getParamGapSize(_currentParamId, pParamData);
	bool gapDetected = false;
	//ParamDataScalaireShort
	ParameterData& crtParameterData = _parameterValues[_currentParamId];
	AMDA::Common::ParameterIndexComponent componentIndex = AMDA::Common::ParameterIndexComponent(-1,-1);

	crtParameterData.preAllocate(_paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex);

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index
					< _paramDataIndexInfo._nbDataToProcess
							+ _paramDataIndexInfo._startIndex; ++index) {
		crtParameterData.addValue(
			pParamData->getTime(index),
			pParamData->get(index),
			pParamData->getMinSampling(),
			gapSize, gapDetected, componentIndex);
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataScalaireFloat *)
 */
void PlotOutput::visit(
		AMDA::Parameters::ParamDataScalaireFloat * pParamData) {
	double gapSize = getParamGapSize(_currentParamId, pParamData);
	bool gapDetected = false;;
	//ParamDataScalaireFloat
	ParameterData& crtParameterData = _parameterValues[_currentParamId];
	AMDA::Common::ParameterIndexComponent componentIndex = AMDA::Common::ParameterIndexComponent(-1,-1);

	crtParameterData.preAllocate(_paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex);

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index
					< _paramDataIndexInfo._nbDataToProcess
							+ _paramDataIndexInfo._startIndex; ++index)
	{
		crtParameterData.addValue(
			pParamData->getTime(index),
			pParamData->get(index),
			pParamData->getMinSampling(),
			gapSize, gapDetected, componentIndex);
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataScalaireDouble *)
 */
void PlotOutput::visit(
		AMDA::Parameters::ParamDataScalaireDouble * pParamData) {
	double gapSize = getParamGapSize(_currentParamId, pParamData);
	bool gapDetected = false;;
	//ParamDataScalaireDouble
	ParameterData& crtParameterData = _parameterValues[_currentParamId];
	AMDA::Common::ParameterIndexComponent componentIndex = AMDA::Common::ParameterIndexComponent(-1,-1);

	crtParameterData.preAllocate(_paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex);

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index
					< _paramDataIndexInfo._nbDataToProcess
							+ _paramDataIndexInfo._startIndex; ++index) {
		crtParameterData.addValue(
			pParamData->getTime(index),
			pParamData->get(index),
			pParamData->getMinSampling(),
			gapSize, gapDetected, componentIndex);
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataScalaireLongDouble *)
 */
void PlotOutput::visit(
		AMDA::Parameters::ParamDataScalaireLongDouble * pParamData) {
	double gapSize = getParamGapSize(_currentParamId, pParamData);
	bool gapDetected = false;;
	//ParamDataScalaireLongDouble
	ParameterData& crtParameterData = _parameterValues[_currentParamId];
	AMDA::Common::ParameterIndexComponent componentIndex = AMDA::Common::ParameterIndexComponent(-1,-1);

	crtParameterData.preAllocate(_paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex);

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index
					< _paramDataIndexInfo._nbDataToProcess
							+ _paramDataIndexInfo._startIndex; ++index) {
		crtParameterData.addValue(
			pParamData->getTime(index),
			pParamData->get(index),
			pParamData->getMinSampling(),
			gapSize, gapDetected, componentIndex);
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataScalaireInt *)
 */
void PlotOutput::visit(
		AMDA::Parameters::ParamDataScalaireInt * pParamData) {
	double gapSize = getParamGapSize(_currentParamId, pParamData);
	bool gapDetected = false;;
	//ParamDataScalaireInt
	ParameterData& crtParameterData = _parameterValues[_currentParamId];
	AMDA::Common::ParameterIndexComponent componentIndex = AMDA::Common::ParameterIndexComponent(-1,-1);

	crtParameterData.preAllocate(_paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex);

	for (unsigned int index = _paramDataIndexInfo._startIndex;
			index
					< _paramDataIndexInfo._nbDataToProcess
							+ _paramDataIndexInfo._startIndex; ++index) {
		crtParameterData.addValue(
			pParamData->getTime(index),
			pParamData->get(index),
			pParamData->getMinSampling(),
			gapSize, gapDetected, componentIndex);
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataLogicalData *)
 */
void PlotOutput::visit(AMDA::Parameters::ParamDataLogicalData *) {
	BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("ParamDataLogicalData data not supported"));
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab1DShort *)
 */
void PlotOutput::visit(AMDA::Parameters::ParamDataTab1DShort *pParamData) {
	double gapSize = getParamGapSize(_currentParamId, pParamData);
	bool gapDetected = false;;
	//ParamDataTab1DShort
	ParameterData& crtParameterData = _parameterValues[_currentParamId];

	//init parameter values container
	if (crtParameterData._indexes.size() == 0)
		crtParameterData._indexes =
			getParamUsedIndexes<short>(_currentParamId,pParamData);

	crtParameterData.preAllocate(_paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex);

	for (unsigned int i = _paramDataIndexInfo._startIndex;
			i < _paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex; ++i) {
		double time = pParamData->getTime(i);
		for (auto& index : crtParameterData._indexes) {
			crtParameterData.addValue(time,
				pParamData->get(i)[index.getDim1Index()],
				pParamData->getMinSampling(),
				gapSize, gapDetected, index);
		}
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab1DFloat *)
 */
void PlotOutput::visit(
		AMDA::Parameters::ParamDataTab1DFloat * pParamData) {
	double gapSize = getParamGapSize(_currentParamId, pParamData);
	bool gapDetected = false;;
	//ParamDataTab1DFloat
	ParameterData& crtParameterData = _parameterValues[_currentParamId];

	//init parameter values container
	if (crtParameterData._indexes.size() == 0)
		crtParameterData._indexes =
			getParamUsedIndexes<float>(_currentParamId,pParamData);

	crtParameterData.preAllocate(_paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex);

	for (unsigned int i = _paramDataIndexInfo._startIndex;
			i < _paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex; ++i) {
		double time = pParamData->getTime(i);
		for (auto& index : crtParameterData._indexes) {
			crtParameterData.addValue(time,
				pParamData->get(i)[index.getDim1Index()],
				pParamData->getMinSampling(),
				gapSize, gapDetected, index);
		}
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab1DDouble *)
 */
void PlotOutput::visit(
		AMDA::Parameters::ParamDataTab1DDouble *pParamData) {
	double gapSize = getParamGapSize(_currentParamId, pParamData);
	bool gapDetected = false;;
	//ParamDataTab1DDouble
	ParameterData& crtParameterData = _parameterValues[_currentParamId];

	//init parameter values container
	if (crtParameterData._indexes.size() == 0)
		crtParameterData._indexes =
			getParamUsedIndexes<double>(_currentParamId,pParamData);

	crtParameterData.preAllocate(_paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex);

	for (unsigned int i = _paramDataIndexInfo._startIndex;
			i < _paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex; ++i) {
		double time = pParamData->getTime(i);
		for (auto& index : crtParameterData._indexes) {
			crtParameterData.addValue(time,
				pParamData->get(i)[index.getDim1Index()],
				pParamData->getMinSampling(),
				gapSize, gapDetected, index);
		}
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab1DLongDouble *)
 */
void PlotOutput::visit(
		AMDA::Parameters::ParamDataTab1DLongDouble *pParamData) {
	double gapSize = getParamGapSize(_currentParamId, pParamData);
	bool gapDetected = false;;
	//ParamDataTab1DLongDouble
	ParameterData& crtParameterData = _parameterValues[_currentParamId];

	//init parameter values container
	if (crtParameterData._indexes.size() == 0)
		crtParameterData._indexes =
			getParamUsedIndexes<long double>(_currentParamId,pParamData);

	crtParameterData.preAllocate(_paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex);

	for (unsigned int i = _paramDataIndexInfo._startIndex;
			i < _paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex; ++i) {
		double time = pParamData->getTime(i);
		for (auto& index : crtParameterData._indexes) {
			crtParameterData.addValue(time,
				pParamData->get(i)[index.getDim1Index()],
				pParamData->getMinSampling(),
				gapSize, gapDetected, index);
		}
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab1DInt *)
 */
void PlotOutput::visit(AMDA::Parameters::ParamDataTab1DInt *pParamData) {
	double gapSize = getParamGapSize(_currentParamId, pParamData);
	bool gapDetected = false;;
	//ParamDataTab1DInt
	ParameterData& crtParameterData = _parameterValues[_currentParamId];

	//init parameter values container
	if (crtParameterData._indexes.size() == 0)
		crtParameterData._indexes =
			getParamUsedIndexes<int>(_currentParamId,pParamData);

	crtParameterData.preAllocate(_paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex);

	for (unsigned int i = _paramDataIndexInfo._startIndex;
			i < _paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex; ++i) {
		double time = pParamData->getTime(i);
		for (auto& index : crtParameterData._indexes) {
			crtParameterData.addValue(time,
				pParamData->get(i)[index.getDim1Index()],
				pParamData->getMinSampling(),
				gapSize, gapDetected, index);
		}
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab1DLogicalData *)
 */
void PlotOutput::visit(AMDA::Parameters::ParamDataTab1DLogicalData *) {
	BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("ParamDataTab1DLogicalData data not supported"));
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab2DShort *)
 */
void PlotOutput::visit(AMDA::Parameters::ParamDataTab2DShort *pParamData) {
	double gapSize = getParamGapSize(_currentParamId, pParamData);
	bool gapDetected = false;;
	//ParamDataTab2DShort
	ParameterData& crtParameterData = _parameterValues[_currentParamId];

	//init parameter values container
	if (crtParameterData._indexes.size() == 0)
		crtParameterData._indexes =
			getParamUsedIndexes<short>(_currentParamId,pParamData);

	crtParameterData.preAllocate(_paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex);

	for (unsigned int i = _paramDataIndexInfo._startIndex;
			i < _paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex; ++i) {
		double time = pParamData->getTime(i);
		for (auto& index : crtParameterData._indexes) {
			crtParameterData.addValue(time,
				pParamData->get(i)[index.getDim1Index()][index.getDim2Index()],
				pParamData->getMinSampling(),
				gapSize, gapDetected, index);
		}
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab2DFloat *)
 */
void PlotOutput::visit(AMDA::Parameters::ParamDataTab2DFloat *pParamData) {
	double gapSize = getParamGapSize(_currentParamId, pParamData);
	bool gapDetected = false;;
	//ParamDataTab2DFloat
	ParameterData& crtParameterData = _parameterValues[_currentParamId];

	//init parameter values container
	if (crtParameterData._indexes.size() == 0)
		crtParameterData._indexes =
				getParamUsedIndexes<float>(_currentParamId,pParamData);

	crtParameterData.preAllocate(_paramDataIndexInfo._nbDataToProcess
			+ _paramDataIndexInfo._startIndex);

	for (unsigned int i = _paramDataIndexInfo._startIndex;
			i < _paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex; ++i) {
		double time = pParamData->getTime(i);
		for (auto& index : crtParameterData._indexes) {
			crtParameterData.addValue(time,
				pParamData->get(i)[index.getDim1Index()][index.getDim2Index()],
				pParamData->getMinSampling(),
				gapSize, gapDetected, index);
		}
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab2DDouble *)
 */
void PlotOutput::visit(AMDA::Parameters::ParamDataTab2DDouble *pParamData) {
	double gapSize = getParamGapSize(_currentParamId, pParamData);
	bool gapDetected = false;;
	//ParamDataTab2DDouble
	ParameterData& crtParameterData = _parameterValues[_currentParamId];

	//init parameter values container
	if (crtParameterData._indexes.size() == 0)
		crtParameterData._indexes =
			getParamUsedIndexes<double>(_currentParamId,pParamData);

	crtParameterData.preAllocate(_paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex);

	for (unsigned int i = _paramDataIndexInfo._startIndex;
			i < _paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex; ++i) {
		double time = pParamData->getTime(i);
		for (auto& index : crtParameterData._indexes) {
			crtParameterData.addValue(time,
				pParamData->get(i)[index.getDim1Index()][index.getDim2Index()],
				pParamData->getMinSampling(),
				gapSize, gapDetected, index);
		}
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab2DLongDouble *)
 */
void PlotOutput::visit(AMDA::Parameters::ParamDataTab2DLongDouble *pParamData) {
	double gapSize = getParamGapSize(_currentParamId, pParamData);
	bool gapDetected = false;;
	//ParamDataTab2DLongDouble
	ParameterData& crtParameterData = _parameterValues[_currentParamId];

	//init parameter values container
	if (crtParameterData._indexes.size() == 0)
		crtParameterData._indexes =
			getParamUsedIndexes<long double>(_currentParamId,pParamData);

	crtParameterData.preAllocate(_paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex);

	for (unsigned int i = _paramDataIndexInfo._startIndex;
			i < _paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex; ++i) {
		double time = pParamData->getTime(i);
		for (auto& index : crtParameterData._indexes) {
			crtParameterData.addValue(time,
				pParamData->get(i)[index.getDim1Index()][index.getDim2Index()],
				pParamData->getMinSampling(),
				gapSize, gapDetected, index);
		}
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab2DInt *)
 */
void PlotOutput::visit(AMDA::Parameters::ParamDataTab2DInt *pParamData) {
	double gapSize = getParamGapSize(_currentParamId, pParamData);
	bool gapDetected = false;;
	//ParamDataTab2DInt
	ParameterData& crtParameterData = _parameterValues[_currentParamId];

	//init parameter values container
	if (crtParameterData._indexes.size() == 0)
		crtParameterData._indexes =
			getParamUsedIndexes<int>(_currentParamId,pParamData);

	crtParameterData.preAllocate(_paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex);

	for (unsigned int i = _paramDataIndexInfo._startIndex;
			i < _paramDataIndexInfo._nbDataToProcess
				+ _paramDataIndexInfo._startIndex; ++i) {
		double time = pParamData->getTime(i);
		for (auto& index : crtParameterData._indexes) {
			crtParameterData.addValue(time,
				pParamData->get(i)[index.getDim1Index()][index.getDim2Index()],
				pParamData->getMinSampling(),
				gapSize, gapDetected, index);
		}
	}
}

/**
 * @overload VisitorOfParamData::visit(ParamDataTab2DLogicalData *)
 */
void PlotOutput::visit(AMDA::Parameters::ParamDataTab2DLogicalData *) {
	BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("ParamDataTab2DLogicalData data not supported"));
}

} /* namespace plot */