ResultModel.cpp

#include "ResultModel.hpp"
#include "ResultModel.hpp"

#include <QApplication>
#include <QDebug>
#include <QQueue>

inline Node* indexToNode(const QModelIndex& index)
{
	return static_cast<Node*>(index.internalPointer());
}

class Node
{
public:
	Node(Node* parent, const QMap<Qt::ItemDataRole, QVariant>& data) :
		_parent(parent),
		_data(data)
	{
	}

	~Node()
	{
		qDeleteAll(_children);
		qDebug() << _data[Qt::DisplayRole];
	}

	Node* parent() const
	{
		return _parent;
	}

	Node* childAt(int index) const
	{
		return _children.at(index);
	}

	Node* takeChild(int index)
	{
		return _children.takeAt(index);
	}

	QVector<Node*> takeChildren(const std::function<bool(const Node*)>& lambda)
	{
		QVector<Node*> result;

		int i = childCount();

		while (i--)
		{
			if (lambda(childAt(i)))
			{
				result.append(takeChild(i));
			}
		}

		return result;
	}

	Node* appendChild(const QMap<Qt::ItemDataRole, QVariant>& data)
	{
		Node* child = new Node(this, data);
		_children.append(child);
		return child;
	}

	QVector<Node*> findChildren(const std::function<bool(const Node*)>& lambda) const
	{
		QVector<Node*> results;
		QQueue<Node*> queue;
		queue.enqueue(const_cast<Node*>(this));

		while (!queue.empty())
		{
			Node* node = queue.dequeue();

			for (Node* child : node->_children)
			{
				queue.enqueue(child);
			}

			if (lambda(node))
			{
				results.push_back(node);
			}
		}

		return results;
	}

	Node* findChild(const std::function<bool(const Node*)>& lambda) const
	{
		auto children = findChildren(lambda);
		return children.isEmpty() ? nullptr : children.first();
	}

	int parentRow() const
	{
		return _parent ? _parent->_children.indexOf(const_cast<Node*>(this)) : 0;
	}

	int childCount() const
	{
		return _children.size();
	}

	bool hasChildren() const
	{
		return !_children.isEmpty();
	}

	QVariant& data(Qt::ItemDataRole role)
	{
		return _data[role];
	}

	QVariant value(Qt::ItemDataRole role, const QVariant& defaultValue = QVariant()) const
	{
		return _data.value(role, defaultValue);
	}

private:
	Node* _parent;
	QVector<Node*> _children;
	QMap<Qt::ItemDataRole, QVariant> _data;
};


ResultModel::ResultModel(QObject *parent) :
	QAbstractItemModel(parent),
	_root(new Node(nullptr, { { Qt::DisplayRole, "root" } }))
{
}

ResultModel::~ResultModel()
{
	delete _root;
}

QModelIndex ResultModel::index(int row, int column, const QModelIndex& parentIndex) const
{
	if (!hasIndex(row, column, parentIndex))
	{
		return QModelIndex();
	}

	Node* parent= parentIndex.isValid() ? indexToNode(parentIndex) : _root;
	Node* child = parent ->childAt(row);
	return child ? createIndex(row, column, child) : QModelIndex();
}

QModelIndex ResultModel::parent(const QModelIndex& childIndex) const
{
	if (!childIndex.isValid())
	{
		return QModelIndex();
	}

	Node* parentNode = indexToNode(childIndex)->parent();

	return parentNode != _root ?
		createIndex(parentNode->parentRow(), 0, parentNode) :
		QModelIndex();
}

int ResultModel::rowCount(const QModelIndex& parentIndex) const
{
	return parentIndex.isValid() ?
		indexToNode(parentIndex)->childCount() :
		_root->childCount();
}

int ResultModel::columnCount(const QModelIndex&) const
{
	return 2;
}

