#include "toonzqt/gutil.h"
#include "toonzqt/treemodel.h"

#include <QStringList>
#include <QTreeView>
#include <QHeaderView>
#include <QMouseEvent>
#include <qvariant.h>
#include <qicon.h>
#include <qtextedit.h>

#include "tfx.h"
#include <assert.h>

//====================================================================================================
// Item
//----------------------------------------------------------------------------------------------------

TreeModel::Item::Item()
    : m_model(0), m_parent(0), m_depth(0), m_row(0), m_opened(false) {}

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

TreeModel::Item::~Item() {
  qDeleteAll(m_childItems);
  m_childItems.clear();
  m_model  = 0;
  m_row    = 0;
  m_depth  = 0;
  m_parent = 0;
}

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

void TreeModel::Item::updateChild(Item *child, int row) {
  assert(m_model);
  child->m_model  = m_model;
  child->m_depth  = m_depth + 1;
  child->m_parent = this;
  child->m_row    = row;
}

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

void TreeModel::Item::updateChildren() {
  int i;
  for (i = 0; i < m_childItems.size(); i++) updateChild(m_childItems[i], i);
}

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

TreeModel::Item *TreeModel::Item::appendChild(TreeModel::Item *child) {
  assert(child);
  assert(!m_childItems.contains(child));
  updateChild(child, m_childItems.size());
  m_childItems.append(child);
  return child;
}

//------------------------------------------------------------------------------------------------------------------
/*
void TreeModel::Item::deleteChild(Item *child)
{
  int index = m_childItems.indexOf(child);
  if(index != -1)
  {
    m_childItems.takeAt(index);
    assert(!m_childItems.contains(child));
    // m_childItems is not supposed to contain duplicated entries
    delete child;
    updateChildren();
  }
}
*/

//------------------------------------------------------------------------------------------------------------------
/*
Item* matchItem(Item*item, QList<Item*> &items)
{
  void *itemData = item->getInternalPointer();
  if(!itemData) return 0;
  int i;
  for(i=0;i<items.size();i++)
    if(items.at(i)->getInternalPointer()==itemData)
      return items.at(i);
  return 0;
}
*/
//------------------------------------------------------------------------------------------------------------------

void TreeModel::Item::setChildren(QList<Item *> &newChildren) {
  assert(m_model);
  QModelIndex itemIndex = createIndex();

  // save old children and clear 'm_childItems'
  QList<Item *> oldChildren(m_childItems);
  m_childItems.clear();
  int i;

  // for each child to add
  for (i = 0; i < newChildren.size(); i++) {
    Item *newChild           = newChildren.at(i);
    void *newInternalPointer = newChild->getInternalPointer();
    if (newInternalPointer != 0) {
      // search among old children
      int j;
      for (j = 0; j < oldChildren.size(); j++)
        if (oldChildren.at(j)->getInternalPointer() == newInternalPointer)
          break;
      if (j < oldChildren.size()) {
        Item *oldChild = oldChildren.takeAt(j);
        if (oldChild != newChild) {
          // Found! Delete newChild, remove it from 'newChildren' and
          // update consequently the index
          delete newChild;
          newChildren.takeAt(i);
          i--;
          // use the found child instead of the new one.
          newChild = oldChild;
          oldChild->refresh();
        } else {
          // should never happen; (if it happens this is not a big problem)
          assert(0);
        }
      }
    }
    // add the new child to 'm_childItems'
    m_childItems.push_back(newChild);
  }
  // update children model, row, parent, etc.
  updateChildren();

  // postpone item deletion to avoid the (possible) reuse of the
  // same pointer for the newly created items. (Pointers match is
  // used updating persistent indices. see: TreeModel::endRefresh())
  for (i = 0; i < oldChildren.size(); i++) {
    Item *itemToDelete = oldChildren[i];
    if (!m_model->m_itemsToDelete.contains(itemToDelete))
      m_model->m_itemsToDelete.push_back(itemToDelete);
  }
}

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

QVariant TreeModel::Item::data(int role) const {
  if (role == Qt::DecorationRole)
    return createQIcon("folder", true);
  else
    return QVariant();
}

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

QModelIndex TreeModel::Item::createIndex() {
  return m_parent ? m_model->createIndex(m_row, 0, this) : QModelIndex();
}

