// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default

#include <QtQmlModels/private/qqmlsortercompositor_p.h>
#include <QtQmlModels/private/qqmlsortfilterproxymodel_p_p.h>
#include <QtQmlModels/private/qqmlsortfilterproxymodel_p.h>

QT_BEGIN_NAMESPACE

QQmlSorterCompositor::QQmlSorterCompositor(QObject *parent)
    : QQmlSorterBase(new QQmlSorterCompositorPrivate, parent)
{
    Q_D(QQmlSorterCompositor);
    d->init();
    // Connect the model reset with the update in the filter
    // The cache need to be updated once the model is reset with the
    // source model data.
    connect(d->m_sfpmModel, &QQmlSortFilterProxyModel::modelReset,
            this, &QQmlSorterCompositor::updateSorters);
    connect(d->m_sfpmModel, &QQmlSortFilterProxyModel::primarySorterChanged,
            this, &QQmlSorterCompositor::updateEffectiveSorters);
}

QQmlSorterCompositor::~QQmlSorterCompositor()
{

}

void QQmlSorterCompositorPrivate::init()
{
    Q_Q(QQmlSorterCompositor);
    m_sfpmModel = qobject_cast<QQmlSortFilterProxyModel *>(q->parent());
}

void QQmlSorterCompositor::append(QQmlListProperty<QQmlSorterBase> *sorterComp, QQmlSorterBase* sorter)
{
    auto *sorterCompositor = reinterpret_cast<QQmlSorterCompositor *>(sorterComp->object);
    sorterCompositor->append(sorter);
}

qsizetype QQmlSorterCompositor::count(QQmlListProperty<QQmlSorterBase> *sorterComp)
{
    auto *sorterCompositor = reinterpret_cast<QQmlSorterCompositor *> (sorterComp->object);
    return sorterCompositor->count();
}

QQmlSorterBase *QQmlSorterCompositor::at(QQmlListProperty<QQmlSorterBase> *sorterComp, qsizetype index)
{
    auto *sorterCompositor = reinterpret_cast<QQmlSorterCompositor *> (sorterComp->object);
    return sorterCompositor->at(index);
}

void QQmlSorterCompositor::clear(QQmlListProperty<QQmlSorterBase> *sorterComp)
{
    auto *sorterCompositor = reinterpret_cast<QQmlSorterCompositor *> (sorterComp->object);
    sorterCompositor->clear();
}

void QQmlSorterCompositor::append(QQmlSorterBase *sorter)
{
    if (!sorter)
        return;
    Q_D(QQmlSorterCompositor);
    d->m_sorters.append(sorter);
    // Update sorter cache depending on the priority
    updateCache();
    // Connect the sorter to the corresponding slot to invalidate the model
    // and the sorter cache
    QObject::connect(sorter, &QQmlSorterBase::invalidateModel,
                         d->m_sfpmModel, &QQmlSortFilterProxyModel::invalidate);
    // This is needed as its required to update cache when there is any
    // change in the filter itself (for instance, a change in the priority of
    // the filter)
    QObject::connect(sorter, &QQmlSorterBase::invalidateCache,
                     this, &QQmlSorterCompositor::updateCache);
    // Reset the primary sort column when any sort order or column
    // changed
    QObject::connect(sorter, &QQmlSorterBase::sortOrderChanged,
                     this, [d] { d->resetPrimarySorter(); });
    QObject::connect(sorter, &QQmlSorterBase::columnChanged,
                     this, [d] { d->resetPrimarySorter(); });
    // Since we added new filter to the list, emit the filter changed signal
    // for the filters thats been appended to the list
    emit d->m_sfpmModel->sortersChanged();
}

qsizetype QQmlSorterCompositor::count()
{
    Q_D(QQmlSorterCompositor);
    return d->m_sorters.count();
}

QQmlSorterBase* QQmlSorterCompositor::at(qsizetype index)
{
    Q_D(QQmlSorterCompositor);
    return d->m_sorters.at(index);
}

void QQmlSorterCompositor::clear()
{
    Q_D(QQmlSorterCompositor);
    d->m_effectiveSorters.clear();
    d->m_sorters.clear();
    // Emit the filter changed signal as we cleared the filter list
    emit d->m_sfpmModel->sortersChanged();
}

QList<QQmlSorterBase *> QQmlSorterCompositor::sorters()
{
    Q_D(QQmlSorterCompositor);
    return d->m_sorters;
}

QQmlListProperty<QQmlSorterBase> QQmlSorterCompositor::sortersListProperty()
{
    Q_D(QQmlSorterCompositor);
    return QQmlListProperty<QQmlSorterBase>(reinterpret_cast<QObject*>(this), &d->m_sorters,
                                                  QQmlSorterCompositor::append,
                                                  QQmlSorterCompositor::count,
                                                  QQmlSorterCompositor::at,
                                                  QQmlSorterCompositor::clear);
}

