#include "toonz/fxcommand.h"

// TnzLib includes

#include "toonz/txsheet.h"

#include "toonz/tcolumnfx.h"

#include "toonz/fxdag.h"

#include "toonz/tcolumnfxset.h"

#include "toonz/txshzeraryfxcolumn.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/txshlevelcolumn.h"

#include "toonz/txshpalettecolumn.h"

#include "toonz/toonzscene.h"

#include "toonz/txsheethandle.h"

#include "toonz/tfxhandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/tscenehandle.h"

#include "historytypes.h"

// TnzBase includes

#include "tparamcontainer.h"

#include "tparamset.h"

#include "tfxattributes.h"

#include "tmacrofx.h"

#include "tpassivecachemanager.h"

// TnzCore includes

#include "tundo.h"

#include "tconst.h"

// Qt includes

#include <qmap></qmap>

// tcg includes

#include "tcg/tcg_macros.h"

#include "tcg/tcg_base.h"

#include <memory></memory>

/*

  Toonz currently has THREE different APIs to deal with scene objects commands:

    1. From the xsheet, see columncommand.cpp

    2. From the stage schematic

    3. From the fx schematic

  *This* is the one version that should 'rule them all' - we still have to

  unify them, though.

TODO:

  - Associated Stage Object copies when copying columns

  - Stage schematic currently ignored (eg delete columns undo)

  - Double-check macro fxs behavior

  - Double-check group behavior

  - Enforce dynamic link groups consistency

*/

//**********************************************************************

//    Local Namespace  stuff

//**********************************************************************

namespace {

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

inline TFx *getActualIn(TFx *fx) {

  TZeraryColumnFx *zcfx = dynamic_cast<tzerarycolumnfx *="">(fx);</tzerarycolumnfx>

  return zcfx ? (assert(zcfx->getZeraryFx()), zcfx->getZeraryFx()) : fx;

}

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

inline TFx *getActualOut(TFx *fx) {

  TZeraryFx *zfx = dynamic_cast<tzeraryfx *="">(fx);</tzeraryfx>

  return (zfx && zfx->getColumnFx()) ? zfx->getColumnFx() : fx;

}

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

inline int inputPortIndex(TFx *fx, TFxPort *port) {

  int p, pCount = fx->getInputPortCount();

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

    if (fx->getInputPort(p) == port) break;

  return p;

}

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

/*!

  Returns whether the specified fx is internal to a macro fx. Fxs

  inside a macro should not be affected by most editing commands - the

  macro is required to be exploded first.

*/

bool isInsideAMacroFx(TFx *fx, TXsheet *xsh) {

  if (!fx) return false;

  TColumnFx *cfx = dynamic_cast<tcolumnfx *="">(fx);</tcolumnfx>

  TXsheetFx *xfx = dynamic_cast<txsheetfx *="">(fx);</txsheetfx>

  TOutputFx *ofx = dynamic_cast<toutputfx *="">(fx);</toutputfx>

  return !cfx && !xfx && !ofx &&

         !(xsh->getFxDag()->getInternalFxs()->containsFx(fx));

}

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

template <typename paramcont=""></typename>

void setParamsToCurrentScene(TXsheet *xsh, const ParamCont *cont) {

  for (int p = 0; p != cont->getParamCount(); ++p) {

    TParam ¶m = *cont->getParam(p);

    if (TDoubleParam *dp = dynamic_cast<tdoubleparam *="">(¶m))</tdoubleparam>

      xsh->getStageObjectTree()->setGrammar(dp);

    else if (TParamSet *paramSet = dynamic_cast<tparamset *="">(¶m))</tparamset>

      setParamsToCurrentScene(xsh, paramSet);

  }

}

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

inline void setFxParamToCurrentScene(TFx *fx, TXsheet *xsh) {

  setParamsToCurrentScene(xsh, fx->getParams());

}

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

void initializeFx(TXsheet *xsh, TFx *fx) {

  if (TZeraryColumnFx *zcfx = dynamic_cast<tzerarycolumnfx *="">(fx))</tzerarycolumnfx>

    fx = zcfx->getZeraryFx();

  // if the fx has not unique name then let assignUniqueId() set the default

  // name

  if (fx->getName() != L"" && fx->getName() == fx->getFxId()) fx->setName(L"");

  xsh->getFxDag()->assignUniqueId(fx);

  setFxParamToCurrentScene(fx, xsh);

}

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

void showFx(TXsheet *xsh, TFx *fx) {

  fx->getAttributes()->setIsOpened(xsh->getFxDag()->getDagGridDimension() == 0);

  if (TZeraryColumnFx *zcfx = dynamic_cast<tzerarycolumnfx *="">(fx))</tzerarycolumnfx>

    fx = zcfx->getZeraryFx();

  fx->getAttributes()->passiveCacheDataIdx() = -1;

}

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

void hideFx(TXsheet *xsh, TFx *fx) {

  if (TZeraryColumnFx *zcfx = dynamic_cast<tzerarycolumnfx *="">(fx))</tzerarycolumnfx>

    fx = zcfx->getZeraryFx();

  TPassiveCacheManager::instance()->disableCache(fx);

}

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

void addFxToCurrentScene(TFx *fx, TXsheet *xsh, bool isNewFx = true) {

  if (isNewFx) initializeFx(xsh, fx);

  xsh->getFxDag()->getInternalFxs()->addFx(fx);

  showFx(xsh, fx);

}

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

void removeFxFromCurrentScene(TFx *fx, TXsheet *xsh) {

  xsh->getFxDag()->getInternalFxs()->removeFx(fx);

  xsh->getFxDag()->getTerminalFxs()->removeFx(fx);

  hideFx(xsh, fx);

}

}  // namespace

