// TnzCore includes

#include "tundo.h"

#include "tconvert.h"

#include "tstream.h"

// TnzBase includes

#include "tdoubleparam.h"

// STD includes

#include <set></set>

#include "tspectrumparam.h"

typedef std::pair<tdoubleparamp, tpixelparamp=""> ColorKeyParam;</tdoubleparamp,>

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

class TSpectrumParamImp

{

	TSpectrumParam *m_sp;

	std::vector<colorkeyparam> m_keys;</colorkeyparam>

public:

	bool m_draggingEnabled;

	bool m_notificationEnabled;

	bool m_isMatteEnabled;

	std::set<tparamobserver *=""> m_observers;</tparamobserver>

public:

	TSpectrumParamImp(TSpectrumParam *sp) : m_sp(sp), m_keys(), m_draggingEnabled(false), m_notificationEnabled(true), m_isMatteEnabled(true)

	{

	}

	TSpectrumParamImp(const TSpectrumParamImp &s)

	{

		copy(s);

	}

	void copy(const TSpectrumParamImp &src)

	{

		m_keys.clear();

		std::vector<colorkeyparam>::const_iterator it = src.m_keys.begin();</colorkeyparam>

		for (; it != src.m_keys.end(); ++it) {

			TDoubleParamP s(it->first->clone());

			TPixelParamP c(it->second->clone());

			m_keys.push_back(std::make_pair(s, c));

		}

	}

	void addKey(const ColorKeyParam &colorKey)

	{

		/*

    m_sp->addParam(colorKey.first);

    m_sp->addParam(colorKey.second);

*/

		m_keys.push_back(colorKey);

	}

	void insertKey(int index, ColorKeyParam &colorKey)

	{

		/*

    m_sp->addParam(colorKey.first);

    m_sp->addParam(colorKey.second);

*/

		std::vector<colorkeyparam>::iterator it = m_keys.begin() + index;</colorkeyparam>

		m_keys.insert(it, colorKey);

	}

	void eraseKey(int index)

	{

		std::vector<colorkeyparam>::iterator colorKeyIt = m_keys.begin() + index;</colorkeyparam>

		/*

    m_sp->removeParam((*colorKeyIt).first);

    m_sp->removeParam((*colorKeyIt).second);

*/

		m_keys.erase(colorKeyIt);

	}

	int getKeyCount() const

	{

		return m_keys.size();

	}

	ColorKeyParam getKey(int index) const

	{

		return m_keys[index];

	}

	void clearKeys()

	{

		m_keys.clear();

	}

	void notify(const TParamChange &change)

	{

		for (std::set<tparamobserver *="">::iterator it = m_observers.begin();</tparamobserver>

			 it != m_observers.end(); ++it)

			(*it)->onChange(change);

	}

private:

	TSpectrumParamImp &operator=(const TSpectrumParamImp &); //not implemented

};

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

PERSIST_IDENTIFIER(TSpectrumParam, "spectrumParam")

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

TSpectrumParam::TSpectrumParam(): m_imp(new TSpectrumParamImp(this)) //brutto...

{

	ColorKeyParam ck1(TDoubleParamP(0.0), TPixelParamP(TPixel32::Black));

	ColorKeyParam ck2(TDoubleParamP(1.0), TPixelParamP(TPixel32::White));

	m_imp->addKey(ck1);

	m_imp->addKey(ck2);

}

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

TSpectrumParam::TSpectrumParam(const TSpectrumParam &src)

	: TParam(src.getName())

	, m_imp(new TSpectrumParamImp(*src.m_imp))

{

}

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

void TSpectrumParam::addObserver(TParamObserver *obs)

{

	m_imp->m_observers.insert(obs);

}

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

void TSpectrumParam::removeObserver(TParamObserver *obs)

{

	m_imp->m_observers.erase(obs);

}

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

TSpectrumParam::TSpectrumParam(int keyCount, TSpectrum::ColorKey keys[])

	: m_imp(new TSpectrumParamImp(this))

