#include "toonz/hook.h"

#include "tstream.h"

#include "tfilepath.h"

#include "tconvert.h"

#include "toonz/txsheet.h"

#include "toonz/txshcell.h"

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

Hook::Hook() : m_id(0), m_trackerObjectId(-1) {}

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

bool Hook::isEmpty() const { return m_frames.empty(); }

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

bool Hook::isKeyframe(const TFrameId &fid) const {

  return m_frames.count(fid) > 0;

}

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

Hook::Frames::const_iterator Hook::find(TFrameId fid) const {

  if (m_frames.empty()) return m_frames.end();

  Frames::const_iterator it;

  it = m_frames.lower_bound(fid);

  if (it == m_frames.end()) {

    // dopo l'ultimo

    assert(it != m_frames.begin());

    --it;

  } else if (it->first == fid || it == m_frames.begin()) {

    // giusto o prima del primo

  } else

    --it;

  return it;

}

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

TPointD Hook::getPos(const TFrameId &fid) const {

  // return TPointD(0,0);

  Frames::const_iterator it = find(fid);

  if (it == m_frames.end())

    return TPointD();

  else

    return it->second.m_pos;

}

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

TPointD Hook::getAPos(const TFrameId &fid) const {

  Frames::const_iterator it = find(fid);

  if (it == m_frames.end())

    return TPointD();

  else if (it->first == fid)

    return it->second.m_aPos;

  else

    return it->second.m_bPos;

}

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

TPointD Hook::getBPos(const TFrameId &fid) const {

  Frames::const_iterator it = find(fid);

  if (it == m_frames.end())

    return TPointD();

  else

    return it->second.m_bPos;

}

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

void Hook::setAPos(const TFrameId &fid, TPointD pos) {

  Frames::iterator it = m_frames.lower_bound(fid);

  Frame f;

  if (it != m_frames.end() && it->first == fid) {

    f = it->second;

    if (f.m_aPos == f.m_bPos)

      f.m_aPos = f.m_bPos = pos;

    else if (tdistance2(pos, f.m_bPos) <= 1)

      f.m_aPos = f.m_bPos;

    else

      f.m_aPos = pos;

  } else {

    f.m_aPos = f.m_bPos = pos;

  }

  m_frames[fid] = f;

  update();

}

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

void Hook::setBPos(const TFrameId &fid, TPointD pos) {

  Frames::iterator it = m_frames.lower_bound(fid);

  Frame f;

  if (it != m_frames.end() && it->first == fid) {

    f = it->second;

    if (tdistance2(pos, f.m_aPos) <= 1)

      f.m_bPos = f.m_aPos;

    else

      f.m_bPos = pos;

  } else {

    f.m_aPos = getAPos(fid);

    f.m_bPos = pos;

  }

  m_frames[fid] = f;

  update();

}

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

TRectD Hook::getTrackerRegion(const TFrameId &fid) {

  TRectD rect;

  rect.x0 = getPos(fid).x - (getTrackerRegionWidth() * 0.5);

  rect.y0 = getPos(fid).y - (getTrackerRegionHeight() * 0.5);

  rect.x1 = getPos(fid).x + (getTrackerRegionWidth() * 0.5);

  rect.y1 = getPos(fid).y + (getTrackerRegionHeight() * 0.5);

  return rect;

}

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

void Hook::update() {

  TPointD delta;

  for (Frames::iterator it = m_frames.begin(); it != m_frames.end(); ++it) {

    it->second.m_pos = it->second.m_aPos + delta;

    delta -= it->second.m_bPos - it->second.m_aPos;

  }

  m_delta = delta;

}

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

void Hook::renumber(const std::map<tframeid, tframeid=""> &renumberTable) {</tframeid,>

  Frames oldFrames = m_frames;

  m_frames.clear();

  for (Frames::iterator it = oldFrames.begin(); it != oldFrames.end(); ++it) {

    std::map<tframeid, tframeid="">::const_iterator j =</tframeid,>

        renumberTable.find(it->first);

    assert(j != renumberTable.end());

    if (j == renumberTable.end()) continue;

    m_frames[j->second] = it->second;

  }

}

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

void Hook::eraseFrame(const TFrameId &fid) { m_frames.erase(fid); }

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