//**********************************************************************

//    Filter Functors  definition

//**********************************************************************

namespace {

struct FilterInsideAMacro {

  TXsheet *m_xsh;

  inline bool operator()(const TFxP &fx) {

    return ::isInsideAMacroFx(fx.getPointer(), m_xsh);

  }

  inline bool operator()(const TFxCommand::Link &link) {

    return ::isInsideAMacroFx(link.m_inputFx.getPointer(), m_xsh) ||

           ::isInsideAMacroFx(link.m_outputFx.getPointer(), m_xsh);

  }

};

struct FilterNonTerminalFxs {

  TXsheet *xsh;

  inline bool operator()(const TFxP &fx) {

    return !xsh->getFxDag()->getTerminalFxs()->containsFx(fx.getPointer());

  }

};

struct FilterTerminalFxs {

  TXsheet *xsh;

  inline bool operator()(const TFxP &fx) {

    return xsh->getFxDag()->getTerminalFxs()->containsFx(fx.getPointer());

  }

};

struct FilterColumnFxs {

  inline bool operator()(const TFxP &fx) {

    return dynamic_cast<tlevelcolumnfx *="">(fx.getPointer());</tlevelcolumnfx>

  }

};

}  // namespace

//**********************************************************************

//    CloneFxFunctor  definition

//**********************************************************************

namespace {

struct CloneFxFunctor {

  TFxP m_src;

  bool m_ownsSrc;

  TFx *operator()() {

    if (m_ownsSrc)

      m_ownsSrc = false;  // Transfer m_src and ownership if it

    else                  // was surrendered

    {

      assert(m_src->getRefCount() >

             1);  // We'll be linking params to the cloned

                  // fx - so it MUST NOT be destroyed on release

      TFx *src = m_src.getPointer();

      m_src    = m_src->clone(false);  // Duplicate and link parameters all

      m_src->linkParams(src);          // the following times

    }

    return m_src.getPointer();

  }

};

}  // namespace

//**********************************************************************

//    FxCommandUndo  definition

//**********************************************************************

class FxCommandUndo : public TUndo {

public:

  virtual ~FxCommandUndo() {}

  virtual bool isConsistent() const = 0;

public:

  template <typename pred=""></typename>

  static TFx *leftmostConnectedFx(TFx *fx, Pred pred);

  template <typename pred=""></typename>

  static TFx *rightmostConnectedFx(TFx *fx, Pred pred);

  static TFx *leftmostConnectedFx(TFx *fx);

  static TFx *rightmostConnectedFx(TFx *fx);

  static std::vector<tfxcommand::link> inputLinks(TXsheet *xsh, TFx *fx);</tfxcommand::link>

  static std::vector<tfxcommand::link> outputLinks(TXsheet *xsh, TFx *fx);</tfxcommand::link>

  int getHistoryType() override { return HistoryType::Schematic; }

protected:

  static TXshZeraryFxColumn *createZeraryFxColumn(TXsheet *xsh, TFx *zfx,

                                                  int row = 0);

