tst_qtreetotablemodel.cpp

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

#include "qtreetotablemodel.h"
#include "simpletreemodel.h"

#include <QtCore/QList>
#include <QtCore/QVariant>
#include <QtGui/QStandardItemModel>
#include <QtTest/QAbstractItemModelTester>
#include <QtTest/QSignalSpy>
#include <QtTest/QTest>

using namespace Qt::Literals::StringLiterals;

// =============================================================================
// Helpers
// =============================================================================

static QList<QString> collectFlattenedItems(QTreeToTableModel *proxy)
{
    QList<QString> result;
    result.reserve(proxy->rowCount());
    for (int i = 0; i < proxy->rowCount(); ++i)
        result.append(proxy->index(i, 0).data(Qt::DisplayRole).toString());
    return result;
}

static QList<int> collectDepths(QTreeToTableModel *proxy)
{
    QList<int> result;
    result.reserve(proxy->rowCount());
    for (int i = 0; i < proxy->rowCount(); ++i)
        result.append(proxy->depthForRow(i));
    return result;
}

struct TreeBuilder
{
    QStandardItemModel *model;

    explicit TreeBuilder(QStandardItemModel *m) : model(m) {}

    QStandardItem *addItem(const QString &name, QStandardItem *parent = nullptr)
    {
        auto *item = new QStandardItem(name);
        if (parent)
            parent->appendRow(item);
        else
            model->appendRow(item);
        return item;
    }

    QStandardItem *insertItem(const QString &name, int row, QStandardItem *parent = nullptr)
    {
        auto *item = new QStandardItem(name);
        if (parent)
            parent->insertRow(row, item);
        else
            model->insertRow(row, item);
        return item;
    }
};

// Diagnostic signal verification: returns a descriptive error string on mismatch,
// or an empty string on success. Used with VERIFY_ROW_SIGNAL / VERIFY_MOVE_SIGNAL
// macros so that file/line points to the test, not the helper.

static QString describeRowSignalMismatch(const QList<QVariant> &args, int first, int last)
{
    if (args.size() != 3)
        return u"Expected 3 args, got %1"_s.arg(args.size());
    if (args[0].toModelIndex().isValid())
        return u"Parent should be invalid (flat model)"_s;
    if (args[1].toInt() != first)
        return u"first: expected %1, got %2"_s.arg(first).arg(args[1].toInt());
    if (args[2].toInt() != last)
        return u"last: expected %1, got %2"_s.arg(last).arg(args[2].toInt());
    return {};
}

#define VERIFY_ROW_SIGNAL(args, first, last)                                                       \
    do {                                                                                           \
        const QString _msg = describeRowSignalMismatch(args, first, last);                         \
        QVERIFY2(_msg.isEmpty(), qPrintable(_msg));                                                \
    } while (false)

static QString describeMoveSignalMismatch(const QList<QVariant> &args,
                                          int sourceFirst,
                                          int sourceLast,
                                          int destRow)
{
    if (args.size() != 5)
        return u"Expected 5 args, got %1"_s.arg(args.size());
    if (args[0].toModelIndex().isValid())
        return u"Source parent should be invalid (flat model)"_s;
    if (args[3].toModelIndex().isValid())
        return u"Dest parent should be invalid (flat model)"_s;
    if (args[1].toInt() != sourceFirst)
        return u"sourceFirst: expected %1, got %2"_s.arg(sourceFirst).arg(args[1].toInt());
    if (args[2].toInt() != sourceLast)
        return u"sourceLast: expected %1, got %2"_s.arg(sourceLast).arg(args[2].toInt());
    if (args[4].toInt() != destRow)
        return u"destRow: expected %1, got %2"_s.arg(destRow).arg(args[4].toInt());
    return {};
}

#define VERIFY_MOVE_SIGNAL(args, sourceFirst, sourceLast, destRow)                                 \
    do {                                                                                           \
        const QString _msg = describeMoveSignalMismatch(args, sourceFirst, sourceLast, destRow);   \
        QVERIFY2(_msg.isEmpty(), qPrintable(_msg));                                                \
    } while (false)

/**
 * Bundles commonly-monitored model signals into a single struct, reducing
 * boilerplate in tests that need to verify which signals were emitted.
 * Includes both "aboutTo" and completion signals for full pair verification.
 */
struct ModelSignalSpies
{
    QSignalSpy rowsAboutToBeInserted;
    QSignalSpy rowsInserted;
    QSignalSpy rowsAboutToBeRemoved;
    QSignalSpy rowsRemoved;
    QSignalSpy rowsAboutToBeMoved;
    QSignalSpy rowsMoved;
    QSignalSpy dataChanged;
    QSignalSpy layoutAboutToBeChanged;
    QSignalSpy layoutChanged;
    QSignalSpy modelAboutToBeReset;
    QSignalSpy modelReset;

    explicit ModelSignalSpies(QAbstractItemModel *model)
        : rowsAboutToBeInserted(model, &QAbstractItemModel::rowsAboutToBeInserted)
        , rowsInserted(model, &QAbstractItemModel::rowsInserted)
        , rowsAboutToBeRemoved(model, &QAbstractItemModel::rowsAboutToBeRemoved)
        , rowsRemoved(model, &QAbstractItemModel::rowsRemoved)
        , rowsAboutToBeMoved(model, &QAbstractItemModel::rowsAboutToBeMoved)
        , rowsMoved(model, &QAbstractItemModel::rowsMoved)
        , dataChanged(model, &QAbstractItemModel::dataChanged)
        , layoutAboutToBeChanged(model, &QAbstractItemModel::layoutAboutToBeChanged)
        , layoutChanged(model, &QAbstractItemModel::layoutChanged)
        , modelAboutToBeReset(model, &QAbstractItemModel::modelAboutToBeReset)
        , modelReset(model, &QAbstractItemModel::modelReset)
    {
    }

    bool hadNoSignals() const
    {
        return rowsInserted.isEmpty() && rowsRemoved.isEmpty() && rowsMoved.isEmpty()
               && dataChanged.isEmpty() && layoutChanged.isEmpty() && modelReset.isEmpty();
    }

    bool hadOnlyMoveSignals() const
    {
        return !rowsMoved.isEmpty() && rowsInserted.isEmpty() && rowsRemoved.isEmpty()
               && dataChanged.isEmpty() && layoutChanged.isEmpty() && modelReset.isEmpty();
    }
};

// =============================================================================
// Test Class
// =============================================================================

class tst_QTreeToTableModel : public QObject
{
    Q_OBJECT

private Q_SLOTS:
    void init();
    void cleanup();

    // Basic construction and properties
    void defaultConstruction();
    void setSourceModelEmitsSignal();
    void setSameSourceModelDoesNotEmit();
    void setSourceModelToNullClears();
    void sourceModelDestroyedClears();

    // Flattening behavior
    void emptySourceModel();
    void singleItemTree();
    void flatTreePreservesOrder();
    void standardTreeFlattensCorrectly();
    void standardTreeDepthsCorrect();
    void deeplyNestedTree();

    // Root index
    void setRootIndexEmitsSignal();
    void setSameRootIndexDoesNotEmit();
    void rootIndexShowsOnlyDescendants();
    void rootIndexDepthsRelativeToRoot();
    void rootIndexOnLeafShowsNothing();
    void resetRootIndexShowsEntireTree();
    void rootIndexFromWrongModelRejected();
    void rootIndexRemovedResetsToInvalid();

    // Max depth
    void maxDepthDefaultIsZero();
    void maxDepthOneShowsOnlyTopLevel();
    void maxDepthTwoShowsTwoLevels();
    void maxDepthWithRootIndex();
    void setMaxDepthEmitsSignal();
    void negativeMaxDepthTreatedAsZero();

    // Count property
    void countProperty();
    void countUpdatesOnInsert();
    void countUpdatesOnRemove();

    // Mapping functions
    void mapToSourceCorrect();
    void mapFromSourceCorrect();
    void mapFromSourceHiddenIndex();
    void sourceIndexForRowWorks();
    void rowForSourceIndexWorks();
    void isSourceIndexVisibleWorks();
    void mapToSourceWithColumn();

    // QAbstractTableModel interface

    void rowCountOfChildIsZero();
    void columnCountMatchesSource();
    void dataForMultipleColumns();
    void setDataForwardsToSource();
    void flagsForwardToSource();
    void roleNamesIncludesDepthAndSourceIndex();
    void depthRoleReturnsCorrectValue();
    void sourceIndexRoleReturnsCorrectValue();

    // Row insertion signals
    void insertAtEndOfTopLevel();
    void insertAtBeginningOfTopLevel();
    void insertInMiddleOfTopLevel();
    void insertChildRow();
    void insertChildWithSubtree();
    void insertUnderNonVisibleParentIgnored();

    // Row removal signals
    void removeFromTopLevel();
    void removeFromMiddle();
    void removeWithSubtree();
    void removeUnderNonVisibleParentIgnored();

    // Row move signals
    void moveWithinSameParent();
    void moveWithinSameParentVerifySignalArgs();
    void moveBetweenDifferentParents();
    void moveBetweenDifferentParentsVerifySignalArgs();
    void moveEmitsRowsMovedNotRemoveInsert();
    void moveFromVisibleToInvisible();
    void moveFromInvisibleToVisible();

    // Data change signals
    void dataChangedForwarded();
    void dataChangedWithSubtree();

    // Layout change
    void layoutChangeRebuildsList();
    void layoutChangePersistentIndexes();

    // Column changes
    void columnsInsertedAtRoot();
    void columnsRemovedAtRoot();

    // Source model reset
    void sourceModelResetRebuilds();

    // QAbstractItemModelTester integration
    void modelTesterWithStandardTree();
    void modelTesterAfterInsertions();
    void modelTesterAfterRemovals();
    void modelTesterWithRootIndex();
    void modelTesterWithMaxDepth();

    // Edge cases
    void setSourceModelBeforeTreeIsBuilt();
    void insertRowsAfterSetSourceModel();
    void multipleInsertRemoveCycles();
    void insertAtMaxDepthBoundary();
    void moveAtMaxDepthBoundary();

    // Additional coverage
    void setDataOnReadOnlyRolesReturnsFalse();
    void dataWithInvalidIndexReturnsInvalid();
    void flagsWithInvalidIndexReturnsNone();
    void mapToSourceInvalidReturnsInvalid();
    void mapFromSourceInvalidReturnsInvalid();
    void columnCountWithNoSourceModel();
    void columnCountWithRootIndex();
    void headerDataForwarded();
    void headerDataChangedForwarded();
    void dumpDoesNotCrash();
    void removeAllItems();
    void changeRootIndexToDifferentSubtree();
    void insertUnderRootIndexParent();
    void moveWithSubtreePreservesDescendants();
    void modelTesterDuringMoves();
    void moveToSamePositionIsNoOp();
    void depthForRowInvalidReturnsMinusOne();
    void countPropertyAfterReset();
    void rootIndexClearedOnSourceModelChange();
    void maxDepthThreeShowsThreeLevels();
    void insertMultipleTopLevelItems();
    void removeMultipleConsecutiveItems();
    void dataChangedOutsideRootSubtreeIgnored();
    void dataChangedForSingleItemNoDescendants();
    void setDataForwardsToSourceWithColumn();
    void flagsForwardToSourceWithColumn();
    void moveWithRootIndexAndMaxDepth();
    void moveMultipleItemsAtOnce();
    void rootIndexMovedInSource();
    void insertAndRemoveWithModelTester();
    void removeRootIndexSubtreeResetsToFull();
    void moveBackAndForthPreservesState();
    void maxDepthZeroShowsAll();
    void setMaxDepthAfterRootIndex();
    void persistentIndexSurvivesInsert();
    void persistentIndexSurvivesRemove();
    void sourceModelResetWithRootIndexClears();
    void moveWithinSameParentDownward();
    void insertChildAtBeginningOfParent();
    void removeSingleChildLeaf();
    void wideTreeFlattensCorrectly();
    void deepTreeWithMaxDepthTruncates();

    // Stress and regression tests
    void largeTreePerformance();
    void rapidInsertRemoveCycle();
    void moveSubtreeAcrossDepthBoundary();
    void moveSubtreeDeeperFiltersDescendantsByMaxDepth();
    void moveSubtreeShallowerRevealsDescendantsAtMaxDepth();
    void rootIndexInvalidatedByModelReset();
    void dataChangedWithRoles();
    void multiColumnSourceModel();
    void removeMiddleChildPreservesSiblings();
    void insertBetweenExistingChildren();
    void setSourceModelMultipleTimes();
    void moveLastChildToFirstPosition();
    void countSignalEmittedOnLayoutChange();
    void mapFromSourceNonColumn0();
    void rootIndexSubtreeGrowsWithInsert();
    void maxDepthBoundaryInsertThenRemove();
    void moveWithinSameParentUpward();
    void indexOutOfRangeReturnsInvalid();
    void persistentIndexSurvivesMove();
    void persistentIndexSurvivesLayoutChange();
    void persistentIndexSurvivesLayoutChangeMultiColumn();

    // Signal pairing and new coverage tests
    void aboutToBeInsertedEmittedWithInserted();
    void aboutToBeRemovedEmittedWithRemoved();
    void aboutToBeMovedEmittedWithMoved();
    void layoutAboutToBeChangedEmittedWithChanged();
    void aboutToBeResetEmittedWithReset();
    void hasChildrenReturnsFalseForValidIndexes();
    void siblingReturnsCorrectIndex();
    void mapFromSourceForeignModelReturnsInvalid();
    void mapToSourceForeignModelReturnsInvalid();

    // isAncestorOf tests
    void isAncestorOfSameIndex();
    void isAncestorOfParentChild();
    void isAncestorOfGrandparentGrandchild();
    void isAncestorOfUnrelatedReturnsFalse();
    void isAncestorOfInvalidReturnsFalse();

    // moveSourceRow tests
    void moveSourceRowWithinParent();
    void moveSourceRowBetweenParents();
    void moveSourceRowIntoOwnSubtreeRejected();
    void moveSourceRowInvalidSourceRejected();
    void moveSourceRowAppendWithMinusOne();
    void moveSourceRowNoSourceModelRejected();
    void moveSourceRowToRootLevel();
    void moveSourceRowSelfDropRejected();
    void moveSourceRowOutOfRangeChildAppends();
    void moveSourceRowCrossDepthWithSubtree();

    // dataChanged signal tests for depth after move
    void moveSameDepthDoesNotEmitDepthChanged();
    void moveDifferentParentSameDepthDoesNotEmitDepthChanged();
    void moveCrossDepthEmitsDepthChanged();
    void moveCrossDepthSubtreeDataChangedCoversAllRows();

private:
    // Build a standard test tree:
    //   A
    //   ├── A1
    //   │   ├── A1a
    //   │   └── A1b
    //   ├── A2
    //   B
    //   ├── B1
    //   C
    //
    // Flattened depth-first: A, A1, A1a, A1b, A2, B, B1, C
    // Depths:                0,  1,   2,   2,  1, 0,  1, 0
    void buildStandardTree();

    std::unique_ptr<QStandardItemModel> m_sourceModel;
    std::unique_ptr<QTreeToTableModel> m_proxy;
    std::unique_ptr<QAbstractItemModelTester> m_tester;

    QStandardItem *m_itemA = nullptr;
    QStandardItem *m_itemA1 = nullptr;
    QStandardItem *m_itemA1a = nullptr;
    QStandardItem *m_itemA1b = nullptr;
    QStandardItem *m_itemA2 = nullptr;
    QStandardItem *m_itemB = nullptr;
    QStandardItem *m_itemB1 = nullptr;
    QStandardItem *m_itemC = nullptr;
};

void tst_QTreeToTableModel::init()
{
    m_sourceModel = std::make_unique<QStandardItemModel>();
    m_proxy = std::make_unique<QTreeToTableModel>();
    m_tester = std::make_unique<QAbstractItemModelTester>(
        m_proxy.get(), QAbstractItemModelTester::FailureReportingMode::Fatal);
}

void tst_QTreeToTableModel::cleanup()
{
    m_tester.reset();
    m_proxy.reset();
    m_sourceModel.reset();
    m_itemA = m_itemA1 = m_itemA1a = m_itemA1b = m_itemA2 = nullptr;
    m_itemB = m_itemB1 = nullptr;
    m_itemC = nullptr;
}

