/*
 * ParamsLegendProperties.cc
 *
 *  Created on: 18 sep. 2014
 *      Author: AKKA
 */

#include "ParamsLegendProperties.hh"

#include <cstring>

namespace plot
{


LegendLineProperties::LegendLineProperties(void) : _symbolProperties(),
			_lineProperties(), _text("None"), _textColor()
{
}

LegendLineProperties::~LegendLineProperties(void)
{
}

/*
 * @brief Get symbol
 */
const SymbolProperties& LegendLineProperties::getSymbolProperties(void) const
{
	return _symbolProperties;
}

/*
 * @brief Set symbol
 */
void LegendLineProperties::setSymbolProperties(const SymbolProperties& symbolProperties)
{
	_symbolProperties = symbolProperties;
}

/*
 * @brief Get line
 */
const LineProperties& LegendLineProperties::getLineProperties(void) const
{
	return _lineProperties;
}

/*
 * @brief Set line
 */
void LegendLineProperties::setLineProperties(const LineProperties& lineProperties)
{
	_lineProperties = lineProperties;
}

/*
 * @brief Get text
 */
const char *LegendLineProperties::getText(void) const
{
	return _text.c_str();
}

/*
 * @brief Set text
 */
void LegendLineProperties::setText(const char *text)
{
	_text = text;
}

/*
 * @brief Set default color
 */
void LegendLineProperties::setDefaultTextColor(const Color &textColor)
{
	_textColor = textColor;
}

/*
 * @brief Get color to use for text
 */
Color LegendLineProperties::getTextColor(bool autoTextColor)
{
	if (!autoTextColor)
		//use default color
		return _textColor;
	if (isLineVisible())
		//use line color
		return _lineProperties.getColor();
	if (isSymbolsVisible())
		//use symbol color
		return _symbolProperties.getColor();
	//else use default color
	return _textColor;
}

/*
 * @brief Line visibility
 */
bool LegendLineProperties::isLineVisible(void)
{
	return (_lineProperties.getType() == LineType::LINE);
}

/*
 * @brief Symbol visibility
 */
bool LegendLineProperties::isSymbolsVisible(void)
{
	return (_symbolProperties.getType() != SymbolType::NO);
}




ParamsLegendProperties::ParamsLegendProperties(void) :
		_isOnlyText(false),
		_defaultTextColor(Color(0,0,0)),
		_isBorderVisible(true), _borderColor(Color(0,0,0)),
		_isVisible(false), _position(ParamsLegendPosition::POS_INSIDE),
		_font("sans-serif", 12), _leftOffset(0.0), _drawn(false), _isParamInfoVisible(true),
		_isIntervalInfoVisible(false),
		_intervalInfoType(ParamsLegendProperties::IntervalInfoType::INDEX)
{

}

ParamsLegendProperties::~ParamsLegendProperties(void)
{
	reset();
}

/*
 * @brief Reset legend for a next plot
 */
void ParamsLegendProperties::reset(void)
{
	_lines.clear();
	_colors.clear();
	_drawn = false;
}

/*
 * @brief Add a serie to the legend
 */
void ParamsLegendProperties::addSerie(SeriesProperties &serie,
		const char *text, Color lineColor, Color symbolColor)
{
	LegendLineProperties lineProp;

	SymbolProperties symbol = serie.getSymbolProperties();
	symbol.setColor(symbolColor);
	lineProp.setSymbolProperties(symbol);

	LineProperties line = serie.getLineProperties();
	line.setColor(lineColor);
	lineProp.setLineProperties(line);

	lineProp.setText(text);

	lineProp.setDefaultTextColor(_defaultTextColor);

	_lines.push_back(lineProp);
}

/*
 * @brief Get color index from a color
 * Create a list of used color
 */
int ParamsLegendProperties::getColorIndex(plstream *pls, Color color)
{
	int r, g, b;

	if (color._colorIndex != -1)
		pls->gcol0(color._colorIndex, r, g,	b);
	else
	{
		r = color._red;
		g = color._green;
		b = color._blue;
	}

	int index = 0;
	for (auto col : _colors)
	{
		if ((col._red == r) &&
			(col._green == g) &&
			(col._blue == b))
			return index;
		++index;
	}

	Color newCol(r,g,b);
	_colors.push_back(newCol);

	return index;
}

/*
 * @brief Set only text option
 */
void ParamsLegendProperties::setOnlyText(bool onlyText)
{
	_isOnlyText = onlyText;
}

/*
 * @brief Get only text option
 */
bool ParamsLegendProperties::isOnlyText(void)
{
	return _isOnlyText;
}

/*
 * @brief Set font
 */
void ParamsLegendProperties::setFont(Font font)
{
	_font = font;
}

/*
 * @brief Get font
 */
Font& ParamsLegendProperties::getFont(void)
{
	return _font;
}

/*
 * @brief Set default text color
 */
void ParamsLegendProperties::setDefaultTextColor(const Color& color)
{
	_defaultTextColor = color;

	for (auto lineProp : _lines)
	{
		lineProp.setDefaultTextColor(_defaultTextColor);
	}
}

/*
 * @brief Set border color
 */
void ParamsLegendProperties::setBorderColor(const Color& color)
{
	_borderColor = color;
}

/*
 * @brief Get border color
 */
Color ParamsLegendProperties::getBorderColor(void)
{
	return _borderColor;
}

/*
 * @brief Set visibility of border
 */
void ParamsLegendProperties::setIsBorderVisible(bool boderVisible)
{
	_isBorderVisible = boderVisible;
}

/*
 * @brief Get visibility of border
 */
bool ParamsLegendProperties::isBorderVisible(void)
{
	return _isBorderVisible;
}

/*
 * @brief Get visibility of legend
 */
bool ParamsLegendProperties::isVisible(void)
{
	return _isVisible;
}

/*
 * @brief Set visibility of the legend
 */
void ParamsLegendProperties::setIsVisible(bool isVisible)
{
	_isVisible = isVisible;
}

/*
 * @brief Get position
 */
ParamsLegendPosition ParamsLegendProperties::getPosition(void)
{
	return _position;
}

/*
 * @brief Set position
 */
void ParamsLegendProperties::setPosition(ParamsLegendPosition position)
{
	_position = position;
}

/*
 * @brief Get left offset
 */
double ParamsLegendProperties::getLeftOffset(void)
{
	return _leftOffset;
}

/*
 * @brief Set left offset
 */
void ParamsLegendProperties::setLeftOffset(double offset)
{
	_leftOffset = offset;
}

/*
 * @brief Estimate the width of the legend
 */
double ParamsLegendProperties::getEstimateWidth(double charSize)
{
	int maxNbChar = 0;
	for (auto line : _lines)
	{
		maxNbChar = std::max(maxNbChar,(int)strlen(line.getText()));
	}

	double width = charSize * (LEGEND_TEXT_OFFSET+maxNbChar);
	if (!_isOnlyText)
		width += LEGEND_LINE_SYM_WIDTH;
	//else
	//	width += charSize * LEGEND_TEXT_OFFSET;

	return width;
}

/*
 * @brief Get list of legend lines
 */
const std::list<LegendLineProperties>& ParamsLegendProperties::getLegendLines(void) const
{
	return _lines;
}

/*
 * @brief Get list of color used by the legend
 */
const std::vector<Color>& ParamsLegendProperties::getColorsMap(void) const
{
	return _colors;
}

/*
 * @brief To know if the legend is already drawn
 */
bool ParamsLegendProperties::isDrawn(void)
{
	return _drawn;
}

/*
 * @brief Set if legend is drawn
 */
void ParamsLegendProperties::setDrawn(bool drawn)
{
	_drawn = drawn;
}

/*
 * @brief Set param info visibility
 */
void ParamsLegendProperties::setParamInfoVisible(bool isVisible)
{
	_isParamInfoVisible = isVisible;
}

/*
 * @brief Get param info visibility
 */
bool ParamsLegendProperties::isParamInfoVisible(void)
{
	return _isParamInfoVisible;
}

/*
 * @brief Set interval info visibility
 */
void ParamsLegendProperties::setIntervalInfoVisible(bool isVisible)
{
	_isIntervalInfoVisible = isVisible;
}

/*
 * @brief Get interval info visibility
 */
bool ParamsLegendProperties::isIntervalInfoVisible(void)
{
	return _isIntervalInfoVisible;
}

/*
 * @brief Set interval info type
 */
void ParamsLegendProperties::setIntervalInfoType(IntervalInfoType type)
{
	_intervalInfoType = type;
}

/*
 * @brief Get interval info type
 */
ParamsLegendProperties::IntervalInfoType ParamsLegendProperties::getIntervalInfoType(void)
{
	return _intervalInfoType;
}

} /* namespace plot */