//====================================================================================================
// TreeModel
//----------------------------------------------------------------------------------------------------

TreeModel::TreeModel(TreeView *parent)
    : QAbstractItemModel(parent), m_rootItem(0), m_view(parent) {}

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

TreeModel::~TreeModel() { delete m_rootItem; }

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

void TreeModel::setExpandedItem(const QModelIndex &index, bool expanded) {
  if (m_view) m_view->setExpanded(index, expanded);
}

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

void TreeModel::beginRefresh() { emit layoutAboutToBeChanged(); }

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

void TreeModel::endRefresh() {
  QList<QModelIndex> oldIndices, newIndices;
  int i;
  QList<Item *>::iterator it;

  for (i = m_itemsToDelete.size() - 1; i >= 0; i--) {
    int row          = m_itemsToDelete[i]->getRow();
    Item *parentItem = m_itemsToDelete[i]->getParent();
    QModelIndex parentIndex =
        parentItem ? parentItem->createIndex() : QModelIndex();

    beginRemoveRows(parentIndex, row, row);
    removeRow(row, parentIndex);  // NOTE: This is currently doing NOTHING? (see
                                  // Qt's manual)
    endRemoveRows();
  }

  qDeleteAll(m_itemsToDelete);
  m_itemsToDelete.clear();

  if (!persistentIndexList().empty()) {
    for (i = 0; i < persistentIndexList().size(); i++) {
      QModelIndex oldIndex = persistentIndexList()[i];
      Item *item           = static_cast<Item *>(oldIndex.internalPointer());
      if (item) {
        QModelIndex newIndex = item->createIndex();
        if (oldIndex != newIndex) {
          oldIndices.push_back(oldIndex);
          newIndices.push_back(newIndex);
        }
      }
    }
    changePersistentIndexList(oldIndices, newIndices);
  }

  emit layoutChanged();
}

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

int TreeModel::columnCount(const QModelIndex &parent) const { return 1; }

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

Qt::ItemFlags TreeModel::flags(const QModelIndex &index) const {
  if (!index.isValid()) return 0;
  return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}

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

QModelIndex TreeModel::index(int row, int column,
                             const QModelIndex &parent) const {
  // column=!0 are not supported
  if (column != 0) return QModelIndex();

  Item *parentItem =
      parent.isValid() ? (Item *)(parent.internalPointer()) : m_rootItem;
  // if m_rootItem has not been defined yet. (It should not happen, but just in
  // case)
  if (!parentItem) return QModelIndex();

  int childCount = parentItem->getChildCount();
  if (row < 0 || row >= childCount) return QModelIndex();

  Item *item = parentItem->getChild(row);
  if (!item) return QModelIndex();  // it should never happen
  return item->createIndex();
}

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

QModelIndex TreeModel::parent(const QModelIndex &index) const {
  if (!index.isValid()) return QModelIndex();

  Item *item = (Item *)index.internalPointer();

  TreeModel::Item *parentItem = item->getParent();

  if (!parentItem || parentItem == m_rootItem) return QModelIndex();

  return parentItem->createIndex();
}

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

int TreeModel::rowCount(const QModelIndex &parent) const {
  if (parent.column() > 0) return 0;

  if (!parent.isValid())
    return m_rootItem ? m_rootItem->getChildCount() : 0;
  else
    return ((Item *)(parent.internalPointer()))->getChildCount();
}

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

void TreeModel::onExpanded(const QModelIndex &index) {
  if (!index.isValid()) return;

  Item *item = (Item *)(index.internalPointer());
  item->setIsOpen(true);
}

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

void TreeModel::onCollapsed(const QModelIndex &index) {
  if (!index.isValid()) return;

  Item *item = (Item *)(index.internalPointer());
  item->setIsOpen(false);
}

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

QVariant TreeModel::data(const QModelIndex &index, int role) const {
  if (!index.isValid()) return QVariant();
  Item *item = static_cast<Item *>(index.internalPointer());
  return item->data(role);
}

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

void TreeModel::setRootItem(Item *rootItem) {
  if (rootItem == m_rootItem) return;
  delete m_rootItem;
  m_rootItem = rootItem;
  if (m_rootItem) m_rootItem->setModel(this);
}

