simpletreemodel.cpp

// SPDX-License-Identifier: MIT
// Copyright (c) 2026, Meld Studio, Inc.

#include "simpletreemodel.h"

#include <QtCore/QVariantMap>

using namespace Qt::Literals::StringLiterals;

// =============================================================================
// Construction / Destruction
// =============================================================================

SimpleTreeModel::SimpleTreeModel(QObject *parent)
    : QAbstractItemModel(parent)
    , m_root(new Node)
{
}

SimpleTreeModel::~SimpleTreeModel()
{
    delete m_root;
}

// =============================================================================
// QAbstractItemModel interface
// =============================================================================

QModelIndex SimpleTreeModel::index(int row, int column,
                                   const QModelIndex &parent) const
{
    Node *parentNode = nodeForIndex(parent);
    if (row < 0 || row >= parentNode->children.size())
        return {};
    if (column < 0 || column >= 1)
        return {};
    return createIndex(row, column, parentNode->children.at(row));
}

QModelIndex SimpleTreeModel::parent(const QModelIndex &child) const
{
    if (!child.isValid())
        return {};
    Node *node = nodeForIndex(child);
    if (!node || !node->parent || node->parent == m_root)
        return {};
    return indexForNode(node->parent);
}

int SimpleTreeModel::rowCount(const QModelIndex &parent) const
{
    return nodeForIndex(parent)->children.size();
}

int SimpleTreeModel::columnCount(const QModelIndex & /*parent*/) const
{
    return 1;
}

QVariant SimpleTreeModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid())
        return {};
    if (role != Qt::DisplayRole && role != Qt::EditRole)
        return {};
    return nodeForIndex(index)->name;
}

bool SimpleTreeModel::setData(const QModelIndex &index, const QVariant &value,
                               int role)
{
    if (!index.isValid())
        return false;
    if (role != Qt::DisplayRole && role != Qt::EditRole)
        return false;

    Node *node = nodeForIndex(index);
    const QString newName = value.toString();
    if (node->name == newName)
        return false;

    node->name = newName;
    emit dataChanged(index, index, {role});
    return true;
}

Qt::ItemFlags SimpleTreeModel::flags(const QModelIndex &index) const
{
    if (!index.isValid())
        return Qt::ItemIsDropEnabled; // Allow drops on the invisible root
    return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable
           | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
}

QHash<int, QByteArray> SimpleTreeModel::roleNames() const
{
    return {
        {Qt::DisplayRole, "display"},
        {Qt::EditRole, "edit"},
    };
}

// =============================================================================
// Row manipulation
// =============================================================================

bool SimpleTreeModel::insertRows(int row, int count,
                                  const QModelIndex &parent)
{
    Node *parentNode = nodeForIndex(parent);
    if (row < 0 || row > parentNode->children.size() || count <= 0)
        return false;

    beginInsertRows(parent, row, row + count - 1);
    for (int i = 0; i < count; ++i) {
        auto *node = new Node;
        node->parent = parentNode;
        parentNode->children.insert(row + i, node);
    }
    endInsertRows();
    return true;
}

bool SimpleTreeModel::removeRows(int row, int count,
                                  const QModelIndex &parent)
{
    Node *parentNode = nodeForIndex(parent);
    if (row < 0 || count <= 0 || row + count > parentNode->children.size())
        return false;

    beginRemoveRows(parent, row, row + count - 1);
    for (int i = 0; i < count; ++i) {
        Node *child = parentNode->children.takeAt(row);
        delete child;
    }
    endRemoveRows();
    return true;
}

