/*
 * SeriesProperties.hh
 *
 *  Created on: Dec 3, 2013
 *      Author: amdadev
 */

#ifndef SERIESPROPERTIES_HH_
#define SERIESPROPERTIES_HH_

#include <iostream>
#include <cmath>
#include <string>

#include "DrawingProperties.hh"
#include "ParameterIndexesTool.hh"
#include "ParameterData.hh"

namespace plot {

/**
 * Drawing properties for a parameter series.Each parameter series
 * depict one parameter dimension (thus for a scalar parameter there should
 * be only one series). Index field of the series indicates the related parameter
 * dimension (starting at 0).
 */
class SeriesProperties: public DrawingProperties {
public:
	static int AUTO_SERIES_ID;

	friend std::ostream& operator<<(std::ostream& out_,
			const SeriesProperties& lprop_);

	/*
	 * @brief Dumps properties for test.
	 */
	void dump(std::ostream& out_, std::string& prefix_);

	SeriesProperties() :
			DrawingProperties(),
			_index(-1,-1),
			_paramId(""),
			_hasXAxis(true),
			_hasYAxis(true),
			_hasZAxis(false),
			_colorSerieId(-1),
			_xId(-1),
			_colorParamId(""),
			_id(-1),
			_computeExpression(""),
			_computeExpressionName("")
	{
	}

	SeriesProperties(const DrawingProperties& ref_) :
			DrawingProperties(ref_),
			_index(-1,-1),
			_paramId(""),
			_hasXAxis(true),
			_hasYAxis(true),
			_hasZAxis(false),
			_colorSerieId(-1),
			_xId(-1),
			_colorParamId(""),
			_id(-1),
			_computeExpression(""),
			_computeExpressionName("")
	{
	}

	SeriesProperties(const SeriesProperties& pParamDrawingProperties_) :
			DrawingProperties(pParamDrawingProperties_),
			_index(pParamDrawingProperties_._index),
			_paramId(pParamDrawingProperties_._paramId),
			_hasXAxis(pParamDrawingProperties_._hasXAxis),
			_hasYAxis(pParamDrawingProperties_._hasYAxis),
			_hasZAxis(pParamDrawingProperties_._hasZAxis),
			_colorSerieId(pParamDrawingProperties_._colorSerieId),
			_xId(pParamDrawingProperties_._xId),
			_colorParamId(pParamDrawingProperties_._colorParamId),
			_id(pParamDrawingProperties_._id),
			_computeExpression(pParamDrawingProperties_._computeExpression),
			_computeExpressionName(pParamDrawingProperties_._computeExpressionName)
	{
	}

	SeriesProperties& operator=(const SeriesProperties& ref_) {
		DrawingProperties::operator=(ref_);
		_index = ref_._index;
		_paramId  = ref_._paramId;
		_hasYAxis = ref_._hasYAxis;
		_hasXAxis = ref_._hasXAxis;
		_hasZAxis = ref_._hasZAxis;
		_colorSerieId = ref_._colorSerieId;
		_xId = ref_._xId;
		_colorParamId = ref_._colorParamId;
		_id		  = ref_._id;
		_computeExpression	= ref_._computeExpression;
		_computeExpressionName = ref_._computeExpressionName;
		return *this;
	}

	virtual ~SeriesProperties() {
	}

	void setIndex(AMDA::Common::ParameterIndexComponent i_) {
		_index = i_;
	}

	AMDA::Common::ParameterIndexComponent getIndex() const {
		return _index;
	}

	std::string getParamId(){
		return _paramId;
	}

	void setParamId(std::string paramId_) {
		_paramId = paramId_;
	}

	bool hasXAxis() const {
		return _hasXAxis;
	}

	void setXAxis(bool hasXAxis) {
		_hasXAxis = hasXAxis;
	}

	bool hasYAxis() const {
		return _hasYAxis;
	}

	void setYAxis(bool hasYAxis) {
		_hasYAxis = hasYAxis;
	}

	bool hasZAxis() const {
		return _hasZAxis;
	}

	void setZAxis(bool hasZAxis) {
		_hasZAxis = hasZAxis;
	}

	int getColorSerieId() const {
		return _colorSerieId;
	}

	void setColorSerieId(int colorSerieId) {
		_colorSerieId = colorSerieId;
	}

	int getXId() const {
		return _xId;
	}

	void setXId(int xId) {
		_xId = xId;
	}

	std::string getColorParamId(void) {
		return _colorParamId;
	}

	void setColorParamId(std::string colorParamId) {
		_colorParamId = colorParamId;
	}

	int getId() const {
		return _id;
	}

	void setId(int id) {
		_id = id;
	}

	const std::string& getComputeExpression() const {
		return _computeExpression;
	}

	void setComputeExpression(const std::string& computeExpression) {
		_computeExpression = computeExpression;
	}

	const std::string& getComputeExpressionName() const {
		return _computeExpressionName;
	}

	void setComputeExpressionName(const std::string& computeExpressionName) {
		_computeExpressionName = computeExpressionName;
	}

	std::vector<AMDA::Common::ParameterIndexComponent> getIndexList(std::map<std::string, ParameterData> *pParameterValues);

private:

	/**
	 * @brief Series index definition
	 */
	AMDA::Common::ParameterIndexComponent _index;

	/**
	 * @brief Related ParamId
	 */
	std::string _paramId;

	/**
	 * @brief Flag that indicates the serie has X Axis
	 */
	bool _hasXAxis;

	/**
	 * @brief Flag that indicates the serie has Y Axis (tickplot has no Y axis)
	 */
	bool _hasYAxis;

	/**
	 * @brief Flag that indicates the serie has Z Axis (ie color axis)
	 */
	bool _hasZAxis;

	/**
	 * @brief Associated Color Serie identifier
	 */
	int _colorSerieId;

	/**
	 * @brief Associated X Serie identifier
	 */
	int _xId;

	/**
	 * @bried Related color param id
	 */
	std::string _colorParamId;

	/**
	 * @brief Serie identifier used by the fill element
	 */
	int _id;

	/**
	 * Compute expression used to set expression results as x values
	 * instead of parameter index
	 */
	std::string _computeExpression;

	/**
	 * Name of the compute expression.
	 * Used for legend axis
	 */
	std::string _computeExpressionName;
};

} /* namespace plot */

#endif /* SERIESPROPERTIES_HH_ */