void Hook::saveData(TOStream &os) {

  Frames::iterator j;

  for (j = m_frames.begin(); j != m_frames.end(); ++j) {

    os.openChild("frame");

    os << j->first.getNumber();

    os << j->second.m_aPos.x << j->second.m_aPos.y;

    os << j->second.m_bPos.x << j->second.m_bPos.y;

    os.closeChild();

  }

  if (m_trackerObjectId >= 0) {

    os.openChild("tracker");

    os << m_trackerObjectId << m_width << m_height;

    os.closeChild();

  }

}

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

void Hook::loadData(TIStream &is) {

  m_frames.clear();

  std::string tagName;

  while (is.matchTag(tagName)) {

    if (tagName == "frame") {

      Frame f;

      int frameNumber = 0;

      is >> frameNumber;

      is >> f.m_aPos.x >> f.m_aPos.y;

      is >> f.m_bPos.x >> f.m_bPos.y;

      m_frames[TFrameId(frameNumber)] = f;

      m_trackerObjectId               = -1;

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

      is >> m_trackerObjectId;

      is >> m_width;

      is >> m_height;

    } else

      throw TException("expected ");

    is.matchEndTag();

  }

  update();

}

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

HookSet::HookSet() : m_trackerObjectsSet(new TrackerObjectsSet) {}

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

HookSet::~HookSet() {

  clearPointerContainer(m_hooks);

  delete m_trackerObjectsSet;

}

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

HookSet::HookSet(const HookSet &other)

    : m_hooks(other.m_hooks), m_trackerObjectsSet(new TrackerObjectsSet) {

  int h, hCount = m_hooks.size();

  for (h                       = 0; h != hCount; ++h)

    if (m_hooks[h]) m_hooks[h] = new Hook(*m_hooks[h]);

}

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

HookSet &HookSet::operator=(const HookSet &other) {

  clearPointerContainer(m_hooks);

  m_hooks = other.m_hooks;

  int h, hCount = m_hooks.size();

  for (h                       = 0; h != hCount; ++h)

    if (m_hooks[h]) m_hooks[h] = new Hook(*m_hooks[h]);

  return *this;

}

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

int HookSet::getHookCount() const { return m_hooks.size(); }

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

Hook *HookSet::getHook(int index) const {

  return 0 <= index && index < getHookCount() ? m_hooks[index] : 0;

}

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

Hook *HookSet::touchHook(int index) {

  assert(0 <= index && index < maxHooksCount);

  if (index < 0 || index >= maxHooksCount) return 0;

  while (index >= (int)m_hooks.size()) m_hooks.push_back(0);

  if (m_hooks[index] == 0) {

    Hook *hook     = new Hook();

    m_hooks[index] = hook;

    hook->m_id     = index;

  }

  return m_hooks[index];

}

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

Hook *HookSet::addHook() {

  int h, hCount = m_hooks.size();

  for (h = 0; h != hCount; ++h) {

    if (m_hooks[h] == 0) {

      Hook *hook = new Hook();

      m_hooks[h] = hook;

      hook->m_id = h;

      return hook;

    } else if (m_hooks[h]->isEmpty())

      return m_hooks[h];

  }

  if (m_hooks.size() >= maxHooksCount) return 0;

  Hook *hook = new Hook();

  hook->m_id = m_hooks.size();

  m_hooks.push_back(hook);

  return hook;

}

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

void HookSet::clearHook(Hook *hook) {

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

    if (m_hooks[i] == hook) m_hooks[i] = 0;

  delete hook;

}

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

void HookSet::clearHooks() {

  for (int i = 0; i < (int)m_hooks.size(); i++) delete m_hooks[i];

  m_hooks.clear();

}

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

TrackerObjectsSet *HookSet::getTrackerObjectsSet() const {

  // Ripulisco l'insieme dei tracker objects

  m_trackerObjectsSet->clearAll();

  // costruisco il tracker object in base agli Hook

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

    Hook *hook = getHook(i);

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

    int trackerObjectId = hook->getTrackerObjectId();

    if (trackerObjectId >= 0)  // se l'Hook ha anche una regione

    {

      TrackerObject *trackerObject =

          m_trackerObjectsSet->getObject(trackerObjectId);

      if (trackerObject == NULL) {

        trackerObject = new TrackerObject(trackerObjectId);

        m_trackerObjectsSet->addObject(trackerObject);

      }

      trackerObject = m_trackerObjectsSet->getObject(trackerObjectId);

      assert(trackerObject != NULL);

      trackerObject->addHook(hook);

    }

  }

  return m_trackerObjectsSet;

}

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

