#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 QIcon(isOpen()
						 ? ":Resources/folder_open.png"
						 : ":Resources/folder_close.png");
	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)
{
	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);
}
 
//---------------------------------------------------------------------------------------------------------------
 
void TreeModel::setRowHidden(int row, const QModelIndex &parent, bool hide)
{
	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;
}
*/