#include "hookselection.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/txsheethandle.h"

#include "toonz/tstageobjecttree.h"

#include "tools/tool.h"

#include "tools/toolhandle.h"

#include "toonzqt/selectioncommandids.h"

#include <qapplication></qapplication>

#include <qclipboard></qclipboard>

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

//

// HookUndo

//

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

HookUndo::HookUndo(const TXshLevelP &level) : m_level(level) {

  HookSet *hookSet = m_level->getHookSet();

  assert(hookSet);

  if (hookSet) m_oldHooks = *hookSet;

}

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

HookUndo::~HookUndo() {}

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

void HookUndo::onAdd() {

  HookSet *hookSet = m_level->getHookSet();

  assert(hookSet);

  if (hookSet) m_newHooks = *hookSet;

}

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

void HookUndo::assignHookSet(const HookSet &src) const {

  HookSet *hookSet = m_level->getHookSet();

  assert(hookSet);

  if (hookSet) *hookSet = src;

  TTool::getApplication()

      ->getCurrentXsheet()

      ->getXsheet()

      ->getStageObjectTree()

      ->invalidateAll();

  TTool *tool = TTool::getApplication()->getCurrentTool()->getTool();

  if (tool) {

    tool->updateMatrix();

    tool->invalidate();

  }

}

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

void HookUndo::undo() const { assignHookSet(m_oldHooks); }

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

void HookUndo::redo() const { assignHookSet(m_newHooks); }

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

int HookUndo::getSize() const { return sizeof(*this) + 2 * sizeof(HookSet); }

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

//

// HooksData

//

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

HooksData::HooksData(const TXshLevelP &level) : m_level(level) {}

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

HooksData::~HooksData() {}

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

HooksData *HooksData::clone() const {

  HooksData *newData       = new HooksData(m_level);

  newData->m_hookPositions = m_hookPositions;

  return newData;

}

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

void HooksData::storeHookPositions(const std::vector<int> &ids) {</int>

  if (ids.empty()) return;

  TTool::Application *app = TTool::getApplication();

  TXshLevelP level        = app->getCurrentLevel()->getLevel();

  assert(level == m_level);

  if (level != m_level || !m_level || m_level->getSimpleLevel()->isReadOnly())

    return;

  HookSet *hookSet = m_level->getHookSet();

  if (!hookSet) return;

  TFrameId fid = app->getCurrentTool()->getTool()->getCurrentFid();

  int i, idsSize = ids.size();

  m_hookPositions.clear();

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

    Hook *hook = hookSet->getHook(ids[i]);

    assert(hook);

    if (!hook) continue;

    TPointD aPos = hook->getAPos(fid);

    TPointD bPos = hook->getBPos(fid);

    m_hookPositions.push_back(HookPosition(ids[i], aPos, bPos));

  }

}

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

void HooksData::restoreHookPositions() const {

  if (m_hookPositions.empty()) return;

  TTool::Application *app = TTool::getApplication();

  TXshLevelP level        = app->getCurrentLevel()->getLevel();

  assert(level == m_level);

  if (level != m_level || !m_level || m_level->getSimpleLevel()->isReadOnly())

    return;

  HookSet *hookSet = m_level->getHookSet();

  if (!hookSet) return;

  TFrameId fid = app->getCurrentTool()->getTool()->getCurrentFid();

  int i, posSize = m_hookPositions.size();

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

    HookPosition hookPos = m_hookPositions[i];

    Hook *hook           = hookSet->getHook(hookPos.m_id);

    assert(hook);

    if (!hook) continue;

    hook->setAPos(fid, hookPos.m_aPos);

    hook->setBPos(fid, hookPos.m_bPos);

  }

}

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

//

// HookSelection

//

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

HookSelection::HookSelection() {}

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

HookSelection::~HookSelection() {}

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

TSelection *HookSelection::clone() const { return new HookSelection(*this); }

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

void HookSelection::select(int id, int side) {

  m_hooks.insert(std::make_pair(id, side));

}

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

void HookSelection::unselect(int id, int side) {

  m_hooks.erase(std::make_pair(id, side));

}

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

bool HookSelection::isSelected(int id, int side) const {

  return m_hooks.count(std::make_pair(id, side)) > 0;

}

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

