// TnzCore includes

#include "tundo.h"

// TnzLib includes

#include "toonz/tobjecthandle.h"

#include "plastictool.h"

using namespace PlasticToolLocals;

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

//    Undo  definitions

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

namespace {

class AnimateValuesUndo : public TUndo {

  int m_row, m_col;  //!< Xsheet coordinates

  int m_v;           //!< Moved vertex

public:

  SkDKey m_oldValues, m_newValues;  //!< Keyframe values

public:

  AnimateValuesUndo(int v) : m_row(::row()), m_col(::column()), m_v(v) {}

  // Again, not accurate. We should get in the details of SkDF... So, let's say

  // around 10 kB - max 10k instances in the standard undos pool.

  int getSize() const { return 10 << 10; }

  void redo() const {

    PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

    if (m_v >= 0) l_plasticTool.setSkeletonSelection(m_v);

    l_suspendParamsObservation =

        true;  // Coalesce params change notifications into one

    l_plasticTool.deformation()->deleteKeyframe(m_row - 1);

    l_plasticTool.deformation()->setKeyframe(m_newValues);

    l_suspendParamsObservation = false;

    l_plasticTool.onChange();

  }

  void undo() const {

    PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

    if (m_v >= 0) l_plasticTool.setSkeletonSelection(m_v);

    l_suspendParamsObservation =

        true;  // Coalesce params change notifications into one

    l_plasticTool.deformation()->deleteKeyframe(

        m_row - 1);  // Yep. Typical frame/row shift... xD

    l_plasticTool.deformation()->setKeyframe(m_oldValues);

    l_suspendParamsObservation = false;

    l_plasticTool.onChange();

  }

};

}  // namespace

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

//    PlasticTool  functions

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

void PlasticTool::mouseMove_animate(const TPointD &pos, const TMouseEvent &me) {

  // Track mouse position

  m_pos = pos;  // Needs to be done now - ensures m_pos is valid

  m_svHigh = m_seHigh = -1;  // Reset highlighted primitives

  if (m_sd) {

    double d, highlightRadius = getPixelSize() * HIGHLIGHT_DISTANCE;

    // Look for nearest vertex

    int v = deformedSkeleton().closestVertex(pos, &d);

    if (v >= 0 && d < highlightRadius) m_svHigh = v;

    invalidate();

  }

}

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

void PlasticTool::leftButtonDown_animate(const TPointD &pos,

                                         const TMouseEvent &me) {

  // Track mouse position

  m_pressedPos = m_pos = pos;

  setSkeletonSelection(m_svHigh);

  if (m_svSel.hasSingleObject()) {

    // Store original vertex position and keyframe values

    m_pressedVxsPos =

        std::vector<tpointd>(1, deformedSkeleton().vertex(m_svSel).P());</tpointd>

    m_sd->getKeyframeAt(frame(), m_pressedSkDF);

  }

  invalidate();

}

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

void PlasticTool::leftButtonDrag_animate(const TPointD &pos,

                                         const TMouseEvent &me) {

  // Track mouse position

  m_pos = pos;

  if (m_sd && m_svSel.hasSingleObject() &&

      m_svSel > 0)  // Avoid move if vertex is root

  {

    l_suspendParamsObservation = true;  // Automatic params notification happen

    // twice (1 x param) - dealing with it manually

    double frame = ::frame();

    // First, retrieve selected vertex's deformation

    SkVD *vd = m_sd->vertexDeformation(::skeletonId(), m_svSel);

    assert(vd);

    // Move selected branch

    if (m_keepDistance.getValue()) {

      ::setKeyframe(vd->m_params[SkVD::ANGLE],

                    frame);  // Set a keyframe for it. It must be done

                             // to set the correct function interpolation

                             // type and other stuff.

      m_sd->updateAngle(*skeleton(), deformedSkeleton(), frame, m_svSel, pos);

    } else {

      ::setKeyframe(vd->m_params[SkVD::ANGLE],

                    frame);  // Same here. NOTE: Not setting a frame on

      ::setKeyframe(vd->m_params[SkVD::DISTANCE],

                    frame);  // vd directly due to SkVD::SO

      m_sd->updatePosition(*skeleton(), deformedSkeleton(), frame, m_svSel,

                           pos);

    }

    l_suspendParamsObservation = false;

    // onChange();                                                     // Due to

    // a nasty Function Editor dependency,

    // it's better to call the following directly

    m_deformedSkeleton.invalidate();

    invalidate();

  }

}

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