// postpone freeing, so existing items can be referenced while refreshing.
void TreeModel::setRootItem_NoFree(Item *rootItem) {
  if (rootItem == m_rootItem) return;
  m_rootItem = rootItem;
  if (m_rootItem) m_rootItem->setModel(this);
}

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

void TreeModel::setRowHidden(int row, const QModelIndex &parent, bool hide) {
  if (m_view) m_view->setRowHidden(row, parent, hide);
}

//====================================================================================================
// TreeView
//----------------------------------------------------------------------------------------------------

TreeView::TreeView(QWidget *parent) : QTreeView(parent), m_dragging(false) {
  header()->hide();
  setUniformRowHeights(true);
  setIconSize(QSize(32, 32));
}

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

//! Resizes viewport to contents
void TreeView::resizeToConts(void) { resizeColumnToContents(0); }

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

void TreeView::resizeEvent(QResizeEvent *event) {
  resizeColumnToContents(0);
  QTreeView::resizeEvent(event);
}

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

void TreeView::setModel(TreeModel *model) {
  QTreeView::setModel(model);
  disconnect();

  connect(this, SIGNAL(expanded(const QModelIndex &)), model,
          SLOT(onExpanded(const QModelIndex &)));
  connect(this, SIGNAL(collapsed(const QModelIndex &)), model,
          SLOT(onCollapsed(const QModelIndex &)));
  // setItemDelegate(new Delegate(this));

  // Connect all possible changes that can alter the
  // bottom horizontal scrollbar to resize contents...
  connect(this, SIGNAL(expanded(const QModelIndex &)), this,
          SLOT(resizeToConts()));

  connect(this, SIGNAL(collapsed(const QModelIndex &)), this,
          SLOT(resizeToConts()));

  connect(this->model(), SIGNAL(layoutChanged()), this, SLOT(resizeToConts()));
}

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

void TreeView::mouseDoubleClickEvent(QMouseEvent *) {
  // ignore double click!
}

void TreeView::mousePressEvent(QMouseEvent *e) {
  if (e->button() != Qt::RightButton) QTreeView::mousePressEvent(e);
  QModelIndex index = indexAt(e->pos());
  if (index.isValid()) {
    TreeModel::Item *item =
        static_cast<TreeModel::Item *>(index.internalPointer());
    QRect itemRect = visualRect(index);
    QPoint itemPos = e->pos() - itemRect.topLeft();
    if (e->button() == Qt::RightButton) {
      if (selectionMode() != QAbstractItemView::ExtendedSelection)
        setCurrentIndex(item->createIndex());
      onClick(item, itemPos, e);
      openContextMenu(item, e->globalPos());
    } else if (e->button() == Qt::LeftButton) {
      m_dragging = true;
      setMouseTracking(true);
      onClick(item, itemPos, e);
    }
    // for drag & drop
    else if (e->button() == Qt::MidButton) {
      m_dragging = true;
      setMouseTracking(true);
      onMidClick(item, itemPos, e);
    }
  }
}

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

void TreeView::mouseMoveEvent(QMouseEvent *e) {
  QTreeView::mouseMoveEvent(e);
  if (m_dragging) {
    QModelIndex index = indexAt(e->pos());
    if (index.isValid()) {
      TreeModel::Item *item =
          static_cast<TreeModel::Item *>(index.internalPointer());
      QRect itemRect = visualRect(index);
      QPoint itemPos = e->pos() - itemRect.topLeft();
      onDrag(item, itemPos, e);
    }
  }
}

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

void TreeView::mouseReleaseEvent(QMouseEvent *e) {
  QTreeView::mouseReleaseEvent(e);
  if (m_dragging) {
    m_dragging = false;
    setMouseTracking(false);
    onRelease();
  }
}

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

/*
bool TreeView::Delegate::editorEvent(QEvent *e, QAbstractItemModel
*abstractModel, const QStyleOptionViewItem &option, const QModelIndex &index)
{
  if(e->type() != QEvent::MouseButtonPress) return false;
  TreeModel *model = dynamic_cast<TreeModel *>(abstractModel);
  if(!model || !index.isValid()) return false;

  TreeModel::Item *item = static_cast<TreeModel::Item
*>(index.internalPointer());
  QMouseEvent* mouseEvent = dynamic_cast<QMouseEvent*>(e);
  QPoint pos = mouseEvent->pos();

  m_treeView->onClick(item, pos, option);
  return true;
}
*/