void QQmlSorterCompositor::updateEffectiveSorters()
{
    Q_D(QQmlSorterCompositor);

    if (!d->m_primarySorter || !d->m_primarySorter->enabled()) {
        updateCache();
        return;
    }

    QList<QQmlSorterBase *> sorters;
    sorters.append(d->m_primarySorter);
    std::copy_if(d->m_effectiveSorters.constBegin(), d->m_effectiveSorters.constEnd(),
                 std::back_inserter(sorters), [d](QQmlSorterBase *sorter){
                     // Consider only the filters that are enabled and exclude the primary
                     // sorter as its already added to the list
                     return (sorter != d->m_primarySorter);
                 });
    d->m_effectiveSorters = sorters;
}

void QQmlSorterCompositor::updateSorters()
{
    Q_D(QQmlSorterCompositor);
    // Update sorters that has dependency with the model data to determine
    // whether it needs to be included or not
    for (auto &sorter: d->m_sorters)
        sorter->update(d->m_sfpmModel);
    updateCache();
}

void QQmlSorterCompositor::updateCache()
{
    Q_D(QQmlSorterCompositor);
    // Clear the existing cache
    d->m_effectiveSorters.clear();
    if (d->m_sfpmModel && d->m_sfpmModel->sourceModel()) {
        // Sort the filter according to their priority
        QList<QQmlSorterBase *> sorters = d->m_sorters;
        std::stable_sort(sorters.begin(), sorters.end(),
                [](QQmlSorterBase *sorterLeft, QQmlSorterBase *sorterRight) {
                        return sorterLeft->priority() < sorterRight->priority();
                });
        // Cache only the filters that are need to be evaluated (in order)
        std::copy_if(sorters.begin(), sorters.end(), std::back_inserter(d->m_effectiveSorters),
                [](QQmlSorterBase *sorter) { return sorter->enabled(); });
        // If there is no primary sorter set by the user explicitly, reset the
        // primary sorter according to the sorters in the lists
        d->resetPrimarySorter();
    }
}

bool QQmlSorterCompositor::lessThan(const QModelIndex& sourceLeft, const QModelIndex& sourceRight, const QQmlSortFilterProxyModel *proxyModel) const
{
    Q_D(const QQmlSorterCompositor);
    for (const auto &sorter : d->m_effectiveSorters) {
        const int sortSection = sorter->column();
        if ((sortSection > -1) && (sortSection < proxyModel->sourceModel()->columnCount())) {
            const auto *sourceModel = proxyModel->sourceModel();
            const QPartialOrdering result = sorter->compare(sourceModel->index(sourceLeft.row(), sortSection),
                                                            sourceModel->index(sourceRight.row(), sortSection),
                                                            proxyModel);
            if (result == QPartialOrdering::Less || result == QPartialOrdering::Greater) {
                auto *priv = static_cast<const QQmlSortFilterProxyModelPrivate *>(QQmlSortFilterProxyModelPrivate::get(proxyModel));
                return (priv->m_sortOrder == sorter->sortOrder()) ? result < 0 : result > 0;
            }
        }
    }
    // Verify the index order when the ordering is either equal or unordered
    return sourceLeft.row() < sourceRight.row();
}

void QQmlSorterCompositorPrivate::setPrimarySorter(QQmlSorterBase *sorter)
{
    if (sorter == nullptr ||
        (std::find(m_sorters.constBegin(), m_sorters.constEnd(), sorter) != m_sorters.constEnd())) {
        m_primarySorter = sorter;
        if (m_primarySorter && m_primarySorter->enabled()) {
            m_sfpmModel->setPrimarySortOrder(m_primarySorter->sortOrder());
            m_sfpmModel->setPrimarySortColumn(m_primarySorter->column());
            return;
        }
    }
    resetPrimarySorter();
}

void QQmlSorterCompositorPrivate::resetPrimarySorter()
{
    if (!m_primarySorter) {
        if (!m_effectiveSorters.isEmpty()) {
            // Set the primary sort column and its order to the proxy model
            const auto *sorter = m_effectiveSorters.at(0);
            m_sfpmModel->setPrimarySortOrder(sorter->sortOrder());
            m_sfpmModel->setPrimarySortColumn(sorter->column());
        } else {
            // By default reset the  sort order to ascending order and the
            // column to 0
            m_sfpmModel->setPrimarySortOrder(Qt::AscendingOrder);
            m_sfpmModel->setPrimarySortColumn(0);
        }
    }
}

QT_END_NAMESPACE

#include "moc_qqmlsortercompositor_p.cpp"