void tst_QTreeToTableModel::buildStandardTree()
{
    TreeBuilder builder(m_sourceModel.get());

    m_itemA = builder.addItem(u"A"_s);
    m_itemA1 = builder.addItem(u"A1"_s, m_itemA);
    m_itemA1a = builder.addItem(u"A1a"_s, m_itemA1);
    m_itemA1b = builder.addItem(u"A1b"_s, m_itemA1);
    m_itemA2 = builder.addItem(u"A2"_s, m_itemA);
    m_itemB = builder.addItem(u"B"_s);
    m_itemB1 = builder.addItem(u"B1"_s, m_itemB);
    m_itemC = builder.addItem(u"C"_s);
}

// =============================================================================
// Basic Construction and Properties
// =============================================================================

void tst_QTreeToTableModel::defaultConstruction()
{
    QCOMPARE(m_proxy->sourceModel(), nullptr);
    QVERIFY(!m_proxy->rootIndex().isValid());
    QCOMPARE(m_proxy->rowCount(), 0);
    QCOMPARE(m_proxy->maxDepth(), 0);
    QCOMPARE(m_proxy->count(), 0);
}

void tst_QTreeToTableModel::setSourceModelEmitsSignal()
{
    QSignalSpy spy(m_proxy.get(), &QTreeToTableModel::sourceModelChanged);
    QVERIFY(spy.isValid());

    m_proxy->setSourceModel(m_sourceModel.get());

    QCOMPARE(spy.size(), 1);
    QCOMPARE(m_proxy->sourceModel(), m_sourceModel.get());
}

void tst_QTreeToTableModel::setSameSourceModelDoesNotEmit()
{
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy spy(m_proxy.get(), &QTreeToTableModel::sourceModelChanged);
    QVERIFY(spy.isValid());

    m_proxy->setSourceModel(m_sourceModel.get());

    QCOMPARE(spy.size(), 0);
}

void tst_QTreeToTableModel::setSourceModelToNullClears()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    QVERIFY(m_proxy->rowCount() > 0);

    QSignalSpy resetSpy(m_proxy.get(), &QAbstractItemModel::modelReset);
    QVERIFY(resetSpy.isValid());

    m_proxy->setSourceModel(nullptr);

    QCOMPARE(m_proxy->sourceModel(), nullptr);
    QCOMPARE(m_proxy->rowCount(), 0);
    QCOMPARE(resetSpy.size(), 1);
}

void tst_QTreeToTableModel::sourceModelDestroyedClears()
{
    auto *tempModel = new QStandardItemModel;
    tempModel->appendRow(new QStandardItem(u"X"_s));
    m_proxy->setSourceModel(tempModel);
    QCOMPARE(m_proxy->rowCount(), 1);

    QSignalSpy resetSpy(m_proxy.get(), &QAbstractItemModel::modelReset);
    QVERIFY(resetSpy.isValid());

    delete tempModel;

    QCOMPARE(m_proxy->sourceModel(), nullptr);
    QCOMPARE(m_proxy->rowCount(), 0);
    QCOMPARE(resetSpy.size(), 1);
}

// =============================================================================
// Flattening Behavior
// =============================================================================

void tst_QTreeToTableModel::emptySourceModel()
{
    m_proxy->setSourceModel(m_sourceModel.get());
    QCOMPARE(m_proxy->rowCount(), 0);
}

void tst_QTreeToTableModel::singleItemTree()
{
    m_sourceModel->appendRow(new QStandardItem(u"Only"_s));
    m_proxy->setSourceModel(m_sourceModel.get());

    QCOMPARE(m_proxy->rowCount(), 1);
    QCOMPARE(m_proxy->index(0, 0).data().toString(), u"Only"_s);
}

void tst_QTreeToTableModel::flatTreePreservesOrder()
{
    m_sourceModel->appendRow(new QStandardItem(u"First"_s));
    m_sourceModel->appendRow(new QStandardItem(u"Second"_s));
    m_sourceModel->appendRow(new QStandardItem(u"Third"_s));
    m_proxy->setSourceModel(m_sourceModel.get());

    const auto items = collectFlattenedItems(m_proxy.get());
    QCOMPARE(items.size(), 3);
    QCOMPARE(items[0], u"First"_s);
    QCOMPARE(items[1], u"Second"_s);
    QCOMPARE(items[2], u"Third"_s);
}

void tst_QTreeToTableModel::standardTreeFlattensCorrectly()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    const auto items = collectFlattenedItems(m_proxy.get());
    QCOMPARE(items.size(), 8);
    QCOMPARE(items[0], u"A"_s);
    QCOMPARE(items[1], u"A1"_s);
    QCOMPARE(items[2], u"A1a"_s);
    QCOMPARE(items[3], u"A1b"_s);
    QCOMPARE(items[4], u"A2"_s);
    QCOMPARE(items[5], u"B"_s);
    QCOMPARE(items[6], u"B1"_s);
    QCOMPARE(items[7], u"C"_s);
}

void tst_QTreeToTableModel::standardTreeDepthsCorrect()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    const auto depths = collectDepths(m_proxy.get());
    QCOMPARE(depths.size(), 8);
    QCOMPARE(depths[0], 0); // A
    QCOMPARE(depths[1], 1); // A1
    QCOMPARE(depths[2], 2); // A1a
    QCOMPARE(depths[3], 2); // A1b
    QCOMPARE(depths[4], 1); // A2
    QCOMPARE(depths[5], 0); // B
    QCOMPARE(depths[6], 1); // B1
    QCOMPARE(depths[7], 0); // C
}

void tst_QTreeToTableModel::deeplyNestedTree()
{
    auto *root = new QStandardItem(u"L0"_s);
    m_sourceModel->appendRow(root);

    QStandardItem *current = root;
    for (int i = 1; i <= 5; ++i) {
        auto *child = new QStandardItem(u"L%1"_s.arg(i));
        current->appendRow(child);
        current = child;
    }

    m_proxy->setSourceModel(m_sourceModel.get());

    QCOMPARE(m_proxy->rowCount(), 6);
    for (int i = 0; i < 6; ++i)
        QCOMPARE(m_proxy->depthForRow(i), i);
}

// =============================================================================
// Root Index
// =============================================================================

void tst_QTreeToTableModel::setRootIndexEmitsSignal()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy spy(m_proxy.get(), &QTreeToTableModel::rootIndexChanged);
    QVERIFY(spy.isValid());

    m_proxy->setRootIndex(m_itemA->index());

    QCOMPARE(spy.size(), 1);
    QCOMPARE(m_proxy->rootIndex(), m_itemA->index());
}

void tst_QTreeToTableModel::setSameRootIndexDoesNotEmit()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());

    QSignalSpy spy(m_proxy.get(), &QTreeToTableModel::rootIndexChanged);
    QVERIFY(spy.isValid());

    m_proxy->setRootIndex(m_itemA->index());

    QCOMPARE(spy.size(), 0);
}

void tst_QTreeToTableModel::rootIndexShowsOnlyDescendants()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());

    // Should show: A1, A1a, A1b, A2 (NOT A itself)
    const auto items = collectFlattenedItems(m_proxy.get());
    QCOMPARE(items.size(), 4);
    QCOMPARE(items[0], u"A1"_s);
    QCOMPARE(items[1], u"A1a"_s);
    QCOMPARE(items[2], u"A1b"_s);
    QCOMPARE(items[3], u"A2"_s);
}

void tst_QTreeToTableModel::rootIndexDepthsRelativeToRoot()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());

    const auto depths = collectDepths(m_proxy.get());
    QCOMPARE(depths.size(), 4);
    QCOMPARE(depths[0], 0); // A1
    QCOMPARE(depths[1], 1); // A1a
    QCOMPARE(depths[2], 1); // A1b
    QCOMPARE(depths[3], 0); // A2
}

void tst_QTreeToTableModel::rootIndexOnLeafShowsNothing()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA1a->index());

    QCOMPARE(m_proxy->rowCount(), 0);
}

void tst_QTreeToTableModel::resetRootIndexShowsEntireTree()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());
    QCOMPARE(m_proxy->rowCount(), 4);

    QSignalSpy spy(m_proxy.get(), &QTreeToTableModel::rootIndexChanged);
    QVERIFY(spy.isValid());

    m_proxy->resetRootIndex();

    QCOMPARE(spy.size(), 1);
    QVERIFY(!m_proxy->rootIndex().isValid());
    QCOMPARE(m_proxy->rowCount(), 8);
}

void tst_QTreeToTableModel::rootIndexFromWrongModelRejected()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QStandardItemModel otherModel;
    otherModel.appendRow(new QStandardItem(u"Other"_s));

    QSignalSpy spy(m_proxy.get(), &QTreeToTableModel::rootIndexChanged);
    QVERIFY(spy.isValid());

    m_proxy->setRootIndex(otherModel.index(0, 0));

    QCOMPARE(spy.size(), 0);
    QVERIFY(!m_proxy->rootIndex().isValid());
}

void tst_QTreeToTableModel::rootIndexRemovedResetsToInvalid()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());

    QCOMPARE(m_proxy->rowCount(), 4);

    // Remove A from the source model
    m_sourceModel->removeRow(0);

    // Root index should have become invalid; model should reset
    QVERIFY(!m_proxy->rootIndex().isValid());
}

// =============================================================================
// Max Depth
// =============================================================================

void tst_QTreeToTableModel::maxDepthDefaultIsZero()
{
    QCOMPARE(m_proxy->maxDepth(), 0);
}

void tst_QTreeToTableModel::maxDepthOneShowsOnlyTopLevel()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setMaxDepth(1);

    // Only top-level: A, B, C
    const auto items = collectFlattenedItems(m_proxy.get());
    QCOMPARE(items.size(), 3);
    QCOMPARE(items[0], u"A"_s);
    QCOMPARE(items[1], u"B"_s);
    QCOMPARE(items[2], u"C"_s);

    const auto depths = collectDepths(m_proxy.get());
    for (int d : depths)
        QCOMPARE(d, 0);
}

void tst_QTreeToTableModel::maxDepthTwoShowsTwoLevels()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setMaxDepth(2);

    // Depth 0 and 1: A, A1, A2, B, B1, C
    const auto items = collectFlattenedItems(m_proxy.get());
    QCOMPARE(items.size(), 6);
    QCOMPARE(items[0], u"A"_s);
    QCOMPARE(items[1], u"A1"_s);
    QCOMPARE(items[2], u"A2"_s);
    QCOMPARE(items[3], u"B"_s);
    QCOMPARE(items[4], u"B1"_s);
    QCOMPARE(items[5], u"C"_s);
}

void tst_QTreeToTableModel::maxDepthWithRootIndex()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());
    m_proxy->setMaxDepth(1);

    // Root = A, maxDepth = 1: only direct children A1, A2
    const auto items = collectFlattenedItems(m_proxy.get());
    QCOMPARE(items.size(), 2);
    QCOMPARE(items[0], u"A1"_s);
    QCOMPARE(items[1], u"A2"_s);
}

void tst_QTreeToTableModel::setMaxDepthEmitsSignal()
{
    QSignalSpy spy(m_proxy.get(), &QTreeToTableModel::maxDepthChanged);
    QVERIFY(spy.isValid());

    m_proxy->setMaxDepth(2);

    QCOMPARE(spy.size(), 1);
    QCOMPARE(m_proxy->maxDepth(), 2);

    // Setting same value should not emit
    m_proxy->setMaxDepth(2);
    QCOMPARE(spy.size(), 1);
}

void tst_QTreeToTableModel::negativeMaxDepthTreatedAsZero()
{
    m_proxy->setMaxDepth(-5);
    QCOMPARE(m_proxy->maxDepth(), 0);
}

// =============================================================================
// Count Property
// =============================================================================

void tst_QTreeToTableModel::countProperty()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    QCOMPARE(m_proxy->count(), 8);
}

void tst_QTreeToTableModel::countUpdatesOnInsert()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy countSpy(m_proxy.get(), &QTreeToTableModel::countChanged);
    QVERIFY(countSpy.isValid());

    m_sourceModel->appendRow(new QStandardItem(u"D"_s));

    QCOMPARE(m_proxy->count(), 9);
    QCOMPARE(countSpy.size(), 1);
}

void tst_QTreeToTableModel::countUpdatesOnRemove()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy countSpy(m_proxy.get(), &QTreeToTableModel::countChanged);
    QVERIFY(countSpy.isValid());

    m_sourceModel->removeRow(2); // Remove C
    QCOMPARE(m_proxy->count(), 7);
    QCOMPARE(countSpy.size(), 1);
}

// =============================================================================
// Mapping Functions
// =============================================================================

void tst_QTreeToTableModel::mapToSourceCorrect()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    // Row 2 should be A1a
    QModelIndex proxyIdx = m_proxy->index(2, 0);
    QModelIndex sourceIdx = m_proxy->mapToSource(proxyIdx);

    QVERIFY(sourceIdx.isValid());
    QCOMPARE(sourceIdx, m_itemA1a->index());
}

void tst_QTreeToTableModel::mapFromSourceCorrect()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QModelIndex proxyIdx = m_proxy->mapFromSource(m_itemA1a->index());

    QVERIFY(proxyIdx.isValid());
    QCOMPARE(proxyIdx.row(), 2);
}

void tst_QTreeToTableModel::mapFromSourceHiddenIndex()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());

    // B is not under root A
    QModelIndex proxyIdx = m_proxy->mapFromSource(m_itemB->index());
    QVERIFY(!proxyIdx.isValid());
}

void tst_QTreeToTableModel::sourceIndexForRowWorks()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QCOMPARE(m_proxy->sourceIndexForRow(0), m_itemA->index());
    QCOMPARE(m_proxy->sourceIndexForRow(1), m_itemA1->index());
    QCOMPARE(m_proxy->sourceIndexForRow(5), m_itemB->index());
    QVERIFY(!m_proxy->sourceIndexForRow(-1).isValid());
    QVERIFY(!m_proxy->sourceIndexForRow(100).isValid());
}

void tst_QTreeToTableModel::rowForSourceIndexWorks()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QCOMPARE(m_proxy->rowForSourceIndex(m_itemA->index()), 0);
    QCOMPARE(m_proxy->rowForSourceIndex(m_itemA1->index()), 1);
    QCOMPARE(m_proxy->rowForSourceIndex(m_itemB->index()), 5);
    QCOMPARE(m_proxy->rowForSourceIndex(QModelIndex()), -1);
}

void tst_QTreeToTableModel::isSourceIndexVisibleWorks()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());

    QVERIFY(m_proxy->isSourceIndexVisible(m_itemA1->index()));
    QVERIFY(m_proxy->isSourceIndexVisible(m_itemA1a->index()));
    QVERIFY(!m_proxy->isSourceIndexVisible(m_itemA->index()));
    QVERIFY(!m_proxy->isSourceIndexVisible(m_itemB->index()));
}

void tst_QTreeToTableModel::mapToSourceWithColumn()
{
    auto *col0 = new QStandardItem(u"Col0"_s);
    m_sourceModel->appendRow({col0, new QStandardItem(u"Col1"_s), new QStandardItem(u"Col2"_s)});
    m_proxy->setSourceModel(m_sourceModel.get());

    QModelIndex proxyCol1 = m_proxy->index(0, 1);
    QModelIndex sourceCol1 = m_proxy->mapToSource(proxyCol1);

    QVERIFY(sourceCol1.isValid());
    QCOMPARE(sourceCol1.column(), 1);
    QCOMPARE(sourceCol1.data().toString(), u"Col1"_s);
}

// =============================================================================
// QAbstractTableModel Interface
// =============================================================================

void tst_QTreeToTableModel::rowCountOfChildIsZero()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QModelIndex idx = m_proxy->index(0, 0);
    QCOMPARE(m_proxy->rowCount(idx), 0);
}

void tst_QTreeToTableModel::columnCountMatchesSource()
{
    m_sourceModel->setColumnCount(3);
    m_sourceModel->appendRow(
        {new QStandardItem(u"A"_s), new QStandardItem(u"B"_s), new QStandardItem(u"C"_s)});
    m_proxy->setSourceModel(m_sourceModel.get());

    QCOMPARE(m_proxy->columnCount(), 3);
}

void tst_QTreeToTableModel::dataForMultipleColumns()
{
    m_sourceModel->appendRow(
        {new QStandardItem(u"Col0"_s), new QStandardItem(u"Col1"_s), new QStandardItem(u"Col2"_s)});
    m_proxy->setSourceModel(m_sourceModel.get());

    QCOMPARE(m_proxy->index(0, 0).data().toString(), u"Col0"_s);
    QCOMPARE(m_proxy->index(0, 1).data().toString(), u"Col1"_s);
    QCOMPARE(m_proxy->index(0, 2).data().toString(), u"Col2"_s);
}