QVariant ResultModel::data(const QModelIndex& index, int role) const
{
	if (!index.isValid())
	{
		return QVariant();
	}

	Node* item = indexToNode(index);
	bool topLevel = item->parent() == _root;
	bool hashCell = index.column() == 0 && topLevel;
	bool pathCell = index.column() == 1 && !topLevel;

	if (role == Qt::DisplayRole)
	{
		if (hashCell || pathCell)
		{
			return item->data(Qt::DisplayRole);
		}
	}

	if (role == Qt::CheckStateRole)
	{
		if (pathCell)
		{
			return item->data(Qt::CheckStateRole);
		}
	}

	return QVariant();
}

bool ResultModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
	Node* item = indexToNode(index);
	bool topLevel = item->parent() == _root;
	bool pathCell = index.column() == 1 && !topLevel;

	if (role == Qt::CheckStateRole && pathCell)
	{
		if (value == Qt::CheckState::Checked)
		{
			++_selectedCount;
		}
		else if (value == Qt::CheckState::Unchecked)
		{
			--_selectedCount;
		}
		else
		{
			qDebug() << "Invalid check state value:" << value;
			return false;
		}

		item->data(Qt::CheckStateRole) = value;
		emit dataChanged(index, index);
		return true;
	}

	return false;
}

QVariant ResultModel::headerData(int section, Qt::Orientation orientation, int role) const
{
	if (orientation != Qt::Horizontal || role != Qt::DisplayRole)
	{
		return QVariant();
	}

	switch (section)
	{
		case 0:
			return "Hash";
		case 1:
			return "Path";
	}

	return QVariant();
}

Qt::ItemFlags ResultModel::flags(const QModelIndex& index) const
{
	if (index.column() != 1)
	{
		return Qt::ItemIsEnabled;
	}

	return Qt::ItemIsEnabled | Qt::ItemIsUserCheckable;
}

void ResultModel::clear()
{
	beginResetModel();
	delete _root;
	_root = new Node(nullptr, { { Qt::DisplayRole, "root" } });
	_totalCount = 0;
	_selectedCount = 0;
	endResetModel();
}

void ResultModel::addPath(const QString& hash, const QString& filePath)
{
	Node* hashNode = _root->findChild([&hash](const Node* node)
	{
		return node->value(Qt::DisplayRole).toString() == hash;
	});

	if (!hashNode)
	{
		hashNode = _root->appendChild({ { Qt::DisplayRole, hash } });
	}

	beginInsertRows(QModelIndex(), 0, 1);
	hashNode->appendChild({ { Qt::DisplayRole, filePath }, { Qt::CheckStateRole, false } });
	++_totalCount;
	endInsertRows();
}

QStringList ResultModel::selectedPaths() const
{
	QStringList results;

	auto isChecked = [&](const Node* node)
	{
		return node->value(Qt::CheckStateRole) == Qt::CheckState::Checked;
	};

	for (Node* node : _root->findChildren(isChecked))
	{
		results.append(node->data(Qt::DisplayRole).toString());
	}

	return results;
}

int ResultModel::totalCount() const
{
	return _totalCount;
}

int ResultModel::selectedCount() const
{
	return _selectedCount;
}

void ResultModel::removePath(const QString& filePath)
{
	const auto pathEquals = [&](const Node* node)
	{
		return node->value(Qt::DisplayRole).toString() == filePath;
	};

	int i = _root->childCount();

	beginResetModel();

	while (i--)
	{
		Node* hashNode = _root->childAt(i);

		for (Node* pathNode : hashNode->takeChildren(pathEquals))
		{
			if (pathNode->data(Qt::CheckStateRole) == Qt::CheckState::Checked)
			{
				--_selectedCount;
			}

			delete pathNode;
			--_totalCount;
		}

		if (hashNode->childCount() < 2)
		{
			if (hashNode->childAt(0)->data(Qt::CheckStateRole) == Qt::CheckState::Checked)
			{
				--_selectedCount;
			}

			--_totalCount;
			delete _root->takeChild(i);
		}
	}

	endResetModel();
}