{

	for (int i = 0; i < keyCount; i++) {

		double v = keys[i].first;

		TPixel32 pix = keys[i].second;

		TDoubleParamP dp(v);

		TPixelParamP pp(pix);

		pp->enableMatte(m_imp->m_isMatteEnabled);

		ColorKeyParam ck(dp, pp);

		m_imp->addKey(ck);

	}

}

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

void TSpectrumParam::copy(TParam *src)

{

	TSpectrumParam *p = dynamic_cast<tspectrumparam *="">(src);</tspectrumparam>

	if (!p)

		throw TException("invalid source for copy");

	setName(src->getName());

	m_imp->copy(*(p->m_imp));

}

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

TSpectrumParam::~TSpectrumParam()

{

}

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

TSpectrum TSpectrumParam::getValue(double frame) const

{

	assert(m_imp);

	std::vector<tspectrum::colorkey> keys;</tspectrum::colorkey>

	int keyCount = m_imp->getKeyCount();

	for (int i = 0; i < keyCount; i++) {

		ColorKeyParam paramKey = m_imp->getKey(i);

		TSpectrum::ColorKey key(

			paramKey.first->getValue(frame),

			paramKey.second->getValue(frame));

		keys.push_back(key);

	}

	return TSpectrum(keys.size(), &keys[0]);

}

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

TSpectrum64 TSpectrumParam::getValue64(double frame) const

{

	assert(m_imp);

	std::vector<tspectrum64::colorkey> keys;</tspectrum64::colorkey>

	int keyCount = m_imp->getKeyCount();

	for (int i = 0; i < keyCount; i++) {

		ColorKeyParam paramKey = m_imp->getKey(i);

		TSpectrum64::ColorKey key(

			paramKey.first->getValue(frame),

			toPixel64(paramKey.second->getValue(frame)));

		keys.push_back(key);

	}

	return TSpectrum64(keys.size(), &keys[0]);

}

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

void TSpectrumParam::setValue(double frame, const TSpectrum &spectrum, bool undoing)

{

	assert(getKeyCount() == spectrum.getKeyCount());

	int keyCount = getKeyCount();

	for (int i = 0; i < keyCount; i++) {

		TSpectrum::Key key = spectrum.getKey(i);

		setValue(frame, i, key.first, key.second, undoing);

	}

}

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

TDoubleParamP TSpectrumParam::getPosition(int index) const

{

	assert(index <= m_imp->getKeyCount());

	return m_imp->getKey(index).first;

}

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

TPixelParamP TSpectrumParam::getColor(int index) const

{

	assert(index <= m_imp->getKeyCount());

	return m_imp->getKey(index).second;

}

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

int TSpectrumParam::getKeyCount() const

{

	assert(m_imp);

	return m_imp->getKeyCount();

}

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

void TSpectrumParam::setValue(double frame, int index, double s, const TPixel32 &color, bool undoing)

{

	assert(m_imp);

	int keyCount = m_imp->getKeyCount();

	if (index < 0 || index >= keyCount)

		throw TException("TSpectrumParam::setValue. Index out of range");

	ColorKeyParam key = m_imp->getKey(index);

	//  beginParameterChange();

	key.first->setValue(frame, s);

	key.second->setValue(frame, color);

	//  endParameterChange();

	m_imp->notify(TParamChange(this, TParamChange::m_minFrame, TParamChange::m_maxFrame, true, m_imp->m_draggingEnabled, false));

}

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

void TSpectrumParam::setDefaultValue(const TSpectrum &value)

{

	assert(value.getKeyCount() == getKeyCount());

	for (int i = 0; i < getKeyCount(); i++) {

		ColorKeyParam dstKeyParam = m_imp->getKey(i);

		TSpectrum::Key srcKey = value.getKey(i);

		dstKeyParam.first->setDefaultValue(srcKey.first);

		dstKeyParam.second->setDefaultValue(srcKey.second);

	}

}

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

void TSpectrumParam::insertKey(int index, double s, const TPixel32 &color)

{

	assert(m_imp);

	int keyCount = m_imp->getKeyCount();

	if (index < 0)

		index = 0;

	else if (index >= keyCount)

		index = keyCount;

	TDoubleParamP dp(s);

	TPixelParamP pp(color);

	pp->enableMatte(m_imp->m_isMatteEnabled);

	ColorKeyParam ck(dp, pp);

	m_imp->insertKey(index, ck);

}

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

