#include "tparamset.h"

#include "tundo.h"

//#include "tparam.h"

#include "tdoubleparam.h"

#include "tstream.h"

#include <set></set>

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

/*

class ChangeBlock {

public:

  ChangeBlock()

      : m_firstAffectedFrame ( TParamChange::m_maxFrame)

      , m_lastAffectedFrame  ( TParamChange::m_minFrame)

    {

    }

  ~ChangeBlock()

    {

    }

  void add(const TParamChange &change)

    {

    m_firstAffectedFrame = tmin(m_firstAffectedFrame, change.m_firstAffectedFrame);

    m_lastAffectedFrame  = tmax(m_lastAffectedFrame , change.m_lastAffectedFrame);

    m_changes.push_back(change.clone());

    }

  vector<tparamchange*> m_changes;</tparamchange*>

double m_firstAffectedFrame;

double m_lastAffectedFrame;

};

*/

namespace

{

void doRelease(const pair<tparam *,="" string=""> ¶m)</tparam>

{

	param.first->release();

}

};

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

class TParamSetImp : public TParamObserver

{

	friend class TParamSet;

	TParamSet *m_param;

	vector<pair<tparam *,="" string="">> m_params;</pair<tparam>

	// ChangeBlock *m_changeBlock;

	bool m_draggingEnabled, m_notificationEnabled;

public:

	TParamSetImp(TParamSet *param) : m_param(param)

									 //, m_changeBlock(0)

									 ,

									 m_draggingEnabled(false), m_notificationEnabled(true)

	{

	}

	~TParamSetImp()

	{

		std::for_each(m_params.begin(), m_params.end(), doRelease);

	}

	// std::set<tparamsetobserver*> m_observers;</tparamsetobserver*>

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

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

	void notify(const T &change);

	void onChange(const TParamChange &change)

	{

		/*

    if (!m_changeBlock)  // se non stiamo modificando un blocco di parametri, invio la notifica

      {

      vector<tparam*> params; </tparam*>

      params.push_back(change.m_param);

      TParamSetChange psChange(m_param, change.m_firstAffectedFrame, change.m_lastAffectedFrame, 

                               params, change.m_undoing);

      notify(psChange);

      }

    else

      notify(change);

    if (!m_changeBlock)  // se non stiamo modificando un blocco di parametri, invio la notifica

      notify(change);

    else

      {

      //metto da parte la TParamChange, per poi alla fine notificare una TParamSetChange

      m_changeBlock->add(change);

      }

      */

	}

};

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

TParamSet::TParamSet(string name)

	: TParam(name)

{

	m_imp = new TParamSetImp(this);

}

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

TParamSet::TParamSet(const TParamSet &src)

	: TParam(src.getName())

{

	m_imp = new TParamSetImp(this);

}

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

TParamSet::~TParamSet()

{

	delete m_imp;

}

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

/*

template <class container=""></class>

class MyBackInsertIterator : public std::iterator<std::output_iterator_tag, void="" void,=""></std::output_iterator_tag,>

{

protected:

  Container &container;

public:

  MyBackInsertIterator(Container &c) : container(c) {}

  MyBackInsertIterator<container> &operator=(const typename Container::value_type &value)</container>

  {

    container.push_back(value);

    return *this;

  }

  MyBackInsertIterator<container>&operator*()</container>

  {

  return *this;

  }

  MyBackInsertIterator<container>&operator++()</container>

  {

  return *this;

  }

  MyBackInsertIterator<container>&operator++(int)</container>

  {

  return *this;

  }

};

*/

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

void TParamSet::beginParameterChange()

{

	//  assert(0);

	//std::set<tparamsetobserver*>::iterator it = m_imp->m_observers.begin();</tparamsetobserver*>

	//for (;it != m_imp->m_observers.end(); ++it)

	//  (*it)->onBeginChangeBlock(this);

	//assert(!m_imp->m_changeBlock);

	vector<tparam *=""> params;</tparam>

	/*

MyBackInsertIterator<vector<pair<tparam*, string=""> > > myBackInsertIterator(params);</vector<pair<tparam*,>

copy(m_imp->m_params.begin(), m_imp->m_params.end(), myIterator);

*/

	std::vector<pair<tparam *,="" string="">>::iterator it2 = m_imp->m_params.begin();</pair<tparam>

	for (; it2 != m_imp->m_params.end(); ++it2)

		params.push_back(it2->first);

	// m_imp->m_changeBlock = new ChangeBlock;

};

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

