
#include "treemodel.h"
#include "treeitem.h"

#include <QtWidgets>

TreeModel::TreeModel(const QStringList& headers, const QString& data, QObject* parent)
	: QAbstractItemModel(parent)
{
	QVector<QVariant> rootData;
	for (const QString& header : headers)
		rootData << header;

	rootItem = new TreeItem(rootData);
	// setupModelData(data.split('\n'), rootItem);
}

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

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

//	if (role != Qt::DisplayRole && role != Qt::EditRole)
//		return QVariant();

//	TreeItem* item = getItem(index);

//	return item->data(index.column());
//}
{
    if (!index.isValid())
        return QVariant();

    TreeItem *item = getItem(index);
    if (role == Qt::DisplayRole)
    {
        return item->data(index.column());
    }
    else if (role == Qt::DecorationRole) {
        return item->getIcon(index.column());
    }
    else if (role == Qt::CheckStateRole)
    {
        if (item->checkable(index.column()))
        {
            return item->isChecked() ? Qt::Checked : Qt::Unchecked;
        }
        return QVariant();
    }
    return QVariant();
}


QVariant TreeModel::headerData(int section, Qt::Orientation orientation, int role) const
{
	if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
		return rootItem->data(section);

	return QVariant();
}

QModelIndex TreeModel::index(int row, int column, const QModelIndex& parent) const
{
	if (parent.isValid() && parent.column() != 0)
		return QModelIndex();

	TreeItem* parentItem = getItem(parent);
	if (!parentItem)
		return QModelIndex();

	TreeItem* childItem = parentItem->child(row);
	if (childItem)
		return createIndex(row, column, childItem);
	return QModelIndex();
}

int TreeModel::columnCount(const QModelIndex& parent) const
{
	Q_UNUSED(parent);
	return rootItem->columnCount();
}

Qt::ItemFlags TreeModel::flags(const QModelIndex& index) const
//{
//	if (!index.isValid())
//		return Qt::NoItemFlags;

//	return Qt::ItemIsEditable | QAbstractItemModel::flags(index);
//}
{
    if (!index.isValid())
        return QAbstractItemModel::flags(index);

    Qt::ItemFlags flags = QAbstractItemModel::flags(index);
    TreeItem *item = getItem(index);
    if (item->checkable(index.column()))
    {
        flags |= Qt::ItemIsUserCheckable;
    }
    return flags;
}



TreeItem* TreeModel::getItem(const QModelIndex& index) const
{
	if (index.isValid())
	{
		TreeItem* item = static_cast<TreeItem*>(index.internalPointer());
		if (item)
			return item;
	}
	return rootItem;
}

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

	TreeItem* childItem = getItem(index);
	TreeItem* parentItem = childItem ? childItem->parent() : nullptr;

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

	return createIndex(parentItem->childNumber(), 0, parentItem);
}

bool TreeModel::insertColumns(int position, int columns, const QModelIndex& parent)
{
	beginInsertColumns(parent, position, position + columns - 1);
	const bool success = rootItem->insertColumns(position, columns);
	endInsertColumns();

	return success;
}

bool TreeModel::insertRows(int position, int rows, const QModelIndex& parent)
{
	TreeItem* parentItem = getItem(parent);
	if (!parentItem)
		return false;

	beginInsertRows(parent, position, position + rows - 1);
	const bool success = parentItem->insertChildren(position,
		rows,
		rootItem->columnCount());
	endInsertRows();

	return success;
}

bool TreeModel::removeColumns(int position, int columns, const QModelIndex& parent)
{
	beginRemoveColumns(parent, position, position + columns - 1);
	const bool success = rootItem->removeColumns(position, columns);
	endRemoveColumns();

	if (rootItem->columnCount() == 0)
		removeRows(0, rowCount());

	return success;
}

bool TreeModel::removeRows(int position, int rows, const QModelIndex& parent)
{
	TreeItem* parentItem = getItem(parent);
	if (!parentItem)
		return false;

	beginRemoveRows(parent, position, position + rows - 1);
	const bool success = parentItem->removeChildren(position, rows);
	endRemoveRows();

	return success;
}


void TreeModel::setRootItem(TreeItem* item)
{
	TreeItem* tempItem = rootItem;
	
	this->beginResetModel();
	rootItem = item;
	this->endResetModel();

	if (tempItem)
	{
		delete tempItem;
		tempItem = nullptr;
	}
}

TreeItem* TreeModel::getRootItem()
{
	return rootItem;
}

void TreeModel::updateData()
{
	this->beginResetModel();
	this->endResetModel();
}

int TreeModel::rowCount(const QModelIndex& parent) const
{
	const TreeItem* parentItem = getItem(parent);

	return parentItem ? parentItem->childCount() : 0;
}


bool TreeModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
    if (!index.isValid())
        return false;

    if (role == Qt::CheckStateRole)
    {
        TreeItem *item = getItem(index);
        if (!item->checkable(index.column()))
        {
            return false;
        }

        item->setChecked(value.toInt() == Qt::Checked);
        emit dataChanged(index, index);
        return true;
    }
    return false;
}


bool TreeModel::setHeaderData(int section, Qt::Orientation orientation, const QVariant& value, int role)
{
	if (role != Qt::EditRole || orientation != Qt::Horizontal)
		return false;

	const bool result = rootItem->setData(section, value);

	if (result)
		emit headerDataChanged(orientation, section, section);

	return result;
}

void TreeModel::setupModelData(const QStringList& lines, TreeItem* parent)
{
	QVector<TreeItem*> parents;
	QVector<int> indentations;
	parents << parent;
	indentations << 0;

	int number = 0;

	while (number < lines.count()) 
	{
		int position = 0;
		while (position < lines[number].length()) 
		{
			if (lines[number].at(position) != ' ')
				break;
			++position;
		}

		const QString lineData = lines[number].mid(position).trimmed();

		if (!lineData.isEmpty())
		{
			// Read the column data from the rest of the line.
			const QStringList columnStrings =
				lineData.split(QLatin1Char('\t'), Qt::SkipEmptyParts);
			QVector<QVariant> columnData;
			columnData.reserve(columnStrings.size());
			for (const QString& columnString : columnStrings)
				columnData << columnString;

			if (position > indentations.last()) {
				// The last child of the current parent is now the new parent
				// unless the current parent has no children.

				if (parents.last()->childCount() > 0) {
					parents << parents.last()->child(parents.last()->childCount() - 1);
					indentations << position;
				}
			}
			else {
				while (position < indentations.last() && parents.count() > 0) {
					parents.pop_back();
					indentations.pop_back();
				}
			}

			// Append a new item to the current parent's list of children.
			TreeItem* parent = parents.last();
			parent->insertChildren(parent->childCount(), 1, rootItem->columnCount());
			for (int column = 0; column < columnData.size(); ++column)
				parent->child(parent->childCount() - 1)->setData(column, columnData[column]);
		}
		++number;
	}
}