void HookSelection::invertSelection(int id, int side) {

  if (isSelected(id, side))

    unselect(id, side);

  else

    select(id, side);

}

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

bool HookSelection::isEmpty() const { return m_hooks.empty(); }

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

HookSet *HookSelection::getHookSet() const {

  TXshLevel *xl = TTool::getApplication()->getCurrentLevel()->getLevel();

  if (!xl) return 0;

  return xl->getHookSet();

}

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

bool HookSelection::select(const TSelection *s) {

  if (const HookSelection *hs = dynamic_cast<const *="" hookselection="">(s)) {</const>

    m_level = hs->m_level;

    m_hooks = hs->m_hooks;

    return true;

  } else

    return false;

}

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

void HookSelection::enableCommands() {

  enableCommand(this, MI_Clear, &HookSelection::deleteSelectedHooks);

  enableCommand(this, MI_Copy, &HookSelection::copySelectedHooks);

  enableCommand(this, MI_Cut, &HookSelection::cutSelectedHooks);

  enableCommand(this, MI_Paste, &HookSelection::pasteSelectedHooks);

}

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

void HookSelection::deleteSelectedHooks() {

  TTool::Application *app = TTool::getApplication();

  TTool *tool             = app->getCurrentTool()->getTool();

  if (!app) return;

  TXshLevel *xl    = app->getCurrentLevel()->getLevel();

  HookSet *hookSet = xl->getHookSet();

  if (!xl || !xl->getSimpleLevel() || !hookSet ||

      xl->getSimpleLevel()->isReadOnly())

    return;

  HookUndo *undo = new HookUndo(xl->getSimpleLevel());

  TFrameId fid   = tool->getCurrentFid();

  for (int i = 0; i < hookSet->getHookCount(); i++) {

    Hook *hook = hookSet->getHook(i);

    if (!hook || hook->isEmpty()) continue;

    if (isSelected(i, 1) && isSelected(i, 2))

      hookSet->clearHook(hook);

    else if (isSelected(i, 2))

      hook->setBPos(fid, hook->getAPos(fid));

    else if (isSelected(i, 1))

      hook->setAPos(fid, hook->getBPos(fid));

  }

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

  app->getCurrentXsheet()->getXsheet()->getStageObjectTree()->invalidateAll();

  tool->invalidate();

}

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

void HookSelection::copySelectedHooks() {

  if (isEmpty()) return;

  std::vector<int> ids;</int>

  std::set<std::pair<int, int="">>::iterator it;</std::pair<int,>

  for (it = m_hooks.begin(); it != m_hooks.end(); it++) {

    if (std::find(ids.begin(), ids.end(), it->first) == ids.end())

      ids.push_back(it->first);

  }

  TXshLevel *xl   = TTool::getApplication()->getCurrentLevel()->getLevel();

  HooksData *data = new HooksData(xl);

  data->storeHookPositions(ids);

  QApplication::clipboard()->setMimeData(data);

}

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

void HookSelection::cutSelectedHooks() {

  copySelectedHooks();

  TXshLevel *xl    = TTool::getApplication()->getCurrentLevel()->getLevel();

  TUndo *undo      = new HookUndo(xl);

  HookSet *hookSet = xl->getHookSet();

  std::set<std::pair<int, int="">>::iterator it;</std::pair<int,>

  for (it = m_hooks.begin(); it != m_hooks.end(); it++) {

    Hook *hook = hookSet->getHook(it->first);

    assert(hook);

    if (!hook) return;

    TFrameId fid =

        TTool::getApplication()->getCurrentTool()->getTool()->getCurrentFid();

    hook->eraseFrame(fid);

  }

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

  TTool::getApplication()->getCurrentTool()->getTool()->invalidate();

}

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

void HookSelection::pasteSelectedHooks() {

  const QMimeData *data      = QApplication::clipboard()->mimeData();

  const HooksData *hooksData = dynamic_cast<const *="" hooksdata="">(data);</const>

  if (!hooksData) return;

  TXshLevel *xl = TTool::getApplication()->getCurrentLevel()->getLevel();

  TUndo *undo   = new HookUndo(xl);

  hooksData->restoreHookPositions();

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

  TTool::getApplication()->getCurrentTool()->getTool()->invalidate();

}