#include <QFileIconProvider>
#include <QHeaderView>
#include <QSortFilterProxyModel>
#include "remotedecklist_treewidget.h"
#include "protocol_items.h"
#include "client.h"

RemoteDeckList_TreeModel::DirectoryNode::DirectoryNode(const QString &_name, RemoteDeckList_TreeModel::DirectoryNode *_parent)
	: RemoteDeckList_TreeModel::Node(_name, _parent)
{
}

RemoteDeckList_TreeModel::DirectoryNode::~DirectoryNode()
{
	clearTree();
}

void RemoteDeckList_TreeModel::DirectoryNode::clearTree()
{
	for (int i = 0; i < size(); ++i)
		delete at(i);
	clear();
}

QString RemoteDeckList_TreeModel::DirectoryNode::getPath() const
{
	if (parent) {
		QString parentPath = parent->getPath();
		if (parentPath.isEmpty())
			return name;
		else
			return parentPath + "/" + name;
	} else
		return name;
}

RemoteDeckList_TreeModel::DirectoryNode *RemoteDeckList_TreeModel::DirectoryNode::getNodeByPath(QStringList path)
{
	QString pathItem;
	if (parent) {
		if (path.isEmpty())
			return this;
		pathItem = path.takeFirst();
		if (pathItem.isEmpty() && name.isEmpty())
			return this;
	}
	
	for (int i = 0; i < size(); ++i) {
		DirectoryNode *node = dynamic_cast<DirectoryNode *>(at(i));
		if (!node)
			continue;
		if (node->getName() == pathItem)
			return node->getNodeByPath(path);
	}
	return 0;
}

RemoteDeckList_TreeModel::FileNode *RemoteDeckList_TreeModel::DirectoryNode::getNodeById(int id) const
{
	for (int i = 0; i < size(); ++i) {
		DirectoryNode *node = dynamic_cast<DirectoryNode *>(at(i));
		if (node) {
			FileNode *result = node->getNodeById(id);
			if (result)
				return result;
		} else {
			FileNode *file = dynamic_cast<FileNode *>(at(i));
			if (file->getId() == id)
				return file;
		}
	}
	return 0;
}

RemoteDeckList_TreeModel::RemoteDeckList_TreeModel(Client *_client, QObject *parent)
	: QAbstractItemModel(parent), client(_client)
{
	QFileIconProvider fip;
	dirIcon = fip.icon(QFileIconProvider::Folder);
	fileIcon = fip.icon(QFileIconProvider::File);

	root = new DirectoryNode;
	refreshTree();
}

RemoteDeckList_TreeModel::~RemoteDeckList_TreeModel()
{
	delete root;
}

int RemoteDeckList_TreeModel::rowCount(const QModelIndex &parent) const
{
	DirectoryNode *node = getNode<DirectoryNode *>(parent);
	if (node)
		return node->size();
	else
		return 0;
}

int RemoteDeckList_TreeModel::columnCount(const QModelIndex &/*parent*/) const
{
	return 3;
}

QVariant RemoteDeckList_TreeModel::data(const QModelIndex &index, int role) const
{
	if (!index.isValid())
		return QVariant();
	if (index.column() >= 3)
		return QVariant();

	Node *temp = static_cast<Node *>(index.internalPointer());
	FileNode *file = dynamic_cast<FileNode *>(temp);
	if (!file) {
		DirectoryNode *node = dynamic_cast<DirectoryNode *>(temp);
		switch (role) {
			case Qt::DisplayRole: {
				switch (index.column()) {
					case 0: return node->getName();
					default:
						return QVariant();
				}
			}
			case Qt::DecorationRole:
				return index.column() == 0 ? dirIcon : QVariant();
			default: return QVariant();
		}
	} else {
		switch (role) {
			case Qt::DisplayRole: {
				switch (index.column()) {
					case 0: return file->getName();
					case 1: return file->getId();
					case 2: return file->getUploadTime();
					default:
						return QVariant();
				}
			}
			case Qt::DecorationRole:
				return index.column() == 0 ? fileIcon : QVariant();
			case Qt::TextAlignmentRole:
				return index.column() == 1 ? Qt::AlignRight : Qt::AlignLeft;
			default: return QVariant();
		}
	}
}

QVariant RemoteDeckList_TreeModel::headerData(int section, Qt::Orientation orientation, int role) const
{
	if (orientation != Qt::Horizontal)
		return QVariant();
	switch (role) {
		case Qt::TextAlignmentRole:
			return section == 1 ? Qt::AlignRight : Qt::AlignLeft;
		case Qt::DisplayRole: {
			switch (section) {
				case 0: return tr("Name");
				case 1: return tr("ID");
				case 2: return tr("Upload time");
				default: return QVariant();
			}
		}
		default: return QVariant();
	}
}

QModelIndex RemoteDeckList_TreeModel::index(int row, int column, const QModelIndex &parent) const
{
	if (!hasIndex(row, column, parent))
		return QModelIndex();

	DirectoryNode *parentNode = getNode<DirectoryNode *>(parent);
	if (row >= parentNode->size())
		return QModelIndex();

	return createIndex(row, column, parentNode->at(row));
}