void TSpectrumParam::addKey(double s, const TPixel32 &color)

{

	/*

  assert(m_imp);

  insertKey(m_imp->getKeyCount(), s,color);

*/

	int index = m_imp->getKeyCount();

	assert(m_imp);

	int keyCount = m_imp->getKeyCount();

	if (index < 0)

		index = 0;

	else if (index >= keyCount)

		index = keyCount;

	TDoubleParamP dp(s);

	TPixelParamP pp(color);

	pp->enableMatte(m_imp->m_isMatteEnabled);

	ColorKeyParam ck(dp, pp);

	m_imp->insertKey(index, ck);

}

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

void TSpectrumParam::removeKey(int index)

{

	assert(m_imp);

	int keyCount = m_imp->getKeyCount();

	if (index < 0 || index >= keyCount)

		throw TException("TSpectrumParam::removeKey. Index out of range");

	m_imp->eraseKey(index);

}

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

bool TSpectrumParam::isKeyframe(double frame) const

{

	int keyCount = m_imp->getKeyCount();

	for (int i = 0; i < keyCount; i++) {

		ColorKeyParam currentKey = m_imp->getKey(i);

		if (currentKey.first->isKeyframe(frame))

			return true;

		if (currentKey.second->isKeyframe(frame))

			return true;

	}

	return false;

}

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

void TSpectrumParam::deleteKeyframe(double frame)

{

	int keyCount = m_imp->getKeyCount();

	for (int i = 0; i < keyCount; i++) {

		ColorKeyParam currentKey = m_imp->getKey(i);

		currentKey.first->deleteKeyframe(frame);

		currentKey.second->deleteKeyframe(frame);

	}

}

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

void TSpectrumParam::clearKeyframes()

{

	assert(m_imp);

	int k, keyCount = m_imp->getKeyCount();

	for (k = 0; k < keyCount; ++k) {

		const ColorKeyParam &key = m_imp->getKey(k);

		key.first->clearKeyframes();

		key.second->clearKeyframes();

	}

	m_imp->notify(TParamChange(this, TParamChange::m_minFrame, TParamChange::m_maxFrame, true, m_imp->m_draggingEnabled, false));

}

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

void TSpectrumParam::assignKeyframe(

	double frame,

	const TParamP &src, double srcFrame,

	bool changedOnly)

{

	TSpectrumParamP spectrum = src;

	if (!spectrum)

		return;

	int keyCount = m_imp->getKeyCount();

	if (keyCount != spectrum->m_imp->getKeyCount())

		return;

	for (int i = 0; i < keyCount; i++) {

		ColorKeyParam dstKey = m_imp->getKey(i);

		ColorKeyParam srcKey = spectrum->m_imp->getKey(i);

		dstKey.first->setValue(frame, srcKey.first->getValue(srcFrame));

		dstKey.second->setValue(frame, srcKey.second->getValue(srcFrame));

	}

}

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

void TSpectrumParam::loadData(TIStream &is)

{

	assert(m_imp);

	m_imp->clearKeys();

	std::string tagName;

	is.openChild(tagName);

	assert(tagName == "spectrum");

	while (!is.eos()) {

		TDoubleParamP pos(0.0);

		TPixelParamP color(TPixel32::Black);

		is.openChild(tagName);

		pos->loadData(is);

		is.closeChild();

		is.openChild(tagName);

		color->loadData(is);

		is.closeChild();

		ColorKeyParam ck(pos, color);

		m_imp->addKey(ck);

	}

	is.closeChild();

}

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

void TSpectrumParam::saveData(TOStream &os)

{

	assert(m_imp);

	int keyCount = m_imp->getKeyCount();

	os.openChild("spectrum");

	for (int i = 0; i < keyCount; i++) {

		ColorKeyParam key = m_imp->getKey(i);

		os.openChild("s_value");

		key.first->saveData(os);

		os.closeChild();

		os.openChild("col_value");

		key.second->saveData(os);

		os.closeChild();

	}

	os.closeChild();

}

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