  static void cloneGroupStack(const QStack<int> &groupIds,</int>

                              const QStack<std::wstring> &groupNames,</std::wstring>

                              TFx *toFx);

  static void cloneGroupStack(TFx *fromFx, TFx *toFx);

  static void copyGroupEditLevel(int editGroupId, TFx *toFx);

  static void copyGroupEditLevel(TFx *fromFx, TFx *toFx);

  static void copyDagPosition(TFx *fromFx, TFx *toFx);

  static void attach(TXsheet *xsh, TFx *inputFx, TFx *outputFx, int port,

                     bool copyGroupData);

  static void attach(TXsheet *xsh, const TFxCommand::Link &link,

                     bool copyGroupData);

  static void attachOutputs(TXsheet *xsh, TFx *insertedFx, TFx *inputFx);

  static void detachFxs(TXsheet *xsh, TFx *fxLeft, TFx *fxRight,

                        bool detachLeft = true);

  static void insertFxs(TXsheet *xsh, const TFxCommand::Link &link, TFx *fxLeft,

                        TFx *fxRight);

  static void insertColumn(TXsheet *xsh, TXshColumn *column, int colIdx,

                           bool removeHole = false, bool autoTerminal = false);

  static void removeFxOrColumn(TXsheet *xsh, TFx *fx, int colIdx,

                               bool insertHole   = false,

                               bool unlinkParams = true);

  static void linkParams(TFx *fx, TFx *linkedFx);

  static void unlinkParams(TFx *fx);

  static void makeNotCurrent(TFxHandle *fxHandle, TFx *fx);

private:

  static void removeColumn(TXsheet *xsh, int colIdx, bool insertHole);

  static void removeNormalFx(TXsheet *xsh, TFx *fx);

  static void removeOutputFx(TXsheet *xsh, TOutputFx *outputFx);

};

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

TXshZeraryFxColumn *FxCommandUndo::createZeraryFxColumn(TXsheet *xsh, TFx *zfx,

                                                        int row) {

  int frameCount = xsh->getScene()->getFrameCount() - row;

  TXshZeraryFxColumn *column =

      new TXshZeraryFxColumn(frameCount > 0 ? frameCount : 100);

  column->getZeraryColumnFx()->setZeraryFx(zfx);

  column->insertEmptyCells(0, row);

  return column;

}

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

void FxCommandUndo::cloneGroupStack(const QStack<int> &groupIds,</int>

                                    const QStack<std::wstring> &groupNames,</std::wstring>

                                    TFx *toFx) {

  toFx->getAttributes()->removeFromAllGroup();

  for (int i = 0; i < groupIds.size(); ++i) {

    toFx->getAttributes()->setGroupId(groupIds[i]);

    toFx->getAttributes()->setGroupName(groupNames[i]);

  }

}

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

void FxCommandUndo::cloneGroupStack(TFx *fromFx, TFx *toFx) {

  if (fromFx->getAttributes()->isGrouped()) {

    cloneGroupStack(fromFx->getAttributes()->getGroupIdStack(),

                    fromFx->getAttributes()->getGroupNameStack(), toFx);

  }

}

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

void FxCommandUndo::copyGroupEditLevel(int editGroupId, TFx *toFx) {

  toFx->getAttributes()->closeAllGroups();

  while (editGroupId != toFx->getAttributes()->getEditingGroupId() &&

         toFx->getAttributes()->editGroup())

    ;

  assert(editGroupId == toFx->getAttributes()->getEditingGroupId());

}

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

void FxCommandUndo::copyGroupEditLevel(TFx *fromFx, TFx *toFx) {

  assert(toFx);

  if (fromFx && fromFx->getAttributes()->isGrouped())

    copyGroupEditLevel(fromFx->getAttributes()->getEditingGroupId(), toFx);

}

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

void FxCommandUndo::copyDagPosition(TFx *fromFx, TFx *toFx) {

  assert(toFx);

  if (fromFx)

    toFx->getAttributes()->setDagNodePos(

        fromFx->getAttributes()->getDagNodePos());

}

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

void FxCommandUndo::attach(TXsheet *xsh, TFx *inputFx, TFx *outputFx, int link,

                           bool copyGroupData) {

  if (outputFx) {

    FxDag *fxDag = xsh->getFxDag();

    inputFx  = ::getActualOut(inputFx);

    outputFx = ::getActualIn(outputFx);

    if (inputFx && link < 0) {

      assert(dynamic_cast<txsheetfx *="">(outputFx));</txsheetfx>

      fxDag->addToXsheet(inputFx);

    } else {

      int ipCount = outputFx->getInputPortCount();

      if (ipCount > 0 && link < ipCount)

        outputFx->getInputPort(link)->setFx(inputFx);

      if (copyGroupData) copyGroupEditLevel(inputFx, outputFx);

    }

  }

}

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