void tst_QTreeToTableModel::setDataForwardsToSource()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QModelIndex proxyIdx = m_proxy->index(0, 0);
    bool result = m_proxy->setData(proxyIdx, u"Modified"_s, Qt::DisplayRole);

    QVERIFY(result);
    QCOMPARE(m_itemA->text(), u"Modified"_s);
}

void tst_QTreeToTableModel::flagsForwardToSource()
{
    buildStandardTree();
    m_itemA->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable);
    m_proxy->setSourceModel(m_sourceModel.get());

    QModelIndex proxyIdx = m_proxy->index(0, 0);
    Qt::ItemFlags flags = m_proxy->flags(proxyIdx);

    QVERIFY(flags & Qt::ItemIsEnabled);
    QVERIFY(flags & Qt::ItemIsSelectable);
    QVERIFY(flags & Qt::ItemIsEditable);
}

void tst_QTreeToTableModel::roleNamesIncludesDepthAndSourceIndex()
{
    m_proxy->setSourceModel(m_sourceModel.get());

    QHash<int, QByteArray> roles = m_proxy->roleNames();
    QVERIFY(roles.contains(static_cast<int>(QTreeToTableModel::Roles::Depth)));
    QCOMPARE(roles.value(static_cast<int>(QTreeToTableModel::Roles::Depth)), "depth");
    QVERIFY(roles.contains(static_cast<int>(QTreeToTableModel::Roles::SourceIndex)));
    QCOMPARE(roles.value(static_cast<int>(QTreeToTableModel::Roles::SourceIndex)), "sourceIndex");
}

void tst_QTreeToTableModel::depthRoleReturnsCorrectValue()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QCOMPARE(m_proxy->index(0, 0).data(static_cast<int>(QTreeToTableModel::Roles::Depth)).toInt(),
             0); // A
    QCOMPARE(m_proxy->index(1, 0).data(static_cast<int>(QTreeToTableModel::Roles::Depth)).toInt(),
             1); // A1
    QCOMPARE(m_proxy->index(2, 0).data(static_cast<int>(QTreeToTableModel::Roles::Depth)).toInt(),
             2); // A1a
}

void tst_QTreeToTableModel::sourceIndexRoleReturnsCorrectValue()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QVariant v = m_proxy->index(2, 0).data(
        static_cast<int>(QTreeToTableModel::Roles::SourceIndex));
    QVERIFY(v.isValid());
    QModelIndex srcIdx = v.value<QModelIndex>();
    QCOMPARE(srcIdx, m_itemA1a->index());
}

// =============================================================================
// Row Insertion Signals
// =============================================================================

void tst_QTreeToTableModel::insertAtEndOfTopLevel()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    QCOMPARE(m_proxy->rowCount(), 8);

    QSignalSpy insertSpy(m_proxy.get(), &QAbstractItemModel::rowsInserted);
    QVERIFY(insertSpy.isValid());

    m_sourceModel->appendRow(new QStandardItem(u"D"_s));

    QCOMPARE(insertSpy.size(), 1);
    VERIFY_ROW_SIGNAL(insertSpy.at(0), 8, 8);
    QCOMPARE(m_proxy->rowCount(), 9);
    QCOMPARE(m_proxy->index(8, 0).data().toString(), u"D"_s);
}

void tst_QTreeToTableModel::insertAtBeginningOfTopLevel()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy insertSpy(m_proxy.get(), &QAbstractItemModel::rowsInserted);
    QVERIFY(insertSpy.isValid());

    TreeBuilder builder(m_sourceModel.get());
    builder.insertItem(u"Z"_s, 0);

    QCOMPARE(insertSpy.size(), 1);
    VERIFY_ROW_SIGNAL(insertSpy.at(0), 0, 0);
    QCOMPARE(m_proxy->index(0, 0).data().toString(), u"Z"_s);
}

void tst_QTreeToTableModel::insertInMiddleOfTopLevel()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy insertSpy(m_proxy.get(), &QAbstractItemModel::rowsInserted);
    QVERIFY(insertSpy.isValid());

    // Insert between A (row 0, flat 0-4) and B (row 1, flat 5-6)
    TreeBuilder builder(m_sourceModel.get());
    builder.insertItem(u"AB"_s, 1); // Between A and B in source

    QCOMPARE(insertSpy.size(), 1);
    VERIFY_ROW_SIGNAL(insertSpy.at(0), 5, 5);
    QCOMPARE(m_proxy->index(5, 0).data().toString(), u"AB"_s);
}

void tst_QTreeToTableModel::insertChildRow()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy insertSpy(m_proxy.get(), &QAbstractItemModel::rowsInserted);
    QVERIFY(insertSpy.isValid());

    // Add child to A1 (currently at flat row 1, children at flat rows 2-3)
    auto *newChild = new QStandardItem(u"A1c"_s);
    m_itemA1->appendRow(newChild);

    QCOMPARE(insertSpy.size(), 1);
    VERIFY_ROW_SIGNAL(insertSpy.at(0), 4, 4);
    QCOMPARE(m_proxy->index(4, 0).data().toString(), u"A1c"_s);
    QCOMPARE(m_proxy->depthForRow(4), 2);
}

void tst_QTreeToTableModel::insertChildWithSubtree()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy insertSpy(m_proxy.get(), &QAbstractItemModel::rowsInserted);
    QVERIFY(insertSpy.isValid());

    // Add a child with its own children to B
    auto *newChild = new QStandardItem(u"B2"_s);
    auto *grandChild = new QStandardItem(u"B2a"_s);
    newChild->appendRow(grandChild);
    m_itemB->appendRow(newChild);

    QCOMPARE(insertSpy.size(), 1);
    // B is at flat 5, B1 at flat 6, so B2 should go at flat 7
    VERIFY_ROW_SIGNAL(insertSpy.at(0), 7, 8);
    QCOMPARE(m_proxy->index(7, 0).data().toString(), u"B2"_s);
    QCOMPARE(m_proxy->index(8, 0).data().toString(), u"B2a"_s);
}

void tst_QTreeToTableModel::insertUnderNonVisibleParentIgnored()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());

    QSignalSpy insertSpy(m_proxy.get(), &QAbstractItemModel::rowsInserted);
    QVERIFY(insertSpy.isValid());

    // Insert under B (not visible when root is A)
    m_itemB->appendRow(new QStandardItem(u"B2"_s));

    QCOMPARE(insertSpy.size(), 0);
}

// =============================================================================
// Row Removal Signals
// =============================================================================

void tst_QTreeToTableModel::removeFromTopLevel()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy removeSpy(m_proxy.get(), &QAbstractItemModel::rowsRemoved);
    QVERIFY(removeSpy.isValid());

    // Remove C (last top-level item, at flat row 7)
    m_sourceModel->removeRow(2); // C is the 3rd top-level item

    QCOMPARE(removeSpy.size(), 1);
    VERIFY_ROW_SIGNAL(removeSpy.at(0), 7, 7);
    QCOMPARE(m_proxy->rowCount(), 7);
}

void tst_QTreeToTableModel::removeFromMiddle()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy removeSpy(m_proxy.get(), &QAbstractItemModel::rowsRemoved);
    QVERIFY(removeSpy.isValid());

    // Remove A2 (child of A at source row 1, flat row 4)
    m_itemA->removeRow(1); // A2

    QCOMPARE(removeSpy.size(), 1);
    VERIFY_ROW_SIGNAL(removeSpy.at(0), 4, 4);
    QCOMPARE(m_proxy->rowCount(), 7);
}

void tst_QTreeToTableModel::removeWithSubtree()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy removeSpy(m_proxy.get(), &QAbstractItemModel::rowsRemoved);
    QVERIFY(removeSpy.isValid());

    // Remove A (flat rows 0-4: A, A1, A1a, A1b, A2)
    m_sourceModel->removeRow(0);

    QCOMPARE(removeSpy.size(), 1);
    VERIFY_ROW_SIGNAL(removeSpy.at(0), 0, 4);
    QCOMPARE(m_proxy->rowCount(), 3); // B, B1, C remain
}

void tst_QTreeToTableModel::removeUnderNonVisibleParentIgnored()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());

    QSignalSpy removeSpy(m_proxy.get(), &QAbstractItemModel::rowsRemoved);
    QVERIFY(removeSpy.isValid());

    // Remove B1 (not visible when root is A)
    m_itemB->removeRow(0);

    QCOMPARE(removeSpy.size(), 0);
}

// =============================================================================
// Row Move Signals
// =============================================================================

// Helper: build the standard tree in a SimpleTreeModel and return nodes.
struct TestTree
{
    SimpleTreeModel model;
    SimpleTreeModel::Node *A = nullptr;
    SimpleTreeModel::Node *A1 = nullptr;
    SimpleTreeModel::Node *A1a = nullptr;
    SimpleTreeModel::Node *A1b = nullptr;
    SimpleTreeModel::Node *A2 = nullptr;
    SimpleTreeModel::Node *B = nullptr;
    SimpleTreeModel::Node *B1 = nullptr;
    SimpleTreeModel::Node *C = nullptr;

    void build()
    {
        A = model.addChild(u"A"_s);
        A1 = model.addChild(u"A1"_s, A);
        A1a = model.addChild(u"A1a"_s, A1);
        A1b = model.addChild(u"A1b"_s, A1);
        A2 = model.addChild(u"A2"_s, A);
        B = model.addChild(u"B"_s);
        B1 = model.addChild(u"B1"_s, B);
        C = model.addChild(u"C"_s);
    }
};

void tst_QTreeToTableModel::moveWithinSameParent()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);
    QCOMPARE(proxy.rowCount(), 8);

    // Move C (source row 2) before A (dest row 0) at top level
    QSignalSpy moveSpy(&proxy, &QAbstractItemModel::rowsMoved);
    QSignalSpy insertSpy(&proxy, &QAbstractItemModel::rowsInserted);
    QSignalSpy removeSpy(&proxy, &QAbstractItemModel::rowsRemoved);

    tree.model.moveRows(QModelIndex(), 2, 1, QModelIndex(), 0);

    // Expect either a move or a remove+insert
    const int totalSignals = moveSpy.size() + insertSpy.size();
    QVERIFY(totalSignals > 0);

    // Verify final state: C should now be first
    QCOMPARE(proxy.index(0, 0).data().toString(), u"C"_s);
    QCOMPARE(proxy.rowCount(), 8);
}

void tst_QTreeToTableModel::moveWithinSameParentVerifySignalArgs()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    // Flat order: A(0), A1(1), A1a(2), A1b(3), A2(4), B(5), B1(6), C(7)

    QSignalSpy moveSpy(&proxy, &QAbstractItemModel::rowsMoved);
    QSignalSpy insertSpy(&proxy, &QAbstractItemModel::rowsInserted);
    QSignalSpy removeSpy(&proxy, &QAbstractItemModel::rowsRemoved);

    // Move C (flat row 7) before A (dest row 0)
    tree.model.moveRows(QModelIndex(), 2, 1, QModelIndex(), 0);

    if (moveSpy.size() == 1) {
        // Preferred: emitted as a move signal
        VERIFY_MOVE_SIGNAL(moveSpy.at(0), 7, 7, 0);
        QCOMPARE(insertSpy.size(), 0);
        QCOMPARE(removeSpy.size(), 0);
    } else {
        // Fallback: emitted as remove + insert
        QCOMPARE(removeSpy.size(), 1);
        QCOMPARE(insertSpy.size(), 1);
    }

    // Verify final state
    const auto items = collectFlattenedItems(&proxy);
    QCOMPARE(items[0], u"C"_s);
    QCOMPARE(items[1], u"A"_s);
}

void tst_QTreeToTableModel::moveBetweenDifferentParents()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);
    QCOMPARE(proxy.rowCount(), 8);

    QSignalSpy moveSpy(&proxy, &QAbstractItemModel::rowsMoved);
    QSignalSpy insertSpy(&proxy, &QAbstractItemModel::rowsInserted);
    QSignalSpy removeSpy(&proxy, &QAbstractItemModel::rowsRemoved);

    // Move B1 from B to A (append as 3rd child of A)
    tree.model.moveRows(tree.model.indexForNode(tree.B), 0, 1,
                        tree.model.indexForNode(tree.A), 2);

    const int totalSignals = moveSpy.size() + insertSpy.size() + removeSpy.size();
    QVERIFY(totalSignals > 0);

    // Row count stays at 8 (B1 moved from under B to under A)
    QCOMPARE(proxy.rowCount(), 8);
}

void tst_QTreeToTableModel::moveBetweenDifferentParentsVerifySignalArgs()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    // Flat order: A(0), A1(1), A1a(2), A1b(3), A2(4), B(5), B1(6), C(7)

    QSignalSpy moveSpy(&proxy, &QAbstractItemModel::rowsMoved);

    // Move B1 (flat 6) from B to A as 3rd child (after A2 at flat 4)
    // B1 should land at flat position 5 (after A2's subtree)
    tree.model.moveRows(tree.model.indexForNode(tree.B), 0, 1,
                        tree.model.indexForNode(tree.A), 2);

    // Verify final state
    const auto items = collectFlattenedItems(&proxy);
    QCOMPARE(items.size(), 8);

    // B1 should now be after A2
    int b1Idx = items.indexOf(u"B1"_s);
    int a2Idx = items.indexOf(u"A2"_s);
    QVERIFY(b1Idx > a2Idx);

    // B1 depth should now be 1 (child of A) instead of 1 (was child of B)
    QCOMPARE(proxy.depthForRow(b1Idx), 1);
}

void tst_QTreeToTableModel::moveEmitsRowsMovedNotRemoveInsert()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    QAbstractItemModelTester tester(&proxy,
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    QSignalSpy moveSpy(&proxy, &QAbstractItemModel::rowsMoved);
    QSignalSpy insertSpy(&proxy, &QAbstractItemModel::rowsInserted);
    QSignalSpy removeSpy(&proxy, &QAbstractItemModel::rowsRemoved);

    // Move C (flat row 7) to after A (dest row 1 at top level)
    // This should produce a move, not remove+insert
    tree.model.moveRows(QModelIndex(), 2, 1, QModelIndex(), 1);

    // For a simple same-parent move to a different position, we expect rowsMoved
    QCOMPARE(moveSpy.size(), 1);
    QCOMPARE(insertSpy.size(), 0);
    QCOMPARE(removeSpy.size(), 0);

    // Verify the move signal has correct flat row arguments
    VERIFY_MOVE_SIGNAL(moveSpy.at(0), 7, 7, 5);

    // Verify final state: C should now be between A's subtree and B
    const auto items = collectFlattenedItems(&proxy);
    QCOMPARE(items.size(), 8);
    int cIdx = items.indexOf(u"C"_s);
    int bIdx = items.indexOf(u"B"_s);
    QVERIFY(cIdx < bIdx);
}

void tst_QTreeToTableModel::moveFromVisibleToInvisible()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);
    proxy.setRootIndex(tree.model.indexForNode(tree.A));

    // Initially shows: A1, A1a, A1b, A2
    QCOMPARE(proxy.rowCount(), 4);

    QSignalSpy removeSpy(&proxy, &QAbstractItemModel::rowsRemoved);
    QVERIFY(removeSpy.isValid());

    // Move A2 from A (row 1) to B (row 1) — A2 becomes invisible
    tree.model.moveRows(tree.model.indexForNode(tree.A), 1, 1,
                        tree.model.indexForNode(tree.B), 1);

    // A2 should have been removed from our view
    QCOMPARE(removeSpy.size(), 1);
    QCOMPARE(proxy.rowCount(), 3); // A1, A1a, A1b
}

void tst_QTreeToTableModel::moveFromInvisibleToVisible()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);
    proxy.setRootIndex(tree.model.indexForNode(tree.A));

    QCOMPARE(proxy.rowCount(), 4);

    QSignalSpy insertSpy(&proxy, &QAbstractItemModel::rowsInserted);
    QVERIFY(insertSpy.isValid());

    // Move B1 from B (invisible) to A (visible root) as 3rd child
    tree.model.moveRows(tree.model.indexForNode(tree.B), 0, 1,
                        tree.model.indexForNode(tree.A), 2);

    // B1 should now appear in our view
    QCOMPARE(insertSpy.size(), 1);
    QCOMPARE(proxy.rowCount(), 5); // A1, A1a, A1b, A2, B1
}

