// TnzCore includes

#include "tconst.h"

#include "tutil.h"

#include "tstream.h"

// TnzBase includes

#include "tparamcontainer.h"

#include "tfxattributes.h"

#include "texternfx.h"

#include "tpassivecachemanager.h"

// STD includes

#include <set></set>

#include "tfx.h"

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

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

{

	TPersist *tmp = 0;

	in >> tmp;

	p = TFxP(dynamic_cast<tfx *="">(tmp));</tfx>

	return in;

}

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

//

// namespace {}

//

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

namespace

{

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

typedef pair<string, *="" tfxport=""> NamePort;</string,>

typedef map<string, *="" tfxport=""> PortTable;</string,>

typedef vector<nameport> PortArray;</nameport>

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

class PortNameEq

{

	string m_name;

public:

	PortNameEq(const string &name) : m_name(name) {}

	~PortNameEq() {}

	bool operator()(const NamePort &np) { return np.first == m_name; }

};

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

void skipChild(TIStream &is)

{

	while (!is.eos()) {

		string dummy = is.getString();

		string tagName;

		while (is.openChild(tagName)) {

			skipChild(is);

			if (is.isBeginEndTag())

				is.matchTag(tagName);

			is.closeChild();

		}

	}

}

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

TPointD updateDagPosition(const TPointD &pos, const VersionNumber &tnzVersion)

{

	if (tnzVersion < VersionNumber(1, 16))

		return TConst::nowhere;

	return pos;

}

} // namespace

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

//

// TFxParamChange

//

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

TFxParamChange::TFxParamChange(TFx *fx, double firstAffectedFrame, double lastAffectedFrame, bool dragging)

	: TFxChange(fx, firstAffectedFrame, lastAffectedFrame, dragging)

{

}

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

TFxParamChange::TFxParamChange(TFx *fx, const TParamChange &src)

	: TFxChange(fx, src.m_firstAffectedFrame, src.m_lastAffectedFrame, src.m_dragging)

{

}

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

//

// TFxChange

//

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

double TFxChange::m_minFrame = -(std::numeric_limits<double>::max)();</double>

double TFxChange::m_maxFrame = +(std::numeric_limits<double>::max)();</double>

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

//

// TFxPortDynamicGroup

//

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

TFxPortDynamicGroup::TFxPortDynamicGroup(const std::string &prefix, int minSize)

	: m_portsPrefix(prefix), m_minPortsCount(minSize)

{

}

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

TFxPortDynamicGroup::~TFxPortDynamicGroup()

{

	clear();

}

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

void TFxPortDynamicGroup::addPort(TFxPort *port)

{

	m_ports.push_back(port);

}

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

void TFxPortDynamicGroup::removePort(TFxPort *port)

{

	m_ports.resize(std::remove(m_ports.begin(), m_ports.end(), port) - m_ports.begin());

	delete port;

}

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

void TFxPortDynamicGroup::clear()

{

	std::for_each(m_ports.begin(), m_ports.end(), TDeleteObjectFunctor());

	m_ports.clear();

}

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

//

// TFxImp

//

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

class TFxImp

{

public:

	TFx *m_fx;				 //!< Fx back-pointer

	TFxImp *m_prev, *m_next; //!< Linked fxs

	wstring m_name;

	wstring m_fxId;

	PortTable m_portTable; //!< Name -> port  map

	PortArray m_portArray; //!< Ports container

	TParamContainer m_paramContainer;

	std::set<tfxport *=""> m_outputPort;</tfxport>

	TFxTimeRegion m_activeTimeRegion;

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

	TFxAttributes m_attributes;

	static unsigned long m_nextId;

	unsigned long m_id; //!< Unique fx identifier, per Toonz session.

	//!< It is intended to be used \b solely to build

	//!< an internal string description of the fx.

public:

	TFxImp(TFx *fx)

		: m_fx(fx), m_activeTimeRegion(TFxTimeRegion::createUnlimited()), m_id()

	{

		m_prev = m_next = this;

	}