void FxCommandUndo::attach(TXsheet *xsh, const TFxCommand::Link &link,

                           bool copyGroupData) {

  attach(xsh, link.m_inputFx.getPointer(), link.m_outputFx.getPointer(),

         link.m_index, copyGroupData);

}

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

void FxCommandUndo::attachOutputs(TXsheet *xsh, TFx *insertedFx, TFx *inputFx) {

  TCG_ASSERT(inputFx, return);

  FxDag *fxDag = xsh->getFxDag();

  insertedFx = ::getActualOut(insertedFx);

  inputFx    = ::getActualOut(inputFx);

  int p, pCount = inputFx->getOutputConnectionCount();

  for (p = pCount - 1; p >= 0;

       --p)  // Backward iteration on output connections -

  {          // it's necessary since TFxPort::setFx() REMOVES

    TFxPort *port = inputFx->getOutputConnection(

        p);  // the corresponding port int the output connections

    port->setFx(

        insertedFx);  // container - thus, it's better to start from the end

  }

  if (fxDag->getTerminalFxs()->containsFx(inputFx)) {

    fxDag->removeFromXsheet(inputFx);

    fxDag->addToXsheet(insertedFx);

  }

}

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

void FxCommandUndo::detachFxs(TXsheet *xsh, TFx *fxLeft, TFx *fxRight,

                              bool detachLeft) {

  assert(fxLeft && fxRight);

  fxLeft  = ::getActualIn(fxLeft);

  fxRight = ::getActualOut(fxRight);

  int ipCount = fxLeft->getInputPortCount();

  // Redirect input/output ports

  TFx *inputFx0 = (ipCount > 0) ? fxLeft->getInputPort(0)->getFx() : 0;

  int p, opCount = fxRight->getOutputConnectionCount();

  for (p = opCount - 1; p >= 0;

       --p)  // Backward iteration due to TFxPort::setFx()

  {

    TFxPort *outPort = fxRight->getOutputConnection(p);

    assert(outPort && outPort->getFx() == fxRight);

    outPort->setFx(inputFx0);

  }

  // Xsheet links redirection

  FxDag *fxDag = xsh->getFxDag();

  if (fxDag->getTerminalFxs()->containsFx(fxRight)) {

    fxDag->removeFromXsheet(fxRight);

    for (int p = 0; p != ipCount; ++p)

      if (TFx *inputFx = fxLeft->getInputPort(p)->getFx())

        fxDag->addToXsheet(inputFx);

  }

  if (detachLeft) fxLeft->disconnectAll();

}

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

void FxCommandUndo::insertFxs(TXsheet *xsh, const TFxCommand::Link &link,

                              TFx *fxLeft, TFx *fxRight) {

  assert(fxLeft && fxRight);

  if (link.m_inputFx && link.m_outputFx) {

    FxCommandUndo::attach(xsh, link.m_inputFx.getPointer(), fxLeft, 0, false);

    FxCommandUndo::attach(xsh, fxRight, link.m_outputFx.getPointer(),

                          link.m_index, false);

    if (link.m_index < 0)

      xsh->getFxDag()->removeFromXsheet(

          ::getActualOut(link.m_inputFx.getPointer()));

  }

}

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

void FxCommandUndo::insertColumn(TXsheet *xsh, TXshColumn *column, int col,

                                 bool removeHole, bool autoTerminal) {

  FxDag *fxDag  = xsh->getFxDag();

  TFx *fx       = column->getFx();

  bool terminal = false;

  if (fx) {

    ::showFx(xsh, fx);

    terminal = fxDag->getTerminalFxs()->containsFx(fx);

  }

  if (removeHole) xsh->removeColumn(col);

  xsh->insertColumn(col, column);  // Attaches the fx to the xsheet, too -

                                   // but not if the column is a palette one.

  if (!autoTerminal) {

    // Preserve the initial terminal state.

    // This lets fxs to be linked to the xsheet while still hidden.

    fxDag->removeFromXsheet(fx);

    if (terminal) fxDag->addToXsheet(fx);

  }

  xsh->updateFrameCount();

}

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