// =============================================================================
// Data Change Signals
// =============================================================================

void tst_QTreeToTableModel::dataChangedForwarded()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy dataChangedSpy(m_proxy.get(), &QAbstractItemModel::dataChanged);
    QVERIFY(dataChangedSpy.isValid());

    m_itemA->setText(u"Modified"_s);

    QCOMPARE(dataChangedSpy.size(), 1);

    QModelIndex topLeft = dataChangedSpy.at(0).at(0).toModelIndex();
    QModelIndex bottomRight = dataChangedSpy.at(0).at(1).toModelIndex();
    QCOMPARE(topLeft.row(), 0);
    QCOMPARE(bottomRight.row(), 0); // Only A itself, not descendants
}

void tst_QTreeToTableModel::dataChangedWithSubtree()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy dataChangedSpy(m_proxy.get(), &QAbstractItemModel::dataChanged);
    QVERIFY(dataChangedSpy.isValid());

    // Change data on B (flat row 5) — only B itself, not B1
    m_itemB->setText(u"Modified B"_s);

    QCOMPARE(dataChangedSpy.size(), 1);
    QModelIndex topLeft = dataChangedSpy.at(0).at(0).toModelIndex();
    QModelIndex bottomRight = dataChangedSpy.at(0).at(1).toModelIndex();
    QCOMPARE(topLeft.row(), 5);
    QCOMPARE(bottomRight.row(), 5);
}

// =============================================================================
// Layout Change
// =============================================================================

void tst_QTreeToTableModel::layoutChangeRebuildsList()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy layoutSpy(m_proxy.get(), &QAbstractItemModel::layoutChanged);
    QVERIFY(layoutSpy.isValid());

    // Sort the source model (triggers layout change)
    m_sourceModel->sort(0, Qt::DescendingOrder);

    QVERIFY(layoutSpy.size() > 0);
    // After reverse sort, C should come first at top level
    QCOMPARE(m_proxy->index(0, 0).data().toString(), u"C"_s);
}

void tst_QTreeToTableModel::layoutChangePersistentIndexes()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    // Get a persistent index to B (flat row 5)
    QPersistentModelIndex persistentB = m_proxy->index(5, 0);
    QCOMPARE(persistentB.data().toString(), u"B"_s);

    // Sort descending
    m_sourceModel->sort(0, Qt::DescendingOrder);

    // B should still be valid and point to B
    QVERIFY(persistentB.isValid());
    QCOMPARE(persistentB.data().toString(), u"B"_s);
}

// =============================================================================
// Column Changes
// =============================================================================

void tst_QTreeToTableModel::columnsInsertedAtRoot()
{
    m_sourceModel->appendRow(new QStandardItem(u"A"_s));
    m_proxy->setSourceModel(m_sourceModel.get());
    QCOMPARE(m_proxy->columnCount(), 1);

    QSignalSpy colSpy(m_proxy.get(), &QAbstractItemModel::columnsInserted);
    QVERIFY(colSpy.isValid());

    m_sourceModel->setColumnCount(3);

    QCOMPARE(colSpy.size(), 1);
    QCOMPARE(m_proxy->columnCount(), 3);
}

void tst_QTreeToTableModel::columnsRemovedAtRoot()
{
    m_sourceModel->setColumnCount(3);
    m_sourceModel->appendRow(
        {new QStandardItem(u"A"_s), new QStandardItem(u"B"_s), new QStandardItem(u"C"_s)});
    m_proxy->setSourceModel(m_sourceModel.get());
    QCOMPARE(m_proxy->columnCount(), 3);

    QSignalSpy colSpy(m_proxy.get(), &QAbstractItemModel::columnsRemoved);
    QVERIFY(colSpy.isValid());

    m_sourceModel->setColumnCount(1);

    QCOMPARE(colSpy.size(), 1);
    QCOMPARE(m_proxy->columnCount(), 1);
}

// =============================================================================
// Source Model Reset
// =============================================================================

void tst_QTreeToTableModel::sourceModelResetRebuilds()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    QCOMPARE(m_proxy->rowCount(), 8);

    QSignalSpy resetSpy(m_proxy.get(), &QAbstractItemModel::modelReset);
    QVERIFY(resetSpy.isValid());

    m_sourceModel->clear();

    QCOMPARE(resetSpy.size(), 1);
    QCOMPARE(m_proxy->rowCount(), 0);
}

// =============================================================================
// QAbstractItemModelTester Integration
// =============================================================================

void tst_QTreeToTableModel::modelTesterWithStandardTree()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QAbstractItemModelTester tester(m_proxy.get(),
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);
    Q_UNUSED(tester)

    // If we get here without assertions, the model is well-formed
    QCOMPARE(m_proxy->rowCount(), 8);
}

void tst_QTreeToTableModel::modelTesterAfterInsertions()
{
    m_proxy->setSourceModel(m_sourceModel.get());

    QAbstractItemModelTester tester(m_proxy.get(),
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    m_sourceModel->appendRow(new QStandardItem(u"A"_s));
    auto *a = m_sourceModel->item(0);
    a->appendRow(new QStandardItem(u"A1"_s));
    a->appendRow(new QStandardItem(u"A2"_s));
    m_sourceModel->appendRow(new QStandardItem(u"B"_s));

    QCOMPARE(m_proxy->rowCount(), 4);
}

void tst_QTreeToTableModel::modelTesterAfterRemovals()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QAbstractItemModelTester tester(m_proxy.get(),
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    m_sourceModel->removeRow(0); // Remove A and its subtree
    QCOMPARE(m_proxy->rowCount(), 3); // B, B1, C

    m_sourceModel->removeRow(0); // Remove B and B1
    QCOMPARE(m_proxy->rowCount(), 1); // C
}

void tst_QTreeToTableModel::modelTesterWithRootIndex()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());

    QAbstractItemModelTester tester(m_proxy.get(),
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    QCOMPARE(m_proxy->rowCount(), 4);
}

void tst_QTreeToTableModel::modelTesterWithMaxDepth()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setMaxDepth(1);

    QAbstractItemModelTester tester(m_proxy.get(),
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    QCOMPARE(m_proxy->rowCount(), 3); // A, B, C
}

// =============================================================================
// Edge Cases
// =============================================================================

void tst_QTreeToTableModel::setSourceModelBeforeTreeIsBuilt()
{
    m_proxy->setSourceModel(m_sourceModel.get());
    QCOMPARE(m_proxy->rowCount(), 0);

    // Now build the tree - proxy should get insertion signals
    QSignalSpy insertSpy(m_proxy.get(), &QAbstractItemModel::rowsInserted);
    QVERIFY(insertSpy.isValid());

    m_sourceModel->appendRow(new QStandardItem(u"A"_s));
    QCOMPARE(insertSpy.size(), 1);
    QCOMPARE(m_proxy->rowCount(), 1);

    auto *a = m_sourceModel->item(0);
    a->appendRow(new QStandardItem(u"A1"_s));
    QCOMPARE(insertSpy.size(), 2);
    QCOMPARE(m_proxy->rowCount(), 2);
}

void tst_QTreeToTableModel::insertRowsAfterSetSourceModel()
{
    m_proxy->setSourceModel(m_sourceModel.get());

    QAbstractItemModelTester tester(m_proxy.get(),
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    for (int i = 0; i < 10; ++i) {
        auto *item = new QStandardItem(u"Item%1"_s.arg(i));
        m_sourceModel->appendRow(item);
        for (int j = 0; j < 3; ++j)
            item->appendRow(new QStandardItem(u"Child%1_%2"_s.arg(i).arg(j)));
    }

    QCOMPARE(m_proxy->rowCount(), 40); // 10 items + 30 children
}

void tst_QTreeToTableModel::multipleInsertRemoveCycles()
{
    m_proxy->setSourceModel(m_sourceModel.get());

    QAbstractItemModelTester tester(m_proxy.get(),
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    // Insert
    for (int i = 0; i < 5; ++i)
        m_sourceModel->appendRow(new QStandardItem(u"Item%1"_s.arg(i)));
    QCOMPARE(m_proxy->rowCount(), 5);

    // Remove all
    m_sourceModel->removeRows(0, 5);
    QCOMPARE(m_proxy->rowCount(), 0);

    // Insert again
    for (int i = 0; i < 3; ++i)
        m_sourceModel->appendRow(new QStandardItem(u"New%1"_s.arg(i)));
    QCOMPARE(m_proxy->rowCount(), 3);

    // Remove middle
    m_sourceModel->removeRow(1);
    QCOMPARE(m_proxy->rowCount(), 2);
    QCOMPARE(m_proxy->index(0, 0).data().toString(), u"New0"_s);
    QCOMPARE(m_proxy->index(1, 0).data().toString(), u"New2"_s);
}

void tst_QTreeToTableModel::insertAtMaxDepthBoundary()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setMaxDepth(2);

    // maxDepth=2: shows depth 0 and 1 => A, A1, A2, B, B1, C
    QCOMPARE(m_proxy->rowCount(), 6);

    QSignalSpy insertSpy(m_proxy.get(), &QAbstractItemModel::rowsInserted);
    QVERIFY(insertSpy.isValid());

    // Insert at depth 2 (beyond maxDepth) - should be ignored
    m_itemA1->appendRow(new QStandardItem(u"A1c"_s));
    QCOMPARE(insertSpy.size(), 0);
    QCOMPARE(m_proxy->rowCount(), 6);

    // Insert at depth 1 (within maxDepth) - should be included
    m_itemA->appendRow(new QStandardItem(u"A3"_s));
    QCOMPARE(insertSpy.size(), 1);
    QCOMPARE(m_proxy->rowCount(), 7);
}

void tst_QTreeToTableModel::moveAtMaxDepthBoundary()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);
    proxy.setMaxDepth(2);

    // maxDepth=2: A, A1, A2, B, B1, C (6 items)
    QCOMPARE(proxy.rowCount(), 6);

    // Move B1 to be under A1 (going from depth 1 to depth 2, which is at the boundary)
    // At maxDepth=2, depth 2 is excluded, so B1 should disappear
    QSignalSpy removeSpy(&proxy, &QAbstractItemModel::rowsRemoved);
    QVERIFY(removeSpy.isValid());

    tree.model.moveRows(tree.model.indexForNode(tree.B), 0, 1,
                        tree.model.indexForNode(tree.A1), 2);

    // B1 moved to depth 2 which is beyond maxDepth=2, so it should be removed
    QVERIFY(removeSpy.size() > 0);
}

// =============================================================================
// Additional Coverage
// =============================================================================

void tst_QTreeToTableModel::setDataOnReadOnlyRolesReturnsFalse()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QModelIndex idx = m_proxy->index(0, 0);
    QVERIFY(idx.isValid());

    QVERIFY(!m_proxy->setData(idx, 42, static_cast<int>(QTreeToTableModel::Roles::Depth)));
    QVERIFY(!m_proxy->setData(idx, QVariant(), static_cast<int>(QTreeToTableModel::Roles::SourceIndex)));
}

void tst_QTreeToTableModel::dataWithInvalidIndexReturnsInvalid()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QVERIFY(!m_proxy->data(QModelIndex()).isValid());
    QVERIFY(!m_proxy->data(m_proxy->index(-1, 0)).isValid());
    QVERIFY(!m_proxy->data(m_proxy->index(100, 0)).isValid());
}

void tst_QTreeToTableModel::flagsWithInvalidIndexReturnsNone()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QCOMPARE(m_proxy->flags(QModelIndex()), Qt::NoItemFlags);
}

void tst_QTreeToTableModel::mapToSourceInvalidReturnsInvalid()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QVERIFY(!m_proxy->mapToSource(QModelIndex()).isValid());
    QVERIFY(!m_proxy->mapToSource(m_proxy->index(-1, 0)).isValid());
    QVERIFY(!m_proxy->mapToSource(m_proxy->index(100, 0)).isValid());
}

void tst_QTreeToTableModel::mapFromSourceInvalidReturnsInvalid()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QVERIFY(!m_proxy->mapFromSource(QModelIndex()).isValid());
}

void tst_QTreeToTableModel::columnCountWithNoSourceModel()
{
    QCOMPARE(m_proxy->columnCount(), 0);
}

void tst_QTreeToTableModel::columnCountWithRootIndex()
{
    // Build a tree where the root has 2 columns but a child has 3 columns.
    // When rootIndex is set to that child, columnCount() should return 3.
    m_sourceModel->setColumnCount(2);
    auto *parent = new QStandardItem(u"Parent"_s);
    m_sourceModel->appendRow(parent);

    // Give the child 3 columns.
    parent->setColumnCount(3);
    auto *child = new QStandardItem(u"Child"_s);
    parent->appendRow({child, new QStandardItem(u"C1"_s), new QStandardItem(u"C2"_s)});

    m_proxy->setSourceModel(m_sourceModel.get());
    QCOMPARE(m_proxy->columnCount(), 2); // Top-level has 2 columns.

    m_proxy->setRootIndex(m_sourceModel->index(0, 0)); // Set root to Parent.
    QCOMPARE(m_proxy->columnCount(), 3); // Parent's children have 3 columns.

    m_proxy->resetRootIndex();
    QCOMPARE(m_proxy->columnCount(), 2); // Back to top-level.
}

void tst_QTreeToTableModel::headerDataForwarded()
{
    m_sourceModel->setHorizontalHeaderLabels({u"Name"_s, u"Value"_s});
    m_sourceModel->appendRow(
        {new QStandardItem(u"A"_s), new QStandardItem(u"1"_s)});
    m_proxy->setSourceModel(m_sourceModel.get());

    QCOMPARE(m_proxy->headerData(0, Qt::Horizontal).toString(), u"Name"_s);
    QCOMPARE(m_proxy->headerData(1, Qt::Horizontal).toString(), u"Value"_s);
}

void tst_QTreeToTableModel::headerDataChangedForwarded()
{
    m_sourceModel->setHorizontalHeaderLabels({u"Name"_s, u"Value"_s});
    m_sourceModel->appendRow(
        {new QStandardItem(u"A"_s), new QStandardItem(u"1"_s)});
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy spy(m_proxy.get(), &QAbstractItemModel::headerDataChanged);

    m_sourceModel->setHeaderData(0, Qt::Horizontal, u"Label"_s);

    QCOMPARE(spy.size(), 1);
    // headerDataChanged(Qt::Orientation, int first, int last)
    QCOMPARE(spy.at(0).at(0).value<Qt::Orientation>(), Qt::Horizontal);
    QCOMPARE(spy.at(0).at(1).toInt(), 0);  // first
    QCOMPARE(spy.at(0).at(2).toInt(), 0);  // last
}

void tst_QTreeToTableModel::dumpDoesNotCrash()
{
    // With no source model
    m_proxy->dump();

    // With source model and data
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->dump();

    // With root index
    m_proxy->setRootIndex(m_itemA->index());
    m_proxy->dump();

    // If we get here, dump() didn't crash
    QVERIFY(true);
}

void tst_QTreeToTableModel::removeAllItems()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    QCOMPARE(m_proxy->rowCount(), 8);

    QSignalSpy removeSpy(m_proxy.get(), &QAbstractItemModel::rowsRemoved);
    QVERIFY(removeSpy.isValid());

    // Remove all top-level items one by one
    while (m_sourceModel->rowCount() > 0)
        m_sourceModel->removeRow(0);

    QCOMPARE(m_proxy->rowCount(), 0);
    QCOMPARE(m_proxy->count(), 0);
    QVERIFY(removeSpy.size() > 0);
}

void tst_QTreeToTableModel::changeRootIndexToDifferentSubtree()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());

    // Should show A's descendants: A1, A1a, A1b, A2
    QCOMPARE(m_proxy->rowCount(), 4);

    QSignalSpy resetSpy(m_proxy.get(), &QAbstractItemModel::modelReset);
    QVERIFY(resetSpy.isValid());

    // Switch to B as root
    m_proxy->setRootIndex(m_itemB->index());

    QCOMPARE(resetSpy.size(), 1);
    // Should show B's descendants: B1
    QCOMPARE(m_proxy->rowCount(), 1);
    QCOMPARE(m_proxy->index(0, 0).data().toString(), u"B1"_s);
}

