#include "tparamset.h"
#include "tdoubleparam.h"
#include "texception.h"
#include "tstream.h"

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

class TRangeParamImp
{
public:
	TRangeParamImp(const DoublePair &v)
		: m_min(new TDoubleParam(v.first)), m_max(new TDoubleParam(v.second))
	{
	}
	TRangeParamImp(const TRangeParamImp &src)
		: m_min(src.m_min->clone()), m_max(src.m_max->clone())
	{
	}

	~TRangeParamImp() {}

	TDoubleParamP m_min, m_max;
};

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

PERSIST_IDENTIFIER(TRangeParam, "rangeParam")

TRangeParam::TRangeParam(const DoublePair &v)
	: m_data(new TRangeParamImp(v))
{
	addParam(m_data->m_min, "min");
	addParam(m_data->m_max, "max");
}

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

TRangeParam::TRangeParam(const TRangeParam &src)
	: TParamSet(src.getName()), m_data(new TRangeParamImp(*src.m_data))
{
	addParam(m_data->m_min, "min");
	addParam(m_data->m_max, "max");
}

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

TRangeParam::~TRangeParam()
{
	delete m_data;
}

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

void TRangeParam::copy(TParam *src)
{
	TRangeParam *p = dynamic_cast<TRangeParam *>(src);
	if (!p)
		throw TException("invalid source for copy");
	setName(src->getName());
	m_data->m_min->copy(p->m_data->m_min.getPointer());
	m_data->m_max->copy(p->m_data->m_max.getPointer());
}

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

DoublePair TRangeParam::getDefaultValue() const
{
	return DoublePair(m_data->m_min->getDefaultValue(), m_data->m_max->getDefaultValue());
}

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

DoublePair TRangeParam::getValue(double frame) const
{
	return DoublePair(m_data->m_min->getValue(frame), m_data->m_max->getValue(frame));
}

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

bool TRangeParam::setValue(double frame, const DoublePair &v)
{
	beginParameterChange();
	m_data->m_min->setValue(frame, v.first);
	m_data->m_max->setValue(frame, v.second);
	endParameterChange();
	return true;
}

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

void TRangeParam::setDefaultValue(const DoublePair &v)
{
	m_data->m_min->setDefaultValue(v.first);
	m_data->m_max->setDefaultValue(v.second);
}

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

void TRangeParam::loadData(TIStream &is)
{
	std::string childName;
	while (is.openChild(childName)) {
		if (childName == "min")
			m_data->m_min->loadData(is);
		else if (childName == "max")
			m_data->m_max->loadData(is);
		else
			throw TException("unknown tag");
		is.closeChild();
	}
}

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

void TRangeParam::saveData(TOStream &os)
{
	os.openChild("min");
	m_data->m_min->saveData(os);
	os.closeChild();
	os.openChild("max");
	m_data->m_max->saveData(os);
	os.closeChild();
}

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

TDoubleParamP &TRangeParam::getMin()
{
	return m_data->m_min;
}

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

TDoubleParamP &TRangeParam::getMax()
{
	return m_data->m_max;
}
#ifdef BUTTA
//---------------------------------------------------------

int TRangeParam::getNextKeyframe(double frame) const
{
	int f_min = m_data->m_min->getNextKeyframe(frame);
	int f_max = m_data->m_max->getNextKeyframe(frame);
	if (f_min <= f_max && f_min != -1)
		return f_min;
	else {
		if (f_max != -1)
			return f_max;
		else
			return -1;
	}
}

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

int TRangeParam::getPrevKeyframe(double frame) const
{
	int f_min = m_data->m_min->getPrevKeyframe(frame);
	int f_max = m_data->m_max->getPrevKeyframe(frame);
	if (f_min >= f_max)
		return f_min;
	else
		return f_max;
}

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

void TRangeParam::deleteKeyframe(double frame, bool undoing)
{
	m_data->m_min->deleteKeyframe(frame, undoing);
	m_data->m_max->deleteKeyframe(frame, undoing);
}

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

bool TRangeParam::isKeyframe(double frame) const
{
	bool min, max;
	min = m_data->m_min->isKeyframe(frame);
	max = m_data->m_max->isKeyframe(frame);
	return (min || max);
}
//---------------------------------------------------------

#endif