

// 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>

#include "tfx.h"

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

TIStream &operator>>(TIStream &in, TFxP &p) {
  TPersist *tmp = 0;
  in >> tmp;
  p = TFxP(dynamic_cast<TFx *>(tmp));
  return in;
}

//==============================================================================
//
// namespace {}
//
//------------------------------------------------------------------------------

namespace {

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

typedef std::pair<std::string, TFxPort *> NamePort;
typedef std::map<std::string, TFxPort *> PortTable;
typedef std::vector<NamePort> PortArray;

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

class PortNameEq {
  std::string m_name;

public:
  PortNameEq(const std::string &name) : m_name(name) {}
  ~PortNameEq() {}
  bool operator()(const NamePort &np) { return np.first == m_name; }
};

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

void skipChild(TIStream &is) {
  while (!is.eos()) {
    std::string dummy = is.getString();
    std::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 TFxChange::m_maxFrame = +(std::numeric_limits<double>::max)();

//==============================================================================
//
// 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

  std::wstring m_name;
  std::wstring m_fxId;

  PortTable m_portTable;  //!< Name -> port  map
  PortArray m_portArray;  //!< Ports container

  TParamContainer m_paramContainer;

  std::set<TFxPort *> m_outputPort;
  TFxTimeRegion m_activeTimeRegion;
  std::set<TFxObserver *> m_observers;

  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::string, std::pair<TFxInfo, TFxDeclaration *>> Table;

  Table m_table;
  std::vector<std::string> m_map;

  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);
    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);
    } else
      return TExternFx::create(name);
  }

  void getFxInfos(std::vector<TFxInfo> &info) const {
    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();
       it != m_imp->m_outputPort.end(); ++it) {
    TFxPort *port = *it;
    port->setFx(0);
  }

  delete m_imp;
}

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

std::wstring TFx::getName() const { return m_imp->m_name; }

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

void TFx::setName(std::wstring name) { m_imp->m_name = name; }

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

std::wstring TFx::getFxId() const { return m_imp->m_fxId; }

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

void TFx::setFxId(std::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));
  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));
    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));

  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);
  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();
  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;
}

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

std::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 std::string &oldName, const std::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)());

  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();
       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();
       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();
       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();
       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();
       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) {
  std::string tagName;
  VersionNumber tnzVersion = is.getVersion();

  QList<int> groupIds;
  QList<std::wstring> groupNames;
  while (is.openChild(tagName)) {
    if (tagName == "params") {
      while (!is.eos()) {
        std::string paramName;
        while (is.openChild(paramName)) {
          TParamVar *paramVar = getParams()->getParamVar(paramName);
          if (paramVar && paramVar->getParam()) {
            paramVar->getParam()->loadData(is);
            if (paramVar->isObsolete())
              onObsoleteParamLoaded(paramVar->getParam()->getName());
          } 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);
      if (fx == 0) throw TException("Missing linkedSetRoot");
      linkParams(fx);
    } else if (tagName == "ports") {
      std::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));

              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(std::string("port '") + portName +
                             "' is not present");

          if (!is.eos()) {
            TPersist *p = 0;
            is >> p;
            TFx *fx = dynamic_cast<TFx *>(p);
            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") {
      int numberId = 0;
      is >> numberId;
      m_imp->m_attributes.setId(numberId);
    } else if (tagName == "passiveCacheId") {
      int passiveCacheId = 0;
      is >> passiveCacheId;

      assert(passiveCacheId > 0);
      TPassiveCacheManager::instance()->declareCached(this, passiveCacheId);
    } else if (tagName == "name") {
      // passo attraverso un filepath solo per evitare i problemi di blank
      // o caratteri strani dentro il nome (sospetto che tfilepath sia gestito
      // correttamente mentre wstring no
      TFilePath tmp;
      is >> tmp;
      setName(tmp.getWideName());
    } else if (tagName == "fxId") {
      TFilePath tmp;
      is >> tmp;
      setFxId(tmp.getWideName());
    } else if (tagName == "enabled") {
      int flag = 1;
      is >> flag;
      m_imp->m_attributes.enable(flag != 0);
    } else if (tagName == "opened") {
      int opened = 1;
      is >> opened;
      m_imp->m_attributes.setIsOpened(opened);
    } else if (tagName == "groupIds") {
      int groupId;
      while (!is.eos()) {
        is >> groupId;
        groupIds.append(groupId);
      }
    } else if (tagName == "groupNames") {
      std::wstring groupName;
      while (!is.eos()) {
        is >> groupName;
        groupNames.append(groupName);
      }
    } else {
      throw TException("Unknown tag!");
    }
    is.closeChild();
  }
  if (!groupIds.isEmpty()) {
    assert(groupIds.size() == groupNames.size());
    int i;
    for (i = 0; i < groupIds.size(); i++) {
      m_imp->m_attributes.setGroupId(groupIds[i]);
      m_imp->m_attributes.setGroupName(groupNames[i]);
    }
  }
}

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