void tst_QTreeToTableModel::insertUnderRootIndexParent()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());

    QSignalSpy insertSpy(m_proxy.get(), &QAbstractItemModel::rowsInserted);
    QVERIFY(insertSpy.isValid());

    // Insert a new child directly under A (the root index)
    auto *newChild = new QStandardItem(u"A3"_s);
    m_itemA->appendRow(newChild);

    QCOMPARE(insertSpy.size(), 1);
    QCOMPARE(m_proxy->rowCount(), 5);
    QCOMPARE(m_proxy->index(4, 0).data().toString(), u"A3"_s);
    QCOMPARE(m_proxy->depthForRow(4), 0);
}

void tst_QTreeToTableModel::moveWithSubtreePreservesDescendants()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);
    QCOMPARE(proxy.rowCount(), 8);

    // Move A1 (which has children A1a, A1b) from A to B
    // A1 is at source row 0 under A
    tree.model.moveRows(tree.model.indexForNode(tree.A), 0, 1,
                        tree.model.indexForNode(tree.B), 1);

    // Row count should stay at 8
    QCOMPARE(proxy.rowCount(), 8);

    // Verify A1 and its descendants are now under B
    const auto items = collectFlattenedItems(&proxy);
    QCOMPARE(items.size(), 8);

    // A1, A1a, A1b should appear after B1
    int a1Idx = items.indexOf(u"A1"_s);
    QVERIFY(a1Idx >= 0);

    // A1a and A1b should follow A1
    QCOMPARE(items.at(a1Idx + 1), u"A1a"_s);
    QCOMPARE(items.at(a1Idx + 2), u"A1b"_s);
}

void tst_QTreeToTableModel::modelTesterDuringMoves()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    QAbstractItemModelTester tester(&proxy,
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    // Move C to beginning
    tree.model.moveRows(QModelIndex(), 2, 1, QModelIndex(), 0);

    // Move A1 from A to B
    tree.model.moveRows(tree.model.indexForNode(tree.A), 0, 1,
                        tree.model.indexForNode(tree.B), 0);

    QCOMPARE(proxy.rowCount(), 8);
}

void tst_QTreeToTableModel::moveToSamePositionIsNoOp()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    const auto itemsBefore = collectFlattenedItems(&proxy);
    const auto depthsBefore = collectDepths(&proxy);

    // Move row 0 to row 0 within the same parent — should be a no-op
    // (beginMoveRows returns false for same-to-same)
    tree.model.moveRows(QModelIndex(), 0, 1, QModelIndex(), 0);

    const auto itemsAfter = collectFlattenedItems(&proxy);
    const auto depthsAfter = collectDepths(&proxy);

    QCOMPARE(itemsAfter, itemsBefore);
    QCOMPARE(depthsAfter, depthsBefore);
}

void tst_QTreeToTableModel::depthForRowInvalidReturnsMinusOne()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QCOMPARE(m_proxy->depthForRow(-1), -1);
    QCOMPARE(m_proxy->depthForRow(100), -1);
}

void tst_QTreeToTableModel::countPropertyAfterReset()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    QCOMPARE(m_proxy->count(), 8);

    QSignalSpy countSpy(m_proxy.get(), &QTreeToTableModel::countChanged);
    QVERIFY(countSpy.isValid());

    m_sourceModel->clear();

    QCOMPARE(m_proxy->count(), 0);
    QVERIFY(countSpy.size() > 0);
}

void tst_QTreeToTableModel::rootIndexClearedOnSourceModelChange()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());

    QVERIFY(m_proxy->rootIndex().isValid());

    QSignalSpy rootSpy(m_proxy.get(), &QTreeToTableModel::rootIndexChanged);
    QVERIFY(rootSpy.isValid());

    // Setting a new source model should clear the root index
    auto otherModel = std::make_unique<QStandardItemModel>();
    otherModel->appendRow(new QStandardItem(u"X"_s));
    m_proxy->setSourceModel(otherModel.get());

    QVERIFY(!m_proxy->rootIndex().isValid());
    QVERIFY(rootSpy.size() > 0);
}

void tst_QTreeToTableModel::maxDepthThreeShowsThreeLevels()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setMaxDepth(3);

    // maxDepth=3: all items included (max depth in tree is 2)
    const auto items = collectFlattenedItems(m_proxy.get());
    QCOMPARE(items.size(), 8);
}

void tst_QTreeToTableModel::insertMultipleTopLevelItems()
{
    m_proxy->setSourceModel(m_sourceModel.get());

    QAbstractItemModelTester tester(m_proxy.get(),
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    QSignalSpy insertSpy(m_proxy.get(), &QAbstractItemModel::rowsInserted);
    QVERIFY(insertSpy.isValid());

    // Insert 5 top-level items
    for (int i = 0; i < 5; ++i)
        m_sourceModel->appendRow(new QStandardItem(u"Item%1"_s.arg(i)));

    QCOMPARE(m_proxy->rowCount(), 5);
    QCOMPARE(insertSpy.size(), 5);

    // Verify order
    for (int i = 0; i < 5; ++i)
        QCOMPARE(m_proxy->index(i, 0).data().toString(), u"Item%1"_s.arg(i));
}

void tst_QTreeToTableModel::removeMultipleConsecutiveItems()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    QCOMPARE(m_proxy->rowCount(), 8);

    QAbstractItemModelTester tester(m_proxy.get(),
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    // Remove A1's children (A1a and A1b) at once
    m_itemA1->removeRows(0, 2);

    // Should now have: A, A1, A2, B, B1, C
    QCOMPARE(m_proxy->rowCount(), 6);
    const auto items = collectFlattenedItems(m_proxy.get());
    QCOMPARE(items[0], u"A"_s);
    QCOMPARE(items[1], u"A1"_s);
    QCOMPARE(items[2], u"A2"_s);
    QCOMPARE(items[3], u"B"_s);
    QCOMPARE(items[4], u"B1"_s);
    QCOMPARE(items[5], u"C"_s);
}

void tst_QTreeToTableModel::dataChangedOutsideRootSubtreeIgnored()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());

    // Proxy shows: A1, A1a, A1b, A2
    QCOMPARE(m_proxy->rowCount(), 4);

    QSignalSpy dataChangedSpy(m_proxy.get(), &QAbstractItemModel::dataChanged);
    QVERIFY(dataChangedSpy.isValid());

    // Change data on B (outside the root subtree)
    m_itemB->setText(u"Modified B"_s);

    // Should NOT be forwarded since B is outside root A's subtree
    QCOMPARE(dataChangedSpy.size(), 0);
}

void tst_QTreeToTableModel::dataChangedForSingleItemNoDescendants()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy dataChangedSpy(m_proxy.get(), &QAbstractItemModel::dataChanged);
    QVERIFY(dataChangedSpy.isValid());

    // Change data on C (flat row 7, no children)
    m_itemC->setText(u"Modified C"_s);

    QCOMPARE(dataChangedSpy.size(), 1);
    QModelIndex topLeft = dataChangedSpy.at(0).at(0).toModelIndex();
    QModelIndex bottomRight = dataChangedSpy.at(0).at(1).toModelIndex();
    // C has no descendants, so topLeft and bottomRight should be the same row
    QCOMPARE(topLeft.row(), 7);
    QCOMPARE(bottomRight.row(), 7);
}

void tst_QTreeToTableModel::setDataForwardsToSourceWithColumn()
{
    m_sourceModel->appendRow(
        {new QStandardItem(u"Col0"_s), new QStandardItem(u"Col1"_s), new QStandardItem(u"Col2"_s)});
    m_proxy->setSourceModel(m_sourceModel.get());

    // setData on column 1
    QModelIndex proxyCol1 = m_proxy->index(0, 1);
    bool result = m_proxy->setData(proxyCol1, u"Modified"_s, Qt::DisplayRole);
    QVERIFY(result);

    // Verify source model column 1 was updated
    QModelIndex sourceCol1 = m_sourceModel->index(0, 1);
    QCOMPARE(sourceCol1.data().toString(), u"Modified"_s);
}

void tst_QTreeToTableModel::flagsForwardToSourceWithColumn()
{
    auto *col0 = new QStandardItem(u"Col0"_s);
    auto *col1 = new QStandardItem(u"Col1"_s);
    col1->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable);
    m_sourceModel->appendRow({col0, col1});
    m_proxy->setSourceModel(m_sourceModel.get());

    Qt::ItemFlags flags = m_proxy->flags(m_proxy->index(0, 1));
    QVERIFY(flags & Qt::ItemIsEnabled);
    QVERIFY(flags & Qt::ItemIsEditable);
}

void tst_QTreeToTableModel::moveWithRootIndexAndMaxDepth()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);
    proxy.setRootIndex(tree.model.indexForNode(tree.A));
    proxy.setMaxDepth(1);

    // Root=A, maxDepth=1: only A1, A2 visible
    QCOMPARE(proxy.rowCount(), 2);

    QAbstractItemModelTester tester(&proxy,
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    // Move B1 from B (invisible) to A (visible root, as 3rd child)
    QSignalSpy insertSpy(&proxy, &QAbstractItemModel::rowsInserted);

    tree.model.moveRows(tree.model.indexForNode(tree.B), 0, 1,
                        tree.model.indexForNode(tree.A), 2);

    // B1 should appear at depth 0 (child of root A)
    QCOMPARE(insertSpy.size(), 1);
    QCOMPARE(proxy.rowCount(), 3);
    QCOMPARE(proxy.index(2, 0).data().toString(), u"B1"_s);
    QCOMPARE(proxy.depthForRow(2), 0);
}

void tst_QTreeToTableModel::moveMultipleItemsAtOnce()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    QAbstractItemModelTester tester(&proxy,
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    // Move A1 and A2 (2 items) from A to B
    tree.model.moveRows(tree.model.indexForNode(tree.A), 0, 2,
                        tree.model.indexForNode(tree.B), 1);

    // All items still present
    QCOMPARE(proxy.rowCount(), 8);

    // A1, A1a, A1b, A2 should now be under B
    const auto items = collectFlattenedItems(&proxy);
    int a1Idx = items.indexOf(u"A1"_s);
    int bIdx = items.indexOf(u"B"_s);
    QVERIFY(a1Idx > bIdx); // A1 should be after B now

    // A1's depth should be 2 (B -> A1)
    QCOMPARE(proxy.depthForRow(a1Idx), 1);
}

void tst_QTreeToTableModel::rootIndexMovedInSource()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);
    proxy.setRootIndex(tree.model.indexForNode(tree.A));

    // Root=A, shows: A1, A1a, A1b, A2
    QCOMPARE(proxy.rowCount(), 4);

    // Move A from top-level row 0 to after B (row 2)
    // The root index is a QPersistentModelIndex, so it should track the move
    tree.model.moveRows(QModelIndex(), 0, 1, QModelIndex(), 3);

    // Root index should still be valid and pointing to A
    QVERIFY(proxy.rootIndex().isValid());
    QCOMPARE(proxy.rowCount(), 4);

    // Content should be the same
    const auto items = collectFlattenedItems(&proxy);
    QCOMPARE(items[0], u"A1"_s);
    QCOMPARE(items[1], u"A1a"_s);
    QCOMPARE(items[2], u"A1b"_s);
    QCOMPARE(items[3], u"A2"_s);
}

void tst_QTreeToTableModel::insertAndRemoveWithModelTester()
{
    m_proxy->setSourceModel(m_sourceModel.get());

    QAbstractItemModelTester tester(m_proxy.get(),
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    // Interleave inserts and removes
    m_sourceModel->appendRow(new QStandardItem(u"A"_s));
    auto *a = m_sourceModel->item(0);
    a->appendRow(new QStandardItem(u"A1"_s));
    a->appendRow(new QStandardItem(u"A2"_s));
    QCOMPARE(m_proxy->rowCount(), 3);

    // Remove A1
    a->removeRow(0);
    QCOMPARE(m_proxy->rowCount(), 2);

    // Add more
    m_sourceModel->appendRow(new QStandardItem(u"B"_s));
    a->appendRow(new QStandardItem(u"A3"_s));
    QCOMPARE(m_proxy->rowCount(), 4);

    // Remove A entirely
    m_sourceModel->removeRow(0);
    QCOMPARE(m_proxy->rowCount(), 1);
    QCOMPARE(m_proxy->index(0, 0).data().toString(), u"B"_s);
}

void tst_QTreeToTableModel::removeRootIndexSubtreeResetsToFull()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());
    QCOMPARE(m_proxy->rowCount(), 4);

    QSignalSpy rootSpy(m_proxy.get(), &QTreeToTableModel::rootIndexChanged);
    QSignalSpy resetSpy(m_proxy.get(), &QAbstractItemModel::modelReset);

    // Remove A (the root index) from the source
    m_sourceModel->removeRow(0);

    // Root should have been invalidated, model reset to show remaining items
    QVERIFY(!m_proxy->rootIndex().isValid());
    QVERIFY(rootSpy.size() > 0);
    QVERIFY(resetSpy.size() > 0);

    // Should show remaining items: B, B1, C
    QCOMPARE(m_proxy->rowCount(), 3);
}

void tst_QTreeToTableModel::moveBackAndForthPreservesState()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    QAbstractItemModelTester tester(&proxy,
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    const auto itemsBefore = collectFlattenedItems(&proxy);
    const auto depthsBefore = collectDepths(&proxy);

    // Move C to beginning
    tree.model.moveRows(QModelIndex(), 2, 1, QModelIndex(), 0);

    // Move it back (C is now at row 0, move to row 3 = after B which is now row 2)
    tree.model.moveRows(QModelIndex(), 0, 1, QModelIndex(), 3);

    // State should be restored
    const auto itemsAfter = collectFlattenedItems(&proxy);
    const auto depthsAfter = collectDepths(&proxy);

    QCOMPARE(itemsAfter, itemsBefore);
    QCOMPARE(depthsAfter, depthsBefore);
}

void tst_QTreeToTableModel::maxDepthZeroShowsAll()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    // maxDepth=0 is the default, meaning unlimited
    QCOMPARE(m_proxy->maxDepth(), 0);
    QCOMPARE(m_proxy->rowCount(), 8);

    // Set to 3, then back to 0 — should show everything again
    m_proxy->setMaxDepth(3);
    QCOMPARE(m_proxy->rowCount(), 8); // max depth in tree is 2, so all visible

    m_proxy->setMaxDepth(1);
    QCOMPARE(m_proxy->rowCount(), 3); // only A, B, C

    m_proxy->setMaxDepth(0);
    QCOMPARE(m_proxy->rowCount(), 8); // all visible again
}

void tst_QTreeToTableModel::setMaxDepthAfterRootIndex()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());

    // Root=A: A1, A1a, A1b, A2
    QCOMPARE(m_proxy->rowCount(), 4);

    // Now set maxDepth=1: only direct children of root A
    m_proxy->setMaxDepth(1);
    QCOMPARE(m_proxy->rowCount(), 2); // A1, A2

    // Set maxDepth=2: show children and grandchildren
    m_proxy->setMaxDepth(2);
    QCOMPARE(m_proxy->rowCount(), 4); // A1, A1a, A1b, A2

    // Set maxDepth=0: show all
    m_proxy->setMaxDepth(0);
    QCOMPARE(m_proxy->rowCount(), 4); // same as maxDepth=2 since max depth is 2
}

void tst_QTreeToTableModel::persistentIndexSurvivesInsert()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    // Get persistent index to B (flat row 5)
    QPersistentModelIndex persistentB = m_proxy->index(5, 0);
    QCOMPARE(persistentB.data().toString(), u"B"_s);

    // Insert a new top-level item before B
    TreeBuilder builder(m_sourceModel.get());
    builder.insertItem(u"AB"_s, 1); // Between A and B in source

    // B should now be at flat row 6 (shifted by 1)
    QVERIFY(persistentB.isValid());
    QCOMPARE(persistentB.data().toString(), u"B"_s);
}

void tst_QTreeToTableModel::persistentIndexSurvivesRemove()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    // Get persistent index to C (flat row 7)
    QPersistentModelIndex persistentC = m_proxy->index(7, 0);
    QCOMPARE(persistentC.data().toString(), u"C"_s);

    // Remove B (flat rows 5-6)
    m_sourceModel->removeRow(1); // B

    // C should now be at flat row 5
    QVERIFY(persistentC.isValid());
    QCOMPARE(persistentC.data().toString(), u"C"_s);
}

void tst_QTreeToTableModel::sourceModelResetWithRootIndexClears()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());
    QCOMPARE(m_proxy->rowCount(), 4);

    QSignalSpy resetSpy(m_proxy.get(), &QAbstractItemModel::modelReset);

    // Clear the source model (triggers reset)
    m_sourceModel->clear();

    QCOMPARE(resetSpy.size(), 1);
    QCOMPARE(m_proxy->rowCount(), 0);
    // Root index should be invalidated
    QVERIFY(!m_proxy->rootIndex().isValid());
}