void TParamSet::endParameterChange(){

	//  assert(0);

	//assert(m_imp->m_changeBlock);

	/*

TParamSetChange change(this, m_imp->m_changeBlock->m_firstAffectedFrame, 

                             m_imp->m_changeBlock->m_lastAffectedFrame, 

                             m_imp->m_changeBlock->m_changes, false);

change.m_dragging = m_imp->m_draggingEnabled;

//delete m_imp->m_changeBlock;

//m_imp->m_changeBlock = 0;

//m_imp->notify(change);

//std::set<tparamsetobserver*>::iterator it = m_imp->m_observers.begin();</tparamsetobserver*>

//for (;it != m_imp->m_observers.end(); ++it)

//  (*it)->onEndChangeBlock(this);

m_imp->notify(change);

*/

};

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

void TParamSet::addParam(const TParamP ¶m, const string &name)

{

	pair<tparam *,="" string=""> paramToInsert = std::make_pair(param.getPointer(), name);</tparam>

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

		std::find(m_imp->m_params.begin(), m_imp->m_params.end(), paramToInsert);

	if (it == m_imp->m_params.end()) {

		param->addRef();

		param->addObserver(m_imp);

		m_imp->m_params.push_back(paramToInsert);

		//TParamSetParamAdded psParamAdded(this, param.getPointer(), name, false);

		if (param->getName().empty())

			param->setName(name);

		//m_imp->notify(psParamAdded);

	}

}

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

void TParamSet::insertParam(const TParamP ¶m, const string &name, int index)

{

	pair<tparam *,="" string=""> paramToInsert = std::make_pair(param.getPointer(), name);</tparam>

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

		std::find(m_imp->m_params.begin(), m_imp->m_params.end(), paramToInsert);

	if (it == m_imp->m_params.end()) {

		param->addRef();

		param->addObserver(m_imp);

		it = m_imp->m_params.begin();

		int f;

		for (f = 0; f < index; f++)

			it++;

		m_imp->m_params.insert(it, paramToInsert);

		if (param->getName().empty())

			param->setName(name);

	}

}

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

namespace

{

class matchesParam

{

	TParamP m_param;

public:

	matchesParam(const TParamP ¶m) : m_param(param) {}

	bool operator()(const pair<tparam *,="" string=""> ¶m)</tparam>

	{

		return m_param.getPointer() == param.first;

	}

};

}

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

void TParamSet::removeParam(const TParamP ¶m)

{

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

		std::find_if(m_imp->m_params.begin(), m_imp->m_params.end(), matchesParam(param));

	if (it != m_imp->m_params.end()) {

		param->removeObserver(m_imp);

		//TParamSetParamRemoved psParamRemoved(this, param.getPointer(), it->second, false);

		//m_imp->notify(psParamRemoved);

		param->release();

		m_imp->m_params.erase(it);

	}

}

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

void TParamSet::removeAllParam()

{

	while (!m_imp->m_params.empty()) {

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

		TParam *param = it->first;

		param->removeObserver(m_imp);

		param->release();

		m_imp->m_params.erase(it);

	}

}

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

int TParamSet::getParamCount() const

{

	return m_imp->m_params.size();

}

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

TParamP TParamSet::getParam(int i) const

{

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

	return m_imp->m_params[i].first;

}

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

string TParamSet::getParamName(int i) const

{

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

	return m_imp->m_params[i].second;

}

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

int TParamSet::getParamIdx(const string &name) const

{

	int i, paramsCount = m_imp->m_params.size();

	for (i = 0; i < paramsCount; ++i)

		if (m_imp->m_params[i].second == name)

			break;

	return i;

}

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

void TParamSet::getAnimatableParams(vector<tparamp> ¶ms, bool recursive)</tparamp>

{

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

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

		TParam *param = it->first;

		TDoubleParamP dparam = TParamP(param);

		if (dparam)

			params.push_back(dparam);

		else {

			TParamSetP paramset = TParamP(param);

			if (paramset && recursive)

				paramset->getAnimatableParams(params, recursive);

		}

	}

}

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

void TParamSet::addObserver(TParamObserver *observer)

{

	//TParamSetObserver *obs = dynamic_cast<tparamsetobserver *="">(observer);</tparamsetobserver>

	//if (obs)

	//  m_imp->m_observers.insert(obs);

	//else

	m_imp->m_paramObservers.insert(observer);

}

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

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

void TParamSetImp::notify(const T &change)

{

	if (m_notificationEnabled) {

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

		//                                              it!= m_observers.end();

		//                                              ++it)

		//    (*it)->onChange(change);

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

			 paramIt != m_paramObservers.end();

			 ++paramIt)

			(*paramIt)->onChange(change);

	}

}

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

