//
// Created by grimmauld on 25.02.24.
//

#include "PsTreeModel.h"

PsTreeModel::PsTreeModel(QObject *parent) : QAbstractItemModel(parent), rootItem(get_process_records()) {}

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

    const ProcessTreeNode *parentItem = parent.isValid()
                                        ? static_cast<ProcessTreeNode *>(parent.internalPointer())
                                        : &rootItem;

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

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

    auto *childItem = static_cast<ProcessTreeNode *>(index.internalPointer());
    ProcessTreeNode *parentItem = childItem->parentItem();

    return parentItem != &rootItem
           ? createIndex(parentItem->row(), 0, parentItem) : QModelIndex{};
}

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

    const ProcessTreeNode *parentItem = parent.isValid()
                                        ? static_cast<const ProcessTreeNode *>(parent.internalPointer())
                                        : &rootItem;

    return parentItem->childCount();
}

int PsTreeModel::columnCount(const QModelIndex &parent) const {
    if (parent.isValid())
        return static_cast<ProcessTreeNode *>(parent.internalPointer())->columnCount();
    return ProcessTreeNode{}.columnCount();
}

QVariant PsTreeModel::data(const QModelIndex &index, int role) const {
    if (!index.isValid() || role != Qt::DisplayRole)
        return {};

    const auto *item = static_cast<const ProcessTreeNode *>(index.internalPointer());
    return item->data(index.column());
}

Qt::ItemFlags PsTreeModel::flags(const QModelIndex &index) const {
    return index.isValid()
           ? QAbstractItemModel::flags(index) : Qt::ItemFlags(Qt::NoItemFlags);
}

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

    return ProcessTreeNode{}.headerData(section);
}

void PsTreeModel::update() {
    auto changes = update_process_records(&rootItem);

    QList<QPersistentModelIndex> changedParents{};
    for(auto* node: changes) {
        changedParents.push_back(createIndex(node->row(), 0, node));
    }
    layoutAboutToBeChanged(changedParents);
}