#include "tnotanimatableparam.h"

#include "tstream.h"

PERSIST_IDENTIFIER(TIntParam, "intParam")

PERSIST_IDENTIFIER(TBoolParam, "boolParam")

PERSIST_IDENTIFIER(TFilePathParam, "filePathParam")

PERSIST_IDENTIFIER(TStringParam, "stringParam")

PERSIST_IDENTIFIER(TNADoubleParam, "naDoubleParam")

//PERSIST_IDENTIFIER(TIntEnumParam, "intEnumParam")

TPersistDeclarationT<tenumparam> TEnumParam::m_declaration("intEnumParam");</tenumparam>

//=========================================================

void TIntParam::loadData(TIStream &is)

{

	int def, value;

	is >> def;

	if (is.eos()) {

		def += 1;

		setDefaultValue(def);

		setValue(def, false);

		return;

	}

	setDefaultValue(def);

	is >> value;

	setValue(value, false);

}

//---------------------------------------------------------

void TIntParam::saveData(TOStream &os)

{

	os << getDefaultValue();

	os << getValue();

}

//---------------------------------------------------------

bool TIntParam::isWheelEnabled() const

{

	return m_isWheelEnabled;

}

//---------------------------------------------------------

void TIntParam::enableWheel(bool on)

{

	m_isWheelEnabled = on;

}

//=========================================================

void TBoolParam::loadData(TIStream &is)

{

	int def, value;

	is >> def >> value;

	setDefaultValue(def ? true : false);

	setValue(value ? true : false, false);

}

//---------------------------------------------------------

void TBoolParam::saveData(TOStream &os)

{

	os << (int)getDefaultValue() << (int)getValue();

}

//=========================================================

void TFilePathParam::loadData(TIStream &is)

{

	TFilePath def, value;

	is >> def >> value;

	setDefaultValue(def);

	setValue(value, false);

}

//---------------------------------------------------------

void TFilePathParam::saveData(TOStream &os)

{

	os << getDefaultValue();

	os << getValue();

}

//=========================================================

void TStringParam::loadData(TIStream &is)

{

	std::wstring def, value;

	is >> def >> value;

	setDefaultValue(def);

	setValue(value, false);

}

void TStringParam::saveData(TOStream &os)

{

	os << getDefaultValue();

	os << getValue();

}

//=========================================================

void TNADoubleParam::loadData(TIStream &is)

{

	double def, value;

	is >> def >> value;

	setDefaultValue(def);

	setValue(value, false);

}

void TNADoubleParam::saveData(TOStream &os)

{

	os << getDefaultValue();

	os << getValue();

}

//=========================================================

//=========================================================

namespace

{

template <typename t=""></typename>

class matchesValue

{

	T m_v;

public:

	matchesValue(T v) : m_v(v) {}

	bool operator()(const std::pair<t, std::string=""> &p) { return m_v == p.first; }</t,>

};

}

//---------------------------------------------------------

class TEnumParamImp

{

public:

	std::vector<std::pair<int, std::string="">> m_items;</std::pair<int,>

	void copy(std::unique_ptr<tenumparamimp>& src)</tenumparamimp>

	{

		m_items.clear();

		std::back_insert_iterator<std::vector<std::pair<int, std::string="">>> bii(m_items);</std::vector<std::pair<int,>

		std::copy(src->m_items.begin(), src->m_items.end(), bii);

	}

	bool checkValue(int v)

	{

		std::vector<std::pair<int, std::string="">>::iterator it =</std::pair<int,>

			std::find_if(m_items.begin(), m_items.end(), matchesValue<int>(v));</int>

		return it != m_items.end();

	}

};

//---------------------------------------------------------

TEnumParam::TEnumParam(const int &v, const std::string &caption)

	: TNotAnimatableParam<int>(v), m_imp(new TEnumParamImp())</int>

{

	addItem(v, caption);

}

//---------------------------------------------------------

void TEnumParam::copy(TParam *src)

{

	TNotAnimatableParam<int>::copy(src);</int>

	TEnumParam *p = dynamic_cast<tenumparam *="">(src);</tenumparam>

	if (!p)

		throw TException("invalid source for copy");

	TEnumParam::setName(src->getName());

	m_imp->copy(p->m_imp);

}

//---------------------------------------------------------

TEnumParam::~TEnumParam()

{

}

//---------------------------------------------------------

TEnumParam::TEnumParam(const TEnumParam &src)

	: TNotAnimatableParam<int>(src), m_imp(new TEnumParamImp(*src.m_imp))</int>

{

}

//---------------------------------------------------------

TEnumParam::TEnumParam()

	: TNotAnimatableParam<int>(), m_imp(new TEnumParamImp())</int>

{

}

//---------------------------------------------------------

void TEnumParam::setValue(int v, bool undoing)

{

	bool valid = false;

	std::vector<std::pair<int, std::string="">>::iterator it = m_imp->m_items.begin();</std::pair<int,>

	for (; it != m_imp->m_items.end(); ++it) {

		if (it->first == v) {

			valid = true;

			break;

		}

	}

	if (!valid)

		throw TException("out of range parameter value");

	TNotAnimatableParam<int>::setValue(v, undoing);</int>

}

//---------------------------------------------------------

void TEnumParam::setValue(const std::string &caption, bool undoing)

{

	bool valid = false;

	int v = 0;

	std::vector<std::pair<int, std::string="">>::iterator it = m_imp->m_items.begin();</std::pair<int,>

	for (; it != m_imp->m_items.end(); ++it) {

		if (it->second == caption) {

			v = it->first;

			valid = true;

			break;

		}

	}

	if (!valid)

		throw TException("out of range parameter value");

	TNotAnimatableParam<int>::setValue(v, undoing);</int>

}

//---------------------------------------------------------

void TEnumParam::addItem(const int &item, const std::string &caption)

{

	m_imp->m_items.push_back(std::make_pair(item, caption));

}

//---------------------------------------------------------

int TEnumParam::getItemCount() const

{

	return m_imp->m_items.size();

}

//---------------------------------------------------------

void TEnumParam::getItem(int i, int &item, std::string &caption) const

{

	assert(i >= 0 && i < m_imp->m_items.size());

	item = m_imp->m_items[i].first;

	caption = m_imp->m_items[i].second;

}

//---------------------------------------------------------

void TEnumParam::loadData(TIStream &is)

{

	int value;

	is >> value;

	try {

		setValue(value, false);

	} catch (TException &) {

		TNotAnimatableParam<int>::reset();</int>

	}

}

//---------------------------------------------------------

void TEnumParam::saveData(TOStream &os)

{

	os << TNotAnimatableParam<int>::getValue();</int>

}

//---------------------------------------------------------

void TIntParam::setValueRange(int min, int max)

{

	assert(min < max);

	minValue = min;

	maxValue = max;

}

bool TIntParam::getValueRange(int &min, int &max) const

{

	min = minValue;

	max = maxValue;

	return min < max;

}