void FxCommandUndo::removeColumn(TXsheet *xsh, int col, bool insertHole) {

  if (TFx *colFx = xsh->getColumn(col)->getFx()) {

    detachFxs(xsh, colFx, colFx);

    ::hideFx(xsh, colFx);

  }

  xsh->removeColumn(col);    // Already detaches any fx in output,

  if (insertHole)            // including the terminal case

    xsh->insertColumn(col);  // Note that fxs in output are not

                             // removed - just detached.

  xsh->updateFrameCount();

}

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

void FxCommandUndo::removeNormalFx(TXsheet *xsh, TFx *fx) {

  detachFxs(xsh, fx, fx);

  ::removeFxFromCurrentScene(fx, xsh);  // Already hideFx()s

}

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

void FxCommandUndo::removeOutputFx(TXsheet *xsh, TOutputFx *outputFx) {

  detachFxs(xsh, outputFx, outputFx);

  xsh->getFxDag()->removeOutputFx(outputFx);

}

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

void FxCommandUndo::linkParams(TFx *fx, TFx *linkedFx) {

  if (linkedFx) ::getActualIn(fx)->linkParams(::getActualIn(linkedFx));

}

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

void FxCommandUndo::unlinkParams(TFx *fx) {

  if (fx = ::getActualIn(fx), fx->getLinkedFx()) fx->unlinkParams();

}

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

void FxCommandUndo::makeNotCurrent(TFxHandle *fxHandle, TFx *fx) {

  if (fx = ::getActualOut(fx), fx == fxHandle->getFx()) fxHandle->setFx(0);

}

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

void FxCommandUndo::removeFxOrColumn(TXsheet *xsh, TFx *fx, int colIdx,

                                     bool insertHole, bool unlinkParams) {

  assert(fx || colIdx >= 0);

  if (!fx)

    fx = xsh->getColumn(colIdx)->getFx();

  else if (TColumnFx *colFx = dynamic_cast<tcolumnfx *="">(fx))</tcolumnfx>

    colIdx = colFx->getColumnIndex();

  else if (TZeraryFx *zfx = dynamic_cast<tzeraryfx *="">(fx)) {</tzeraryfx>

    if (zfx->getColumnFx())

      fx     = zfx->getColumnFx(),

      colIdx = static_cast<tcolumnfx *="">(fx)->getColumnIndex();</tcolumnfx>

  }

  if (fx) {

    // Discriminate special fx types

    if (TZeraryColumnFx *zcfx = dynamic_cast<tzerarycolumnfx *="">(fx)) {</tzerarycolumnfx>

      // Removed as a column

      fx = zcfx->getZeraryFx();

    } else if (TOutputFx *outputFx = dynamic_cast<toutputfx *="">(fx)) {</toutputfx>

      assert(xsh->getFxDag()->getOutputFxCount() > 1);

      FxCommandUndo::removeOutputFx(xsh, outputFx);

    } else if (colIdx < 0)

      FxCommandUndo::removeNormalFx(xsh, fx);

    if (unlinkParams) FxCommandUndo::unlinkParams(fx);

  }

  if (colIdx >= 0) FxCommandUndo::removeColumn(xsh, colIdx, insertHole);

}

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

template <typename pred=""></typename>

TFx *FxCommandUndo::leftmostConnectedFx(TFx *fx, Pred pred) {

  assert(fx);

  fx = rightmostConnectedFx(fx, pred);  // The rightmost fx should be discovered

                                        // first, then, we'll descend from that

  do {

    fx = ::getActualIn(fx);

    if (!((fx->getInputPortCount() > 0) && fx->getInputPort(0)->isConnected() &&

          pred(fx->getInputPort(0)->getFx())))

      break;

    fx = fx->getInputPort(0)->getFx();

  } while (true);

  return fx;

}

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

template <typename pred=""></typename>

TFx *FxCommandUndo::rightmostConnectedFx(TFx *fx, Pred pred) {

  assert(fx);

  do {

    fx = ::getActualOut(fx);

    if (!(fx->getOutputConnectionCount() > 0 &&

          pred(fx->getOutputConnection(0)->getOwnerFx())))

      break;

    fx = fx->getOutputConnection(0)->getOwnerFx();

  } while (true);

  return fx;

}

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

namespace {

struct True_pred {

  bool operator()(TFx *fx) { return true; }

};

}  // namespace