	~TFxImp()

	{

		m_prev->m_next = m_next;

		m_next->m_prev = m_prev;

	}

	bool checkLinks() const

	{

		assert(m_prev);

		assert(m_next);

		assert(m_prev->m_next == this);

		assert(m_next->m_prev == this);

		return true;

	}

private:

	// not copyable

	TFxImp(const TFxImp &);

	TFxImp &operator=(const TFxImp &);

};

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

unsigned long TFxImp::m_nextId = 0;

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

//

// TFxFactory

//

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

class TFxFactory // singleton

{

	typedef std::map

					 std::pair<tfxinfo, *="" tfxdeclaration="">> Table;</tfxinfo,>

	Table m_table;

	std::vector<string> m_map;</string>

	TFxFactory() {}

public:

	static TFxFactory *instance()

	{

		static TFxFactory _instance;

		return &_instance;

	}

	void add(const TFxInfo &info, TFxDeclaration *decl)

	{

		// check for dups ???

		std::pair<tfxinfo, *="" tfxdeclaration=""> p(info, decl);</tfxinfo,>

		m_table[info.m_name] = p;

	}

	TFx *create(std::string name)

	{

		Table::iterator it = m_table.find(name);

		if (it != m_table.end()) {

			TFxDeclaration *decl = it->second.second;

			TPersist *obj = decl->create();

			assert(obj);

			return dynamic_cast<tfx *="">(obj);</tfx>

		} else

			return TExternFx::create(name);

	}

	void getFxInfos(std::vector<tfxinfo> &info) const</tfxinfo>

	{

		for (Table::const_iterator it = m_table.begin(); it != m_table.end(); ++it)

			info.push_back(it->second.first);

	}

	TFxInfo getFxInfo(const std::string &fxIdentifier) const

	{

		Table::const_iterator it = m_table.find(fxIdentifier);

		return (it != m_table.end()) ? it->second.first : TFxInfo();

	}

};

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

//

// TFxDeclaration

//

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

TFxDeclaration::TFxDeclaration(const TFxInfo &info)

	: TPersistDeclaration(info.m_name)

{

	TFxFactory::instance()->add(info, this);

}

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

//

// TFx

//

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

DEFINE_CLASS_CODE(TFx, 3)

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

TFx::TFx()

	: TSmartObject(m_classCode) // TPersist(TFxImp::m_instances)

	  ,

	  m_imp(new TFxImp(this))

{

}

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

TFx::~TFx()

{

	for (std::set<tfxport *="">::iterator it = m_imp->m_outputPort.begin();</tfxport>

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

		TFxPort *port = *it;

		port->setFx(0);

	}

	delete m_imp;

}

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

wstring TFx::getName() const

{

	return m_imp->m_name;

}

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

void TFx::setName(wstring name)

{

	m_imp->m_name = name;

}

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

wstring TFx::getFxId() const

{

	return m_imp->m_fxId;

}

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

void TFx::setFxId(wstring id)

{

	m_imp->m_fxId = id;

}

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

TFxAttributes *TFx::getAttributes() const

{

	return &m_imp->m_attributes;

}

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

const TParamContainer *TFx::getParams() const

{

	return &m_imp->m_paramContainer;

}

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

TParamContainer *TFx::getParams()

{

	return &m_imp->m_paramContainer;

}

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

TFx *TFx::clone(bool recursive) const

{

	TFx *fx = TFx::create(getFxType());

	assert(fx);

	return this->clone(fx, recursive);

}

TFx *TFx::clone(TFx *fx, bool recursive) const