QModelIndex RemoteDeckList_TreeModel::parent(const QModelIndex &ind) const
{
	if (!ind.isValid())
		return QModelIndex();

	return nodeToIndex(static_cast<Node *>(ind.internalPointer())->getParent());
}

Qt::ItemFlags RemoteDeckList_TreeModel::flags(const QModelIndex &index) const
{
	if (!index.isValid())
		return 0;

	return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}

QModelIndex RemoteDeckList_TreeModel::nodeToIndex(Node *node) const
{
	if (node == root)
		return QModelIndex();
	return createIndex(node->getParent()->indexOf(node), 0, node);
}

void RemoteDeckList_TreeModel::addFileToTree(DeckList_File *file, DirectoryNode *parent)
{
	beginInsertRows(nodeToIndex(parent), parent->size(), parent->size());
	parent->append(new FileNode(file->getName(), file->getId(), file->getUploadTime(), parent));
	endInsertRows();
}

void RemoteDeckList_TreeModel::addFolderToTree(DeckList_Directory *folder, DirectoryNode *parent)
{
	addFolderToTree(folder->getName(), folder->getTreeItems(), parent);
}

void RemoteDeckList_TreeModel::addFolderToTree(const QString &name, const QList<DeckList_TreeItem *> &folderItems, DirectoryNode *parent)
{
	DirectoryNode *newItem = new DirectoryNode(name, parent);
	beginInsertRows(nodeToIndex(parent), parent->size(), parent->size());
	parent->append(newItem);
	endInsertRows();
	
	for (int i = 0; i < folderItems.size(); ++i) {
		DeckList_Directory *subFolder = dynamic_cast<DeckList_Directory *>(folderItems[i]);
		if (subFolder)
			addFolderToTree(subFolder, newItem);
		else
			addFileToTree(dynamic_cast<DeckList_File *>(folderItems[i]), newItem);
	}
}

void RemoteDeckList_TreeModel::removeNode(RemoteDeckList_TreeModel::Node *node)
{
	int ind = node->getParent()->indexOf(node);
	beginRemoveRows(nodeToIndex(node->getParent()), ind, ind);
	node->getParent()->removeAt(ind);
	endRemoveRows();
	delete node;
}

void RemoteDeckList_TreeModel::refreshTree()
{
	Command_DeckList *command = new Command_DeckList;
	connect(command, SIGNAL(finished(ProtocolResponse *)), this, SLOT(deckListFinished(ProtocolResponse *)));
	client->sendCommand(command);
}

void RemoteDeckList_TreeModel::deckListFinished(ProtocolResponse *r)
{
	Response_DeckList *resp = qobject_cast<Response_DeckList *>(r);
	if (!resp)
		return;

	root->clearTree();
	reset();
	
	addFolderToTree(resp->getRoot(), root);
	emit treeRefreshed();
}

RemoteDeckList_TreeWidget::RemoteDeckList_TreeWidget(Client *_client, QWidget *parent)
	: QTreeView(parent)
{
	treeModel = new RemoteDeckList_TreeModel(_client, this);
	proxyModel = new QSortFilterProxyModel(this);
	proxyModel->setSourceModel(treeModel);
	proxyModel->setDynamicSortFilter(true);
	proxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
	setModel(proxyModel);
	connect(treeModel, SIGNAL(treeRefreshed()), this, SLOT(expandAll()));

	header()->setResizeMode(QHeaderView::ResizeToContents);
	setUniformRowHeights(true);
	setSortingEnabled(true);
	proxyModel->sort(0, Qt::AscendingOrder);
	header()->setSortIndicator(0, Qt::AscendingOrder);
}

RemoteDeckList_TreeModel::Node *RemoteDeckList_TreeWidget::getNode(const QModelIndex &ind) const
{
	return treeModel->getNode<RemoteDeckList_TreeModel::Node *>(proxyModel->mapToSource(ind));
}

RemoteDeckList_TreeModel::Node *RemoteDeckList_TreeWidget::getCurrentItem() const
{
	return getNode(selectionModel()->currentIndex());
}

RemoteDeckList_TreeModel::DirectoryNode *RemoteDeckList_TreeWidget::getNodeByPath(const QString &path) const
{
	return treeModel->getRoot()->getNodeByPath(path.split("/"));
}

RemoteDeckList_TreeModel::FileNode *RemoteDeckList_TreeWidget::getNodeById(int id) const
{
	return treeModel->getRoot()->getNodeById(id);
}

void RemoteDeckList_TreeWidget::addFileToTree(DeckList_File *file, RemoteDeckList_TreeModel::DirectoryNode *parent)
{
	treeModel->addFileToTree(file, parent);
}

void RemoteDeckList_TreeWidget::addFolderToTree(DeckList_Directory *folder, RemoteDeckList_TreeModel::DirectoryNode *parent)
{
	treeModel->addFolderToTree(folder, parent);
}

void RemoteDeckList_TreeWidget::addFolderToTree(const QString &name, RemoteDeckList_TreeModel::DirectoryNode *parent)
{
	treeModel->addFolderToTree(name, QList<DeckList_TreeItem *>(), parent);
}

void RemoteDeckList_TreeWidget::removeNode(RemoteDeckList_TreeModel::Node *node)
{
	treeModel->removeNode(node);
}

void RemoteDeckList_TreeWidget::refreshTree()
{
	treeModel->refreshTree();
}