void TFx::saveData(TOStream &os) {
  TFx *linkedSetRoot = this;
  if (m_imp->m_next != m_imp) {
    TFxImp *imp = m_imp->m_next;
    int guard   = 0;
    while (guard++ < 1000 && imp != m_imp) {
      if (imp->m_fx < linkedSetRoot) linkedSetRoot = imp->m_fx;
      imp                                          = imp->m_next;
    }
    assert(imp == m_imp);
    assert(linkedSetRoot);
  }
  if (linkedSetRoot == this) {
    os.openChild("params");
    for (int i = 0; i < getParams()->getParamCount(); i++) {
      std::string paramName     = getParams()->getParamName(i);
      const TParamVar *paramVar = getParams()->getParamVar(i);
      // skip saving for the obsolete parameters
      if (paramVar->isObsolete()) continue;
      os.openChild(paramName);
      paramVar->getParam()->saveData(os);
      os.closeChild();
    }
    os.closeChild();
  } else {
    os.openChild("paramsLinkedTo");
    os << linkedSetRoot;
    os.closeChild();
  }

  os.openChild("ports");
  for (PortTable::iterator pit = m_imp->m_portTable.begin();
       pit != m_imp->m_portTable.end(); ++pit) {
    os.openChild(pit->first);
    if (pit->second->isConnected())
      os << TFxP(pit->second->getFx()).getPointer();
    os.closeChild();
  }
  os.closeChild();

  TPointD p = m_imp->m_attributes.getDagNodePos();
  if (p != TConst::nowhere) os.child("dagNodePos") << p.x << p.y;
  int numberId = m_imp->m_attributes.getId();
  os.child("numberId") << numberId;
  bool cacheEnabled = TPassiveCacheManager::instance()->cacheEnabled(this);
  if (cacheEnabled)
    os.child("passiveCacheId")
        << TPassiveCacheManager::instance()->getPassiveCacheId(this);
  std::wstring name = getName();
  if (name != L"") os.child("name") << TFilePath(name);
  std::wstring fxId = getFxId();
  os.child("fxId") << fxId;
  if (!m_imp->m_attributes.isEnabled()) os.child("enabled") << 0;
  os.child("opened") << (int)m_imp->m_attributes.isOpened();
  if (m_imp->m_attributes.isGrouped()) {
    os.openChild("groupIds");
    QStack<int> groupIdStack = m_imp->m_attributes.getGroupIdStack();
    int i;
    for (i = 0; i < groupIdStack.size(); i++) os << groupIdStack[i];
    os.closeChild();
    os.openChild("groupNames");
    QStack<std::wstring> groupNameStack =
        m_imp->m_attributes.getGroupNameStack();
    for (i = 0; i < groupNameStack.size(); i++) os << groupNameStack[i];
    os.closeChild();
  }
}

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

void TFx::loadPreset(TIStream &is) {
  std::string tagName;
  while (is.openChild(tagName)) {
    if (tagName == "dvpreset") {
      std::string fxId = is.getTagAttribute("fxId");
      if (fxId != getFxType())
        throw TException("Preset doesn't match the fx type");
    } else if (tagName == "params") {
      while (!is.eos()) {
        std::string paramName;
        while (is.openChild(paramName)) {
          try {
            TParamP param = getParams()->getParam(paramName);
            param->loadData(is);
          } catch (TException &) { /*skip*/
          }                        // il parametro non e' presente
          is.closeChild();
        }
      }
    } else {
      throw TException("Fx preset unknown tag!");
    }
  }
}

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

void TFx::savePreset(TOStream &os) {
  std::map<std::string, std::string> attributes;
  attributes.insert(std::make_pair(std::string("ver"), std::string("1.0")));
  attributes.insert(std::make_pair(std::string("fxId"), getFxType()));

  os.openChild("dvpreset", attributes);

  os.openChild("params");
  for (int i = 0; i < getParams()->getParamCount(); i++) {
    std::string paramName = getParams()->getParamName(i);
    TParam *param         = getParams()->getParam(i);
    os.openChild(paramName);
    param->saveData(os);
    os.closeChild();
  }
  os.closeChild();

  os.closeChild();
}

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

void TFx::disconnectAll() {
  int p, pCount = getInputPortCount();
  for (p = 0; p != pCount; ++p) getInputPort(p)->setFx(0);
}

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

TFx *TFx::create(std::string name) {
  return TFxFactory::instance()->create(name);
}

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

void TFx::listFxs(std::vector<TFxInfo> &info) {
  TFxFactory::instance()->getFxInfos(info);
}

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

TFxInfo TFx::getFxInfo(const std::string &fxIdentifier) {
  return TFxFactory::instance()->getFxInfo(fxIdentifier);
}

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

TFx *TFx::getLinkedFx() const {
  assert(m_imp->m_next);
  assert(m_imp->m_next->m_prev == m_imp);
  assert(m_imp->m_next->m_fx != 0);
  return m_imp->m_next->m_fx;
}

//===================================================
//
// TFxTimeRegion
//
//--------------------------------------------------

//! Creates an unlimited time region.
TFxTimeRegion::TFxTimeRegion()
    : m_start((std::numeric_limits<double>::max)())
    , m_end(-(std::numeric_limits<double>::max)()) {}

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

//! Creates a time region with specified start (included) and end (\b excluded).
TFxTimeRegion::TFxTimeRegion(double start, double end)
    : m_start(start), m_end(end) {}

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

TFxTimeRegion TFxTimeRegion::createUnlimited() {
  return TFxTimeRegion(-(std::numeric_limits<double>::max)(),
                       (std::numeric_limits<double>::max)());
}

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

bool TFxTimeRegion::contains(double time) const {
  return (m_start <= time && time < m_end);
}

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

bool TFxTimeRegion::isUnlimited() const {
  return (m_start == -(std::numeric_limits<double>::max)() ||
          m_end == (std::numeric_limits<double>::max)());
}

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

bool TFxTimeRegion::isEmpty() const { return (m_end <= m_start); }

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

bool TFxTimeRegion::getFrameCount(int &count) const {
  if (isUnlimited()) return false;
  count = tfloor(m_end) - tceil(m_start);
  return true;
}

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

int TFxTimeRegion::getFirstFrame() const { return tceil(m_start); }

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

int TFxTimeRegion::getLastFrame() const {
  if (m_end == (std::numeric_limits<double>::max)())
    return (std::numeric_limits<int>::max)();
  else
    return tceil(m_end) - 1;
}

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