{

	// Copy misc stuff

	fx->m_imp->m_activeTimeRegion = m_imp->m_activeTimeRegion;

	fx->setIdentifier(getIdentifier());

	fx->getParams()->copy(getParams());

	fx->setFxId(getFxId());

	fx->setName(getName());

	// Copy attributes

	*fx->getAttributes() = *getAttributes();

	// Clone the dynamic ports pool

	if (hasDynamicPortGroups()) {

		int p, pCount = m_imp->m_portArray.size();

		for (p = 0; p != pCount; ++p) {

			const NamePort &namedPort = m_imp->m_portArray[p];

			int groupIdx = namedPort.second->getGroupIndex();

			if (groupIdx >= 0 && !fx->getInputPort(namedPort.first))

				fx->addInputPort(namedPort.first, new TRasterFxPort, groupIdx);

		}

		assert(pCount == fx->getInputPortCount());

	}

	// copia ricorsiva sulle porte

	if (recursive) {

		int p, pCount = getInputPortCount();

		for (p = 0; p != pCount; ++p) {

			TFxPort *port = getInputPort(p);

			if (port->getFx())

				fx->connect(getInputPortName(p), port->getFx()->clone(true));

		}

	}

	return fx;

}

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

void TFx::linkParams(TFx *fx)

{

	if (this == fx)

		return;

	getParams()->link(fx->getParams());

	m_imp->m_activeTimeRegion = fx->m_imp->m_activeTimeRegion;

	// aggiorno i link

	assert(m_imp->checkLinks());

	assert(fx->m_imp->checkLinks());

	tswap(m_imp->m_next, fx->m_imp->m_next);

	tswap(m_imp->m_next->m_prev, fx->m_imp->m_next->m_prev);

	assert(m_imp->checkLinks());

	assert(fx->m_imp->checkLinks());

}

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

void TFx::unlinkParams()

{

	// clone dei parametri

	getParams()->unlink();

	assert(m_imp->m_prev);

	assert(m_imp->m_next);

	assert(m_imp->m_prev->m_next == m_imp);

	assert(m_imp->m_next->m_prev == m_imp);

	m_imp->m_prev->m_next = m_imp->m_next;

	m_imp->m_next->m_prev = m_imp->m_prev;

	m_imp->m_next = m_imp->m_prev = m_imp;

	notify(TFxParamsUnlinked(this));

}

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

bool TFx::addInputPort(const std::string &name, TFxPort &port)

{

	PortTable::iterator it = m_imp->m_portTable.find(name);

	if (it != m_imp->m_portTable.end())

		return false;

	m_imp->m_portTable[name] = &port;

	m_imp->m_portArray.push_back(NamePort(name, &port));

	port.setOwnerFx(this); // back pointer to the owner...

	return true;

}

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

bool TFx::addInputPort(const std::string &name, TFxPort *port, int groupIndex)

{

	if (!port) {

		assert(port);

		return false;

	}

	if (groupIndex >= dynamicPortGroupsCount()) {

		assert(groupIndex < dynamicPortGroupsCount());

		return false;

	}

	if (!addInputPort(name, *port))

		return false;

	// Assign the port to the associated group

	port->m_groupIdx = groupIndex;

	TFxPortDG *group = const_cast<tfxportdg *="">(dynamicPortGroup(groupIndex));</tfxportdg>

	group->addPort(port);

	assert(name.find(group->m_portsPrefix) == 0);

	return true;

}

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

bool TFx::removeInputPort(const std::string &name)

{

	m_imp->m_portTable.erase(name);

	PortArray::iterator it = std::find_if(m_imp->m_portArray.begin(), m_imp->m_portArray.end(), PortNameEq(name));

	if (it == m_imp->m_portArray.end())

		return false;

	TFxPort *port = it->second;

	port->setOwnerFx(0);

	if (port->m_groupIdx >= 0) {

		TFxPortDG *group = const_cast<tfxportdg *="">(this->dynamicPortGroup(port->m_groupIdx));</tfxportdg>

		group->removePort(port); // The port is DELETED here

	}

	m_imp->m_portArray.erase(it);

	return true;

}

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

namespace

{

struct IsPrefix {

	const std::string &m_prefix;

	bool operator()(const NamePort &nameport)

	{

		return (strncmp(m_prefix.c_str(), nameport.first.c_str(), m_prefix.size()) == 0);

	}

};

} // namespace

void TFx::clearDynamicPortGroup(int g)