bool SimpleTreeModel::moveRows(const QModelIndex &sourceParent,
                                int sourceRow, int count,
                                const QModelIndex &destinationParent,
                                int destinationChild)
{
    Node *srcParent = nodeForIndex(sourceParent);
    Node *dstParent = nodeForIndex(destinationParent);

    if (sourceRow < 0 || count <= 0
        || sourceRow + count > srcParent->children.size()) {
        return false;
    }
    if (destinationChild < 0 || destinationChild > dstParent->children.size())
        return false;

    // Prevent moving into own subtree: walk dstParent up to see if it's a
    // descendant of any of the items being moved.
    for (int i = 0; i < count; ++i) {
        Node *movingNode = srcParent->children.at(sourceRow + i);
        Node *check = dstParent;
        while (check) {
            if (check == movingNode)
                return false;
            check = check->parent;
        }
    }

    if (!beginMoveRows(sourceParent, sourceRow, sourceRow + count - 1,
                       destinationParent, destinationChild)) {
        return false;
    }

    QList<Node *> moved;
    moved.reserve(count);
    for (int i = 0; i < count; ++i)
        moved.append(srcParent->children.takeAt(sourceRow));

    // When moving within the same parent, Qt's beginMoveRows already accounts
    // for the shifted indices, but our actual data structure needs the adjusted
    // insert position since we already removed the items above.
    int insertAt = destinationChild;
    if (srcParent == dstParent && sourceRow < destinationChild)
        insertAt -= count;

    for (int i = 0; i < count; ++i) {
        moved[i]->parent = dstParent;
        dstParent->children.insert(insertAt + i, moved[i]);
    }

    endMoveRows();
    return true;
}

// =============================================================================
// QML convenience methods
// =============================================================================

void SimpleTreeModel::appendRow(const QVariant &data)
{
    const QString name = extractName(data);
    addChild(name, m_root);
}

void SimpleTreeModel::appendRow(const QModelIndex &parent, const QVariant &data)
{
    const QString name = extractName(data);
    Node *parentNode = nodeForIndex(parent);
    addChild(name, parentNode);
}

void SimpleTreeModel::removeItem(const QModelIndex &index)
{
    if (!index.isValid())
        return;
    removeRows(index.row(), 1, index.parent());
}

bool SimpleTreeModel::setData(const QModelIndex &index, const QVariant &value,
                               const QString &roleName)
{
    const QHash<int, QByteArray> roles = roleNames();
    const QByteArray roleNameBytes = roleName.toUtf8();
    for (auto it = roles.constBegin(); it != roles.constEnd(); ++it) {
        if (it.value() == roleNameBytes)
            return setData(index, value, it.key());
    }
    return false;
}

// =============================================================================
// C++ convenience
// =============================================================================

SimpleTreeModel::Node *SimpleTreeModel::rootNode() const
{
    return m_root;
}

SimpleTreeModel::Node *SimpleTreeModel::nodeForIndex(const QModelIndex &index) const
{
    if (!index.isValid())
        return m_root;
    return static_cast<Node *>(index.internalPointer());
}

QModelIndex SimpleTreeModel::indexForNode(Node *node) const
{
    if (!node || node == m_root)
        return {};
    Node *p = node->parent;
    if (!p)
        return {};
    const int row = p->children.indexOf(node);
    if (row < 0)
        return {};
    return createIndex(row, 0, node);
}

SimpleTreeModel::Node *SimpleTreeModel::addChild(const QString &name,
                                                   Node *parent)
{
    if (!parent)
        parent = m_root;
    const int row = parent->children.size();
    beginInsertRows(indexForNode(parent), row, row);
    auto *node = new Node;
    node->name = name;
    node->parent = parent;
    parent->children.append(node);
    endInsertRows();
    return node;
}

// =============================================================================
// Internal helpers
// =============================================================================

QString SimpleTreeModel::extractName(const QVariant &data)
{
    // Use toMap() which handles both QVariantMap and QJSValue (from QML).
    const QVariantMap map = data.toMap();
    if (!map.isEmpty()) {
        // Try "name" first (matches the demo's convention), then "display"
        if (map.contains(u"name"_s))
            return map.value(u"name"_s).toString();
        if (map.contains(u"display"_s))
            return map.value(u"display"_s).toString();
    }
    // Fallback: treat the entire variant as a string
    return data.toString();
}