/*
 * XYPlot.cc
 *
 *  Created on: 29 oct. 2013
 *      Author: CS
 */

#include <fstream>
#include <iomanip>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>

#include "XYPlot.hh"
#include "ParamsNode.hh"
#include "AxesNode.hh"
#include "PlotLogger.hh"
#include "PlotOutput.hh"
#include "TimeUtil.hh"
#include "ParamMgr.hh"
#include "AxisLegendManager.hh"

using namespace AMDA::Parameters;
using namespace AMDA::Info;

namespace plot {

XYPlot::XYPlot(AMDA::Parameters::ParameterManager& manager,
		boost::shared_ptr<Panel> panel) :
		PanelPlotOutput(manager, panel), _isIsotropic(false) {

}

XYPlot::~XYPlot() {
}

/**
 * @overload PanelPlotOutput::preparePlotArea()
 */
void XYPlot::preparePlotArea(double startTime, double stopTime, int intervalIndex) {
	// for test, dump plot properties
	const char* lBuildType=getenv("BUILD_TYPE");
	if(lBuildType && std::string(lBuildType) == "Debug") {
		std::ofstream out("xyPlot.txt");
		dump(out);
		out.close();
	}

	// Configure range of series and color.
	configureSeriesAxis();
	configureAxisLegend();

	// Configure params legend
	configureParamsLegend(startTime,stopTime,intervalIndex);

	// If panel title is empty, replace it with start and end date.
	if (_panel->_title._text.empty() || _panel->_updateTitleOnNextInterval) {
		//Title must be updated during the next interval plot
		_panel->_updateTitleOnNextInterval = true;
		// Set start date and end date.
		std::string lTimeFormat("%H:%M %d/%m/%y");

		long int lStartTime = static_cast<long int>(startTime);
		tm * lStartTimeTm = gmtime(&lStartTime);
		char lStartTimeChr[80];

		// Format date.
		strftime(lStartTimeChr, 80, lTimeFormat.c_str(), lStartTimeTm);

		long int lStopTime = static_cast<long int>(stopTime);
		tm * lStopTimeTm = gmtime(&lStopTime);
		char lStopTimeChr[80];

		// Format date.
		strftime(lStopTimeChr, 80, lTimeFormat.c_str(), lStopTimeTm);

		_panel->_title._text = std::string(lStartTimeChr) + " - " + std::string(lStopTimeChr);
	}

	PanelPlotOutput::preparePlotArea(startTime,stopTime,intervalIndex);
}

void XYPlot::createParameters(std::list<std::string>& usedParametersId_)
{

	for (ParameterAxesList::iterator it = _parameterAxesList.begin();
				it != _parameterAxesList.end(); ++it)
	{
		std::map<AMDA::Common::ParameterIndexComponent, SeriesProperties>::iterator ity;
		AMDA::Parameters::ParameterSPtr originalYParam =
			_parameterManager.getParameter(it->_originalParamId);

		double samplingYValue = 0.;
		double samplingXValue = 0.;

		for (ity = it->getYSeriePropertiesMap().begin(); ity != it->getYSeriePropertiesMap().end();
				++ity)
		{
			XSeriesProperties& xSerie = getSerieOnXAxis(ity->second.getXAxisId());

			ParameterAxes& xparameter = getParameterAxeOnXAxis(ity->second.getXAxisId());

			ParameterAxes* colorSerieParameterAxes = getParameterAxesByColorSerieId(ity->second.getColorSerieId());

			AMDA::Parameters::ParameterSPtr originalColorParam;
			if (colorSerieParameterAxes != NULL)
				originalColorParam = _parameterManager.getParameter(colorSerieParameterAxes->_originalParamId);

			AMDA::Parameters::ParameterSPtr usedXParam;
			AMDA::Parameters::ParameterSPtr usedYParam;

			AMDA::Parameters::ParameterSPtr originalXParam = _parameterManager.getParameter(xparameter._originalParamId);;
			if (!ity->second.getComputeExpression().empty())
			{
				if (samplingXValue == 0.)
					samplingXValue = getSamplingInTreeParameter(originalXParam);

				double correctedSamplingValue = getCorrectedSamplingValue(ity->second.getMaxResolution(), samplingXValue);

				if (abs(samplingXValue - correctedSamplingValue) > 1.)
				{
					//create resampling parameter for xparam
					usedXParam = createSampledParameter(originalXParam, correctedSamplingValue);
				}
				else
				{
					usedXParam = originalXParam;
				}

				if (std::find (usedParametersId_.begin(),usedParametersId_.end(),usedXParam->getId()) == usedParametersId_.end())
					usedParametersId_.push_back(usedXParam->getId());

				std::string expr = ity->second.getComputeExpression();
				boost::replace_all(expr, OrbitParamComponentName, usedXParam->getId());

				//create parameter from expression
				usedYParam = _parameterManager.getParameterFromExpression(expr);

				if (usedYParam == nullptr)
				{
					LOG4CXX_ERROR(gLogger, "XYPlot::createParameters - Cannot create parameter from expression " << expr);
					continue;
				}

				AMDA::Info::ParamInfoSPtr paramYInfo = AMDA::Info::ParamMgr::getInstance()->getParamInfoFromId(usedYParam->getId(),true);
				AMDA::Info::ParamInfoSPtr paramXInfo = AMDA::Info::ParamMgr::getInstance()->getParamInfoFromId(originalXParam->getInfoId(),true);
				if (paramYInfo != nullptr)
				{
					paramYInfo->setShortName(ity->second.getComputeExpressionName());
					if (paramXInfo != nullptr)
					{
						paramYInfo->setUnits(paramXInfo->getUnits());
						paramYInfo->setCoordinatesSystem(paramXInfo->getCoordinatesSystem());
					}
				}

				if (std::find (usedParametersId_.begin(),usedParametersId_.end(),usedYParam->getId()) == usedParametersId_.end())
					usedParametersId_.push_back(usedYParam->getId());

				//link serie to this resampled parameter
				ity->second.setParamId(usedYParam->getId());
				xSerie.addParamId(usedYParam->getId(), usedXParam->getId());

				if (originalColorParam != nullptr)
				{
					AMDA::Parameters::ParameterSPtr usedColorParam = createSampledParameterUnderReferenceParameter(originalColorParam, usedYParam);
					//Add used color parameter to parameters list
					if (std::find (usedParametersId_.begin(),usedParametersId_.end(),usedColorParam->getId()) == usedParametersId_.end())
						usedParametersId_.push_back(usedColorParam->getId());
					//link this color parameter to the y serie
					ity->second.setColorParamId(usedColorParam->getId());
					//link the used parameter to the color serie
					colorSerieParameterAxes->getColorSeriePropertiesById(ity->second.getColorSerieId()).addParamId(usedYParam->getId(), usedColorParam->getId());
					//activate the Z Axis
					ity->second.setZAxis(true);
				}

				usedYParam.reset();

				continue;
			}

			if (samplingYValue == 0.)
				samplingYValue = getSamplingInTreeParameter(originalYParam);

			samplingXValue = getSamplingInTreeParameter(originalXParam);
			switch (ity->second.getResamplingProperties().getType())
			{
			case ResamplingType::MANUAL :
				{
					LOG4CXX_DEBUG(gLogger, "XYPlot::createSeriesParameters - ResamplingType::MANUAL");
					//create resampling parameters for xparam
					usedXParam = createSampledParameter(originalXParam, ity->second.getResamplingProperties().getValue());
					if (std::find (usedParametersId_.begin(),usedParametersId_.end(),usedXParam->getId()) == usedParametersId_.end())
						usedParametersId_.push_back(usedXParam->getId());
					if (originalXParam == originalYParam)
					{
						//same original parameter => re-use xparam
						usedYParam = usedXParam;
					}
					else
					{
						//create resampling parameters for xparam
						usedYParam = createSampledParameter(originalYParam, ity->second.getResamplingProperties().getValue());
						if (std::find (usedParametersId_.begin(),usedParametersId_.end(),usedYParam->getId()) == usedParametersId_.end())
							usedParametersId_.push_back(usedYParam->getId());
					}
				}
				break;
			case ResamplingType::AUTO   :
			case ResamplingType::XPARAM :
				{
					LOG4CXX_DEBUG(gLogger, "XYPlot::createSeriesParameters - ResamplingType::XPARAM");
					double correctedSamplingValue = getCorrectedSamplingValue(ity->second.getMaxResolution(), samplingXValue);
					if (abs(samplingXValue - correctedSamplingValue) > 1.)
					{
						//create resampling parameter for xparam
						usedXParam = createSampledParameter(originalXParam, correctedSamplingValue);
						if (std::find (usedParametersId_.begin(),usedParametersId_.end(),usedXParam->getId()) == usedParametersId_.end())
							usedParametersId_.push_back(usedXParam->getId());
						if (originalXParam == originalYParam)
						{
							//same original parameter => re-use xparam
							usedYParam = usedXParam;
						}
						else
						{
							//create resampling parameter for yparam
							usedYParam = createSampledParameter(originalYParam, correctedSamplingValue);
							if (std::find (usedParametersId_.begin(),usedParametersId_.end(),usedYParam->getId()) == usedParametersId_.end())
								usedParametersId_.push_back(usedYParam->getId());
						}
					}
					else
					{
						//get original parameter for xparam
						usedXParam = originalXParam;
						if (std::find (usedParametersId_.begin(),usedParametersId_.end(),usedXParam->getId()) == usedParametersId_.end())
							usedParametersId_.push_back(usedXParam->getId());
						if (originalXParam == originalYParam)
						{
							//same original parameter => re-use xparam
							usedYParam = usedXParam;
						}
						else
						{
							//create resampled parameter under times of xparam for yparam
							usedYParam = createSampledParameterUnderReferenceParameter(originalYParam, originalXParam);
							if (std::find (usedParametersId_.begin(),usedParametersId_.end(),usedYParam->getId()) == usedParametersId_.end())
								usedParametersId_.push_back(usedYParam->getId());
						}
					}
				}
				break;
			case ResamplingType::YPARAM :
				LOG4CXX_DEBUG(gLogger, "XYPlot::createSeriesParameters - ResamplingType::YPARAM");
				double correctedSamplingValue = getCorrectedSamplingValue(ity->second.getMaxResolution(), samplingYValue);
				if (abs(samplingYValue - correctedSamplingValue) > 1.)
				{
					//create resampling parameter for xparam
					usedXParam = createSampledParameter(originalXParam, correctedSamplingValue);
					if (std::find (usedParametersId_.begin(),usedParametersId_.end(),usedXParam->getId()) == usedParametersId_.end())
						usedParametersId_.push_back(usedXParam->getId());
					if (originalXParam == originalYParam)
					{
						//same original parameter => re-use xparam
						usedYParam = usedXParam;
					}
					else
					{
						//create resampling parameter for yparam
						usedYParam = createSampledParameter(originalYParam, correctedSamplingValue);
						if (std::find (usedParametersId_.begin(),usedParametersId_.end(),usedYParam->getId()) == usedParametersId_.end())
							usedParametersId_.push_back(usedYParam->getId());
					}
				}
				else
				{
					//get original parameter for yparam
					usedYParam = originalYParam;
					if (std::find (usedParametersId_.begin(),usedParametersId_.end(),usedYParam->getId()) == usedParametersId_.end())
						usedParametersId_.push_back(usedYParam->getId());
					if (originalXParam == originalYParam)
					{
						//same original parameter => re-use yparam
						usedXParam = usedYParam;
					}
					else
					{
						//create resampled parameter under times of yparam for cparam
						usedXParam = createSampledParameterUnderReferenceParameter(originalXParam, originalYParam);
						if (std::find (usedParametersId_.begin(),usedParametersId_.end(),usedXParam->getId()) == usedParametersId_.end())
							usedParametersId_.push_back(usedXParam->getId());
					}
				}
				break;
			}

			//link serie to this resampled parameter
			ity->second.setParamId(usedYParam->getId());
			xSerie.addParamId(usedYParam->getId(), usedXParam->getId());

			if (originalColorParam != nullptr)
			{
				AMDA::Parameters::ParameterSPtr usedColorParam = createSampledParameterUnderReferenceParameter(originalColorParam, usedYParam);
				//Add used color parameter to parameters list
				if (std::find (usedParametersId_.begin(),usedParametersId_.end(),usedColorParam->getId()) == usedParametersId_.end())
					usedParametersId_.push_back(usedColorParam->getId());
				//link this color parameter to the y serie
				ity->second.setColorParamId(usedColorParam->getId());
				//link the used parameter to the color serie
				colorSerieParameterAxes->getColorSeriePropertiesById(ity->second.getColorSerieId()).addParamId(usedYParam->getId(), usedColorParam->getId());
				//activate the Z Axis
				ity->second.setZAxis(true);
			}
		}
	}
}

/**
 * Gets parameter that is it-self or a component on xAxis.
 */
ParameterAxes& XYPlot::getParameterAxeOnXAxis(const std::string& xAxisId) {
	for (ParameterAxesList::iterator it = _parameterAxesList.begin();
			it != _parameterAxesList.end(); ++it) {
		std::map<AMDA::Common::ParameterIndexComponent, XSeriesProperties>::const_iterator itx;
		for (itx = it->getXSeriePropertiesMap().begin();
				itx != it->getXSeriePropertiesMap().end(); ++itx) {
			if (itx->second.getAxisId() == xAxisId) {
				return *it;
			}
		}
	}
	// xseries not found, not expected ... stop process
	std::stringstream lError;
	lError << "XYPlot::getSerieOnXAxis : no parameter for xAxis of id "
			<< xAxisId;
	BOOST_THROW_EXCEPTION(
			PanelPlotOutputException() << AMDA::ex_msg(lError.str()));
}

/**
 * Gets x serie configured on a given x axis id.
 */
XSeriesProperties& XYPlot::getSerieOnXAxis(const std::string& axisId_) {
	for (ParameterAxesList::iterator paramAxeIt = _parameterAxesList.begin();
			paramAxeIt != _parameterAxesList.end(); ++paramAxeIt) {
		try {
			XSeriesProperties& props = getSerieOnXAxisfromParameter(axisId_, *paramAxeIt);
			// if not found, exception is raised
			// if found, return serie
			return props;
		}
		catch(PanelPlotOutputException& ex){
			// nop
		}
	}
	// xseries not found, not expected ... stop process
	std::stringstream lError;
	lError << "XYPlot::getSerieOnXAxis : no parameter for xAxis of id " << axisId_;
	BOOST_THROW_EXCEPTION(
			PanelPlotOutputException() << AMDA::ex_msg(lError.str()));
}

/**
 * Gets x serie from a parameter configured on a given x axis id.
 * @throw PanelPlotOutputException if not found
 */
XSeriesProperties& XYPlot::getSerieOnXAxisfromParameter(const std::string& axisId_,
		ParameterAxes& parameter_) {
	std::map<AMDA::Common::ParameterIndexComponent, XSeriesProperties>::iterator itx;
	for (itx = parameter_.getXSeriePropertiesMap().begin();
			itx != parameter_.getXSeriePropertiesMap().end(); ++itx) {
		if (itx->second.getAxisId() == axisId_) {
			return itx->second;
		}
	}

	// xseries not found, not expected ... stop process
	std::stringstream lError;
	lError
			<< "XYPlot::getXSeriefromParameter : no parameter for xAxis of id "
			<< axisId_;
	BOOST_THROW_EXCEPTION(
			PanelPlotOutputException() << AMDA::ex_msg(lError.str()));
}

/*
 * Dumps properties for test.
 */
void XYPlot::dump(std::ostream& out_){
	PanelPlotOutput::dump(out_);
	out_ << "isotropic=" << std::boolalpha << _isIsotropic;
}


void XYPlot::calculatePlotArea(Bounds& bounds_) {
	PanelPlotOutput::calculatePlotArea(bounds_);

	if (_isIsotropic) {
		// Parse each parameter to define size of axis.
		double lHorizontalAxisGap = 0;
		Range lHorizontalRange;
		double lVerticalAxisGap = 0;
		Range lVerticalRange;
		SeriesProperties lSeriesProperties;
		boost::shared_ptr<Axis> lYAxis;
		boost::shared_ptr<Axis> lXAxis;
		for (auto param: _parameterAxesList) {
			// Get Y axis
			for (auto index: param.getYSerieIndexList(_pParameterValues)) {
				lSeriesProperties = param.getYSeriePropertiesAt(index);
				lYAxis = _panel->getAxis(lSeriesProperties.getYAxisId());
				if (lYAxis.get() == nullptr) {
					std::stringstream lError;
					lError << "XYPlot::calculatePlotArea" << ": Y axis with id '" << lSeriesProperties.getYAxisId() << "' not found.";
					BOOST_THROW_EXCEPTION(PanelPlotOutputException() << AMDA::ex_msg(lError.str()));
				}

				lVerticalRange = lYAxis->getRange();
				// Get gap for this parameter data
				if (lVerticalRange.isSet()) {
					double lTmpVerticalAxisGap = fabs(lVerticalRange.getMin() - lVerticalRange.getMax());
					// We get the maximum gap in case where there are several parameter to draw on Y axis(axes).
					lVerticalAxisGap = std::max(lVerticalAxisGap, lTmpVerticalAxisGap);
				}
			}

			// Get X axis.
			for (auto lXSeries: param.getXSeriePropertiesMap()) {
				lXAxis = _panel->getAxis(lXSeries.second.getAxisId());
				if (lXAxis.get() == nullptr) {
					std::stringstream lError;
					lError << "XYPlot::calculatePlotArea" << ": X axis with id '" << lSeriesProperties.getXAxisId() << "' not found.";
					BOOST_THROW_EXCEPTION(PanelPlotOutputException() << AMDA::ex_msg(lError.str()));
				}

				lHorizontalRange = lXAxis->getRange();
				// Get gap for this parameter data
				if (lHorizontalRange.isSet()) {
					double lTmpHorizontalAxisGap = fabs(lHorizontalRange.getMin() - lHorizontalRange.getMax());
					lHorizontalAxisGap = std::max(lHorizontalAxisGap, lTmpHorizontalAxisGap);
				}
			}

			// If one of gap is 0 do nothing (gap of range can't be 0).
			if ((lVerticalAxisGap == 0) || (lHorizontalAxisGap == 0))
				continue;

			double lRequestedRatio = lVerticalAxisGap / lHorizontalAxisGap;
			double lPlotAreaRatio = bounds_._height / bounds_._width;
			double pageWidth = std::get < 1 > (_panel->_page->getSize());
			double pageHeight = std::get < 0 > (_panel->_page->getSize());
			double lPageRatio = 0;

			// Page width and height doesn't depend on orientation...
			// so we computes page ratio depending on orientation...
			if (_panel->_page->_orientation == PlotCommon::Orientation::LANDSCAPE)
				lPageRatio = pageWidth / pageHeight;
			else
				lPageRatio = pageHeight / pageWidth;

			// Get bounds of panel
			Bounds lPanelBounds(Panel::getCoordinateInPlPage(_pls.get(), _panel->_bounds, _panel->_page));

			// Calculate width of plot area to keep uniformity of the two scale (axes).
			double lPlotAreaIsoW = ((bounds_._height * lPageRatio) / lRequestedRatio);
			// Calculate height of plot area to keep uniformity of the two scale (axes).
			double lPlotAreaIsoH = ((bounds_._width / lPageRatio) * lRequestedRatio);

			// When ratio is lower than 1. it signifies that plot area width is bigger than height.
			// So reduce width.
			// The upper condition is only valid if new width is purely lower than current plot area width.
			// Otherwise we must modify height.
			if ( ((lPlotAreaRatio < 1.) && (lPlotAreaIsoW < bounds_._width)) ||
  				 ((lPlotAreaRatio > 1.) && (lPlotAreaIsoH > bounds_._height))) {

				// Calculate X min bounds of plot area if it can be centered.
				double lPlotAreaIsoX = ((lPanelBounds._width - lPlotAreaIsoW) / 2.) + lPanelBounds._x;

				// Check if plot area can be centered.
				if (lPlotAreaIsoX  > bounds_._x) {
					bounds_._x = lPlotAreaIsoX;
				} else {
					bounds_._x += (bounds_._width - lPlotAreaIsoW) / 2.;
				}
				bounds_._width = lPlotAreaIsoW;
			} else {
				// Calculate Y min bounds of plot area if it can be centered.
				double lPlotAreaIsoY = ((lPanelBounds._height - lPlotAreaIsoH) / 2.) + lPanelBounds._y;

				// Check if plot area can be centered.
				if (lPlotAreaIsoY  > bounds_._y) {
					bounds_._y = lPlotAreaIsoY;
				} else {
					bounds_._y += (bounds_._height - lPlotAreaIsoH) / 2.;
				}
				bounds_._height = lPlotAreaIsoH;
			}
		}
	}
}

std::string XYPlot::formatDateTime (double dateTime, const std::string &format) {
	long int lTime = static_cast<long int>(dateTime);
	tm * lTimeTm = gmtime(&lTime);

	// Format date.
	char timeBuf[80];
	strftime (timeBuf, sizeof (timeBuf), format.c_str(), lTimeTm);

	return std::string(timeBuf);
}

void XYPlot::drawTimeTicks(SeriesProperties& pSeries, AMDA::Common::ParameterIndexComponent pParamIndex,
		double* timeValues, int nbTimeValues) {
	LOG4CXX_DEBUG(gLogger, "XYPlot::drawTimeTicks");

	TimeTickProperties ttProps = pSeries.getTimeTickProperties();

	// Draw Time ticks if required !
	if ((ttProps.getStep().compare("0") == 0) && (ttProps.getNumber() == 0))
		return;

	// Get parameter sampling, data, start time and end time
	ParameterAxes& xParameter = getParameterAxeOnXAxis(pSeries.getXAxisId());

	std::string paramId = pSeries.getParamId();

	XSeriesProperties& xSerie = getSerieOnXAxisfromParameter(pSeries.getXAxisId(), xParameter);

	ParameterData& xData = (*_pParameterValues)[xSerie.getXParamIds()[paramId]];
	ParameterData& yData = (*_pParameterValues)[paramId];

	double startTime = timeValues[0];
	double stopTime  = timeValues[nbTimeValues-1];
	double totalDuration = stopTime - startTime;
	double deltaMajorTick, deltaMinorTick;

//	LOG4CXX_DEBUG(gLogger, "drawTimeTicks totalDuration " << totalDuration);

	// Compute x and y coordinates for major and minor time ticks
	int nbTotMajor = 0;
	int nbTotMinor = 0;
	int nbMinorPerMajor = ttProps.getMinor();

	if (ttProps.getStep().compare("0") != 0)
	{
		if (ttProps.getStep().compare("auto") == 0) {
//			LOG4CXX_DEBUG(gLogger, "drawTimeTicks auto");
			deltaMajorTick = TimeAxis::computeAutoMajorTickSpace (startTime, stopTime);
		}
		else {
//			LOG4CXX_DEBUG(gLogger, "drawTimeTicks time step");
			deltaMajorTick = DD_Time2Double (ttProps.getStep().c_str());
		}

		nbTotMajor = (int) (totalDuration / deltaMajorTick) + 1;
		deltaMinorTick = deltaMajorTick / (nbMinorPerMajor + 1);

		// Update totalDuration & stopTime depending on the nbMinorPerMajor value
		if (nbMinorPerMajor == 0) {
			nbTotMinor = 0;
			totalDuration = (nbTotMajor - 1) * deltaMajorTick;
			stopTime = startTime + totalDuration;
		}
		else {
			nbTotMinor = (nbTotMajor-1) * nbMinorPerMajor;
			nbTotMinor += (int) ((totalDuration - (nbTotMajor - 1) * deltaMajorTick) / deltaMinorTick);
			totalDuration = (nbTotMajor + nbTotMinor - 1) * deltaMinorTick;
			stopTime = startTime + totalDuration;
		}
//		LOG4CXX_DEBUG(gLogger, "drawTimeTicks totalDuration " << totalDuration);
	}
	else if (ttProps.getNumber() != 0) {
//		LOG4CXX_DEBUG(gLogger, "drawTimeTicks step number");
		nbTotMajor = ttProps.getNumber();
		deltaMajorTick = totalDuration / (nbTotMajor -1);
		nbTotMinor = (nbTotMajor-1) * nbMinorPerMajor;
	}

//	LOG4CXX_DEBUG(gLogger, "drawTimeTicks nbMajor " << nbTotMajor);
//	LOG4CXX_DEBUG(gLogger, "drawTimeTicks nbMinor " << nbTotMinor);
//	LOG4CXX_DEBUG(gLogger, "drawTimeTicks deltaMajorDuration " << deltaMajorTick);

	// Build & compute graduation
	double *majorX, *majorY, *minorX, *minorY, *tickLabel;

	majorX = new double [nbTotMajor];
	majorY = new double [nbTotMajor];
	minorX = new double [nbTotMinor];
	minorY = new double [nbTotMinor];
	tickLabel = new double [nbTotMajor];

	int nbGrad = nbTotMajor + nbTotMinor;
	int curMajorGrad = 0;
	int curMinorGrad = 0;

	//XSeriesProperties& xSerie = getSerieOnXAxisfromParameter(pSeries.getXAxisId(), xParameter);

	for (int grad=0; grad<nbGrad; grad++) {
		double curTime = startTime + grad * (totalDuration / (nbGrad - 1));

		// Compute major graduation pos & Record tick label (based on date)
		if ((grad%(nbMinorPerMajor+1)) == 0) {
			tickLabel [curMajorGrad] = curTime;

			majorX [curMajorGrad] = xData.getInterpolatedValue (curTime, xSerie.getIndex());
			majorY [curMajorGrad] = yData.getInterpolatedValue (curTime, pParamIndex);
			curMajorGrad++;
		}
		// Compute minor graduation pos
		else {
			minorX [curMinorGrad] = xData.getInterpolatedValue (curTime, xSerie.getIndex());
			minorY [curMinorGrad] = yData.getInterpolatedValue (curTime, pParamIndex);
			curMinorGrad++;
		}
	}

	// Draw first time tick major symbol, other time tick major Symbols and minor time ticks symbols
	if (nbTotMajor != 0) {
		drawSymbols(
			ttProps.getFirstSymbol().getType(),
			ttProps.getSymbol().getSize(), 1.,
			ttProps.getFirstSymbol().getColor(),
			1, majorX, majorY);

		drawSymbols(
			ttProps.getSymbol().getType(),
			ttProps.getSymbol().getSize(), 1.,
			ttProps.getSymbol().getColor(),
			nbTotMajor-1, &majorX[1], &majorY[1]);
	}

	if (nbTotMinor != 0) {
		drawSymbols(
			ttProps.getSymbol().getType(),
			ttProps.getSymbol().getSize(), 0.5,
			ttProps.getSymbol().getColor(),
			nbTotMinor, minorX, minorY);
	}

	// Draw text Label for major tick by building a list of textPlots
	if (nbTotMajor != 0) {
		TextPlots textPlots;
		TextPlot baseTextPlot;
		baseTextPlot._color = ttProps.getColor();
		baseTextPlot._font = ttProps.getFont();

		std::string computedTimeFormat = getPlTimeFormat (std::string("hh:mm"), startTime, stopTime, nbTotMajor);
//		LOG4CXX_DEBUG(gLogger, "drawTimeTicks computedTimeFormat" << computedTimeFormat);

		Range lXRange = getXAxisRange (pSeries, _panel->getAxis(pSeries.getXAxisId()));
		Range lYRange = getYAxisRange (pSeries, _panel->getAxis(pSeries.getYAxisId()));

		double deltaX = 0; // (lXRange.getMax () - lXRange.getMin ()) / 80;
		double deltaY = (lYRange.getMax () - lYRange.getMin ()) / 80;

		for (int g=0; g<nbTotMajor; g++) {
			boost::shared_ptr<TextPlot> textPlot (new TextPlot (baseTextPlot));
			textPlot->_x = boost::lexical_cast<std::string>(majorX [g] + deltaX);
			textPlot->_y = boost::lexical_cast<std::string>(majorY [g] + deltaY);
			textPlot->_text = formatDateTime (tickLabel [g], computedTimeFormat);

			textPlots.push_back (textPlot);
		}

		PlWindow lPlWindow = PlWindow(lXRange.getMin(), lXRange.getMax(), lYRange.getMin(), lYRange.getMax());

		// Draw textPlots for major graduations
		drawTextPlots (lPlWindow, textPlots);
	}

	// Free major & minor graduations positions
	delete [] majorX;
	delete [] majorY;
	delete [] minorX;
	delete [] minorY;
	delete [] tickLabel;
}

void XYPlot::drawSeries(double startDate, double stopDate, int intervalIndex, std::string pParamId,
		SeriesProperties& pSeries, AMDA::Common::ParameterIndexComponent pParamIndex,
		ParameterAxes& param, bool moreThanOneSerieForAxis) {
	// This will configure window, draw axes (if needed) and legend of axes.

	LOG4CXX_DEBUG(gLogger, "XYPlot::drawSeries");

	PanelPlotOutput::drawSeries(startDate, stopDate, intervalIndex, pParamId, pSeries, pParamIndex, param, moreThanOneSerieForAxis);

	//get x serie values
	double* lXData = NULL;
	double* lXTime = NULL;
	int     nbXValues = 0;

	if (!getXComputedValuesFromSerieAndInterval(startDate, stopDate, pSeries,
			&lXData, &lXTime, nbXValues))
	{
		LOG4CXX_DEBUG(gLogger, "XYPlot::drawSeries - Cannot get computed values for x serie");
		return;
	}

	//get y serie values
	double* lYData = NULL;
	double* lYTime = NULL;
	int     nbYValues = 0;

	if (!getComputedValuesFromSerieAndInterval(startDate, stopDate, pSeries,
			pParamIndex, &lYData, &lYTime, nbYValues))
	{
		LOG4CXX_DEBUG(gLogger, "XYPlot::drawSeries - Cannot get computed values for y serie");
		return;
	}

	double *coloredComputedValues = NULL;
	double *coloredTimeValues     = NULL;
	//get colored value if needed
	if (!pSeries.getColorParamId().empty() && (_panel->getColorAxis() != nullptr))
	{
		int nbColoredValues;
		if (!getColoredComputedValuesFromSerieAndInterval(startDate, stopDate, pSeries,
				&coloredComputedValues, &coloredTimeValues, nbColoredValues))
		{
			LOG4CXX_DEBUG(gLogger, "XYPlot::drawSeries - Cannot get computed values for colored parameter");
			return;
		}
	}

	PlWindow lPlWindow = PlWindow(_panel->getAxis(pSeries.getXAxisId())->getRange().getMin(), _panel->getAxis(pSeries.getXAxisId())->getRange().getMax(),
			_panel->getAxis(pSeries.getYAxisId())->getRange().getMin(), _panel->getAxis(pSeries.getYAxisId())->getRange().getMax());

	_pls->wind(std::get<0>(lPlWindow), std::get<1>(lPlWindow),
				std::get<2>(lPlWindow), std::get<3>(lPlWindow));

	//draw serie
	Color lineColor   = getSerieLineColor(pSeries, moreThanOneSerieForAxis);
	Color symbolColor = getSerieSymbolColor(pSeries, lineColor);


	drawSymbols(
		pSeries.getSymbolProperties().getType(),
		pSeries.getSymbolProperties().getSize(), 1.,
		symbolColor,
		nbYValues, lXData, lYData, coloredComputedValues);


	drawLines(
		pSeries.getLineProperties().getType(),
		pSeries.getLineProperties().getStyle(),
		pSeries.getLineProperties().getWidth(),
		lineColor,
		nbYValues, lXData, lYData, coloredComputedValues);

	// Draw eventual Time ticks
	drawTimeTicks(pSeries, pParamIndex, lYTime, nbYValues);

	//draw interval
	drawSerieInterval(pSeries,lXData,lYData,lYTime,nbYValues,intervalIndex);

	//add serie to param legend
	addSerieToParamsLegend(pSeries,pParamIndex,param._originalParamId, lineColor,symbolColor,startDate, stopDate, intervalIndex);

	delete[] lXData;
	delete[] lYData;
	if (coloredComputedValues != NULL)
		delete[] coloredComputedValues;
}

/**
 * Draws Curve
 */
void XYPlot::drawCurvePlot(CurvePlot &curvePlot)
{
	if (curvePlot.isDrawn())
		return;

	LOG4CXX_DEBUG(gLogger, "XYPlot::drawCurvePlot");

	//retrieve associated y serie properties
	for (ParameterAxesList::iterator it = _parameterAxesList.begin();
			it != _parameterAxesList.end(); ++it)
	{
		std::map<AMDA::Common::ParameterIndexComponent, SeriesProperties>::iterator ity;
		for (ity = it->getYSeriePropertiesMap().begin(); ity != it->getYSeriePropertiesMap().end();
				++ity)
		{
			if (curvePlot._serieId == ity->second.getId())
			{
				//get curve points
				int resolution = ity->second.getMaxResolution();
				if (resolution <= 0)
					resolution = 100;
				CurveFunctionWriter::CurvePointList pointList = curvePlot.getPointList(resolution);

				if (pointList.empty())
					return; //nothing to plot

				//prepare data in relation to axis of the associated serie
				double xData[pointList.size()];
				double yData[pointList.size()];
				double xMin = DBL_MAX;
				double xMax = -DBL_MAX;
				double yMin = DBL_MAX;
				double yMax = -DBL_MAX;
				int i = 0;
				for (auto point : pointList)
				{
					xData[i] = point.x;
					xMin = std::min(xMin,point.x);
					xMax = std::max(xMax,point.x);
					yData[i] = point.y;
					yMin = std::min(yMin,point.y);
					yMax = std::max(yMax,point.y);
					++i;
				}

				double* lXData = _panel->getAxis(ity->second.getXAxisId())->getComputedValues(
									xData,
									pointList.size(), xMin, xMax);

				if(lXData == NULL)
				{
					std::stringstream lError;
					lError << "XYPlot::drawCurvePlot : no value for x, check the request x parameter definition";
					BOOST_THROW_EXCEPTION(
							PanelPlotOutputException() << AMDA::ex_msg(lError.str()));
				}

				double* lYData = _panel->getAxis(ity->second.getYAxisId())->getComputedValues(
									yData,
									pointList.size(), yMin, yMax);

				//draw the curve
				drawLines(
					LineType::LINE,
					curvePlot._style,
					curvePlot._width,
					curvePlot._color,
					pointList.size(), lXData, lYData);

				curvePlot.setDrawn(true);

				//delete data
				delete [] lXData;
				delete [] lYData;
				return;
			}
		}
	}

	//cannot retrieve the associted y serie => exception
	std::stringstream lError;
	lError << "XYPlot::drawCurvePlots : y serie with id " << curvePlot._serieId << " not found.";
	BOOST_THROW_EXCEPTION(PanelPlotOutputException() << AMDA::ex_msg(lError.str()));
}

void XYPlot::configureSeriesAxis() {
	// map<X/YAxisId, automaticRange>
	std::map<std::string, Range> lAxisRangeMap;
	Range lColorAxeRange;

	boost::shared_ptr<ColorAxis> lZAxis = _panel->getColorAxis();

	SeriesProperties lSeriesProperties;
	// Parse each parameter to define on which axis to draw series.
	for (auto param: _parameterAxesList) {
		// Configure range of X axis.
		for (auto lXSeries: param.getXSeriePropertiesMap()) {
			boost::shared_ptr<Axis> lXAxis = _panel->getAxis(lXSeries.second.getAxisId());
			if (lXAxis.get() == nullptr) {
				std::stringstream lError;
				lError << "XYPlot::configureSeriesAxis" << ": X axis with id '" << lSeriesProperties.getXAxisId() << "' not found.";
				BOOST_THROW_EXCEPTION(PanelPlotOutputException() << AMDA::ex_msg(lError.str()));
			}
			lXAxis->_used = true;

			Range lXRange(lXAxis->getRange());
			// If user didn't set a range, calculate range automatically (based on parameters values).
			if (!lXRange.isSet()) {
				Range lEstimatedRange(lAxisRangeMap[lXAxis->_id]);


				// for each paramId get min and max value.
				for (auto paramId: lXSeries.second.getXParamIds()) {

					ParameterData& xData = (*_pParameterValues)[lXSeries.second.getXParamIds()[paramId.first]];

					Range lRangeSampling(xData.getMin(lXSeries.first), xData.getMax(lXSeries.first));

					if (!lEstimatedRange.isSet()) {
						lEstimatedRange = lRangeSampling;
					} else {
						lEstimatedRange.setMin(std::min(lEstimatedRange.getMin(), lRangeSampling.getMin()));
						lEstimatedRange.setMax(std::max(lEstimatedRange.getMax(), lRangeSampling.getMax()));
					}
				}
				lAxisRangeMap[lXAxis->_id] = lEstimatedRange;
			}
		}

		// Get number of series to draw
		// For each "Y" index of parameter identify on which axis series must be drawn.
		// Also configure X axis for range.
		for (auto index: param.getYSerieIndexList(_pParameterValues)) {
			lSeriesProperties = param.getYSeriePropertiesAt(index);
			boost::shared_ptr<Axis> lYAxis = _panel->getAxis(lSeriesProperties.getYAxisId());
			if (lYAxis.get() == nullptr) {
				std::stringstream lError;
				lError << "XYPlot::configureSeriesAxis" << ": Y axis with id '" << lSeriesProperties.getYAxisId() << "' not found.";
				BOOST_THROW_EXCEPTION(PanelPlotOutputException() << AMDA::ex_msg(lError.str()));
			}
			lYAxis->_used = true;

			// Configure range for Y axis.
			Range lYRange(lYAxis->getRange());
			// If range status for this axis is set by the user do not update range "automatically".
			if (isnan(lYRange.getMin()) && isnan(lYRange.getMax())) {
				ParameterData& yData = (*_pParameterValues)[lSeriesProperties.getParamId()];

				Range lEstimatedRange(lAxisRangeMap[lYAxis->_id]);
				Range lParamIndexRange(
						yData.getMin(index), yData.getMax(index));

				if (isnan(lEstimatedRange.getMin()) && isnan(lEstimatedRange.getMax())) {
					lEstimatedRange.setMin(lParamIndexRange.getMin());
					lEstimatedRange.setMax(lParamIndexRange.getMax());
				} else {
					lEstimatedRange.setMin(std::min(lEstimatedRange.getMin(), lParamIndexRange.getMin()));
					lEstimatedRange.setMax(std::max(lEstimatedRange.getMax(), lParamIndexRange.getMax()));
				}
				lEstimatedRange._extend = lYRange._extend;
				lAxisRangeMap[lYAxis->_id] = lEstimatedRange;
			}

			// Set ZAxis range if a color param is defined for this serie
			if (lZAxis != nullptr)
			{
				if (!lSeriesProperties.getColorParamId().empty())
				{
					lZAxis->_used = true;
					Range lRange(lZAxis->getRange());
					ParameterAxes* colorSerieParameterAxes = getParameterAxesByColorSerieId(lSeriesProperties.getColorSerieId());
					if (colorSerieParameterAxes == NULL)
						continue;
					ColorSeriesProperties& colorSerieProp = colorSerieParameterAxes->getColorSeriePropertiesById(lSeriesProperties.getColorSerieId());
					// If range status for this axis is set by the user do not update range "automatically".
					if (isnan(lRange.getMin()) && isnan(lRange.getMax())) {
						Range lEstimatedRange(lColorAxeRange);
						Range lParamIndexRange(
							(*_pParameterValues)[lSeriesProperties.getColorParamId()].getMin(
								colorSerieProp.getIndex()),
							(*_pParameterValues)[lSeriesProperties.getColorParamId()].getMax(
								colorSerieProp.getIndex()));

						if (isnan(lEstimatedRange.getMin()) && isnan(lEstimatedRange.getMax())) {
							lEstimatedRange.setMin(lParamIndexRange.getMin());
							lEstimatedRange.setMax(lParamIndexRange.getMax());
						} else {
							lEstimatedRange.setMin(std::min(lEstimatedRange.getMin(), lParamIndexRange.getMin()));
							lEstimatedRange.setMax(std::max(lEstimatedRange.getMax(), lParamIndexRange.getMax()));
						}
						lEstimatedRange._extend = lRange._extend;
						lColorAxeRange = lEstimatedRange;
					}
				}
			}
		}
	}

	// Update range of axis.
	for (auto lAxis: lAxisRangeMap) {
		_panel->getAxis(lAxis.first)->setRange(lAxis.second);
	}

	if (lZAxis != nullptr && lColorAxeRange.isSet())
		lZAxis->setRange(lColorAxeRange);
}

void XYPlot::configureAxisLegend () {
	// Y axis
	AxisLegendManager::configureYAxisLegendForSeries(this);

	// X axis
	AxisLegendManager::configureXAxisLegendForSeries(this);

	// Z axis
	AxisLegendManager::configureColorAxisLegendForSeries(this);
}

/*
 * @brief Get computed X values (in relation with the x axis definition) for a serie and a time interval
 * Do not forget to delete computedValues !!
 * Don't delete timeValues !!
 */
bool XYPlot::getXComputedValuesFromSerieAndInterval(double startDate, double stopDate, SeriesProperties &rSeriesProperties,
		double** computedValues, double** timeValues, int& nbValues)
{
	LOG4CXX_DEBUG(gLogger, "XYPlot::getXComputedValuesFromSerieAndInterval");

	ParameterAxes& xparameter = getParameterAxeOnXAxis(rSeriesProperties.getXAxisId());

	XSeriesProperties& xSerie = getSerieOnXAxisfromParameter(
			rSeriesProperties.getXAxisId(), xparameter);

	//get parameter x data for this serie
	ParameterData& xData = (*_pParameterValues)[xSerie.getXParamIds()[rSeriesProperties.getParamId()]];

	int startIndex;
	double *valuesInterval = xData.getIntervalValues(startDate, stopDate, xSerie.getIndex(),
				startIndex, nbValues);

	if (valuesInterval == NULL)
	{
		LOG4CXX_DEBUG(gLogger, "XYPlot::getXComputedValuesFromSerieAndInterval - Cannot find data for the x serie");
		return false;
	}

	//get computed data for interval [startDate, stopDate] in relation with the serie y axis
	(*computedValues) = _panel->getAxis(rSeriesProperties.getXAxisId())->getComputedValues(
			valuesInterval,
			nbValues,
			xSerie.getMin(),
			xSerie.getMax());

	//get time values
	(*timeValues) = &xData.getTimes()[startIndex];

	return true;
}

/*
 * @overload PanelPlotOutput::getSerieParamsLegendString Return the associated params legend to a xy serie
 */
std::string XYPlot::getSerieParamsLegendString(SeriesProperties &rSeriesProperties,
			AMDA::Common::ParameterIndexComponent& index, std::string originalParamId)
{
	//retrieve x axis properties

	ParameterAxes& xparameter = getParameterAxeOnXAxis(rSeriesProperties.getXAxisId());

	XSeriesProperties xSerie = getSerieOnXAxisfromParameter(
			rSeriesProperties.getXAxisId(), xparameter);

	// Retrieve ParamInfo Manager
	ParamMgr 		*piMgr =ParamMgr::getInstance();

	// Build parameter text legend depending on the availability of paramInfo
	// for Y and X component

	//For y component, re-use the text of the PanelPlotOutput
	std::stringstream paramLegendText;
	paramLegendText << PanelPlotOutput::getSerieParamsLegendString(rSeriesProperties,index,originalParamId);

	// Try to retrieve informations from paramInfo for Y componenet
	ParameterSPtr p = _parameterManager.getParameter(rSeriesProperties.getParamId());

	paramLegendText << " = f(";

	// Try to retrieve informations from paramInfo for X component
	p = _parameterManager.getParameter(xparameter._originalParamId);
	ParamInfoSPtr paramInfo = piMgr->getParamInfoFromId(p->getInfoId());

	// Build parameter text legend depending on the availability of paramInfo
	if (paramInfo)
	{
		if ((xSerie.getIndex().getDim1Index() == -1) && (xSerie.getIndex().getDim2Index() == -1))
		{
			// parameter legend text = short_name
			paramLegendText << paramInfo->getShortName();
		}
		else
		{
			if (paramInfo->getComponents(xSerie.getIndex()).empty() == false)
				// parameter legend text = components at index index]
				paramLegendText << paramInfo->getComponents(xSerie.getIndex());
			else
			{
				// parameter legend text = short_name [index]
				paramLegendText << paramInfo->getShortName() << "[" << xSerie.getIndex().getDim1Index();
				if (xSerie.getIndex().getDim2Index() != -1)
					paramLegendText << "," << xSerie.getIndex().getDim2Index();
				paramLegendText << "]";
			}
		}
	}
	else
	{
		if ((xSerie.getIndex().getDim1Index() == -1) && (xSerie.getIndex().getDim2Index() == -1))
			// parameter legend text = _originalParamId
			paramLegendText << xparameter._originalParamId;
		else
		{
			// parameter legend text = _originalParamId [index]
			paramLegendText << xparameter._originalParamId << "[" << xSerie.getIndex().getDim1Index();
			if (xSerie.getIndex().getDim2Index() != -1)
				paramLegendText << "," << xSerie.getIndex().getDim2Index();
			paramLegendText << "]";
		}
	}

	paramLegendText << ")";

	return paramLegendText.str();
}

} /* namespace plot */