void TSpectrumParam::enableDragging(bool on)

{

	m_imp->m_draggingEnabled = on;

}

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

void TSpectrumParam::enableNotification(bool on)

{

	m_imp->m_notificationEnabled = on;

}

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

bool TSpectrumParam::isNotificationEnabled() const

{

	return m_imp->m_notificationEnabled;

}

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

namespace

{

inline std::string to_string(const TPixel32 &color)

{

	std::string alias = "(";

	alias += std::to_string(color.r) + ",";

	alias += std::to_string(color.g) + ",";

	alias += std::to_string(color.b) + ",";

	alias += std::to_string(color.m);

	alias += ")";

	return alias;

}

inline std::string toString(const TSpectrum::ColorKey &key, int precision)

{

	std::string alias = "(";

	alias += ::to_string(key.first, precision) + ",";

	alias += to_string(key.second);

	alias += ")";

	return alias;

}

} // namespace

std::string TSpectrumParam::getValueAlias(double frame, int precision)

{

	std::vector<tspectrum::colorkey> keys;</tspectrum::colorkey>

	int keyCount = m_imp->getKeyCount();

	for (int i = 0; i < keyCount; i++) {

		ColorKeyParam paramKey = m_imp->getKey(i);

		TSpectrum::ColorKey key(

			paramKey.first->getValue(frame),

			paramKey.second->getValue(frame));

		keys.push_back(key);

	}

	std::string alias = "(";

	if (!keys.empty()) {

		std::vector<tspectrum::colorkey>::iterator it = keys.begin();</tspectrum::colorkey>

		std::vector<tspectrum::colorkey>::iterator end = keys.begin();</tspectrum::colorkey>

		std::advance(end, keys.size() - 1);

		for (; it != end; ++it) {

			alias += toString(*it, precision);

			alias += ",";

		}

		alias += toString(*it, precision);

	}

	alias += ")";

	return alias;

}

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

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

void TSpectrumParam::enableMatte(bool on)

{

	m_imp->m_isMatteEnabled = on;

}

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

bool TSpectrumParam::isMatteEnabled() const

{

	return m_imp->m_isMatteEnabled;

}

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

bool TSpectrumParam::hasKeyframes() const

{

	int keyCount = m_imp->getKeyCount();

	for (int i = 0; i < keyCount; i++) {

		ColorKeyParam currentKey = m_imp->getKey(i);

		if (currentKey.first->hasKeyframes() || currentKey.second->hasKeyframes())

			return true;

	}

	return false;

}

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

void TSpectrumParam::getKeyframes(std::set<double> &frames) const</double>

{

	int keyCount = m_imp->getKeyCount();

	for (int i = 0; i < keyCount; i++) {

		ColorKeyParam currentKey = m_imp->getKey(i);

		currentKey.first->getKeyframes(frames);

		currentKey.second->getKeyframes(frames);

	}

}

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

int TSpectrumParam::getNextKeyframe(double frame) const

{

	std::set<double> frames;</double>

	getKeyframes(frames);

	std::set<double>::iterator it = frames.upper_bound(frame);</double>

	if (it == frames.end())

		return -1;

	else

		return std::distance(frames.begin(), it);

}

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

int TSpectrumParam::getPrevKeyframe(double frame) const

{

	std::set<double> frames;</double>

	getKeyframes(frames);

	std::set<double>::iterator it = frames.lower_bound(frame);</double>

	if (it == frames.begin())

		return -1;

	else {

		--it;

		return std::distance(frames.begin(), it);

	}

}

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

double TSpectrumParam::keyframeIndexToFrame(int index) const

{

	std::set<double> frames;</double>

	getKeyframes(frames);

	assert(0 <= index && index < (int)frames.size());

	std::set<double>::const_iterator it = frames.begin();</double>

	std::advance(it, index);

	return *it;

}

TIStream &operator>>(TIStream &in, TSpectrumParamP &p)

{

	TPersist *tmp;

	in >> tmp;

	p = TSpectrumParamP(dynamic_cast<tspectrumparam *="">(tmp));</tspectrumparam>

	return in;

}