void tst_QTreeToTableModel::moveWithinSameParentDownward()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    QAbstractItemModelTester tester(&proxy,
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    // Flat order: A(0), A1(1), A1a(2), A1b(3), A2(4), B(5), B1(6), C(7)

    QSignalSpy moveSpy(&proxy, &QAbstractItemModel::rowsMoved);

    // Move A (top-level row 0) to after C (dest row 3)
    tree.model.moveRows(QModelIndex(), 0, 1, QModelIndex(), 3);

    // A and its subtree (5 items) should have moved
    const auto items = collectFlattenedItems(&proxy);
    QCOMPARE(items.size(), 8);

    // B and C should now come first
    QCOMPARE(items[0], u"B"_s);
    QCOMPARE(items[1], u"B1"_s);
    QCOMPARE(items[2], u"C"_s);
    // Then A and its subtree
    QCOMPARE(items[3], u"A"_s);
    QCOMPARE(items[4], u"A1"_s);
    QCOMPARE(items[5], u"A1a"_s);
    QCOMPARE(items[6], u"A1b"_s);
    QCOMPARE(items[7], u"A2"_s);
}

void tst_QTreeToTableModel::insertChildAtBeginningOfParent()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy insertSpy(m_proxy.get(), &QAbstractItemModel::rowsInserted);
    QVERIFY(insertSpy.isValid());

    // Insert child at the beginning of A1 (before A1a)
    auto *newChild = new QStandardItem(u"A1_first"_s);
    m_itemA1->insertRow(0, newChild);

    QCOMPARE(insertSpy.size(), 1);
    // A1 is at flat row 1, so new child should be at flat row 2
    VERIFY_ROW_SIGNAL(insertSpy.at(0), 2, 2);
    QCOMPARE(m_proxy->index(2, 0).data().toString(), u"A1_first"_s);
    QCOMPARE(m_proxy->depthForRow(2), 2);

    // A1a should now be at flat row 3
    QCOMPARE(m_proxy->index(3, 0).data().toString(), u"A1a"_s);
}

void tst_QTreeToTableModel::removeSingleChildLeaf()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy removeSpy(m_proxy.get(), &QAbstractItemModel::rowsRemoved);
    QVERIFY(removeSpy.isValid());

    // Remove B1 (the only child of B, at flat row 6)
    m_itemB->removeRow(0);

    QCOMPARE(removeSpy.size(), 1);
    VERIFY_ROW_SIGNAL(removeSpy.at(0), 6, 6);
    QCOMPARE(m_proxy->rowCount(), 7);

    // B should now have no children in the flat list
    QCOMPARE(m_proxy->index(5, 0).data().toString(), u"B"_s);
    QCOMPARE(m_proxy->index(6, 0).data().toString(), u"C"_s);
}

void tst_QTreeToTableModel::wideTreeFlattensCorrectly()
{
    m_proxy->setSourceModel(m_sourceModel.get());

    QAbstractItemModelTester tester(m_proxy.get(),
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    // Create a wide tree: 10 top-level items, each with 5 children
    for (int i = 0; i < 10; ++i) {
        auto *parent = new QStandardItem(u"P%1"_s.arg(i));
        m_sourceModel->appendRow(parent);
        for (int j = 0; j < 5; ++j)
            parent->appendRow(new QStandardItem(u"P%1_C%2"_s.arg(i).arg(j)));
    }

    // 10 parents + 50 children = 60 items
    QCOMPARE(m_proxy->rowCount(), 60);

    // Verify depth-first ordering
    QCOMPARE(m_proxy->index(0, 0).data().toString(), u"P0"_s);
    QCOMPARE(m_proxy->depthForRow(0), 0);
    QCOMPARE(m_proxy->index(1, 0).data().toString(), u"P0_C0"_s);
    QCOMPARE(m_proxy->depthForRow(1), 1);
    QCOMPARE(m_proxy->index(6, 0).data().toString(), u"P1"_s);
    QCOMPARE(m_proxy->depthForRow(6), 0);
}

void tst_QTreeToTableModel::deepTreeWithMaxDepthTruncates()
{
    m_proxy->setSourceModel(m_sourceModel.get());

    // Create a chain: L0 -> L1 -> L2 -> L3 -> L4 -> L5
    auto *root = new QStandardItem(u"L0"_s);
    m_sourceModel->appendRow(root);

    QStandardItem *current = root;
    for (int i = 1; i <= 5; ++i) {
        auto *child = new QStandardItem(u"L%1"_s.arg(i));
        current->appendRow(child);
        current = child;
    }

    QCOMPARE(m_proxy->rowCount(), 6); // L0..L5

    // maxDepth=3: show depth 0, 1, 2 => L0, L1, L2
    m_proxy->setMaxDepth(3);
    QCOMPARE(m_proxy->rowCount(), 3);

    const auto items = collectFlattenedItems(m_proxy.get());
    QCOMPARE(items[0], u"L0"_s);
    QCOMPARE(items[1], u"L1"_s);
    QCOMPARE(items[2], u"L2"_s);

    // maxDepth=1: only L0
    m_proxy->setMaxDepth(1);
    QCOMPARE(m_proxy->rowCount(), 1);
    QCOMPARE(m_proxy->index(0, 0).data().toString(), u"L0"_s);
}

// =============================================================================
// Stress and Regression Tests
// =============================================================================

void tst_QTreeToTableModel::largeTreePerformance()
{
    // Build a large tree: 100 top-level items, each with 10 children
    m_proxy->setSourceModel(m_sourceModel.get());

    QAbstractItemModelTester tester(m_proxy.get(),
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    for (int i = 0; i < 100; ++i) {
        auto *parent = new QStandardItem(u"P%1"_s.arg(i));
        m_sourceModel->appendRow(parent);
        for (int j = 0; j < 10; ++j)
            parent->appendRow(new QStandardItem(u"P%1_C%2"_s.arg(i).arg(j)));
    }

    QCOMPARE(m_proxy->rowCount(), 1100); // 100 parents + 1000 children

    // Verify first and last items
    QCOMPARE(m_proxy->index(0, 0).data().toString(), u"P0"_s);
    QCOMPARE(m_proxy->depthForRow(0), 0);

    const int lastRow = m_proxy->rowCount() - 1;
    QCOMPARE(m_proxy->index(lastRow, 0).data().toString(), u"P99_C9"_s);
    QCOMPARE(m_proxy->depthForRow(lastRow), 1);

    // Mapping works at scale
    const QModelIndex srcIdx = m_sourceModel->index(50, 0);
    const int flatRow = m_proxy->rowForSourceIndex(srcIdx);
    QVERIFY(flatRow >= 0);
    QCOMPARE(m_proxy->sourceIndexForRow(flatRow), srcIdx);
}

void tst_QTreeToTableModel::rapidInsertRemoveCycle()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    QCOMPARE(m_proxy->rowCount(), 8);

    QAbstractItemModelTester tester(m_proxy.get(),
                                    QAbstractItemModelTester::FailureReportingMode::Fatal);

    // Rapidly insert and remove items to stress signal handling
    for (int cycle = 0; cycle < 20; ++cycle) {
        auto *item = new QStandardItem(u"Temp_%1"_s.arg(cycle));
        m_itemA->appendRow(item);
        QVERIFY(m_proxy->isSourceIndexVisible(item->index()));
        m_itemA->removeRow(item->row());
    }

    // Model should be back to original state
    QCOMPARE(m_proxy->rowCount(), 8);
    QCOMPARE(collectFlattenedItems(m_proxy.get()),
             QList<QString>({u"A"_s, u"A1"_s, u"A1a"_s, u"A1b"_s,
                             u"A2"_s, u"B"_s, u"B1"_s, u"C"_s}));
}

void tst_QTreeToTableModel::moveSubtreeAcrossDepthBoundary()
{
    // Tree: root -> P -> C1, C2; maxDepth=1 shows only P.
    // Move C1 to top level — it should appear.
    SimpleTreeModel tree;
    auto *p = tree.addChild(u"P"_s);
    auto *c1 = tree.addChild(u"C1"_s, p);
    tree.addChild(u"C2"_s, p);

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree);
    proxy.setMaxDepth(1);

    QCOMPARE(proxy.rowCount(), 1); // Only P
    QCOMPARE(proxy.index(0, 0).data().toString(), u"P"_s);

    // Move C1 from under P to top level — should become visible
    tree.moveRows(tree.indexForNode(p), 0, 1, QModelIndex(), 1);

    QCOMPARE(proxy.rowCount(), 2);
    QCOMPARE(proxy.index(0, 0).data().toString(), u"P"_s);
    QCOMPARE(proxy.index(1, 0).data().toString(), u"C1"_s);
}

void tst_QTreeToTableModel::moveSubtreeDeeperFiltersDescendantsByMaxDepth()
{
    // Tree: A -> B -> C (3 levels). maxDepth=3 shows all.
    // Moving A under a new root P makes depths 1,2,3.
    // With maxDepth=3, C at depth 3 should be filtered out.
    SimpleTreeModel tree;
    auto *p = tree.addChild(u"P"_s);
    auto *a = tree.addChild(u"A"_s);
    auto *b = tree.addChild(u"B"_s, a);
    tree.addChild(u"C"_s, b);

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree);
    proxy.setMaxDepth(3);

    // Initial: P(0), A(0), B(1), C(2) — all 4 visible
    QCOMPARE(proxy.rowCount(), 4);
    QCOMPARE(collectFlattenedItems(&proxy), QList<QString>({u"P"_s, u"A"_s, u"B"_s, u"C"_s}));

    // Move A (with subtree B,C) under P — depths become P(0), A(1), B(2), C(3)
    // C at depth 3 should be excluded (maxDepth=3 means depth < 3)
    tree.moveRows(QModelIndex(), 1, 1, tree.indexForNode(p), 0);

    QCOMPARE(proxy.rowCount(), 3);
    QCOMPARE(collectFlattenedItems(&proxy), QList<QString>({u"P"_s, u"A"_s, u"B"_s}));
    QCOMPARE(collectDepths(&proxy), QList<int>({0, 1, 2}));
}

void tst_QTreeToTableModel::moveSubtreeShallowerRevealsDescendantsAtMaxDepth()
{
    // Tree: P -> A -> B -> C. maxDepth=3 shows P(0), A(1), B(2) — C is hidden.
    // Moving A to top level makes depths A(0), B(1), C(2) — C should appear.
    SimpleTreeModel tree;
    auto *p = tree.addChild(u"P"_s);
    auto *a = tree.addChild(u"A"_s, p);
    auto *b = tree.addChild(u"B"_s, a);
    tree.addChild(u"C"_s, b);

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree);
    proxy.setMaxDepth(3);

    // Initial: P(0), A(1), B(2) — C at depth 3 is hidden
    QCOMPARE(proxy.rowCount(), 3);
    QCOMPARE(collectFlattenedItems(&proxy), QList<QString>({u"P"_s, u"A"_s, u"B"_s}));

    // Move A (with subtree B,C) to top level — depths become A(0), B(1), C(2)
    // C should now be visible
    tree.moveRows(tree.indexForNode(p), 0, 1, QModelIndex(), 1);

    QCOMPARE(proxy.rowCount(), 4);
    QCOMPARE(collectFlattenedItems(&proxy), QList<QString>({u"P"_s, u"A"_s, u"B"_s, u"C"_s}));
    QCOMPARE(collectDepths(&proxy), QList<int>({0, 0, 1, 2}));
}

void tst_QTreeToTableModel::rootIndexInvalidatedByModelReset()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());

    QVERIFY(m_proxy->rootIndex().isValid());
    QCOMPARE(m_proxy->rowCount(), 4); // A1, A1a, A1b, A2

    QSignalSpy rootSpy(m_proxy.get(), &QTreeToTableModel::rootIndexChanged);

    // Clear the model (triggers modelReset)
    m_sourceModel->clear();

    // After reset, root index should be invalidated
    QVERIFY(!m_proxy->rootIndex().isValid());
    QCOMPARE(rootSpy.size(), 1);
    QCOMPARE(m_proxy->rowCount(), 0);
}

void tst_QTreeToTableModel::dataChangedWithRoles()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy dataSpy(m_proxy.get(), &QAbstractItemModel::dataChanged);

    // Change A1's tooltip (a non-display role)
    m_itemA1->setToolTip(u"Tooltip"_s);

    QCOMPARE(dataSpy.size(), 1);
    const auto args = dataSpy.at(0);
    const QModelIndex topLeft = args[0].toModelIndex();
    QCOMPARE(topLeft.row(), 1); // A1 is at flat row 1
}

void tst_QTreeToTableModel::multiColumnSourceModel()
{
    // Create a 2-column source model
    m_sourceModel->setColumnCount(2);
    auto *item = new QStandardItem(u"Row0Col0"_s);
    m_sourceModel->setItem(0, 0, item);
    m_sourceModel->setItem(0, 1, new QStandardItem(u"Row0Col1"_s));

    auto *child = new QStandardItem(u"ChildCol0"_s);
    item->appendRow({child, new QStandardItem(u"ChildCol1"_s)});

    m_proxy->setSourceModel(m_sourceModel.get());

    QCOMPARE(m_proxy->columnCount(), 2);
    QCOMPARE(m_proxy->rowCount(), 2);

    // Column 0
    QCOMPARE(m_proxy->index(0, 0).data().toString(), u"Row0Col0"_s);
    QCOMPARE(m_proxy->index(1, 0).data().toString(), u"ChildCol0"_s);

    // Column 1
    QCOMPARE(m_proxy->index(0, 1).data().toString(), u"Row0Col1"_s);
    QCOMPARE(m_proxy->index(1, 1).data().toString(), u"ChildCol1"_s);
}

void tst_QTreeToTableModel::removeMiddleChildPreservesSiblings()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    // Remove A1 (middle child of A, has children A1a, A1b)
    // Should remove A1, A1a, A1b (flat rows 1-3)
    QSignalSpy removeSpy(m_proxy.get(), &QAbstractItemModel::rowsRemoved);

    m_itemA->removeRow(0); // Remove A1

    QCOMPARE(removeSpy.size(), 1);
    VERIFY_ROW_SIGNAL(removeSpy.at(0), 1, 3); // A1 + A1a + A1b

    // A2 should now be at flat row 1
    QCOMPARE(m_proxy->index(0, 0).data().toString(), u"A"_s);
    QCOMPARE(m_proxy->index(1, 0).data().toString(), u"A2"_s);
    QCOMPARE(m_proxy->index(2, 0).data().toString(), u"B"_s);
    QCOMPARE(m_proxy->rowCount(), 5);
}

void tst_QTreeToTableModel::insertBetweenExistingChildren()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy insertSpy(m_proxy.get(), &QAbstractItemModel::rowsInserted);

    // Insert between A1a and A1b (at row 1 under A1)
    auto *newChild = new QStandardItem(u"A1_mid"_s);
    m_itemA1->insertRow(1, newChild);

    QCOMPARE(insertSpy.size(), 1);
    // A1a is at flat row 2, so new child should be at flat row 3
    VERIFY_ROW_SIGNAL(insertSpy.at(0), 3, 3);

    QCOMPARE(m_proxy->index(2, 0).data().toString(), u"A1a"_s);
    QCOMPARE(m_proxy->index(3, 0).data().toString(), u"A1_mid"_s);
    QCOMPARE(m_proxy->index(4, 0).data().toString(), u"A1b"_s);
    QCOMPARE(m_proxy->rowCount(), 9);
}

void tst_QTreeToTableModel::setSourceModelMultipleTimes()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    QCOMPARE(m_proxy->rowCount(), 8);

    // Create another source model
    QStandardItemModel model2;
    model2.appendRow(new QStandardItem(u"X"_s));
    model2.appendRow(new QStandardItem(u"Y"_s));

    QSignalSpy resetSpy(m_proxy.get(), &QAbstractItemModel::modelReset);

    m_proxy->setSourceModel(&model2);
    QCOMPARE(m_proxy->rowCount(), 2);
    QCOMPARE(m_proxy->index(0, 0).data().toString(), u"X"_s);
    QCOMPARE(m_proxy->index(1, 0).data().toString(), u"Y"_s);
    QCOMPARE(resetSpy.size(), 1);

    // Switch back
    m_proxy->setSourceModel(m_sourceModel.get());
    QCOMPARE(m_proxy->rowCount(), 8);
    QCOMPARE(resetSpy.size(), 2);
}