{

	TFxPortDG *dg = const_cast<tfxportdg *="">(this->dynamicPortGroup(g));</tfxportdg>

	const std::string &prefix = dg->portsPrefix();

	std::string prefixEnd = prefix;

	++prefixEnd[prefixEnd.size() - 1];

	{

		// Delete all associated ports from the ports table

		PortTable::iterator pBegin(m_imp->m_portTable.lower_bound(prefix));

		PortTable::iterator pEnd(m_imp->m_portTable.lower_bound(prefixEnd));

		m_imp->m_portTable.erase(pBegin, pEnd);

		// Traverse the ports array and remove all ports in the group

		IsPrefix func = {prefix};

		m_imp->m_portArray.resize(std::remove_if(m_imp->m_portArray.begin(), m_imp->m_portArray.end(), func) - m_imp->m_portArray.begin());

	}

	dg->clear(); // Has ports ownership, so deletes them

}

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

bool TFx::addOutputConnection(TFxPort *port)

{

	assert(port->getFx() == this);

	return m_imp->m_outputPort.insert(port).second;

}

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

bool TFx::removeOutputConnection(TFxPort *port)

{

	std::set<tfxport *="">::iterator it = m_imp->m_outputPort.find(port);</tfxport>

	if (it == m_imp->m_outputPort.end())

		return false;

	m_imp->m_outputPort.erase(it);

	return true;

}

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

int TFx::getOutputConnectionCount() const

{

	return m_imp->m_outputPort.size();

}

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

TFxPort *TFx::getOutputConnection(int i) const

{

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

	std::set<tfxport *="">::iterator it = m_imp->m_outputPort.begin();</tfxport>

	std::advance(it, i);

	if (it == m_imp->m_outputPort.end())

		return 0;

	return *it;

}

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

bool TFx::disconnect(const std::string &name)

{

	TFxPort *port = getInputPort(name);

	if (!port)

		return false;

	port->setFx(0);

	return true;

}

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

bool TFx::connect(const std::string &name, TFx *fx)

{

	TFxPort *port = getInputPort(name);

	if (!port)

		return false;

	port->setFx(fx);

	return true;

}

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

int TFx::getInputPortCount() const

{

	return m_imp->m_portArray.size();

}

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

TFxPort *TFx::getInputPort(int index) const

{

	assert(0 <= index && index < (int)m_imp->m_portArray.size());

	return m_imp->m_portArray[index].second;

}

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

string TFx::getInputPortName(int index) const

{

	assert(0 <= index && index < (int)(m_imp->m_portArray.size()));

	return m_imp->m_portArray[index].first;

}

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

bool TFx::renamePort(const string &oldName, const string &newName)

{

	PortTable::iterator it = m_imp->m_portTable.find(oldName);

	if (it == m_imp->m_portTable.end())

		return false;

	TFxPort *port = it->second;

	m_imp->m_portTable.erase(it);

	m_imp->m_portTable[newName] = port;

	PortArray::iterator it2;

	for (it2 = m_imp->m_portArray.begin(); it2 != m_imp->m_portArray.end(); ++it2) {

		if (it2->first != oldName)

			continue;

		it2->first = newName;

		break;

	}

	return true;

}

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

TFxPort *TFx::getInputPort(const std::string &name) const

{

	PortTable::iterator it = m_imp->m_portTable.find(name);

	if (it == m_imp->m_portTable.end())

		return 0;

	return m_imp->m_portTable[name];

}

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

int TFx::getReferenceColumnIndex() const

{

	if (!m_imp->m_portArray.empty()) {

		TFx *fx = m_imp->m_portArray[0].second->getFx();

		if (fx)

			return fx->getReferenceColumnIndex();

	}

	return -1;

}

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

TFxTimeRegion TFx::getTimeRegion() const