void HookSet::renumber(const std::map<tframeid, tframeid=""> &renumberTable) {</tframeid,>

  for (int i = 0; i < getHookCount(); i++)

    if (getHook(i)) getHook(i)->renumber(renumberTable);

}

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

void HookSet::eraseFrame(const TFrameId &fid) {

  for (int i = 0; i < getHookCount(); i++)

    if (getHook(i)) getHook(i)->eraseFrame(fid);

}

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

void HookSet::saveData(TOStream &os) {

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

    os.openChild("hook");

    Hook *hook = getHook(i);

    // Pay attention: it is necessary that empty hook will be however saved

    // in the xml file.

    if (hook) hook->saveData(os);

    os.closeChild();

  }

}

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

void HookSet::loadData(TIStream &is) {

  std::string tagName;

  while (is.matchTag(tagName)) {

    if (tagName == "hook") {

      Hook *hook = new Hook();

      hook->m_id = m_hooks.size();

      hook->loadData(is);

      is.matchEndTag();

      m_hooks.push_back(hook);

    } else

      return;

    is.matchEndTag();

  }

}

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

//

//	TRACKER

//

Hook *TrackerObject::getHook(int index) {

  assert(index >= 0 && index < getHooksCount());

  return m_hooks.at(index);

}

void TrackerObject::addHook(Hook *hook) { m_hooks.push_back(hook); }

void TrackerObject::removeHook(int index) {

  assert(index >= 0 && index < (int)m_hooks.size());

  m_hooks.erase(m_hooks.begin() + index);

}

TrackerObject *TrackerObjectsSet::getObject(int objectId) {

  assert(objectId >= 0);

  std::map<int, *="" trackerobject="">::iterator it = m_trackerObjects.find(objectId);</int,>

  if (it != m_trackerObjects.end())

    return it->second;

  else

    return NULL;

}

TrackerObject *TrackerObjectsSet::getObjectFromIndex(int index) {

  assert(index >= 0 && index < (int)m_trackerObjects.size());

  return m_trackerObjects[index];

}

// return objectIndex, return -1 if objectId doesn't exist

int TrackerObjectsSet::getIndexFromId(int objectId) {

  int index = -1;

  int i     = 0;

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

    int id = m_trackerObjects[i]->getId();

    if (id == objectId) {

      index = i;

      break;

    }

  }

  return index;

}

int TrackerObjectsSet::getIdFromIndex(int index) {

  assert(index >= 0 && index < (int)m_trackerObjects.size());

  return m_trackerObjects[index]->getId();

}

// add new object, return new object Id

int TrackerObjectsSet::addObject() {

  // assegno l'id

  int id;

  if (m_trackerObjects.size() > 0) {

    std::map<int, *="" trackerobject="">::iterator it = m_trackerObjects.end();</int,>

    --it;

    id = it->first + 1;

  } else

    id = 0;

  TrackerObject *trackerObject = new TrackerObject(id);

  m_trackerObjects[id]         = trackerObject;

  return id;

}

void TrackerObjectsSet::addObject(TrackerObject *trackerObject) {

  assert(trackerObject);

  int id = trackerObject->getId();

  assert(id >= 0);

  m_trackerObjects[id] = trackerObject;

}

void TrackerObjectsSet::removeObject(int objectId) {

  assert(objectId >= 0);

  std::map<int, *="" trackerobject="">::iterator tt = m_trackerObjects.find(objectId);</int,>

  if (tt != m_trackerObjects.end()) {

    delete tt->second;

    m_trackerObjects.erase(tt);

  }

}

void TrackerObjectsSet::clearAll() {

  std::map<int, *="" trackerobject="">::iterator tt, tEnd(m_trackerObjects.end());</int,>

  for (tt = m_trackerObjects.begin(); tt != tEnd; ++tt) delete tt->second;

  m_trackerObjects.clear();

}

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

std::string getHookName(int code) {

  assert(0 <= code && code < 10);

  if (code == 0)

    return "B";

  else

    return "H" + std::to_string(code);

}