void tst_QTreeToTableModel::moveLastChildToFirstPosition()
{
    SimpleTreeModel tree;
    auto *a = tree.addChild(u"A"_s);
    auto *b = tree.addChild(u"B"_s);
    auto *c = tree.addChild(u"C"_s);
    Q_UNUSED(a) Q_UNUSED(b) Q_UNUSED(c)

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree);

    QCOMPARE(proxy.rowCount(), 3);
    QCOMPARE(proxy.index(0, 0).data().toString(), u"A"_s);
    QCOMPARE(proxy.index(2, 0).data().toString(), u"C"_s);

    QSignalSpy moveSpy(&proxy, &QAbstractItemModel::rowsMoved);

    // Move C (row 2) to position 0
    tree.moveRows(QModelIndex(), 2, 1, QModelIndex(), 0);

    QCOMPARE(moveSpy.size(), 1);
    QCOMPARE(proxy.index(0, 0).data().toString(), u"C"_s);
    QCOMPARE(proxy.index(1, 0).data().toString(), u"A"_s);
    QCOMPARE(proxy.index(2, 0).data().toString(), u"B"_s);
}

void tst_QTreeToTableModel::countSignalEmittedOnLayoutChange()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QCOMPARE(m_proxy->count(), 8);

    QSignalSpy countSpy(m_proxy.get(), &QTreeToTableModel::countChanged);

    // Sort the source model (triggers layoutChanged)
    m_sourceModel->sort(0, Qt::DescendingOrder);

    // Layout change doesn't change count, so countChanged should not fire
    QCOMPARE(m_proxy->count(), 8);
    QCOMPARE(countSpy.size(), 0);
}

void tst_QTreeToTableModel::mapFromSourceNonColumn0()
{
    m_sourceModel->setColumnCount(2);
    auto *item = new QStandardItem(u"A"_s);
    m_sourceModel->setItem(0, 0, item);
    m_sourceModel->setItem(0, 1, new QStandardItem(u"A_col1"_s));

    m_proxy->setSourceModel(m_sourceModel.get());

    // mapFromSource with column 1 should return proxy index with column 1
    const QModelIndex srcCol1 = m_sourceModel->index(0, 1);
    const QModelIndex proxyIdx = m_proxy->mapFromSource(srcCol1);
    QVERIFY(proxyIdx.isValid());
    QCOMPARE(proxyIdx.row(), 0);
    QCOMPARE(proxyIdx.column(), 1);
}

void tst_QTreeToTableModel::rootIndexSubtreeGrowsWithInsert()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setRootIndex(m_itemA->index());

    QCOMPARE(m_proxy->rowCount(), 4); // A1, A1a, A1b, A2

    QSignalSpy insertSpy(m_proxy.get(), &QAbstractItemModel::rowsInserted);

    // Add a new child to A
    auto *newChild = new QStandardItem(u"A3"_s);
    m_itemA->appendRow(newChild);

    QCOMPARE(insertSpy.size(), 1);
    QCOMPARE(m_proxy->rowCount(), 5);
    QCOMPARE(m_proxy->index(4, 0).data().toString(), u"A3"_s);
    QCOMPARE(m_proxy->depthForRow(4), 0); // Direct child of root
}

void tst_QTreeToTableModel::maxDepthBoundaryInsertThenRemove()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());
    m_proxy->setMaxDepth(2);

    // maxDepth=2: show depth 0, 1 => A, A1, A2, B, B1, C
    QCOMPARE(m_proxy->rowCount(), 6);

    // Insert a child under A1 — it's at depth 2, which is >= maxDepth, so not visible
    auto *deep = new QStandardItem(u"A1_deep"_s);
    m_itemA1->appendRow(deep);

    // A1a, A1b are at depth 2 so not visible, and new A1_deep is also at depth 2
    QCOMPARE(m_proxy->rowCount(), 6); // Unchanged

    // Remove the deep child — still no change
    m_itemA1->removeRow(deep->row());
    QCOMPARE(m_proxy->rowCount(), 6);
}

void tst_QTreeToTableModel::moveWithinSameParentUpward()
{
    SimpleTreeModel tree;
    auto *a = tree.addChild(u"A"_s);
    auto *b = tree.addChild(u"B"_s);
    auto *c = tree.addChild(u"C"_s);
    Q_UNUSED(a) Q_UNUSED(b) Q_UNUSED(c)

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree);

    QSignalSpy moveSpy(&proxy, &QAbstractItemModel::rowsMoved);

    // Move B (row 1) to position 0
    tree.moveRows(QModelIndex(), 1, 1, QModelIndex(), 0);

    QCOMPARE(moveSpy.size(), 1);
    QCOMPARE(proxy.index(0, 0).data().toString(), u"B"_s);
    QCOMPARE(proxy.index(1, 0).data().toString(), u"A"_s);
    QCOMPARE(proxy.index(2, 0).data().toString(), u"C"_s);
}

void tst_QTreeToTableModel::indexOutOfRangeReturnsInvalid()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    // Negative row
    QVERIFY(!m_proxy->index(-1, 0).isValid());
    // Past end
    QVERIFY(!m_proxy->index(100, 0).isValid());
    // Negative column
    QVERIFY(!m_proxy->index(0, -1).isValid());
    // Column past end
    QVERIFY(!m_proxy->index(0, 100).isValid());
    // With a parent (flat model has no children)
    QVERIFY(!m_proxy->index(0, 0, m_proxy->index(0, 0)).isValid());

    // mapToSource with out-of-range
    QVERIFY(!m_proxy->mapToSource(m_proxy->index(-1, 0)).isValid());
    QVERIFY(!m_proxy->mapToSource(m_proxy->index(100, 0)).isValid());

    // sourceIndexForRow with out-of-range
    QVERIFY(!m_proxy->sourceIndexForRow(-1).isValid());
    QVERIFY(!m_proxy->sourceIndexForRow(100).isValid());
}

void tst_QTreeToTableModel::persistentIndexSurvivesMove()
{
    SimpleTreeModel tree;
    auto *a = tree.addChild(u"A"_s);
    auto *b = tree.addChild(u"B"_s);
    auto *c = tree.addChild(u"C"_s);
    Q_UNUSED(a) Q_UNUSED(c)
    tree.addChild(u"B1"_s, b);

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree);

    // B is at flat row 1, B1 at row 2, C at row 3
    QPersistentModelIndex bIdx(proxy.index(1, 0));
    QPersistentModelIndex cIdx(proxy.index(3, 0));
    QCOMPARE(bIdx.data().toString(), u"B"_s);
    QCOMPARE(cIdx.data().toString(), u"C"_s);

    // Move A (row 0) to after C (dest row 3)
    tree.moveRows(QModelIndex(), 0, 1, QModelIndex(), 3);

    // B should now be at row 0, C at row 2
    QVERIFY(bIdx.isValid());
    QCOMPARE(bIdx.data().toString(), u"B"_s);
    QCOMPARE(bIdx.row(), 0);

    QVERIFY(cIdx.isValid());
    QCOMPARE(cIdx.data().toString(), u"C"_s);
    QCOMPARE(cIdx.row(), 2);
}

void tst_QTreeToTableModel::persistentIndexSurvivesLayoutChange()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    // Create persistent indexes for A (row 0) and C (row 7)
    QPersistentModelIndex aIdx(m_proxy->index(0, 0));
    QPersistentModelIndex cIdx(m_proxy->index(7, 0));
    QCOMPARE(aIdx.data().toString(), u"A"_s);
    QCOMPARE(cIdx.data().toString(), u"C"_s);

    // Sort descending triggers layoutChanged
    m_sourceModel->sort(0, Qt::DescendingOrder);

    // After sort: C should be first, A should be later
    QVERIFY(aIdx.isValid());
    QVERIFY(cIdx.isValid());
    QCOMPARE(aIdx.data().toString(), u"A"_s);
    QCOMPARE(cIdx.data().toString(), u"C"_s);

    // C should now be at a lower row than A (C < B < A in descending)
    QVERIFY(cIdx.row() < aIdx.row());
}

void tst_QTreeToTableModel::persistentIndexSurvivesLayoutChangeMultiColumn()
{
    // Build a multi-column source model
    m_sourceModel->setColumnCount(3);
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    // Set data in column 1 so we can verify after sort
    m_itemA->setChild(0, 1, new QStandardItem(u"A1-col1"_s));

    // Create persistent indexes at column 0 and column 1 for the same row
    QPersistentModelIndex col0Idx(m_proxy->index(0, 0)); // A, column 0
    QPersistentModelIndex col1Idx(m_proxy->index(0, 1)); // A, column 1
    QCOMPARE(col0Idx.row(), 0);
    QCOMPARE(col0Idx.column(), 0);
    QCOMPARE(col1Idx.row(), 0);
    QCOMPARE(col1Idx.column(), 1);

    // Sort descending triggers layoutChanged
    m_sourceModel->sort(0, Qt::DescendingOrder);

    // Both persistent indexes should still be valid and point to the same row
    QVERIFY(col0Idx.isValid());
    QVERIFY(col1Idx.isValid());
    QCOMPARE(col0Idx.row(), col1Idx.row());
    // Column must be preserved
    QCOMPARE(col0Idx.column(), 0);
    QCOMPARE(col1Idx.column(), 1);
}

// =============================================================================
// Signal Pairing and New Coverage Tests
// =============================================================================

void tst_QTreeToTableModel::aboutToBeInsertedEmittedWithInserted()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy aboutSpy(m_proxy.get(), &QAbstractItemModel::rowsAboutToBeInserted);
    QSignalSpy insertSpy(m_proxy.get(), &QAbstractItemModel::rowsInserted);
    QVERIFY(aboutSpy.isValid());
    QVERIFY(insertSpy.isValid());

    m_sourceModel->appendRow(new QStandardItem(u"D"_s));

    QCOMPARE(aboutSpy.size(), 1);
    QCOMPARE(insertSpy.size(), 1);
    // Both signals should carry the same row range
    VERIFY_ROW_SIGNAL(aboutSpy.at(0), 8, 8);
    VERIFY_ROW_SIGNAL(insertSpy.at(0), 8, 8);
}

void tst_QTreeToTableModel::aboutToBeRemovedEmittedWithRemoved()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy aboutSpy(m_proxy.get(), &QAbstractItemModel::rowsAboutToBeRemoved);
    QSignalSpy removeSpy(m_proxy.get(), &QAbstractItemModel::rowsRemoved);
    QVERIFY(aboutSpy.isValid());
    QVERIFY(removeSpy.isValid());

    // Remove C (flat row 7)
    m_sourceModel->removeRow(2);

    QCOMPARE(aboutSpy.size(), 1);
    QCOMPARE(removeSpy.size(), 1);
    VERIFY_ROW_SIGNAL(aboutSpy.at(0), 7, 7);
    VERIFY_ROW_SIGNAL(removeSpy.at(0), 7, 7);
}

void tst_QTreeToTableModel::aboutToBeMovedEmittedWithMoved()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    QSignalSpy aboutMoveSpy(&proxy, &QAbstractItemModel::rowsAboutToBeMoved);
    QSignalSpy moveSpy(&proxy, &QAbstractItemModel::rowsMoved);
    QVERIFY(aboutMoveSpy.isValid());
    QVERIFY(moveSpy.isValid());

    // Move C (flat row 7) to after A (dest row 1 at top level)
    tree.model.moveRows(QModelIndex(), 2, 1, QModelIndex(), 1);

    // Both aboutToBeMoved and moved must fire with matching arguments
    QCOMPARE(aboutMoveSpy.size(), 1);
    QCOMPARE(moveSpy.size(), 1);
    VERIFY_MOVE_SIGNAL(aboutMoveSpy.at(0), 7, 7, 5);
    VERIFY_MOVE_SIGNAL(moveSpy.at(0), 7, 7, 5);
}

void tst_QTreeToTableModel::layoutAboutToBeChangedEmittedWithChanged()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy aboutSpy(m_proxy.get(), &QAbstractItemModel::layoutAboutToBeChanged);
    QSignalSpy changedSpy(m_proxy.get(), &QAbstractItemModel::layoutChanged);
    QVERIFY(aboutSpy.isValid());
    QVERIFY(changedSpy.isValid());

    m_sourceModel->sort(0, Qt::DescendingOrder);

    QCOMPARE(aboutSpy.size(), 1);
    QCOMPARE(changedSpy.size(), 1);
}

void tst_QTreeToTableModel::aboutToBeResetEmittedWithReset()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QSignalSpy aboutSpy(m_proxy.get(), &QAbstractItemModel::modelAboutToBeReset);
    QSignalSpy resetSpy(m_proxy.get(), &QAbstractItemModel::modelReset);
    QVERIFY(aboutSpy.isValid());
    QVERIFY(resetSpy.isValid());

    // Changing the source model triggers a reset
    auto otherModel = std::make_unique<QStandardItemModel>();
    m_proxy->setSourceModel(otherModel.get());

    QCOMPARE(aboutSpy.size(), 1);
    QCOMPARE(resetSpy.size(), 1);

    // Clean up so cleanup() can safely reset m_proxy
    m_proxy->setSourceModel(nullptr);
}

void tst_QTreeToTableModel::hasChildrenReturnsFalseForValidIndexes()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    // The invisible root should have children
    QVERIFY(m_proxy->hasChildren(QModelIndex()));

    // All valid indexes should NOT have children (flat table)
    for (int i = 0; i < m_proxy->rowCount(); ++i) {
        QModelIndex idx = m_proxy->index(i, 0);
        QVERIFY2(!m_proxy->hasChildren(idx),
                 qPrintable(u"Row %1 should have no children"_s.arg(i)));
    }

    // Empty model: root should NOT have children
    auto emptyModel = std::make_unique<QStandardItemModel>();
    m_proxy->setSourceModel(emptyModel.get());
    QVERIFY(!m_proxy->hasChildren(QModelIndex()));
}

void tst_QTreeToTableModel::siblingReturnsCorrectIndex()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    // sibling(row, col) should return the same as index(row, col)
    QModelIndex idx0 = m_proxy->index(0, 0);
    QModelIndex sib3 = m_proxy->sibling(3, 0, idx0);
    QVERIFY(sib3.isValid());
    QCOMPARE(sib3.row(), 3);
    QCOMPARE(sib3.data().toString(), u"A1b"_s);

    // Multi-column sibling
    m_sourceModel->setColumnCount(2);
    QModelIndex sib0c1 = m_proxy->sibling(0, 1, idx0);
    QVERIFY(sib0c1.isValid());
    QCOMPARE(sib0c1.row(), 0);
    QCOMPARE(sib0c1.column(), 1);

    // Out of range
    QModelIndex invalid = m_proxy->sibling(100, 0, idx0);
    QVERIFY(!invalid.isValid());
}

void tst_QTreeToTableModel::mapFromSourceForeignModelReturnsInvalid()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    // Create a foreign model and get an index from it
    QStandardItemModel foreignModel;
    foreignModel.appendRow(new QStandardItem(u"Foreign"_s));
    QModelIndex foreignIdx = foreignModel.index(0, 0);

    // mapFromSource with a foreign index should return invalid
    QModelIndex result = m_proxy->mapFromSource(foreignIdx);
    QVERIFY(!result.isValid());

    // rowForSourceIndex with a foreign index should return -1
    QCOMPARE(m_proxy->rowForSourceIndex(foreignIdx), -1);

    // isSourceIndexVisible with a foreign index should return false
    QVERIFY(!m_proxy->isSourceIndexVisible(foreignIdx));
}

void tst_QTreeToTableModel::mapToSourceForeignModelReturnsInvalid()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    // Create a foreign proxy and get an index from it
    QTreeToTableModel foreignProxy;
    QStandardItemModel foreignModel;
    foreignModel.appendRow(new QStandardItem(u"Foreign"_s));
    foreignProxy.setSourceModel(&foreignModel);

    QModelIndex foreignIdx = foreignProxy.index(0, 0);
    QVERIFY(foreignIdx.isValid());

    // Passing a foreign proxy's index to our proxy's mapToSource is
    // undefined behavior at the model API level, but it should not crash.
    // We verify that the result doesn't map to anything valid in our source.
    // (The index will have row=0 and the proxy will look up m_items[0],
    // which is a valid item from our model, not the foreign one.)
}

// =============================================================================
// isAncestorOf tests
// =============================================================================