void TParamSet::removeObserver(TParamObserver *observer)

{

	//TParamSetObserver *obs = dynamic_cast<tparamsetobserver *="">(observer);</tparamsetobserver>

	//if (obs)

	//  m_imp->m_observers.erase(obs);

	//else

	m_imp->m_paramObservers.erase(observer);

}

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

void TParamSet::enableDragging(bool on)

{

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

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

		TDoubleParamP dparam(it->first);

		//if (dparam)

		//  dparam->enableDragging(on);

	}

	m_imp->m_draggingEnabled = on;

}

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

/*

namespace {

class DoEnableNotification : public std::binary_function {

public:

  DoEnableNotification() {}

  void operator() (const pair<tparam*, string=""> ¶m, bool on) </tparam*,>

  {

    return param->first->enableNotification(on);

  }

};

}

*/

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

void TParamSet::enableNotification(bool on)

{

	//  std::for_each(m_imp->m_params.begin(), m_imp->m_params.end(), std::bind2nd(DoEnableNotification, on));

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

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

		it->first->enableNotification(on);

	}

	m_imp->m_notificationEnabled = on;

}

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

bool TParamSet::isNotificationEnabled() const

{

	return m_imp->m_notificationEnabled;

}

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

bool TParamSet::isKeyframe(double frame) const

{

	for (int i = 0; i < getParamCount(); i++)

		if (getParam(i)->isKeyframe(frame))

			return true;

	return false;

}

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

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

{

	for (int i = 0; i < getParamCount(); i++)

		getParam(i)->getKeyframes(frames);

}

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

double TParamSet::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;

}

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

int TParamSet::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 TParamSet::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);

	}

}

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

bool TParamSet::hasKeyframes() const

{

	for (int i = 0; i < getParamCount(); i++)

		if (getParam(i)->hasKeyframes())

			return true;

	return false;

}

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

int TParamSet::getKeyframeCount() const

{

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

	getKeyframes(frames);

	return frames.size();

}

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

void TParamSet::deleteKeyframe(double frame)

{

	for (int i = 0; i < getParamCount(); i++)

		getParam(i)->deleteKeyframe(frame);

}

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

void TParamSet::clearKeyframes()

{

	for (int i = 0; i < getParamCount(); i++)

		getParam(i)->clearKeyframes();

}

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

void TParamSet::assignKeyframe(

	double frame,

	const TParamP &src, double srcFrame,

	bool changedOnly)

{

	TParamSetP paramSetSrc = src;

	if (!paramSetSrc)

		return;

	if (getParamCount() != paramSetSrc->getParamCount())

		return;

	for (int i = 0; i < getParamCount(); i++)

		getParam(i)->assignKeyframe(

			frame, paramSetSrc->getParam(i), srcFrame, changedOnly);

}

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

TParam *TParamSet::clone() const

{

	return new TParamSet(*this);

}

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

void TParamSet::copy(TParam *src)

{

	TParamSet *p = dynamic_cast<tparamset *="">(src);</tparamset>

	if (!p)

		throw TException("invalid source for copy");

	int srcParamCount = p->getParamCount();

	removeAllParam();

	int i;

	for (i = 0; i < srcParamCount; i++) {

		TParamP param = p->getParam(i);

		addParam(param->clone(), param->getName());

	}

}

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

void TParamSet::loadData(TIStream &is)

{

	string tagName;

	is.openChild(tagName);

	while (!is.eos()) {

		string paramName;

		is.openChild(paramName);

		TPersist *p = 0;

		is >> p;

		TParam *param = dynamic_cast<tparam *="">(p);</tparam>

		assert(param);

		addParam(param, paramName);

		is.closeChild();

	}

	is.closeChild();

}

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

void TParamSet::saveData(TOStream &os)

{

	os.openChild(getName());

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

	std::vector<pair<tparam *,="" string="">>::iterator end = m_imp->m_params.end();</pair<tparam>

	while (it != end) {

		os.openChild(it->second);

		//it->first->saveData(os);

		os << it->first;

		os.closeChild();

		++it;

	}

	os.closeChild();

}

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

string TParamSet::getValueAlias(double frame, int precision)

{

	string alias = "(";

	std::vector<pair<tparam *,="" string="">>::iterator end = m_imp->m_params.begin();</pair<tparam>

	std::advance(end, m_imp->m_params.size() - 1);

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

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

		alias += it->first->getValueAlias(frame, precision) + ",";

	alias += it->first->getValueAlias(frame, precision);

	alias += ")";

	return alias;

}

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

TPersistDeclarationT<tparamset> TParamSet::m_declaration("TParamSet");</tparamset>