TFx *FxCommandUndo::leftmostConnectedFx(TFx *fx) {

  return leftmostConnectedFx(fx, ::True_pred());

}

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

TFx *FxCommandUndo::rightmostConnectedFx(TFx *fx) {

  return rightmostConnectedFx(fx, ::True_pred());

}

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

std::vector<tfxcommand::link> FxCommandUndo::inputLinks(TXsheet *xsh, TFx *fx) {</tfxcommand::link>

  std::vector<tfxcommand::link> result;</tfxcommand::link>

  fx = ::getActualIn(fx);

  int il, ilCount = fx->getInputPortCount();

  for (il = 0; il != ilCount; ++il) {

    TFxPort *port = fx->getInputPort(il);

    assert(port);

    if (port->isConnected())

      result.push_back(TFxCommand::Link(port->getFx(), fx, il));

  }

  return result;

}

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

std::vector<tfxcommand::link> FxCommandUndo::outputLinks(TXsheet *xsh,</tfxcommand::link>

                                                         TFx *fx) {

  std::vector<tfxcommand::link> result;</tfxcommand::link>

  fx = ::getActualOut(fx);

  int ol, olCount = fx->getOutputConnectionCount();

  for (ol = 0; ol != olCount; ++ol) {

    TFxPort *port = fx->getOutputConnection(ol);

    TFx *ownerFx  = port->getOwnerFx();

    int portIndex = ::inputPortIndex(ownerFx, port);

    result.push_back(TFxCommand::Link(fx, ownerFx, portIndex));

  }

  FxDag *fxDag = xsh->getFxDag();

  if (fxDag->getTerminalFxs()->containsFx(fx))

    result.push_back(TFxCommand::Link(fx, fxDag->getXsheetFx(), -1));

  return result;

}

//**********************************************************************

//    Insert Fx  command

//**********************************************************************

class InsertFxUndo final : public FxCommandUndo {

  QList<tfxp> m_selectedFxs;</tfxp>

  QList<tfxcommand::link> m_selectedLinks;</tfxcommand::link>

  TApplication *m_app;

  QList<tfxp> m_insertedFxs;</tfxp>

  TXshZeraryFxColumnP m_insertedColumn;

  int m_colIdx;

  bool m_columnReplacesHole;

  bool m_attachOutputs;

public:

  InsertFxUndo(const TFxP &fx, int row, int col, const QList<tfxp> &selectedFxs,</tfxp>

               QList<tfxcommand::link> selectedLinks, TApplication *app,</tfxcommand::link>

               bool attachOutputs = true)

      : m_selectedFxs(selectedFxs)

      , m_selectedLinks(selectedLinks)

      , m_insertedColumn(0)

      , m_app(app)

      , m_colIdx(col)

      , m_columnReplacesHole(false)

      , m_attachOutputs(attachOutputs) {

    initialize(fx, row, col);

  }

  bool isConsistent() const override { return !m_insertedFxs.isEmpty(); }

  void redo() const override;

  void undo() const override;

  int getSize() const override { return sizeof(*this); }

  QString getHistoryString() override;

private:

  void initialize(const TFxP &newFx, int row, int col);

};

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

inline bool has_fx_column(TFx *fx) {

  if (TPluginInterface *plgif = dynamic_cast<tplugininterface *="">(fx))</tplugininterface>

    return plgif->isPluginZerary();

  else if (TZeraryFx *zfx = dynamic_cast<tzeraryfx *="">(fx))</tzeraryfx>

    return zfx->isZerary();

  return false;

}

namespace {

bool containsInputFx(const QList<tfxp> &fxs, const TFxCommand::Link &link) {</tfxp>

  return fxs.contains(link.m_inputFx);

}

}  // namespace

