/*
 * SeriesNode.hh
 *
 *  Created on: Dec 9, 2013
 *      Author: amdadev
 */

#ifndef SERIESNODE_HH_
#define SERIESNODE_HH_

#include <libxml/globals.h>
#include <libxml/tree.h>
#include <libxml/xmlstring.h>
#include <iosfwd>

#include "FileConfigurator.hh"
#include "DrawingPropertiesNode.hh"
#include "PlotLogger.hh"
#include "SeriesProperties.hh"
#include "XSeriesProperties.hh"

namespace plot {

const std::string OrbitParamComponentName = "_AMDA_PARAM_COMP_";

/**
 * Class that handle a <serie> xml node.
 * Template class that should be instanciated for each subclass of PanelOutputPanel.
 */
template<class PlotType>
class SeriesNode: public plot::DrawingPropertiesNode<PlotType> {
public:
	SeriesNode() :
			DrawingPropertiesNode<PlotType>() {
	}
	virtual ~SeriesNode() {
	}
	void proceed(xmlNodePtr pNode_,
			const AMDA::Parameters::CfgContext& pContext_) {
		LOG4CXX_DEBUG(gLogger, "SerieNode::proceed");
		PlotType* plotOutput = pContext_.get<PlotType*>();
		xmlChar* name = pContext_.get<xmlChar*>();

		// initialize series with default properties
		DrawingProperties defaultProps = plotOutput->getParameter(
				(const char*) name).getDefaultProperties();
		SeriesProperties serie(defaultProps);

		// parse attributes...
		parseAttributes(pNode_, serie);
		// add series definition to parameter
		DrawingProperties* drawingProp = plotOutput->getParameter((const char*) name).addYSerieProperties(serie);

		// parse children nodes
		AMDA::Parameters::CfgContext context;
		context.push<xmlChar*>(name);
		context.push<DrawingProperties*>(drawingProp);
		AMDA::XMLConfigurator::NodeGrpCfg::proceed(pNode_, context);

	}
protected:
	void parseAttributes(xmlNodePtr pNode_, DrawingProperties& props_) {
		// read parent attributes
		DrawingPropertiesNode<PlotType>::parseAttributes(pNode_, props_);
		// specific series node attributes :
		xmlChar * value = NULL;

		value = xmlGetProp(pNode_, (const xmlChar*) "index");
		if (value) {
			AMDA::Common::ParameterIndexComponentList indexList;
			if (!AMDA::Common::ParameterIndexesTool::parse((const char*) value, -1, -1, indexList) || indexList.empty())
			{
				LOG4CXX_ERROR(gLogger, "SerieNode::parseAttributes - Bad index definition " << (const char*) value);
				xmlFree(value);
				BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("Bad serie index definition"));
			}
			((SeriesProperties&) props_).setIndex(indexList.front());
			xmlFree(value);
		} else {
			((SeriesProperties&) props_).setIndex(AMDA::Common::ParameterIndexComponent(-1,-1)); // default case: if no index attribute, we use default index value -1 which means for all series.
		}

		// -- parameter resolution
		value = xmlGetProp(pNode_, (const xmlChar *) "resolution");
		if( value ) {
			props_.setMaxResolution(atoi((const char*)value));
			xmlFree(value);
		}

		value = xmlGetProp(pNode_, (const xmlChar*) "id");
		if (value) {
			((SeriesProperties&) props_).setId(atoi((const char*) value));
			xmlFree(value);
		}

		// -- associated color serie id
		value = xmlGetProp(pNode_, (const xmlChar*) "colorSerieId");
		if (value) {
			((SeriesProperties&) props_).setColorSerieId(atoi((const char*) value));
			xmlFree(value);
		}

		// -- associated x serie id
		value = xmlGetProp(pNode_, (const xmlChar*) "xId");
		if (value) {
			((SeriesProperties&) props_).setXId(atoi((const char*) value));
			xmlFree(value);
		}
	}
};