void PlasticTool::leftButtonUp_animate(const TPointD &pos,

                                       const TMouseEvent &me) {

  // Track mouse position

  m_pos = pos;

  if (m_svSel.hasSingleObject() && m_dragged) {

    // Set a keyframe to each skeleton vertex, if that was requested

    if (m_globalKey.getValue())

      ::setKeyframe(m_sd, ::frame());  // Already invokes keyframes rebuild

    else

      stageObject()->updateKeyframes();  // Otherwise, must be explicit

    // Add a corresponding undo

    AnimateValuesUndo *undo = new AnimateValuesUndo(m_svSel);

    undo->m_oldValues = m_pressedSkDF;

    m_sd->getKeyframeAt(frame(), undo->m_newValues);

    TUndoManager::manager()->add(undo);

    // This is needed to refresh the xsheet (there may be new keyframes)

    TTool::getApplication()->getCurrentObject()->notifyObjectIdChanged(false);

  }

  // In case one of the vertices is attached (as a hook) to an external

  // position,

  // we need to update the whole skeleton according to the updated vertex.

  updateMatrix();

  invalidate();

}

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

void PlasticTool::addContextMenuActions_animate(QMenu *menu) {

  bool ret = true;

  if (!m_svSel.isEmpty()) {

    QAction *setKey = menu->addAction(tr("Set Key"));

    ret = ret && connect(setKey, SIGNAL(triggered()), &l_plasticTool,

                         SLOT(setKey_undo()));

    QAction *setRestKey = menu->addAction(tr("Set Rest Key"));

    ret = ret && connect(setRestKey, SIGNAL(triggered()), &l_plasticTool,

                         SLOT(setRestKey_undo()));

  }

  QAction *setGlobalKey = menu->addAction(tr("Set Global Key"));

  ret = ret && connect(setGlobalKey, SIGNAL(triggered()), &l_plasticTool,

                       SLOT(setGlobalKey_undo()));

  QAction *setGlobalRestKey = menu->addAction(tr("Set Global Rest Key"));

  ret = ret && connect(setGlobalRestKey, SIGNAL(triggered()), &l_plasticTool,

                       SLOT(setGlobalRestKey_undo()));

  menu->addSeparator();

  assert(ret);

}

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

void PlasticTool::keyFunc_undo(void (PlasticTool::*keyFunc)()) {

  assert(m_svSel.objects().size() <= 1);

  double frame = ::frame();

  AnimateValuesUndo *undo = new AnimateValuesUndo(m_svSel);

  m_sd->getKeyframeAt(frame, undo->m_oldValues);

  (this->*keyFunc)();

  m_sd->getKeyframeAt(frame, undo->m_newValues);

  TUndoManager::manager()->add(undo);

}

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

void PlasticTool::draw_animate() {

  double pixelSize = getPixelSize();

  PlasticSkeleton &deformedSkeleton = this->deformedSkeleton();

  // Draw deformed skeleton

  if (m_sd) {

    drawOnionSkinSkeletons_animate(pixelSize);

    drawSkeleton(deformedSkeleton, pixelSize);

    drawSelections(m_sd, deformedSkeleton, pixelSize);

    drawAngleLimits(m_sd, m_skelId, m_svSel, pixelSize);

  }

  drawHighlights(m_sd, &deformedSkeleton, pixelSize);

}