void InsertFxUndo::initialize(const TFxP &newFx, int row, int col) {

  struct Locals {

    InsertFxUndo *m_this;

    inline void storeFx(TXsheet *xsh, TFx *fx) {

      ::initializeFx(xsh, fx);

      m_this->m_insertedFxs.push_back(fx);

    }

  } locals = {this};

  TXsheet *xsh = m_app->getCurrentXsheet()->getXsheet();

  TFx *fx      = newFx.getPointer();

  assert(!dynamic_cast<tzerarycolumnfx *="">(fx));</tzerarycolumnfx>

  TZeraryFx *zfx = dynamic_cast<tzeraryfx *="">(fx);</tzeraryfx>

  if (has_fx_column(fx)) {

    m_insertedColumn = InsertFxUndo::createZeraryFxColumn(xsh, fx, row);

    locals.storeFx(xsh, fx);

    if (xsh->getColumn(col) && xsh->getColumn(col)->isEmpty())

      m_columnReplacesHole = true;

  } else {

    if (m_selectedFxs.isEmpty() && m_selectedLinks.isEmpty()) {

      // Attempt retrieval of current Fx from the fxHandle

      if (TFx *currentFx = m_app->getCurrentFx()->getFx())

        m_selectedFxs.push_back(currentFx);

      else {

        // Isolated case

        locals.storeFx(xsh, fx);

        return;

      }

    }

    // Remove all unacceptable input fxs

    ::FilterInsideAMacro filterInMacroFxs = {xsh};

    m_selectedFxs.erase(std::remove_if(m_selectedFxs.begin(),

                                       m_selectedFxs.end(), filterInMacroFxs),

                        m_selectedFxs.end());

    // Remove all unacceptable links or links whose input fx was already

    // selected

    m_selectedLinks.erase(

        std::remove_if(m_selectedLinks.begin(), m_selectedLinks.end(),

                       filterInMacroFxs),

        m_selectedLinks.end());

    m_selectedLinks.erase(

        std::remove_if(m_selectedLinks.begin(), m_selectedLinks.end(),

                       [this](const TFxCommand::Link &link) {

                         return containsInputFx(m_selectedFxs, link);

                       }),

        m_selectedLinks.end());

    // Build an fx for each of the specified inputs

    ::CloneFxFunctor cloneFx = {fx, true};

    int f, fCount = m_selectedFxs.size();

    for (f = 0; f != fCount; ++f) {

      TFx *fx = cloneFx();

      FxCommandUndo::cloneGroupStack(m_selectedFxs[f].getPointer(), fx);

      locals.storeFx(xsh, fx);

    }

    fCount = m_selectedLinks.size();

    for (f = 0; f != fCount; ++f) {

      TFx *fx = cloneFx();

      FxCommandUndo::cloneGroupStack(m_selectedLinks[f].m_inputFx.getPointer(),

                                     fx);

      locals.storeFx(xsh, fx);

    }

  }

}

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

void InsertFxUndo::redo() const {

  struct OnExit {

    const InsertFxUndo *m_this;

    ~OnExit() {

      m_this->m_app->getCurrentFx()->setFx(

          m_this->m_insertedFxs.back().getPointer());

      m_this->m_app->getCurrentXsheet()->notifyXsheetChanged();

      m_this->m_app->getCurrentScene()->setDirtyFlag(true);

    }

  } onExit = {this};

  TXsheet *xsh = m_app->getCurrentXsheet()->getXsheet();

  // Zerary case

  if (m_insertedColumn) {

    FxCommandUndo::insertColumn(xsh, m_insertedColumn.getPointer(), m_colIdx,

                                m_columnReplacesHole, true);

    return;

  }

  // Isolated Fx case

  if (m_selectedLinks.isEmpty() && m_selectedFxs.isEmpty()) {

    assert(m_insertedFxs.size() == 1);

    ::addFxToCurrentScene(m_insertedFxs.back().getPointer(), xsh,

                          false);  // Already showFx()s

  } else {

    // Selected links

    int i;

    for (i = 0; i < m_selectedLinks.size(); ++i) {

      const TFxCommand::Link &link = m_selectedLinks[i];

      TFx *insertedFx              = m_insertedFxs[i].getPointer();

      ::addFxToCurrentScene(insertedFx, xsh, false);

      FxCommandUndo::insertFxs(xsh, link, insertedFx, insertedFx);

      FxCommandUndo::copyGroupEditLevel(link.m_inputFx.getPointer(),

                                        insertedFx);

    }

    // Selected fxs

    int j, t;

    for (j = 0, t = 0; j < m_selectedFxs.size(); j++) {

      TFx *fx = m_selectedFxs[j].getPointer();

      assert(fx);

      TFx *insertedFx = m_insertedFxs[i + t].getPointer();

      t++;

      assert(insertedFx);

      ::addFxToCurrentScene(insertedFx, xsh, false);

      if (m_attachOutputs) FxCommandUndo::attachOutputs(xsh, insertedFx, fx);

      FxCommandUndo::attach(xsh, fx, insertedFx, 0, true);