template<class PlotType>
class XSeriesNode: public AMDA::XMLConfigurator::NodeCfg {
public:
	XSeriesNode():
		AMDA::XMLConfigurator::NodeCfg() {
	}
	virtual ~XSeriesNode() {
	}

	void proceed(xmlNodePtr pNode_,const AMDA::Parameters::CfgContext& pContext_) {
		LOG4CXX_DEBUG(gLogger, "XSeriesNode::proceed");
		PlotType* plotOutput = pContext_.get<PlotType*>();
		xmlChar* name = pContext_.get<xmlChar*>();

		XSeriesProperties serie;

		xmlChar * value = NULL;
		// -- serie identifier
		value = xmlGetProp(pNode_, (const xmlChar *) "id");
		if( value ) {
			serie.setId(atoi((const char*) value));
		}

		// -- parameter component index
		value = xmlGetProp(pNode_, (const xmlChar *) "index");
		if( value ) {
			serie.setIndex(atoi((const char*)value));
			xmlFree(value);
		}

		// -- min information
		value = xmlGetProp(pNode_, (const xmlChar *) "min");
		if( value ){
			serie.setMin(atof((const char*)value));
			xmlFree(value);
		}
		else {
			serie.setMin(nan(""));
		}

		// -- max information
		value = xmlGetProp(pNode_, (const xmlChar *) "max");
		if( value ){
			serie.setMax(atof((const char*)value));
			xmlFree(value);
		}
		else {
			serie.setMax(nan(""));
		}

		// add series definition to parameter
		serie.setParamId((const char*)name);
		plotOutput->getParameter((const char*)name).addXSerieProperties( serie );
	}
};

template<class PlotType>
class ColorSeriesNode: public AMDA::XMLConfigurator::NodeCfg {
public:
	ColorSeriesNode():
		AMDA::XMLConfigurator::NodeCfg() {
	}
	virtual ~ColorSeriesNode() {
	}

	void proceed(xmlNodePtr pNode_,const AMDA::Parameters::CfgContext& pContext_) {
		LOG4CXX_DEBUG(gLogger, "ColorSeriesNode::proceed");
		PlotType* plotOutput = pContext_.get<PlotType*>();
		xmlChar* name = pContext_.get<xmlChar*>();

		ColorSeriesProperties serie;

		xmlChar * value = NULL;
		// -- color serie identifier
		value = xmlGetProp(pNode_, (const xmlChar *) "id");
		if( value ) {
			serie.setId(atoi((const char*)value));
			xmlFree(value);
		}

		// -- parameter component index
		value = xmlGetProp(pNode_, (const xmlChar *) "index");
		if( value ) {
			serie.setIndex(atoi((const char*)value));
			xmlFree(value);
		}

		// add series definition to parameter
		plotOutput->getParameter((const char*)name).addColorSerieProperties( serie );
	}
};

/**
 * Class that handle a <serie> xml node.
 * Template class that should be instanciated for each subclass of PanelOutputPanel.
 */
template<class PlotType>
class OrbitSeriesNode: public plot::DrawingPropertiesNode<PlotType> {
public:

	OrbitSeriesNode() :	DrawingPropertiesNode<PlotType>() {
	}

	virtual ~OrbitSeriesNode() {
	}