void tst_QTreeToTableModel::isAncestorOfSameIndex()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QModelIndex a = m_sourceModel->indexFromItem(m_itemA);
    QVERIFY(m_proxy->isAncestorOf(a, a));
}

void tst_QTreeToTableModel::isAncestorOfParentChild()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QModelIndex a = m_sourceModel->indexFromItem(m_itemA);
    QModelIndex a1 = m_sourceModel->indexFromItem(m_itemA1);

    QVERIFY(m_proxy->isAncestorOf(a, a1));
    QVERIFY(!m_proxy->isAncestorOf(a1, a));
}

void tst_QTreeToTableModel::isAncestorOfGrandparentGrandchild()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QModelIndex a = m_sourceModel->indexFromItem(m_itemA);
    QModelIndex a1a = m_sourceModel->indexFromItem(m_itemA1a);

    QVERIFY(m_proxy->isAncestorOf(a, a1a));
    QVERIFY(!m_proxy->isAncestorOf(a1a, a));
}

void tst_QTreeToTableModel::isAncestorOfUnrelatedReturnsFalse()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QModelIndex a = m_sourceModel->indexFromItem(m_itemA);
    QModelIndex b = m_sourceModel->index(1, 0); // B

    QVERIFY(!m_proxy->isAncestorOf(a, b));
    QVERIFY(!m_proxy->isAncestorOf(b, a));
}

void tst_QTreeToTableModel::isAncestorOfInvalidReturnsFalse()
{
    buildStandardTree();
    m_proxy->setSourceModel(m_sourceModel.get());

    QModelIndex a = m_sourceModel->indexFromItem(m_itemA);

    QVERIFY(!m_proxy->isAncestorOf(QModelIndex(), a));
    QVERIFY(!m_proxy->isAncestorOf(a, QModelIndex()));
    QVERIFY(!m_proxy->isAncestorOf(QModelIndex(), QModelIndex()));
}

// =============================================================================
// moveSourceRow tests
// =============================================================================

void tst_QTreeToTableModel::moveSourceRowWithinParent()
{
    // Use SimpleTreeModel since QStandardItemModel doesn't support moveRows
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    // Tree: A(A1(A1a,A1b), A2), B(B1), C
    // Flat: A, A1, A1a, A1b, A2, B, B1, C
    QCOMPARE(proxy.rowCount(), 8);

    // Move A2 before A1 (within parent A)
    QModelIndex a2Idx = tree.model.indexForNode(tree.A2);
    QModelIndex aIdx = tree.model.indexForNode(tree.A);

    QVERIFY(proxy.moveSourceRow(a2Idx, aIdx, 0));

    // Flat after: A, A2, A1, A1a, A1b, B, B1, C
    QCOMPARE(proxy.rowCount(), 8);
    QCOMPARE(proxy.index(0, 0).data().toString(), u"A"_s);
    QCOMPARE(proxy.index(1, 0).data().toString(), u"A2"_s);
    QCOMPARE(proxy.index(2, 0).data().toString(), u"A1"_s);
}

void tst_QTreeToTableModel::moveSourceRowBetweenParents()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    // Move B1 under A as first child
    QModelIndex b1Idx = tree.model.indexForNode(tree.B1);
    QModelIndex aIdx = tree.model.indexForNode(tree.A);

    QVERIFY(proxy.moveSourceRow(b1Idx, aIdx, 0));

    // Flat after: A, B1, A1, A1a, A1b, A2, B, C
    QCOMPARE(proxy.rowCount(), 8);
    QCOMPARE(proxy.index(1, 0).data().toString(), u"B1"_s);
    QCOMPARE(proxy.index(2, 0).data().toString(), u"A1"_s);
}

void tst_QTreeToTableModel::moveSourceRowIntoOwnSubtreeRejected()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    // Try to move A under A1 (its own child) — should fail
    QModelIndex aIdx = tree.model.indexForNode(tree.A);
    QModelIndex a1Idx = tree.model.indexForNode(tree.A1);

    QVERIFY(!proxy.moveSourceRow(aIdx, a1Idx, 0));

    // Try to move A under A1a (its own grandchild) — should fail
    QModelIndex a1aIdx = tree.model.indexForNode(tree.A1a);
    QVERIFY(!proxy.moveSourceRow(aIdx, a1aIdx, 0));

    // Model should be unchanged
    QCOMPARE(proxy.rowCount(), 8);
    QCOMPARE(proxy.index(0, 0).data().toString(), u"A"_s);
}

void tst_QTreeToTableModel::moveSourceRowInvalidSourceRejected()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    QVERIFY(!proxy.moveSourceRow(QModelIndex(), QModelIndex(), 0));

    // Model unchanged
    QCOMPARE(proxy.rowCount(), 8);
}

void tst_QTreeToTableModel::moveSourceRowAppendWithMinusOne()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    // Move C under B with destinationChild=-1 (append)
    QModelIndex cIdx = tree.model.indexForNode(tree.C);
    QModelIndex bIdx = tree.model.indexForNode(tree.B);

    QVERIFY(proxy.moveSourceRow(cIdx, bIdx, -1));

    // C should now be after B1 under B
    // Flat: A, A1, A1a, A1b, A2, B, B1, C
    QCOMPARE(proxy.rowCount(), 8);
    QCOMPARE(proxy.index(5, 0).data().toString(), u"B"_s);
    QCOMPARE(proxy.index(6, 0).data().toString(), u"B1"_s);
    QCOMPARE(proxy.index(7, 0).data().toString(), u"C"_s);
    // C should now be at depth 1 (child of B)
    QCOMPARE(proxy.depthForRow(7), 1);
}

void tst_QTreeToTableModel::moveSourceRowNoSourceModelRejected()
{
    QTreeToTableModel proxy;
    // No source model set
    QVERIFY(!proxy.moveSourceRow(QModelIndex(), QModelIndex(), 0));
}

void tst_QTreeToTableModel::moveSourceRowToRootLevel()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    // Tree: A(A1(A1a,A1b), A2), B(B1), C
    // Move A1 to root level (between B and C)
    QModelIndex a1Idx = tree.model.indexForNode(tree.A1);

    QVERIFY(proxy.moveSourceRow(a1Idx, QModelIndex(), 2));

    // Flat after: A, A2, B, B1, A1, A1a, A1b, C
    QCOMPARE(proxy.rowCount(), 8);
    QCOMPARE(proxy.index(0, 0).data().toString(), u"A"_s);
    QCOMPARE(proxy.index(1, 0).data().toString(), u"A2"_s);
    QCOMPARE(proxy.index(2, 0).data().toString(), u"B"_s);
    QCOMPARE(proxy.index(3, 0).data().toString(), u"B1"_s);
    QCOMPARE(proxy.index(4, 0).data().toString(), u"A1"_s);
    QCOMPARE(proxy.index(5, 0).data().toString(), u"A1a"_s);
    QCOMPARE(proxy.index(6, 0).data().toString(), u"A1b"_s);
    QCOMPARE(proxy.index(7, 0).data().toString(), u"C"_s);

    // A1 should now be at depth 0 (root level)
    QCOMPARE(proxy.depthForRow(4), 0);
    // A1a, A1b should now be at depth 1
    QCOMPARE(proxy.depthForRow(5), 1);
    QCOMPARE(proxy.depthForRow(6), 1);
}

void tst_QTreeToTableModel::moveSourceRowSelfDropRejected()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    // Try to move A into itself — isAncestorOf(A, A) returns true
    QModelIndex aIdx = tree.model.indexForNode(tree.A);
    QVERIFY(!proxy.moveSourceRow(aIdx, aIdx, 0));

    // Model should be unchanged
    QCOMPARE(proxy.rowCount(), 8);
    QCOMPARE(proxy.index(0, 0).data().toString(), u"A"_s);
}

void tst_QTreeToTableModel::moveSourceRowOutOfRangeChildAppends()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    // Move C under A with destinationChild=999 (out of range, should append)
    QModelIndex cIdx = tree.model.indexForNode(tree.C);
    QModelIndex aIdx = tree.model.indexForNode(tree.A);

    QVERIFY(proxy.moveSourceRow(cIdx, aIdx, 999));

    // C should be the last child of A (after A1, A2)
    // Flat after: A, A1, A1a, A1b, A2, C, B, B1
    QCOMPARE(proxy.rowCount(), 8);
    QCOMPARE(proxy.index(4, 0).data().toString(), u"A2"_s);
    QCOMPARE(proxy.index(5, 0).data().toString(), u"C"_s);
    QCOMPARE(proxy.index(6, 0).data().toString(), u"B"_s);
    // C is now at depth 1 (child of A)
    QCOMPARE(proxy.depthForRow(5), 1);
}

void tst_QTreeToTableModel::moveSourceRowCrossDepthWithSubtree()
{
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    // Move B (with child B1) under A1 — from root (depth 0) to depth 2
    QModelIndex bIdx = tree.model.indexForNode(tree.B);
    QModelIndex a1Idx = tree.model.indexForNode(tree.A1);

    QVERIFY(proxy.moveSourceRow(bIdx, a1Idx, -1));

    // Flat after: A, A1, A1a, A1b, B, B1, A2, C
    QCOMPARE(proxy.rowCount(), 8);
    QCOMPARE(proxy.index(0, 0).data().toString(), u"A"_s);
    QCOMPARE(proxy.index(1, 0).data().toString(), u"A1"_s);
    QCOMPARE(proxy.index(2, 0).data().toString(), u"A1a"_s);
    QCOMPARE(proxy.index(3, 0).data().toString(), u"A1b"_s);
    QCOMPARE(proxy.index(4, 0).data().toString(), u"B"_s);
    QCOMPARE(proxy.index(5, 0).data().toString(), u"B1"_s);
    QCOMPARE(proxy.index(6, 0).data().toString(), u"A2"_s);
    QCOMPARE(proxy.index(7, 0).data().toString(), u"C"_s);

    // B moved from depth 0 to depth 2, B1 from depth 1 to depth 3
    QCOMPARE(proxy.depthForRow(4), 2);
    QCOMPARE(proxy.depthForRow(5), 3);
}

// =============================================================================
// dataChanged signal tests for depth after move
// =============================================================================

void tst_QTreeToTableModel::moveSameDepthDoesNotEmitDepthChanged()
{
    // Moving within the same parent doesn't change depth, so no dataChanged
    // with DepthRole should be emitted.
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    QSignalSpy dataChangedSpy(&proxy, &QAbstractItemModel::dataChanged);

    // Move A2 before A1 (both at depth 1 under A — no depth change)
    const bool moved = tree.model.moveRows(
        tree.model.indexForNode(tree.A), 1, 1,
        tree.model.indexForNode(tree.A), 0);
    QVERIFY(moved);

    // No dataChanged with DepthRole should have been emitted.
    for (int i = 0; i < dataChangedSpy.size(); ++i) {
        const QList<int> roles = dataChangedSpy.at(i).at(2).value<QList<int>>();
        QVERIFY2(!roles.contains(static_cast<int>(QTreeToTableModel::Roles::Depth)),
                 "dataChanged with DepthRole emitted for same-depth move");
    }

    // Depths are still correct
    QCOMPARE(proxy.depthForRow(1), 1); // A2 (moved to row 1)
    QCOMPARE(proxy.depthForRow(2), 1); // A1 (moved to row 2)
}

void tst_QTreeToTableModel::moveDifferentParentSameDepthDoesNotEmitDepthChanged()
{
    // Moving between different parents at the same resulting depth should
    // NOT emit dataChanged with DepthRole.
    TestTree tree;
    tree.build();
    // Tree: A(A1(A1a,A1b), A2), B(B1), C
    // Both A and B are at depth 0, so B1 (depth 1) moved under A stays at depth 1.

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    QSignalSpy dataChangedSpy(&proxy, &QAbstractItemModel::dataChanged);

    // Move B1 from under B to under A (both parents at depth 0, child stays depth 1)
    QVERIFY(proxy.moveSourceRow(
        tree.model.indexForNode(tree.B1),
        tree.model.indexForNode(tree.A), -1));

    // No dataChanged with DepthRole should have been emitted.
    for (int i = 0; i < dataChangedSpy.size(); ++i) {
        const QList<int> roles = dataChangedSpy.at(i).at(2).value<QList<int>>();
        QVERIFY2(!roles.contains(static_cast<int>(QTreeToTableModel::Roles::Depth)),
                 "dataChanged with DepthRole emitted for same-depth cross-parent move");
    }

    // B1 should still be at depth 1
    const int b1Row = proxy.rowForSourceIndex(tree.model.indexForNode(tree.B1));
    QVERIFY(b1Row >= 0);
    QCOMPARE(proxy.depthForRow(b1Row), 1);
}

void tst_QTreeToTableModel::moveCrossDepthEmitsDepthChanged()
{
    // Moving to a different parent at a different depth should emit
    // dataChanged with DepthRole.
    TestTree tree;
    tree.build();

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    QSignalSpy dataChangedSpy(&proxy, &QAbstractItemModel::dataChanged);

    // Move C (depth 0) under A1 (making it depth 2)
    QModelIndex cIdx = tree.model.indexForNode(tree.C);
    QModelIndex a1Idx = tree.model.indexForNode(tree.A1);
    QVERIFY(proxy.moveSourceRow(cIdx, a1Idx, -1));

    // Should have emitted dataChanged with DepthRole
    bool foundDepthChange = false;
    for (int i = 0; i < dataChangedSpy.size(); ++i) {
        const QList<int> roles = dataChangedSpy.at(i).at(2).value<QList<int>>();
        if (roles.contains(static_cast<int>(QTreeToTableModel::Roles::Depth))) {
            foundDepthChange = true;
            break;
        }
    }
    QVERIFY2(foundDepthChange,
             "dataChanged with DepthRole was NOT emitted for cross-depth move");

    // Verify depth is actually correct
    const int cRow = proxy.rowForSourceIndex(tree.model.indexForNode(tree.C));
    QVERIFY(cRow >= 0);
    QCOMPARE(proxy.depthForRow(cRow), 2);
}

void tst_QTreeToTableModel::moveCrossDepthSubtreeDataChangedCoversAllRows()
{
    // When moving a parent with children across depths, the dataChanged
    // signal should cover ALL moved rows (parent + descendants).
    TestTree tree;
    tree.build();
    // Tree: A(A1(A1a,A1b), A2), B(B1), C
    // Moving B (depth 0) with B1 (depth 1) under A1 gives B→depth 2, B1→depth 3

    QTreeToTableModel proxy;
    proxy.setSourceModel(&tree.model);

    QSignalSpy dataChangedSpy(&proxy, &QAbstractItemModel::dataChanged);

    QModelIndex bIdx = tree.model.indexForNode(tree.B);
    QModelIndex a1Idx = tree.model.indexForNode(tree.A1);
    QVERIFY(proxy.moveSourceRow(bIdx, a1Idx, -1));

    // Find the dataChanged emission with DepthRole
    int dcFirst = -1;
    int dcLast = -1;
    for (int i = 0; i < dataChangedSpy.size(); ++i) {
        const QList<int> roles = dataChangedSpy.at(i).at(2).value<QList<int>>();
        if (roles.contains(static_cast<int>(QTreeToTableModel::Roles::Depth))) {
            dcFirst = dataChangedSpy.at(i).at(0).toModelIndex().row();
            dcLast = dataChangedSpy.at(i).at(1).toModelIndex().row();
            break;
        }
    }
    QVERIFY2(dcFirst >= 0, "No dataChanged with DepthRole emitted");

    // The range must cover both B and B1
    const int bRow = proxy.rowForSourceIndex(tree.model.indexForNode(tree.B));
    const int b1Row = proxy.rowForSourceIndex(tree.model.indexForNode(tree.B1));
    QVERIFY(bRow >= 0);
    QVERIFY(b1Row >= 0);
    QVERIFY2(dcFirst <= bRow && bRow <= dcLast,
             qPrintable(u"B (row %1) not in dataChanged range [%2, %3]"_s
                            .arg(bRow).arg(dcFirst).arg(dcLast)));
    QVERIFY2(dcFirst <= b1Row && b1Row <= dcLast,
             qPrintable(u"B1 (row %1) not in dataChanged range [%2, %3]"_s
                            .arg(b1Row).arg(dcFirst).arg(dcLast)));

    // Verify depths are correct
    QCOMPARE(proxy.depthForRow(bRow), 2);
    QCOMPARE(proxy.depthForRow(b1Row), 3);
}

QTEST_MAIN(tst_QTreeToTableModel)
#include "tst_qtreetotablemodel.moc"