{

	if (m_imp->m_portTable.empty())

		return TFxTimeRegion::createUnlimited();

	TFxTimeRegion tr((std::numeric_limits<double>::max)(), -(std::numeric_limits<double>::max)());</double></double>

	PortTable::iterator it = m_imp->m_portTable.begin();

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

		TFxPort *port = it->second;

		if (port && port->isConnected() && !port->isaControlPort()) {

			TFx *fx = port->getFx();

			assert(fx);

			tr += fx->getTimeRegion();

		}

	}

	return tr;

}

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

void TFx::setActiveTimeRegion(const TFxTimeRegion &tr)

{

	m_imp->m_activeTimeRegion = tr;

}

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

TFxTimeRegion TFx::getActiveTimeRegion() const

{

	return m_imp->m_activeTimeRegion;

}

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

void TFx::onChange(const TParamChange &c)

{

	TFxParamChange change(this, c);

	notify(change);

}

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

void TFx::addObserver(TFxObserver *obs)

{

	m_imp->m_observers.insert(obs);

}

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

void TFx::removeObserver(TFxObserver *obs)

{

	m_imp->m_observers.erase(obs);

}

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

void TFx::notify(const TFxChange &change)

{

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

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

		(*it)->onChange(change);

}

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

void TFx::notify(const TFxPortAdded &change)

{

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

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

		(*it)->onChange(change);

}

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

void TFx::notify(const TFxPortRemoved &change)

{

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

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

		(*it)->onChange(change);

}

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

void TFx::notify(const TFxParamAdded &change)

{

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

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

		(*it)->onChange(change);

}

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

void TFx::notify(const TFxParamRemoved &change)

{

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

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

		(*it)->onChange(change);

}

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

unsigned long TFx::getIdentifier() const

{

	return m_imp->m_id;

}

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

void TFx::setIdentifier(unsigned long id)

{

	m_imp->m_id = id;

}

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

void TFx::setNewIdentifier()

{

	m_imp->m_id = ++m_imp->m_nextId;

}

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

void TFx::loadData(TIStream &is)

{

	string tagName;

	VersionNumber tnzVersion = is.getVersion();

	QList<int> groupIds;</int>

	QList<wstring> groupNames;</wstring>

	while (is.openChild(tagName)) {

		if (tagName == "params") {

			while (!is.eos()) {

				string paramName;

				while (is.openChild(paramName)) {

					TParamP param = getParams()->getParam(paramName);

					if (param)

						param->loadData(is);

					else // il parametro non e' presente -> skip

						skipChild(is);

					is.closeChild();

				}

			}

		} else if (tagName == "paramsLinkedTo") {

			TPersist *p = 0;

			is >> p;

			TFx *fx = dynamic_cast<tfx *="">(p);</tfx>

			if (fx == 0)

				throw TException("Missing linkedSetRoot");

			linkParams(fx);

		} else if (tagName == "ports") {

			string portName;

			while (!is.eos()) {

				while (is.openChild(portName)) {

					VersionNumber version = is.getVersion();

					compatibilityTranslatePort(version.first, version.second, portName);

					// Try to find the specified port

					TFxPort *port = getInputPort(portName);

					if (!port) {

						// Scan dynamic port groups for a containing one - add a port there if found

						int g, gCount = dynamicPortGroupsCount();

						for (g = 0; g != gCount; ++g) {

							TFxPortDG *group = const_cast<tfxportdg *="">(dynamicPortGroup(g));</tfxportdg>

							if (group->contains(portName)) {

								addInputPort(portName, port = new TRasterFxPort, g);

								break;

							}

						}

					}

					// Could not find (or add) a port with the corresponding name - throw

					if (!port)

						throw TException(string("port '") + portName + "' is not present");

					if (!is.eos()) {

						TPersist *p = 0;

						is >> p;

						TFx *fx = dynamic_cast<tfx *="">(p);</tfx>

						port->setFx(fx);

					}

					is.closeChild();

				}

			}

		} else if (tagName == "dagNodePos") {

			TPointD p;

			is >> p.x >> p.y;

			m_imp->m_attributes.setDagNodePos(updateDagPosition(p, tnzVersion));

		} else if (tagName == "numberId") {