	void proceed(xmlNodePtr pNode_, const AMDA::Parameters::CfgContext& pContext_) {
		LOG4CXX_DEBUG(gLogger, "OrbitSeriesNode::proceed");

		PlotType* plotOutput = pContext_.get<PlotType*>();
		xmlChar* name = pContext_.get<xmlChar*>();

		// initialize series with default properties
		DrawingProperties defaultProps = plotOutput->getParameter((const char*) name).getDefaultProperties();

		// Build y and x series associated with orbit plot
		// ---------------------------------------------------------------------

		SeriesProperties yserie(defaultProps);
		XSeriesProperties xserie;
		xserie.setId(SeriesProperties::AUTO_SERIES_ID);
		++SeriesProperties::AUTO_SERIES_ID;

		// parse attributes for ySerie
		// ---------------------------------------------------------------------

		// read parent attributes
		DrawingPropertiesNode<PlotType>::parseAttributes(pNode_, yserie);
		yserie.setXId(xserie.getId());

		// specific series node attributes :
		xmlChar * value = NULL;
		char expression [128];

		value = xmlGetProp(pNode_, (const xmlChar*) "projection");
		if (value) {
			std::string projecttion((const char *)value);

			// Depending on the value of the first letter of the projection
			// set corresponding index on xserie
			switch (projecttion.at(0)) {
			case 'X' :
				xserie.setIndex(0);
				break;
			case 'Y' :
				xserie.setIndex(1);
				break;
			case 'Z' :
				xserie.setIndex(2);
				break;
			default :
				throw std::logic_error("Invalid projection");
				break;
			}

			// Depending on the value of the second letter of the projection
			// set corresponding index on yserie
			switch (projecttion.at(1)) {
			case 'X' :
				yserie.setIndex(0);
				break;
			case 'Y' :
				yserie.setIndex(1);
				break;
			case 'Z' :
				yserie.setIndex(2);
				break;
			case 'R' :
				yserie.setIndex(-1);

				if (projecttion.at(0) == 'X') {
					sprintf (expression, "sqrt($%s[1]*$%s[1]+$%s[2]*$%s[2])",
							OrbitParamComponentName.c_str(), OrbitParamComponentName.c_str(),
							OrbitParamComponentName.c_str(), OrbitParamComponentName.c_str()
							);
					yserie.setComputeExpression(expression);
				}
				else if (projecttion.at(0) == 'Y') {
					sprintf (expression, "sqrt($%s[0]*$%s[0]+$%s[2]*$%s[2])",
							OrbitParamComponentName.c_str(), OrbitParamComponentName.c_str(),
							OrbitParamComponentName.c_str(), OrbitParamComponentName.c_str()
							);
					yserie.setComputeExpression(expression);
				}
				else if (projecttion.at(0) == 'Z') {
					sprintf (expression, "sqrt($%s[0]*$%s[0]+$%s[1]*$%s[1])",
							OrbitParamComponentName.c_str(), OrbitParamComponentName.c_str(),
							OrbitParamComponentName.c_str(), OrbitParamComponentName.c_str()
							);
					yserie.setComputeExpression(expression);
				}
				else
					throw std::logic_error("Invalid projection");
				yserie.setComputeExpressionName("R");
				break;
			default :
				throw std::logic_error("Invalid projection");
				break;
			}
			xmlFree(value);
		}

		// -- parameter resolution
		value = xmlGetProp(pNode_, (const xmlChar *) "resolution");
		if( value ) {
			yserie.setMaxResolution(atoi((const char*)value));
			xmlFree(value);
		}

		value = xmlGetProp(pNode_, (const xmlChar*) "id");
		if (value) {
			yserie.setId(atoi((const char*) value));
			xmlFree(value);
		}

		// -- associated color serie id
		value = xmlGetProp(pNode_, (const xmlChar*) "colorSerieId");
		if (value) {
			yserie.setColorSerieId(atoi((const char*) value));
			xmlFree(value);
		}

		// add x and y series definition to parameter
		plotOutput->getParameter((const char*)name).addXSerieProperties(xserie );
		DrawingProperties* drawingProp = plotOutput->getParameter((const char*) name).addYSerieProperties(yserie);

		// parse children nodes
		AMDA::Parameters::CfgContext context;
		context.push<xmlChar*>(name);
		context.push<DrawingProperties*>(drawingProp);
		AMDA::XMLConfigurator::NodeGrpCfg::proceed(pNode_, context);

	}
};

}
/* namespace plot */

#endif /* SERIESNODE_HH_ */