model.cpp

/******************************************************************************
 *
 *  SPDX-FileCopyrightText: 2008 Szymon Tomasz Stefanek <pragma@kvirc.net>
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *
 *******************************************************************************/
 
//
// This class is a rather huge monster. It's something that resembles a QAbstractItemModel
// (because it has to provide the interface for a QTreeView) but isn't entirely one
// (for optimization reasons). It basically manages a tree of items of two types:
// GroupHeaderItem and MessageItem. Be sure to read the docs for ViewItemJob.
//
// A huge credit here goes to Till Adam which seems to have written most
// (if not all) of the original KMail threading code. The KMHeaders implementation,
// the documentation and his clever ideas were my starting points and essential tools.
// This is why I'm adding his copyright entry (copied from headeritem.cpp) here even if
// he didn't write a byte in this file until now :)
//
//                                       Szymon Tomasz Stefanek, 03 Aug 2008 04:50 (am)
//
// This class contains ideas from:
//
//   kmheaders.cpp / kmheaders.h, headeritem.cpp / headeritem.h
//   Copyright: (c) 2004 Till Adam < adam at kde dot org >
//
#include "core/model.h"
#include "core/filter.h"
#include "core/groupheaderitem.h"
#include "core/item_p.h"
#include "core/messageitem.h"
#include "core/messageitemsetmanager.h"
#include "core/model_p.h"
#include "core/modelinvariantrowmapper.h"
#include "core/storagemodelbase.h"
#include "core/theme.h"
#include "core/view.h"
#include "messagelist_debug.h"
#include <config-messagelist.h>
 
#include "MessageCore/StringUtil"
#include <Akonadi/Item>
#include <Akonadi/MessageStatus>
 
#include <KLocalizedString>
 
#include <QApplication>
#include <QDateTime>
#include <QElapsedTimer>
#include <QIcon>
#include <QLocale>
#include <QScrollBar>
#include <QTimer>
 
#include <algorithm>
#include <chrono>
 
using namespace std::chrono_literals;
 
namespace MessageList
{
namespace Core
{
Q_GLOBAL_STATIC(QTimer, _k_heartBeatTimer)
 
/**
 * A job in a "View Fill" or "View Cleanup" or "View Update" task.
 *
 * For a "View Fill" task a job is a set of messages
 * that are contiguous in the storage. The set is expressed as a range
 * of row indexes. The task "sweeps" the storage in the specified
 * range, creates the appropriate Item instances and places them
 * in the right position in the tree.
 *
 * The idea is that in a single instance and for the same StorageModel
 * the jobs should never "cover" the same message twice. This assertion
 * is enforced all around this source file.
 *
 * For a "View Cleanup" task the job is a list of ModelInvariantIndex
 * objects (that are in fact MessageItem objects) that need to be removed
 * from the view.
 *
 * For a "View Update" task the job is a list of ModelInvariantIndex
 * objects (that are in fact MessageItem objects) that need to be updated.
 *
 * The interesting fact is that all the tasks need
 * very similar operations to be performed on the message tree.
 *
 * For a "View Fill" we have 5 passes.
 *
 * Pass 1 scans the underlying storage, creates the MessageItem objects
 * (which are subclasses of ModelInvariantIndex) and retrieves invariant
 * storage indexes for them. It also builds threading caches and
 * attempts to do some "easy" threading. If it succeeds in threading
 * and some conditions apply then it also attaches the items to the view.
 * Any unattached message is placed in a list.
 *
 * Pass 2 scans the list of messages that haven't been attached in
 * the first pass and performs perfect and reference based threading.
 * Since grouping of messages may depend on the "shape" of the thread
 * then certain threads aren't attached to the view yet.
 * Unassigned messages get stuffed into a list waiting for Pass3
 * or directly to a list waiting for Pass4 (that is, Pass3 may be skipped
 * if there is no hope to find an imperfect parent by subject based threading).
 *
 * Pass 3 scans the list of messages that haven't been attached in
 * the first and second passes and performs subject based threading.
 * Since grouping of messages may depend on the "shape" of the thread
 * then certain threads aren't attached to the view yet.
 * Anything unattached gets stuffed into the list waiting for Pass4.
 *
 * Pass 4 scans the unattached threads and puts them in the appropriate
 * groups. After this pass nothing is unattached.
 *
 * Pass 5 eventually re-sorts the groups and removes the empty ones.
 *
 * For a "View Cleanup" we still have 5 passes.
 *
 * Pass 1 scans the list of invalidated ModelInvariantIndex-es, casts
 * them to MessageItem objects and detaches them from the view.
 * The orphan children of the destroyed items get stuffed in the list
 * of unassigned messages that has been used also in the "View Fill" task above.
 *
 * Pass 2, 3, 4 and 5: same as "View Fill", just operating on the "orphaned"
 * messages that need to be reattached to the view.
 *
 * For a "View Update" we still have 5 passes.
 *
 * Pass 1 scans the list of ModelInvariantIndex-es that need an update, casts
 * them to MessageItem objects and handles the updates from storage.
 * The updates may cause a regrouping so items might be stuffed in one
 * of the lists for pass 4 or 5.
 *
 * Pass 2, 3 and 4 are simply empty.
 *
 * Pass 5: same as "View Fill", just operating on groups that require updates
 * after the messages have been moved in pass 1.
 *
 * That's why we in fact have Pass1Fill, Pass1Cleanup, Pass1Update, Pass2, Pass3, Pass4 and Pass5 below.
 * Pass1Fill, Pass1Cleanup and Pass1Update are exclusive and all of them proceed with Pass2 when finished.
 */
class ViewItemJob
{
public:
    enum Pass {
        Pass1Fill = 0, ///< Build threading caches, *TRY* to do some threading, try to attach something to the view
        Pass1Cleanup = 1, ///< Kill messages, build list of orphans
        Pass1Update = 2, ///< Update messages
        Pass2 = 3, ///< Thread everything by using caches, try to attach more to the view
        Pass3 = 4, ///< Do more threading (this time try to guess), try to attach more to the view
        Pass4 = 5, ///< Attach anything is still unattached
        Pass5 = 6, ///< Eventually Re-sort group headers and remove the empty ones
        LastIndex = 7 ///< Keep this at the end, needed to get the size of the enum
    };
 
private:
    // Data for "View Fill" jobs
    int mStartIndex; ///< The first index (in the underlying storage) of this job
    int mCurrentIndex; ///< The current index (in the underlying storage) of this job
    int mEndIndex; ///< The last index (in the underlying storage) of this job
 
    // Data for "View Cleanup" jobs
    QList<ModelInvariantIndex *> *mInvariantIndexList; ///< Owned list of shallow pointers
 
    // Common data
 
    // The maximum time that we can spend "at once" inside viewItemJobStep() (milliseconds)
    // The bigger this value, the larger chunks of work we do at once and less the time
    // we loose in "breaking and resuming" the job. On the other side large values tend
    // to make the view less responsive up to a "freeze" perception if this value is larger
    // than 2000.
    int mChunkTimeout;
 
    // The interval between two fillView steps. The larger the interval, the more interactivity
    // we have. The shorter the interval the more work we get done per second.
    int mIdleInterval;
 
    // The minimum number of messages we process in every viewItemJobStep() call
    // The larger this value the less time we loose in checking the timeout every N messages.
    // On the other side, making this very large may make the view less responsive
    // if we're processing very few messages at a time and very high values (say > 10000) may
    // eventually make our job unbreakable until the end.
    int mMessageCheckCount;
    Pass mCurrentPass;
 
    // If this parameter is true then this job uses a "disconnected" UI.
    // It's FAR faster since we don't need to call beginInsertRows()/endInsertRows()
    // and we simply Q_EMIT a layoutChanged() at the end. It can be done only as the first
    // job though: subsequent jobs can't use layoutChanged() as it looses the expanded
    // state of items.
    bool mDisconnectUI;
 
public:
    /**
     * Creates a "View Fill" operation job
     */
    ViewItemJob(int startIndex, int endIndex, int chunkTimeout, int idleInterval, int messageCheckCount, bool disconnectUI = false)
        : mStartIndex(startIndex)
        , mCurrentIndex(startIndex)
        , mEndIndex(endIndex)
        , mInvariantIndexList(nullptr)
        , mChunkTimeout(chunkTimeout)
        , mIdleInterval(idleInterval)
        , mMessageCheckCount(messageCheckCount)
        , mCurrentPass(Pass1Fill)
        , mDisconnectUI(disconnectUI)
    {
    }
 
    /**
     * Creates a "View Cleanup" or "View Update" operation job
     */
    ViewItemJob(Pass pass, QList<ModelInvariantIndex *> *invariantIndexList, int chunkTimeout, int idleInterval, int messageCheckCount)
        : mStartIndex(0)
        , mCurrentIndex(0)
        , mEndIndex(invariantIndexList->count() - 1)
        , mInvariantIndexList(invariantIndexList)
        , mChunkTimeout(chunkTimeout)
        , mIdleInterval(idleInterval)
        , mMessageCheckCount(messageCheckCount)
        , mCurrentPass(pass)
        , mDisconnectUI(false)
    {
    }
 
    ~ViewItemJob()
    {
        delete mInvariantIndexList;
    }
 
public:
    [[nodiscard]] int startIndex() const
    {
        return mStartIndex;
    }
 
    void setStartIndex(int startIndex)
    {
        mStartIndex = startIndex;
        mCurrentIndex = startIndex;
    }
 
    [[nodiscard]] int currentIndex() const
    {
        return mCurrentIndex;
    }
 
    void setCurrentIndex(int currentIndex)
    {
        mCurrentIndex = currentIndex;
    }
 
    [[nodiscard]] int endIndex() const
    {
        return mEndIndex;
    }
 
    void setEndIndex(int endIndex)
    {
        mEndIndex = endIndex;
    }
 
    [[nodiscard]] Pass currentPass() const
    {
        return mCurrentPass;
    }
 
    void setCurrentPass(Pass pass)
    {
        mCurrentPass = pass;
    }
 
    [[nodiscard]] int idleInterval() const
    {
        return mIdleInterval;
    }
 
    [[nodiscard]] int chunkTimeout() const
    {
        return mChunkTimeout;
    }
 
    [[nodiscard]] int messageCheckCount() const
    {
        return mMessageCheckCount;
    }
 
    [[nodiscard]] QList<ModelInvariantIndex *> *invariantIndexList() const
    {
        return mInvariantIndexList;
    }
 
    [[nodiscard]] bool disconnectUI() const
    {
        return mDisconnectUI;
    }
};
} // namespace Core
} // namespace MessageList
 
using namespace MessageList::Core;
 
Model::Model(View *pParent)
    : QAbstractItemModel(pParent)
    , d(new ModelPrivate(this))
{
    d->mRecursionCounterForReset = 0;
    d->mStorageModel = nullptr;
    d->mView = pParent;
    d->mAggregation = nullptr;
    d->mTheme = nullptr;
    d->mSortOrder = nullptr;
    d->mFilter = nullptr;
    d->mPersistentSetManager = nullptr;
    d->mInLengthyJobBatch = false;
    d->mLastSelectedMessageInFolder = nullptr;
    d->mLoading = false;
 
    d->mRootItem = new Item(Item::InvisibleRoot);
    d->mRootItem->setViewable(nullptr, true);
 
    d->mFillStepTimer.setSingleShot(true);
    d->mInvariantRowMapper = new ModelInvariantRowMapper();
    d->mModelForItemFunctions = this;
    connect(&d->mFillStepTimer, &QTimer::timeout, this, [this]() {
        d->viewItemJobStep();
    });
 
    d->mCachedTodayLabel = i18n("Today");
    d->mCachedYesterdayLabel = i18n("Yesterday");
    d->mCachedUnknownLabel = i18nc("Unknown date", "Unknown");
    d->mCachedLastWeekLabel = i18n("Last Week");
    d->mCachedTwoWeeksAgoLabel = i18n("Two Weeks Ago");
    d->mCachedThreeWeeksAgoLabel = i18n("Three Weeks Ago");
    d->mCachedFourWeeksAgoLabel = i18n("Four Weeks Ago");
    d->mCachedFiveWeeksAgoLabel = i18n("Five Weeks Ago");
 
    d->mCachedWatchedOrIgnoredStatusBits = Akonadi::MessageStatus::statusIgnored().toQInt32() | Akonadi::MessageStatus::statusWatched().toQInt32();
 
    connect(_k_heartBeatTimer(), &QTimer::timeout, this, [this]() {
        d->checkIfDateChanged();
    });
 
    if (!_k_heartBeatTimer->isActive()) { // First model starts it
        _k_heartBeatTimer->start(1min); // 1 minute
    }
}
 
Model::~Model()
{
    setStorageModel(nullptr);
 
    d->clearJobList();
    d->mOldestItem = nullptr;
    d->mNewestItem = nullptr;
    d->clearUnassignedMessageLists();
    d->clearOrphanChildrenHash();
    d->clearThreadingCacheReferencesIdMD5ToMessageItem();
    d->clearThreadingCacheMessageSubjectMD5ToMessageItem();
    delete d->mPersistentSetManager;
    // Delete the invariant row mapper before removing the items.
    // It's faster since the items will not need to call the invariant
    delete d->mInvariantRowMapper;
    delete d->mRootItem;
}
 
void Model::setAggregation(const Aggregation *aggregation)
{
    d->mAggregation = aggregation;
    d->mView->setRootIsDecorated((d->mAggregation->grouping() == Aggregation::NoGrouping) && (d->mAggregation->threading() != Aggregation::NoThreading));
}
 
void Model::setTheme(const Theme *theme)
{
    d->mTheme = theme;
}
 
void Model::setSortOrder(const SortOrder *sortOrder)
{
    d->mSortOrder = sortOrder;
}
 
const SortOrder *Model::sortOrder() const
{
    return d->mSortOrder;
}
 
void Model::setFilter(const Filter *filter)
{
    d->mFilter = filter;
 
    if (d->mFilter) {
        connect(d->mFilter, &Filter::finished, this, [this]() {
            d->slotApplyFilter();
        });
    }
 
    d->slotApplyFilter();
}
 
void ModelPrivate::slotApplyFilter()
{
    auto childList = mRootItem->childItems();
    if (!childList) {
        return;
    }
 
    QModelIndex idx; // invalid
 
    QApplication::setOverrideCursor(Qt::WaitCursor);
    for (const auto child : std::as_const(*childList)) {
        applyFilterToSubtree(child, idx);
    }
 
    QApplication::restoreOverrideCursor();
}
 
bool ModelPrivate::applyFilterToSubtree(Item *item, const QModelIndex &parentIndex)
{
    // This function applies the current filter (eventually empty)
    // to a message tree starting at "item".
 
    if (!mModelForItemFunctions) {
        qCWarning(MESSAGELIST_LOG) << "Cannot apply filter, the UI must be not disconnected.";
        return true;
    }
    Q_ASSERT(item); // the item must obviously be valid
    Q_ASSERT(item->isViewable()); // the item must be viewable
 
    // Apply to children first
 
    auto childList = item->childItems();
 
    bool childrenMatch = false;
 
    QModelIndex thisIndex = q->index(item, 0);
 
    if (childList) {
        for (const auto child : std::as_const(*childList)) {
            if (applyFilterToSubtree(child, thisIndex)) {
                childrenMatch = true;
            }
        }
    }
 
    if (!mFilter) { // empty filter always matches (but does not expand items)
        mView->setRowHidden(thisIndex.row(), parentIndex, false);
        return true;
    }
 
    if (childrenMatch) {
        mView->setRowHidden(thisIndex.row(), parentIndex, false);
 
        if (!mView->isExpanded(thisIndex)) {
            mView->expand(thisIndex);
        }
        return true;
    }
 
    if (item->type() == Item::Message) {
        if (mFilter->match((MessageItem *)item)) {
            mView->setRowHidden(thisIndex.row(), parentIndex, false);
            return true;
        }
    } // else this is a group header and it never explicitly matches
 
    // filter doesn't match, hide the item
    mView->setRowHidden(thisIndex.row(), parentIndex, true);
 
    return false;
}
 
int Model::columnCount(const QModelIndex &parent) const
{
    if (!d->mTheme) {
        return 0;
    }
    if (parent.column() > 0) {
        return 0;
    }
    return d->mTheme->columns().count();
}
 
QVariant Model::data(const QModelIndex &index, int role) const
{
    /// this is called only when Akonadi is using the selectionmodel
    ///  for item actions. since akonadi uses the ETM ItemRoles, and the
    ///  messagelist uses its own internal roles, here we respond
    ///  to the ETM ones.
 
    auto item = static_cast<Item *>(index.internalPointer());
 
    switch (role) {
    /// taken from entitytreemodel.h
    case Qt::UserRole + 1: // EntityTreeModel::ItemIdRole
        if (item->type() == MessageList::Core::Item::Message) {
            auto mItem = static_cast<MessageItem *>(item);
            return QVariant::fromValue(mItem->akonadiItem().id());
        } else {
            return {};
        }
        break;
    case Qt::UserRole + 2: // EntityTreeModel::ItemRole
        if (item->type() == MessageList::Core::Item::Message) {
            auto mItem = static_cast<MessageItem *>(item);
            return QVariant::fromValue(mItem->akonadiItem());
        } else {
            return {};
        }
        break;
    case Qt::UserRole + 3: // EntityTreeModel::MimeTypeRole
        if (item->type() == MessageList::Core::Item::Message) {
            return QStringLiteral("message/rfc822");
        } else {
            return {};
        }
        break;
    case Qt::AccessibleTextRole:
        if (item->type() == MessageList::Core::Item::Message) {
            auto mItem = static_cast<MessageItem *>(item);
            return mItem->accessibleText(d->mTheme, index.column());
        } else if (item->type() == MessageList::Core::Item::GroupHeader) {
            if (index.column() > 0) {
                return QString();
            }
            auto hItem = static_cast<GroupHeaderItem *>(item);
            return hItem->label();
        }
        return QString();
        break;
    default:
        return {};
    }
}
 
QVariant Model::headerData(int section, Qt::Orientation, int role) const
{
    if (!d->mTheme) {
        return {};
    }
 
    auto column = d->mTheme->column(section);
    if (!column) {
        return {};
    }
 
    if (d->mStorageModel && column->isSenderOrReceiver() && (role == Qt::DisplayRole)) {
        if (d->mStorageModelContainsOutboundMessages) {
            return QVariant(i18n("Receiver"));
        }
        return QVariant(i18n("Sender"));
    }
 
    const bool columnPixmapEmpty(column->pixmapName().isEmpty());
    if ((role == Qt::DisplayRole) && columnPixmapEmpty) {
        return QVariant(column->label());
    } else if ((role == Qt::ToolTipRole) && !columnPixmapEmpty) {
        return QVariant(column->label());
    } else if ((role == Qt::DecorationRole) && !columnPixmapEmpty) {
        return QVariant(QIcon::fromTheme(column->pixmapName()));
    }
 
    return {};
}
 
QModelIndex Model::index(Item *item, int column) const
{
    if (!d->mModelForItemFunctions) {
        return {}; // called with disconnected UI: the item isn't known on the Qt side, yet
    }
 
    if (!item) {
        return {};
    }
    // FIXME: This function is a bottleneck (the caching in indexOfChildItem only works 30% of the time)
    auto par = item->parent();
    if (!par) {
        if (item != d->mRootItem) {
            item->dump(QString());
        }
        return {};
    }
 
    const int index = par->indexOfChildItem(item);
    if (index < 0) {
        return {}; // BUG
    }
    return createIndex(index, column, item);
}
 
QModelIndex Model::index(int row, int column, const QModelIndex &parent) const
{
    if (!d->mModelForItemFunctions) {
        return {}; // called with disconnected UI: the item isn't known on the Qt side, yet
    }
 
#ifdef READD_THIS_IF_YOU_WANT_TO_PASS_MODEL_TEST
    if (column < 0) {
        return QModelIndex(); // senseless column (we could optimize by skipping this check but ModelTest from trolltech is pedantic)
    }
#endif
 
    const Item *item;
    if (parent.isValid()) {
        item = static_cast<const Item *>(parent.internalPointer());
        if (!item) {
            return {}; // should never happen
        }
    } else {
        item = d->mRootItem;
    }
 
    if (parent.column() > 0) {
        return {}; // parent column is not 0: shouldn't have children (as per Qt documentation)
    }
 
    Item *child = item->childItem(row);
    if (!child) {
        return {}; // no such row in parent
    }
    return createIndex(row, column, child);
}
 
QModelIndex Model::parent(const QModelIndex &modelIndex) const
{
    Q_ASSERT(d->mModelForItemFunctions); // should be never called with disconnected UI
 
    if (!modelIndex.isValid()) {
        return {}; // should never happen
    }
    auto item = static_cast<Item *>(modelIndex.internalPointer());
    if (!item) {
        return {};
    }
    auto par = item->parent();
    if (!par) {
        return {}; // should never happen
    }
    // return index( par, modelIndex.column() );
    return index(par, 0); // parents are always in column 0 (as per Qt documentation)
}
 
int Model::rowCount(const QModelIndex &parent) const
{
    if (!d->mModelForItemFunctions) {
        return 0; // called with disconnected UI
    }
 
    const Item *item;
    if (parent.isValid()) {
        item = static_cast<const Item *>(parent.internalPointer());
        if (!item) {
            return 0; // should never happen
        }
    } else {
        item = d->mRootItem;
    }
 
    if (!item->isViewable()) {
        return 0;
    }
 
    return item->childItemCount();
}
 
class RecursionPreventer
{
public:
    RecursionPreventer(int &counter)
        : mCounter(counter)
    {
        mCounter++;
    }
 
    ~RecursionPreventer()
    {
        mCounter--;
    }
 
    [[nodiscard]] bool isRecursive() const
    {
        return mCounter > 1;
    }
 
private:
    int &mCounter;
};
 
StorageModel *Model::storageModel() const
{
    return d->mStorageModel;
}
 
void ModelPrivate::clear()
{
    q->beginResetModel();
    if (mFillStepTimer.isActive()) {
        mFillStepTimer.stop();
    }
 
    // Kill pre-selection at this stage
    mPreSelectionMode = PreSelectNone;
    mLastSelectedMessageInFolder = nullptr;
    mOldestItem = nullptr;
    mNewestItem = nullptr;
 
    // Reset the row mapper before removing items
    // This is faster since the items don't need to access the mapper.
    mInvariantRowMapper->modelReset();
 
    clearJobList();
    clearUnassignedMessageLists();
    clearOrphanChildrenHash();
    mGroupHeaderItemHash.clear();
    mGroupHeadersThatNeedUpdate.clear();
    mThreadingCacheMessageIdMD5ToMessageItem.clear();
    mThreadingCacheMessageInReplyToIdMD5ToMessageItem.clear();
    clearThreadingCacheReferencesIdMD5ToMessageItem();
    clearThreadingCacheMessageSubjectMD5ToMessageItem();
    mViewItemJobStepChunkTimeout = 100;
    mViewItemJobStepIdleInterval = 10;
    mViewItemJobStepMessageCheckCount = 10;
    delete mPersistentSetManager;
    mPersistentSetManager = nullptr;
    mCurrentItemToRestoreAfterViewItemJobStep = nullptr;
 
    mTodayDate = QDate::currentDate();
 
    // FIXME: CLEAR THE FILTER HERE AS WE CAN'T APPLY IT WITH UI DISCONNECTED!
 
    mRootItem->killAllChildItems();
 
    q->endResetModel();
    // Q_EMIT headerDataChanged();
 
    mView->selectionModel()->clearSelection();
}
 
void Model::setStorageModel(StorageModel *storageModel, PreSelectionMode preSelectionMode)
{
    // Prevent a case of recursion when opening a folder that has a message and the folder was
    // never opened before.
    RecursionPreventer preventer(d->mRecursionCounterForReset);
    if (preventer.isRecursive()) {
        return;
    }
 
    d->clear();
 
    if (d->mStorageModel) {
        // Disconnect all signals from old storageModel
        std::for_each(d->mStorageModelConnections.cbegin(), d->mStorageModelConnections.cend(), [](const QMetaObject::Connection &c) -> bool {
            return QObject::disconnect(c);
        });
        d->mStorageModelConnections.clear();
    }
 
    const bool isReload = (d->mStorageModel == storageModel);
    d->mStorageModel = storageModel;
 
    if (!d->mStorageModel) {
        return; // no folder: nothing to fill
    }
 
    // Save threading cache of the previous folder, but only if the cache was
    // enabled and a different folder is being loaded - reload of the same folder
    // means change in aggregation in which case we will have to re-build the
    // cache so there's no point saving the current threading cache.
    if (d->mThreadingCache.isEnabled() && !isReload) {
        d->mThreadingCache.save();
    } else {
        if (isReload) {
            qCDebug(MESSAGELIST_LOG) << "Identical folder reloaded, not saving old threading cache";
        } else {
            qCDebug(MESSAGELIST_LOG) << "Threading disabled in previous folder, not saving threading cache";
        }
    }
    // Load threading cache for the new folder, but only if threading is enabled,
    // otherwise we would just be caching a flat list.
    if (d->mAggregation->threading() != Aggregation::NoThreading) {
        d->mThreadingCache.setEnabled(true);
        d->mThreadingCache.load(d->mStorageModel->id(), d->mAggregation);
    } else {
        // No threading, no cache - don't even bother inserting entries into the
        // cache or trying to look them up there
        d->mThreadingCache.setEnabled(false);
        qCDebug(MESSAGELIST_LOG) << "Threading disabled in folder" << d->mStorageModel->id() << ", not using threading cache";
    }
 
    d->mPreSelectionMode = preSelectionMode;
    d->mStorageModelContainsOutboundMessages = d->mStorageModel->containsOutboundMessages();
 
    d->mStorageModelConnections = {connect(d->mStorageModel,
                                           &StorageModel::rowsInserted,
                                           this,
                                           [this](const QModelIndex &parent, int first, int last) {
                                               d->slotStorageModelRowsInserted(parent, first, last);
                                           }),
                                   connect(d->mStorageModel,
                                           &StorageModel::rowsRemoved,
                                           this,
                                           [this](const QModelIndex &parent, int first, int last) {
                                               d->slotStorageModelRowsRemoved(parent, first, last);
                                           }),
                                   connect(d->mStorageModel,
                                           &StorageModel::layoutChanged,
                                           this,
                                           [this]() {
                                               d->slotStorageModelLayoutChanged();
                                           }),
                                   connect(d->mStorageModel,
                                           &StorageModel::modelReset,
                                           this,
                                           [this]() {
                                               d->slotStorageModelLayoutChanged();
                                           }),
                                   connect(d->mStorageModel,
                                           &StorageModel::dataChanged,
                                           this,
                                           [this](const QModelIndex &topLeft, const QModelIndex &bottomRight) {
                                               d->slotStorageModelDataChanged(topLeft, bottomRight);
                                           }),
                                   connect(d->mStorageModel, &StorageModel::headerDataChanged, this, [this](Qt::Orientation orientation, int first, int last) {
                                       d->slotStorageModelHeaderDataChanged(orientation, first, last);
                                   })};
 
    if (d->mStorageModel->rowCount() == 0) {
        return; // folder empty: nothing to fill
    }
 
    // Here we use different strategies based on user preference and the folder size.
    // The knobs we can tune are:
    //
    // - The number of jobs used to scan the whole folder and their order
    //
    //   There are basically two approaches to this. One is the "single big job"
    //   approach. It scans the folder from the beginning to the end in a single job
    //   entry. The job passes are done only once. It's advantage is that it's simpler
    //   and it's less likely to generate imperfect parent threadings. The bad
    //   side is that since the folders are "sort of" date ordered then the most interesting
    //   messages show up at the end of the work. Not nice for large folders.
    //   The other approach uses two jobs. This is a bit slower but smarter strategy.
    //   First we scan the latest 1000 messages and *then* take care of the older ones.
    //   This will show up the most interesting messages almost immediately. (Well...
    //   All this assuming that the underlying storage always appends the newly arrived messages)
    //   The strategy is slower since it  generates some imperfect parent threadings which must be
    //   adjusted by the second job. For instance, in my kernel mailing list folder this "smart" approach
    //   generates about 150 additional imperfectly threaded children... but the "today"
    //   messages show up almost immediately. The two-chunk job also makes computing
    //   the percentage user feedback a little harder and might break some optimization
    //   in the insertions (we're able to optimize appends and prepends but a chunked
    //   job is likely to split our work at a boundary where messages are always inserted
    //   in the middle of the list).
    //
    // - The maximum time to spend inside a single job step
    //
    //   The larger this time, the greater the number of messages per second that this
    //   engine can process but also greater time with frozen UI -> less interactivity.
    //   Reasonable values start at 50 msecs. Values larger than 300 msecs are very likely
    //   to be perceived by the user as UI non-reactivity.
    //
    // - The number of messages processed in each job step subchunk.
    //
    //   A job subchunk is processed without checking the maximum time above. This means
    //   that each job step will process at least the number of messages specified by this value.
    //   Very low values mean that we respect the maximum time very carefully but we also
    //   waste time to check if we ran out of time :)
    //   Very high values are likely to cause the engine to not respect the maximum step time.
    //   Reasonable values go from 5 to 100.
    //
    // - The "idle" time between two steps
    //
    //   The lower this time, the greater the number of messages per second that this
    //   engine can process but also lower time for the UI to process events -> less interactivity.
    //   A value of 0 here means that Qt will trigger the timer as soon as it has some
    //   idle time to spend. UI events will be still processed but slowdowns are possible.
    //   0 is reasonable though. Values larger than 200 will tend to make the total job
    //   completion times high.
    //
 
    // If we have no filter it seems that we can apply a huge optimization.
    // We disconnect the UI for the first huge filling job. This allows us
    // to save the extremely expensive beginInsertRows()/endInsertRows() calls
    // and call a single layoutChanged() at the end. This slows down a lot item
    // expansion. But on the other side if only few items need to be expanded
    // then this strategy is better. If filtering is enabled then this strategy
    // isn't applicable (because filtering requires interaction with the UI
    // while the data is loading).
 
    // So...
 
    // For the very first small chunk it's ok to work with disconnected UI as long
    // as we have no filter. The first small chunk is always 1000 messages, so
    // even if all of them are expanded, it's still somewhat acceptable.
    bool canDoFirstSmallChunkWithDisconnectedUI = !d->mFilter;
 
    // Larger works need a bigger condition: few messages must be expanded in the end.
    bool canDoJobWithDisconnectedUI = // we have no filter
        !d->mFilter
        && (
            // we do no threading at all
            (d->mAggregation->threading() == Aggregation::NoThreading) || // or we never expand threads
            (d->mAggregation->threadExpandPolicy() == Aggregation::NeverExpandThreads) || // or we expand threads but we'll be going to expand really only a few
            (
                // so we don't expand them all
                (d->mAggregation->threadExpandPolicy() != Aggregation::AlwaysExpandThreads) && // and we'd expand only a few in fact
                (d->mStorageModel->initialUnreadRowCountGuess() < 1000)));
 
    switch (d->mAggregation->fillViewStrategy()) {
    case Aggregation::FavorInteractivity:
        // favor interactivity
        if ((!canDoJobWithDisconnectedUI) && (d->mStorageModel->rowCount() > 3000)) { // empiric value
            // First a small job with the most recent messages. Large chunk, small (but non zero) idle interval
            // and a larger number of messages to process at once.
            auto job1 =
                new ViewItemJob(d->mStorageModel->rowCount() - 1000, d->mStorageModel->rowCount() - 1, 200, 20, 100, canDoFirstSmallChunkWithDisconnectedUI);
            d->mViewItemJobs.append(job1);
            // Then a larger job with older messages. Small chunk, bigger idle interval, small number of messages to
            // process at once.
            auto job2 = new ViewItemJob(0, d->mStorageModel->rowCount() - 1001, 100, 50, 10, false);
            d->mViewItemJobs.append(job2);
 
            // We could even extremize this by splitting the folder in several
            // chunks and scanning them from the newest to the oldest... but the overhead
            // due to imperfectly threaded children would be probably too big.
        } else {
            // small folder or can be done with disconnected UI: single chunk work.
            // Lag the CPU a bit more but not too much to destroy even the earliest interactivity.
            auto job = new ViewItemJob(0, d->mStorageModel->rowCount() - 1, 150, 30, 30, canDoJobWithDisconnectedUI);
            d->mViewItemJobs.append(job);
        }
        break;
    case Aggregation::FavorSpeed:
        // More batchy jobs, still interactive to a certain degree
        if ((!canDoJobWithDisconnectedUI) && (d->mStorageModel->rowCount() > 3000)) { // empiric value
            // large folder, but favor speed
            auto job1 =
                new ViewItemJob(d->mStorageModel->rowCount() - 1000, d->mStorageModel->rowCount() - 1, 250, 0, 100, canDoFirstSmallChunkWithDisconnectedUI);
            d->mViewItemJobs.append(job1);
            auto job2 = new ViewItemJob(0, d->mStorageModel->rowCount() - 1001, 200, 0, 10, false);
            d->mViewItemJobs.append(job2);
        } else {
            // small folder or can be done with disconnected UI and favor speed: single chunk work.
            // Lag the CPU more, get more work done
            auto job = new ViewItemJob(0, d->mStorageModel->rowCount() - 1, 250, 0, 100, canDoJobWithDisconnectedUI);
            d->mViewItemJobs.append(job);
        }
        break;
    case Aggregation::BatchNoInteractivity: {
        // one large job, never interrupt, block UI
        auto job = new ViewItemJob(0, d->mStorageModel->rowCount() - 1, 60000, 0, 100000, canDoJobWithDisconnectedUI);
        d->mViewItemJobs.append(job);
        break;
    }
    default:
        qCWarning(MESSAGELIST_LOG) << "Unrecognized fill view strategy";
        Q_ASSERT(false);
        break;
    }
 
    d->mLoading = true;
 
    d->viewItemJobStep();
}
 
void ModelPrivate::checkIfDateChanged()
{
    // This function is called by MessageList::Core::Manager once in a while (every 1 minute or sth).
    // It is used to check if the current date has changed (with respect to mTodayDate).
    //
    // Our message items cache the formatted dates (as formatting them
    // on the fly would be too expensive). We also cache the labels of the groups which often display dates.
    // When the date changes we would need to fix all these strings.
    //
    // A dedicated algorithm to refresh the labels of the items would be either too complex
    // or would block on large trees. Fixing the labels of the groups is also quite hard...
    //
    // So to keep the things simple we just reload the view.
 
    if (!mStorageModel) {
        return; // nothing to do
    }
 
    if (mLoading) {
        return; // not now
    }
 
    if (!mViewItemJobs.isEmpty()) {
        return; // not now
    }
 
    if (mTodayDate == QDate::currentDate()) {
        return; // date not changed
    }
 
    // date changed, reload the view (and try to preserve the current selection)
    q->setStorageModel(mStorageModel, PreSelectLastSelected);
}
 
void Model::setPreSelectionMode(PreSelectionMode preSelect)
{
    d->mPreSelectionMode = preSelect;
    d->mLastSelectedMessageInFolder = nullptr;
}
 
//
// The "view fill" algorithm implemented in the functions below is quite smart but also quite complex.
// It's governed by the following goals:
//
// - Be flexible: allow different configurations from "unsorted flat list" to a "grouped and threaded
//     list with different sorting algorithms applied to each aggregation level"
// - Be reasonably fast
// - Be non blocking: UI shouldn't freeze while the algorithm is running
// - Be interruptible: user must be able to abort the execution and just switch to another folder in the middle
//
 
void ModelPrivate::clearUnassignedMessageLists()
{
    // This is a bit tricky...
    // The three unassigned message lists contain messages that have been created
    // but not yet attached to the view. There may be two major cases for a message:
    // - it has no parent -> it must be deleted and it will delete its children too
    // - it has a parent -> it must NOT be deleted since it will be deleted by its parent.
 
    // Sometimes the things get a little complicated since in Pass2 and Pass3
    // we have transitional states in that the MessageItem object can be in two of these lists.
 
    // WARNING: This function does NOT fixup mNewestItem and mOldestItem. If one of these
    // two messages is in the lists below, it's deleted and the member becomes a dangling pointer.
    // The caller must ensure that both mNewestItem and mOldestItem are set to 0
    // and this is enforced in the assert below to avoid errors. This basically means
    // that this function should be called only when the storage model changes or
    // when the model is destroyed.
    Q_ASSERT((mOldestItem == nullptr) && (mNewestItem == nullptr));
 
    if (!mUnassignedMessageListForPass2.isEmpty()) {
        // We're actually in Pass1* or Pass2: everything is mUnassignedMessageListForPass2
        // Something may *also* be in mUnassignedMessageListForPass3 and mUnassignedMessageListForPass4
        // but that are duplicates for sure.
 
        // We can't just sweep the list and delete parentless items since each delete
        // could kill children which are somewhere AFTER in the list: accessing the children
        // would then lead to a SIGSEGV. We first sweep the list gathering parentless
        // items and *then* delete them without accessing the parented ones.
 
        QList<MessageItem *> parentless;
        for (const auto mi : std::as_const(mUnassignedMessageListForPass2)) {
            if (!mi->parent()) {
                parentless.append(mi);
            }
        }
 
        for (const auto mi : std::as_const(parentless)) {
            delete mi;
        }
 
        mUnassignedMessageListForPass2.clear();
        // Any message these list contain was also in mUnassignedMessageListForPass2
        mUnassignedMessageListForPass3.clear();
        mUnassignedMessageListForPass4.clear();
        return;
    }
 
    // mUnassignedMessageListForPass2 is empty
 
    if (!mUnassignedMessageListForPass3.isEmpty()) {
        // We're actually at the very end of Pass2 or inside Pass3
        // Pass2 pushes stuff in mUnassignedMessageListForPass3 *or* mUnassignedMessageListForPass4
        // Pass3 pushes stuff from mUnassignedMessageListForPass3 to mUnassignedMessageListForPass4
        // So if we're in Pass2 then the two lists contain distinct messages but if we're in Pass3
        // then the two lists may contain the same messages.
 
        if (!mUnassignedMessageListForPass4.isEmpty()) {
            // We're actually in Pass3: the messiest one.
 
            QSet<MessageItem *> itemsToDelete;
            for (const auto mi : std::as_const(mUnassignedMessageListForPass3)) {
                if (!mi->parent()) {
                    itemsToDelete.insert(mi);
                }
            }
            for (const auto mi : std::as_const(mUnassignedMessageListForPass4)) {
                if (!mi->parent()) {
                    itemsToDelete.insert(mi);
                }
            }
            for (const auto mi : std::as_const(itemsToDelete)) {
                delete mi;
            }
 
            mUnassignedMessageListForPass3.clear();
            mUnassignedMessageListForPass4.clear();
            return;
        }
 
        // mUnassignedMessageListForPass4 is empty so we must be at the end of a very special kind of Pass2
        // We have the same problem as in mUnassignedMessageListForPass2.
        QList<MessageItem *> parentless;
        for (const auto mi : std::as_const(mUnassignedMessageListForPass3)) {
            if (!mi->parent()) {
                parentless.append(mi);
            }
        }
        for (const auto mi : std::as_const(parentless)) {
            delete mi;
        }
 
        mUnassignedMessageListForPass3.clear();
        return;
    }
 
    // mUnassignedMessageListForPass3 is empty
    if (!mUnassignedMessageListForPass4.isEmpty()) {
        // we're in Pass4.. this is easy.
 
        // We have the same problem as in mUnassignedMessageListForPass2.
        QList<MessageItem *> parentless;
        for (const auto mi : std::as_const(mUnassignedMessageListForPass4)) {
            if (!mi->parent()) {
                parentless.append(mi);
            }
        }
        for (const auto mi : std::as_const(parentless)) {
            delete mi;
        }
 
        mUnassignedMessageListForPass4.clear();
        return;
    }
}
 
void ModelPrivate::clearThreadingCacheReferencesIdMD5ToMessageItem()
{
    qDeleteAll(mThreadingCacheMessageReferencesIdMD5ToMessageItem);
    mThreadingCacheMessageReferencesIdMD5ToMessageItem.clear();
}
 
void ModelPrivate::clearThreadingCacheMessageSubjectMD5ToMessageItem()
{
    qDeleteAll(mThreadingCacheMessageSubjectMD5ToMessageItem);
    mThreadingCacheMessageSubjectMD5ToMessageItem.clear();
}
 
void ModelPrivate::clearOrphanChildrenHash()
{
    qDeleteAll(mOrphanChildrenHash);
    mOrphanChildrenHash.clear();
}
 
void ModelPrivate::clearJobList()
{
    if (mViewItemJobs.isEmpty()) {
        return;
    }
 
    if (mInLengthyJobBatch) {
        mInLengthyJobBatch = false;
    }
 
    qDeleteAll(mViewItemJobs);
    mViewItemJobs.clear();
 
    mModelForItemFunctions = q; // make sure it's true, as there remains no job with disconnected UI
}
 
void ModelPrivate::attachGroup(GroupHeaderItem *ghi)
{
    if (ghi->parent()) {
        if (((ghi)->childItemCount() > 0) // has children
            && (ghi)->isViewable() // is actually attached to the viewable root
            && mModelForItemFunctions // the UI is not disconnected
            && mView->isExpanded(q->index(ghi, 0)) // is actually expanded
        ) {
            saveExpandedStateOfSubtree(ghi);
        }
 
        // FIXME: This *WILL* break selection and current index... :/
 
        ghi->parent()->takeChildItem(mModelForItemFunctions, ghi);
    }
 
    ghi->setParent(mRootItem);
 
    // I'm using a macro since it does really improve readability.
    // I'm NOT using a helper function since gcc will refuse to inline some of
    // the calls because they make this function grow too much.
#define INSERT_GROUP_WITH_COMPARATOR(_ItemComparator)                                                                                                          \
    switch (mSortOrder->groupSortDirection()) {                                                                                                                \
    case SortOrder::Ascending:                                                                                                                                 \
        mRootItem->d_ptr->insertChildItem<_ItemComparator, true>(mModelForItemFunctions, ghi);                                                                 \
        break;                                                                                                                                                 \
    case SortOrder::Descending:                                                                                                                                \
        mRootItem->d_ptr->insertChildItem<_ItemComparator, false>(mModelForItemFunctions, ghi);                                                                \
        break;                                                                                                                                                 \
    default: /* should never happen... */                                                                                                                      \
        mRootItem->appendChildItem(mModelForItemFunctions, ghi);                                                                                               \
        break;                                                                                                                                                 \
    }
 
    switch (mSortOrder->groupSorting()) {
    case SortOrder::SortGroupsByDateTime:
        INSERT_GROUP_WITH_COMPARATOR(ItemDateComparator)
        break;
    case SortOrder::SortGroupsByDateTimeOfMostRecent:
        INSERT_GROUP_WITH_COMPARATOR(ItemMaxDateComparator)
        break;
    case SortOrder::SortGroupsBySenderOrReceiver:
        INSERT_GROUP_WITH_COMPARATOR(ItemSenderOrReceiverComparator)
        break;
    case SortOrder::SortGroupsBySender:
        INSERT_GROUP_WITH_COMPARATOR(ItemSenderComparator)
        break;
    case SortOrder::SortGroupsByReceiver:
        INSERT_GROUP_WITH_COMPARATOR(ItemReceiverComparator)
        break;
    case SortOrder::NoGroupSorting:
        mRootItem->appendChildItem(mModelForItemFunctions, ghi);
        break;
    default: // should never happen
        mRootItem->appendChildItem(mModelForItemFunctions, ghi);
        break;
    }
 
    if (ghi->initialExpandStatus() == Item::ExpandNeeded) { // this actually is a "non viewable expanded state"
        if (ghi->childItemCount() > 0) {
            if (mModelForItemFunctions) { // the UI is not disconnected
                syncExpandedStateOfSubtree(ghi);
            }
        }
    }
 
    // A group header is always viewable, when attached: apply the filter, if we have it.
    if (mFilter) {
        Q_ASSERT(mModelForItemFunctions); // UI must be NOT disconnected
        // apply the filter to subtree
        applyFilterToSubtree(ghi, QModelIndex());
    }
}
 
void ModelPrivate::saveExpandedStateOfSubtree(Item *root)
{
    Q_ASSERT(mModelForItemFunctions); // UI must be NOT disconnected here
    Q_ASSERT(root);
 
    root->setInitialExpandStatus(Item::ExpandNeeded);
 
    auto children = root->childItems();
    if (!children) {
        return;
    }
    for (const auto mi : std::as_const(*children)) {
        if (mi->childItemCount() > 0 // has children
            && mi->isViewable() // is actually attached to the viewable root
            && mView->isExpanded(q->index(mi, 0))) { // is actually expanded
            saveExpandedStateOfSubtree(mi);
        }
    }
}
 
void ModelPrivate::syncExpandedStateOfSubtree(Item *root)
{
    Q_ASSERT(mModelForItemFunctions); // UI must be NOT disconnected here
 
    // WE ASSUME that:
    // - the item is viewable
    // - its initialExpandStatus() is Item::ExpandNeeded
    // - it has at least one children (well.. this is not a strict requirement, but it's a waste of resources to expand items that don't have children)
 
    QModelIndex idx = q->index(root, 0);
 
    // if ( !mView->isExpanded( idx ) ) // this is O(logN!) in Qt.... very ugly... but it should never happen here
    mView->expand(idx); // sync the real state in the view
    root->setInitialExpandStatus(Item::ExpandExecuted);
 
    auto children = root->childItems();
    if (!children) {
        return;
    }
 
    for (const auto mi : std::as_const(*children)) {
        if (mi->initialExpandStatus() == Item::ExpandNeeded) {
            if (mi->childItemCount() > 0) {
                syncExpandedStateOfSubtree(mi);
            }
        }
    }
}
 
void ModelPrivate::attachMessageToGroupHeader(MessageItem *mi)
{
    QString groupLabel;
    time_t date;
 
    // compute the group header label and the date
    switch (mAggregation->grouping()) {
    case Aggregation::GroupByDate:
    case Aggregation::GroupByDateRange: {
        if (mAggregation->threadLeader() == Aggregation::MostRecentMessage) {
            date = mi->maxDate();
        } else {
            date = mi->date();
        }
 
        QDateTime dt;
        dt.setSecsSinceEpoch(date);
        QDate dDate = dt.date();
        int daysAgo = -1;
        const int daysInWeek = 7;
        if (dDate.isValid() && mTodayDate.isValid()) {
            daysAgo = dDate.daysTo(mTodayDate);
        }
 
        if ((daysAgo < 0) // In the future
            || (static_cast<uint>(date) == static_cast<uint>(-1))) { // Invalid
            groupLabel = mCachedUnknownLabel;
        } else if (daysAgo == 0) { // Today
            groupLabel = mCachedTodayLabel;
        } else if (daysAgo == 1) { // Yesterday
            groupLabel = mCachedYesterdayLabel;
        } else if (daysAgo > 1 && daysAgo < daysInWeek) { // Within last seven days
            auto dayName = mCachedDayNameLabel.find(dDate.dayOfWeek()); // non-const call, but non-shared container
            if (dayName == mCachedDayNameLabel.end()) {
                dayName = mCachedDayNameLabel.insert(dDate.dayOfWeek(), QLocale::system().standaloneDayName(dDate.dayOfWeek()));
            }
            groupLabel = *dayName;
        } else if (mAggregation->grouping() == Aggregation::GroupByDate) { // GroupByDate seven days or more ago
            groupLabel = QLocale::system().toString(dDate, QLocale::ShortFormat);
        } else if (dDate.month() == mTodayDate.month() // GroupByDateRange within this month
                   && dDate.year() == mTodayDate.year()) {
            const int startOfWeekDaysAgo = (daysInWeek + mTodayDate.dayOfWeek() - QLocale().firstDayOfWeek()) % daysInWeek;
            const int weeksAgo = ((daysAgo - startOfWeekDaysAgo) / daysInWeek) + 1;
            switch (weeksAgo) {
            case 0: // This week
                groupLabel = QLocale::system().standaloneDayName(dDate.dayOfWeek());
                break;
            case 1: // 1 week ago
                groupLabel = mCachedLastWeekLabel;
                break;
            case 2:
                groupLabel = mCachedTwoWeeksAgoLabel;
                break;
            case 3:
                groupLabel = mCachedThreeWeeksAgoLabel;
                break;
            case 4:
                groupLabel = mCachedFourWeeksAgoLabel;
                break;
            case 5:
                groupLabel = mCachedFiveWeeksAgoLabel;
                break;
            default: // should never happen
                groupLabel = mCachedUnknownLabel;
            }
        } else if (dDate.year() == mTodayDate.year()) { // GroupByDateRange within this year
            auto monthName = mCachedMonthNameLabel.find(dDate.month()); // non-const call, but non-shared container
            if (monthName == mCachedMonthNameLabel.end()) {
                monthName = mCachedMonthNameLabel.insert(dDate.month(), QLocale::system().standaloneMonthName(dDate.month()));
            }
            groupLabel = *monthName;
        } else { // GroupByDateRange in previous years
            auto monthName = mCachedMonthNameLabel.find(dDate.month()); // non-const call, but non-shared container
            if (monthName == mCachedMonthNameLabel.end()) {
                monthName = mCachedMonthNameLabel.insert(dDate.month(), QLocale::system().standaloneMonthName(dDate.month()));
            }
            groupLabel = i18nc("Message Aggregation Group Header: Month name and Year number",
                               "%1 %2",
                               *monthName,
                               QLocale::system().toString(dDate, QLatin1StringView("yyyy")));
        }
        break;
    }
 
    case Aggregation::GroupBySenderOrReceiver:
        date = mi->date();
        groupLabel = mi->displaySenderOrReceiver();
        break;
 
    case Aggregation::GroupBySender:
        date = mi->date();
        groupLabel = mi->displaySender();
        break;
 
    case Aggregation::GroupByReceiver:
        date = mi->date();
        groupLabel = mi->displayReceiver();
        break;
 
    case Aggregation::NoGrouping:
        // append directly to root
        attachMessageToParent(mRootItem, mi);
        return;
 
    default:
        // should never happen
        attachMessageToParent(mRootItem, mi);
        return;
    }
 
    GroupHeaderItem *ghi;
 
    ghi = mGroupHeaderItemHash.value(groupLabel, nullptr);
    if (!ghi) {
        // not found
 
        ghi = new GroupHeaderItem(groupLabel);
        ghi->initialSetup(date, mi->size(), mi->sender(), mi->receiver(), mi->useReceiver());
 
        switch (mAggregation->groupExpandPolicy()) {
        case Aggregation::NeverExpandGroups:
            // nothing to do
            break;
        case Aggregation::AlwaysExpandGroups:
            // expand always
            ghi->setInitialExpandStatus(Item::ExpandNeeded);
            break;
        case Aggregation::ExpandRecentGroups:
            // expand only if "close" to today
            if (mViewItemJobStepStartTime > ghi->date()) {
                if ((mViewItemJobStepStartTime - ghi->date()) < (3600 * 72)) {
                    ghi->setInitialExpandStatus(Item::ExpandNeeded);
                }
            } else {
                if ((ghi->date() - mViewItemJobStepStartTime) < (3600 * 72)) {
                    ghi->setInitialExpandStatus(Item::ExpandNeeded);
                }
            }
            break;
        default:
            // b0rken
            break;
        }
 
        attachMessageToParent(ghi, mi);
 
        attachGroup(ghi); // this will expand the group if required
 
        mGroupHeaderItemHash.insert(groupLabel, ghi);
    } else {
        // the group was already there (certainly viewable)
 
        // This function may be also called to re-group a message.
        // That is, to eventually find a new group for a message that has changed
        // its properties (but was already attached to a group).
        // So it may happen that we find out that in fact re-grouping wasn't really
        // needed because the message is already in the correct group.
        if (mi->parent() == ghi) {
            return; // nothing to be done
        }
 
        attachMessageToParent(ghi, mi);
    }
 
    // Remember this message as a thread leader
    mThreadingCache.updateParent(mi, nullptr);
}
 
MessageItem *ModelPrivate::findMessageParent(MessageItem *mi)
{
    Q_ASSERT(mAggregation->threading() != Aggregation::NoThreading); // caller must take care of this
 
    // This function attempts to find a thread parent for the item "mi"
    // which actually may already have a children subtree.
 
    // Forged or plain broken message trees are dangerous here.
    // For example, a message tree with circular references like
    //
    //        Message mi, Id=1, In-Reply-To=2
    //          Message childOfMi, Id=2, In-Reply-To=1
    //
    // is perfectly possible and will cause us to find childOfMi
    // as parent of mi. This will then create a loop in the message tree
    // (which will then no longer be a tree in fact) and cause us to freeze
    // once we attempt to climb the parents. We need to take care of that.
 
    bool bMessageWasThreadable = false;
    MessageItem *pParent;
 
    // First of all try to find a "perfect parent", that is the message for that
    // we have the ID in the "In-Reply-To" field. This is actually done by using
    // MD5 caches of the message ids because of speed. Collisions are very unlikely.
 
    QByteArray md5 = mi->inReplyToIdMD5();
    if (!md5.isEmpty()) {
        // have an In-Reply-To field MD5
        pParent = mThreadingCacheMessageIdMD5ToMessageItem.value(md5, nullptr);
        if (pParent) {
            // Take care of circular references
            if ((mi == pParent) // self referencing message
                || ((mi->childItemCount() > 0) // mi already has children, this is fast to determine
                    && pParent->hasAncestor(mi) // pParent is in the mi's children tree
                    )) {
                qCWarning(MESSAGELIST_LOG) << "Circular In-Reply-To reference loop detected in the message tree";
                mi->setThreadingStatus(MessageItem::NonThreadable);
                return nullptr; // broken message: throw it away
            }
            mi->setThreadingStatus(MessageItem::PerfectParentFound);
            return pParent; // got a perfect parent for this message
        }
 
        // got no perfect parent
        bMessageWasThreadable = true; // but the message was threadable
    }
 
    if (mAggregation->threading() == Aggregation::PerfectOnly) {
        mi->setThreadingStatus(bMessageWasThreadable ? MessageItem::ParentMissing : MessageItem::NonThreadable);
        return nullptr; // we're doing only perfect parent matches
    }
 
    // Try to use the "References" field. In fact we have the MD5 of the
    // (n-1)th entry in References.
    //
    // Original rationale from KMHeaders:
    //
    // If we don't have a replyToId, or if we have one and the
    // corresponding message is not in this folder, as happens
    // if you keep your outgoing messages in an OUTBOX, for
    // example, try the list of references, because the second
    // to last will likely be in this folder. replyToAuxIdMD5
    // contains the second to last one.
 
    md5 = mi->referencesIdMD5();
    if (!md5.isEmpty()) {
        pParent = mThreadingCacheMessageIdMD5ToMessageItem.value(md5, nullptr);
        if (pParent) {
            // Take care of circular references
            if ((mi == pParent) // self referencing message
                || ((mi->childItemCount() > 0) // mi already has children, this is fast to determine
                    && pParent->hasAncestor(mi) // pParent is in the mi's children tree
                    )) {
                qCWarning(MESSAGELIST_LOG) << "Circular reference loop detected in the message tree";
                mi->setThreadingStatus(MessageItem::NonThreadable);
                return nullptr; // broken message: throw it away
            }
            mi->setThreadingStatus(MessageItem::ImperfectParentFound);
            return pParent; // got an imperfect parent for this message
        }
 
        auto messagesWithTheSameReferences = mThreadingCacheMessageReferencesIdMD5ToMessageItem.value(md5, nullptr);
        if (messagesWithTheSameReferences) {
            Q_ASSERT(!messagesWithTheSameReferences->isEmpty());
 
            pParent = messagesWithTheSameReferences->first();
            if (mi != pParent && (mi->childItemCount() == 0 || !pParent->hasAncestor(mi))) {
                mi->setThreadingStatus(MessageItem::ImperfectParentFound);
                return pParent;
            }
        }
 
        // got no imperfect parent
        bMessageWasThreadable = true; // but the message was threadable
    }
 
    if (mAggregation->threading() == Aggregation::PerfectAndReferences) {
        mi->setThreadingStatus(bMessageWasThreadable ? MessageItem::ParentMissing : MessageItem::NonThreadable);
        return nullptr; // we're doing only perfect parent matches
    }
 
    Q_ASSERT(mAggregation->threading() == Aggregation::PerfectReferencesAndSubject);
 
    // We are supposed to do subject based threading but we can't do it now.
    // This is because the subject based threading *may* be wrong and waste
    // time by creating circular references (that we'd need to detect and fix).
    // We first try the perfect and references based threading on all the messages
    // and then run subject based threading only on the remaining ones.
 
    mi->setThreadingStatus((bMessageWasThreadable || mi->subjectIsPrefixed()) ? MessageItem::ParentMissing : MessageItem::NonThreadable);
    return nullptr;
}
 
// Subject threading cache stuff
 
#if 0
// Debug helpers
void dump_iterator_and_list(QList< MessageItem * >::Iterator &iter, QList< MessageItem * > *list)
{
    qCDebug(MESSAGELIST_LOG) << "Threading cache part dump";
    if (iter == list->end()) {
        qCDebug(MESSAGELIST_LOG) << "Iterator pointing to end of the list";
    } else {
        qCDebug(MESSAGELIST_LOG) << "Iterator pointing to " << *iter << " subject [" << (*iter)->subject() << "] date [" << (*iter)->date() << "]";
    }
 
    for (QList< MessageItem * >::Iterator it = list->begin(); it != list->end(); ++it) {
        qCDebug(MESSAGELIST_LOG) << "List element " << *it << " subject [" << (*it)->subject() << "] date [" << (*it)->date() << "]";
    }
 
    qCDebug(MESSAGELIST_LOG) << "End of threading cache part dump";
}
 
void dump_list(QList< MessageItem * > *list)
{
    qCDebug(MESSAGELIST_LOG) << "Threading cache part dump";
 
    for (QList< MessageItem * >::Iterator it = list->begin(); it != list->end(); ++it) {
        qCDebug(MESSAGELIST_LOG) << "List element " << *it << " subject [" << (*it)->subject() << "] date [" << (*it)->date() << "]";
    }
 
    qCDebug(MESSAGELIST_LOG) << "End of threading cache part dump";
}
 
#endif // debug helpers
 
// a helper class used in a qLowerBound() call below
class MessageLessThanByDate
{
public:
    inline bool operator()(const MessageItem *mi1, const MessageItem *mi2) const
    {
        if (mi1->date() < mi2->date()) { // likely
            return true;
        }
        if (mi1->date() > mi2->date()) { // likely
            return false;
        }
        // dates are equal, compare by pointer
        return mi1 < mi2;
    }
};
 
void ModelPrivate::addMessageToReferencesBasedThreadingCache(MessageItem *mi)
{
    // Messages in this cache are sorted by date, and if dates are equal then they are sorted by pointer value.
    // Sorting by date is used to optimize the parent lookup in guessMessageParent() below.
 
    // WARNING: If the message date changes for some reason (like in the "update" step)
    //          then the cache may become unsorted. For this reason the message about to
    //          be changed must be first removed from the cache and then reinserted.
 
    auto messagesWithTheSameReference = mThreadingCacheMessageReferencesIdMD5ToMessageItem.value(mi->referencesIdMD5(), nullptr);
 
    if (!messagesWithTheSameReference) {
        messagesWithTheSameReference = new QList<MessageItem *>();
        mThreadingCacheMessageReferencesIdMD5ToMessageItem.insert(mi->referencesIdMD5(), messagesWithTheSameReference);
        messagesWithTheSameReference->append(mi);
        return;
    }
 
    // Found: assert that we have no duplicates in the cache.
    Q_ASSERT(!messagesWithTheSameReference->contains(mi));
 
    // Ordered insert: first by date then by pointer value.
    auto it = std::lower_bound(messagesWithTheSameReference->begin(), messagesWithTheSameReference->end(), mi, MessageLessThanByDate());
    messagesWithTheSameReference->insert(it, mi);
}
 
void ModelPrivate::removeMessageFromReferencesBasedThreadingCache(MessageItem *mi)
{
    // We assume that the caller knows what he is doing and the message is actually in the cache.
    // If the message isn't in the cache then we should not be called at all.
 
    auto messagesWithTheSameReference = mThreadingCacheMessageReferencesIdMD5ToMessageItem.value(mi->referencesIdMD5(), nullptr);
 
    // We assume that the message is there so the list must be non null.
    Q_ASSERT(messagesWithTheSameReference);
 
    // The cache *MUST* be ordered first by date then by pointer value
    auto it = std::lower_bound(messagesWithTheSameReference->begin(), messagesWithTheSameReference->end(), mi, MessageLessThanByDate());
 
    // The binary based search must have found a message
    Q_ASSERT(it != messagesWithTheSameReference->end());
 
    // and it must have found exactly the message requested
    Q_ASSERT(*it == mi);
 
    // Kill it
    messagesWithTheSameReference->erase(it);
 
    // And kill the list if it was the last one
    if (messagesWithTheSameReference->isEmpty()) {
        mThreadingCacheMessageReferencesIdMD5ToMessageItem.remove(mi->referencesIdMD5());
        delete messagesWithTheSameReference;
    }
}
 
void ModelPrivate::addMessageToSubjectBasedThreadingCache(MessageItem *mi)
{
    // Messages in this cache are sorted by date, and if dates are equal then they are sorted by pointer value.
    // Sorting by date is used to optimize the parent lookup in guessMessageParent() below.
 
    // WARNING: If the message date changes for some reason (like in the "update" step)
    //          then the cache may become unsorted. For this reason the message about to
    //          be changed must be first removed from the cache and then reinserted.
 
    // Lookup the list of messages with the same stripped subject
    auto messagesWithTheSameStrippedSubject = mThreadingCacheMessageSubjectMD5ToMessageItem.value(mi->strippedSubjectMD5(), nullptr);
 
    if (!messagesWithTheSameStrippedSubject) {
        // Not there yet: create it and append.
        messagesWithTheSameStrippedSubject = new QList<MessageItem *>();
        mThreadingCacheMessageSubjectMD5ToMessageItem.insert(mi->strippedSubjectMD5(), messagesWithTheSameStrippedSubject);
        messagesWithTheSameStrippedSubject->append(mi);
        return;
    }
 
    // Found: assert that we have no duplicates in the cache.
    Q_ASSERT(!messagesWithTheSameStrippedSubject->contains(mi));
 
    // Ordered insert: first by date then by pointer value.
    auto it = std::lower_bound(messagesWithTheSameStrippedSubject->begin(), messagesWithTheSameStrippedSubject->end(), mi, MessageLessThanByDate());
    messagesWithTheSameStrippedSubject->insert(it, mi);
}
 
void ModelPrivate::removeMessageFromSubjectBasedThreadingCache(MessageItem *mi)
{
    // We assume that the caller knows what he is doing and the message is actually in the cache.
    // If the message isn't in the cache then we should not be called at all.
    //
    // The game is called "performance"
 
    // Grab the list of all the messages with the same stripped subject (all potential parents)
    auto messagesWithTheSameStrippedSubject = mThreadingCacheMessageSubjectMD5ToMessageItem.value(mi->strippedSubjectMD5(), nullptr);
 
    // We assume that the message is there so the list must be non null.
    Q_ASSERT(messagesWithTheSameStrippedSubject);
 
    // The cache *MUST* be ordered first by date then by pointer value
    auto it = std::lower_bound(messagesWithTheSameStrippedSubject->begin(), messagesWithTheSameStrippedSubject->end(), mi, MessageLessThanByDate());
 
    // The binary based search must have found a message
    Q_ASSERT(it != messagesWithTheSameStrippedSubject->end());
 
    // and it must have found exactly the message requested
    Q_ASSERT(*it == mi);
 
    // Kill it
    messagesWithTheSameStrippedSubject->erase(it);
 
    // And kill the list if it was the last one
    if (messagesWithTheSameStrippedSubject->isEmpty()) {
        mThreadingCacheMessageSubjectMD5ToMessageItem.remove(mi->strippedSubjectMD5());
        delete messagesWithTheSameStrippedSubject;
    }
}
 
MessageItem *ModelPrivate::guessMessageParent(MessageItem *mi)
{
    // This function implements subject based threading
    // It attempts to guess a thread parent for the item "mi"
    // which actually may already have a children subtree.
 
    // We have all the problems of findMessageParent() plus the fact that
    // we're actually guessing (and often we may be *wrong*).
 
    Q_ASSERT(mAggregation->threading() == Aggregation::PerfectReferencesAndSubject); // caller must take care of this
    Q_ASSERT(mi->subjectIsPrefixed()); // caller must take care of this
    Q_ASSERT(mi->threadingStatus() == MessageItem::ParentMissing);
 
    // Do subject based threading
    const QByteArray md5 = mi->strippedSubjectMD5();
    if (!md5.isEmpty()) {
        auto messagesWithTheSameStrippedSubject = mThreadingCacheMessageSubjectMD5ToMessageItem.value(md5, nullptr);
 
        if (messagesWithTheSameStrippedSubject) {
            Q_ASSERT(!messagesWithTheSameStrippedSubject->isEmpty());
 
            // Need to find the message with the maximum date lower than the one of this message
 
            auto maxTime = (time_t)0;
            MessageItem *pParent = nullptr;
 
            // Here'we re really guessing so circular references are possible
            // even on perfectly valid trees. This is why we don't consider it
            // an error but just continue searching.
 
            // FIXME: This might be speed up with an initial binary search (?)
            // ANSWER: No. We can't rely on date order (as it can be updated on the fly...)
            for (const auto it : std::as_const(*messagesWithTheSameStrippedSubject)) {
                int delta = mi->date() - it->date();
 
                // We don't take into account messages with a delta smaller than 120.
                // Assuming that our date() values are correct (that is, they take into
                // account timezones etc..) then one usually needs more than 120 seconds
                // to answer to a message. Better safe than sorry.
 
                // This check also includes negative deltas so messages later than mi aren't considered
 
                if (delta < 120) {
                    break; // The list is ordered by date (ascending) so we can stop searching here
                }
 
                // About the "magic" 3628899 value here comes a Till's comment from the original KMHeaders:
                //
                //   "Parents more than six weeks older than the message are not accepted. The reasoning being
                //   that if a new message with the same subject turns up after such a long time, the chances
                //   that it is still part of the same thread are slim. The value of six weeks is chosen as a
                //   result of a poll conducted on kde-devel, so it's probably bogus. :)"
 
                if (delta < 3628899) {
                    // Compute the closest.
                    if ((maxTime < it->date())) {
                        // This algorithm *can* be (and often is) wrong.
                        // Take care of circular threading which is really possible at this level.
                        // If mi contains "it" inside its children subtree then we have
                        // found such a circular threading problem.
 
                        // Note that here we can't have it == mi because of the delta >= 120 check above.
 
                        if ((mi->childItemCount() == 0) || !it->hasAncestor(mi)) {
                            maxTime = it->date();
                            pParent = it;
                        }
                    }
                }
            }
 
            if (pParent) {
                mi->setThreadingStatus(MessageItem::ImperfectParentFound);
                return pParent; // got an imperfect parent for this message
            }
        }
    }
 
    return nullptr;
}
 
//
// A little template helper, hopefully inlineable.
//
// Return true if the specified message item is in the wrong position
// inside the specified parent and needs re-sorting. Return false otherwise.
// Both parent and messageItem must not be null.
//
// Checking if a message needs re-sorting instead of just re-sorting it
// is very useful since re-sorting is an expensive operation.
//
template<class ItemComparator>
static bool messageItemNeedsReSorting(SortOrder::SortDirection messageSortDirection, ItemPrivate *parent, MessageItem *messageItem)
{
    if ((messageSortDirection == SortOrder::Ascending) || (parent->mType == Item::Message)) {
        return parent->childItemNeedsReSorting<ItemComparator, true>(messageItem);
    }
    return parent->childItemNeedsReSorting<ItemComparator, false>(messageItem);
}
 
bool ModelPrivate::handleItemPropertyChanges(int propertyChangeMask, Item *parent, Item *item)
{
    // The facts:
    //
    // - If dates changed:
    //   - If we're sorting messages by min/max date then at each level the messages might need resorting.
    //   - If the thread leader is the most recent message of a thread then the uppermost
    //     message of the thread might need re-grouping.
    //   - If the groups are sorted by min/max date then the group might need re-sorting too.
    //
    // This function explicitly doesn't re-apply the filter when ActionItemStatus changes.
    // This is because filters must be re-applied due to a broader range of status variations:
    // this is done in viewItemJobStepInternalForJobPass1Update() instead (which is the only
    // place in that ActionItemStatus may be set).
 
    if (parent->type() == Item::InvisibleRoot) {
        // item is either a message or a group attached to the root.
        // It might need resorting.
        if (item->type() == Item::GroupHeader) {
            // item is a group header attached to the root.
            if ((
                    // max date changed
                    (propertyChangeMask & MaxDateChanged) && // groups sorted by max date
                    (mSortOrder->groupSorting() == SortOrder::SortGroupsByDateTimeOfMostRecent))
                || (
                    // date changed
                    (propertyChangeMask & DateChanged) && // groups sorted by date
                    (mSortOrder->groupSorting() == SortOrder::SortGroupsByDateTime))) {
                // This group might need re-sorting.
 
                // Groups are large container of messages so it's likely that
                // another message inserted will cause this group to be marked again.
                // So we wait until the end to do the grand final re-sorting: it will be done in Pass4.
                mGroupHeadersThatNeedUpdate.insert(static_cast<GroupHeaderItem *>(item), static_cast<GroupHeaderItem *>(item));
            }
        } else {
            // item is a message. It might need re-sorting.
 
            // Since sorting is an expensive operation, we first check if it's *really* needed.
            // Re-sorting will actually not change min/max dates at all and
            // will not climb up the parent's ancestor tree.
 
            switch (mSortOrder->messageSorting()) {
            case SortOrder::SortMessagesByDateTime:
                if (propertyChangeMask & DateChanged) { // date changed
                    if (messageItemNeedsReSorting<ItemDateComparator>(mSortOrder->messageSortDirection(), parent->d_ptr, static_cast<MessageItem *>(item))) {
                        attachMessageToParent(parent, static_cast<MessageItem *>(item));
                    }
                } // else date changed, but it doesn't match sorting order: no need to re-sort
                break;
            case SortOrder::SortMessagesByDateTimeOfMostRecent:
                if (propertyChangeMask & MaxDateChanged) { // max date changed
                    if (messageItemNeedsReSorting<ItemMaxDateComparator>(mSortOrder->messageSortDirection(), parent->d_ptr, static_cast<MessageItem *>(item))) {
                        attachMessageToParent(parent, static_cast<MessageItem *>(item));
                    }
                } // else max date changed, but it doesn't match sorting order: no need to re-sort
                break;
            case SortOrder::SortMessagesByActionItemStatus:
                if (propertyChangeMask & ActionItemStatusChanged) { // todo status changed
                    if (messageItemNeedsReSorting<ItemActionItemStatusComparator>(mSortOrder->messageSortDirection(),
                                                                                  parent->d_ptr,
                                                                                  static_cast<MessageItem *>(item))) {
                        attachMessageToParent(parent, static_cast<MessageItem *>(item));
                    }
                } // else to do status changed, but it doesn't match sorting order: no need to re-sort
                break;
            case SortOrder::SortMessagesByUnreadStatus:
                if (propertyChangeMask & UnreadStatusChanged) { // new / unread status changed
                    if (messageItemNeedsReSorting<ItemUnreadStatusComparator>(mSortOrder->messageSortDirection(),
                                                                              parent->d_ptr,
                                                                              static_cast<MessageItem *>(item))) {
                        attachMessageToParent(parent, static_cast<MessageItem *>(item));
                    }
                } // else new/unread status changed, but it doesn't match sorting order: no need to re-sort
                break;
            case SortOrder::SortMessagesByImportantStatus:
                if (propertyChangeMask & ImportantStatusChanged) { // important status changed
                    if (messageItemNeedsReSorting<ItemImportantStatusComparator>(mSortOrder->messageSortDirection(),
                                                                                 parent->d_ptr,
                                                                                 static_cast<MessageItem *>(item))) {
                        attachMessageToParent(parent, static_cast<MessageItem *>(item));
                    }
                } // else new/unread status changed, but it doesn't match sorting order: no need to re-sort
                break;
            case SortOrder::SortMessagesByAttachmentStatus:
                if (propertyChangeMask & AttachmentStatusChanged) { // attachment status changed
                    if (messageItemNeedsReSorting<ItemAttachmentStatusComparator>(mSortOrder->messageSortDirection(),
                                                                                  parent->d_ptr,
                                                                                  static_cast<MessageItem *>(item))) {
                        attachMessageToParent(parent, static_cast<MessageItem *>(item));
                    }
                } // else new/unread status changed, but it doesn't match sorting order: no need to re-sort
                break;
            default:
                // this kind of message sorting isn't affected by the property changes: nothing to do.
                break;
            }
        }
 
        return false; // the invisible root isn't affected by any change.
    }
 
    if (parent->type() == Item::GroupHeader) {
        // item is a message attached to a GroupHeader.
        // It might need re-grouping or re-sorting (within the same group)
 
        // Check re-grouping here.
        if ((
                // max date changed
                (propertyChangeMask & MaxDateChanged) && // thread leader is most recent message
                (mAggregation->threadLeader() == Aggregation::MostRecentMessage))
            || (
                // date changed
                (propertyChangeMask & DateChanged) && // thread leader the topmost message
                (mAggregation->threadLeader() == Aggregation::TopmostMessage))) {
            // Might really need re-grouping.
            // attachMessageToGroupHeader() will find the right group for this message
            // and if it's different than the current it will move it.
            attachMessageToGroupHeader(static_cast<MessageItem *>(item));
            // Re-grouping fixes the properties of the involved group headers
            // so at exit of attachMessageToGroupHeader() the parent can't be affected
            // by the change anymore.
            return false;
        }
 
        // Re-grouping wasn't needed. Re-sorting might be.
    } // else item is a message attached to another message and might need re-sorting only.
 
    // Check if message needs re-sorting.
 
    switch (mSortOrder->messageSorting()) {
    case SortOrder::SortMessagesByDateTime:
        if (propertyChangeMask & DateChanged) { // date changed
            if (messageItemNeedsReSorting<ItemDateComparator>(mSortOrder->messageSortDirection(), parent->d_ptr, static_cast<MessageItem *>(item))) {
                attachMessageToParent(parent, static_cast<MessageItem *>(item));
            }
        } // else date changed, but it doesn't match sorting order: no need to re-sort
        break;
    case SortOrder::SortMessagesByDateTimeOfMostRecent:
        if (propertyChangeMask & MaxDateChanged) { // max date changed
            if (messageItemNeedsReSorting<ItemMaxDateComparator>(mSortOrder->messageSortDirection(), parent->d_ptr, static_cast<MessageItem *>(item))) {
                attachMessageToParent(parent, static_cast<MessageItem *>(item));
            }
        } // else max date changed, but it doesn't match sorting order: no need to re-sort
        break;
    case SortOrder::SortMessagesByActionItemStatus:
        if (propertyChangeMask & ActionItemStatusChanged) { // todo status changed
            if (messageItemNeedsReSorting<ItemActionItemStatusComparator>(mSortOrder->messageSortDirection(),
                                                                          parent->d_ptr,
                                                                          static_cast<MessageItem *>(item))) {
                attachMessageToParent(parent, static_cast<MessageItem *>(item));
            }
        } // else to do status changed, but it doesn't match sorting order: no need to re-sort
        break;
    case SortOrder::SortMessagesByUnreadStatus:
        if (propertyChangeMask & UnreadStatusChanged) { // new / unread status changed
            if (messageItemNeedsReSorting<ItemUnreadStatusComparator>(mSortOrder->messageSortDirection(), parent->d_ptr, static_cast<MessageItem *>(item))) {
                attachMessageToParent(parent, static_cast<MessageItem *>(item));
            }
        } // else new/unread status changed, but it doesn't match sorting order: no need to re-sort
        break;
    case SortOrder::SortMessagesByImportantStatus:
        if (propertyChangeMask & ImportantStatusChanged) { // important status changed
            if (messageItemNeedsReSorting<ItemImportantStatusComparator>(mSortOrder->messageSortDirection(), parent->d_ptr, static_cast<MessageItem *>(item))) {
                attachMessageToParent(parent, static_cast<MessageItem *>(item));
            }
        } // else important status changed, but it doesn't match sorting order: no need to re-sort
        break;
    case SortOrder::SortMessagesByAttachmentStatus:
        if (propertyChangeMask & AttachmentStatusChanged) { // attachment status changed
            if (messageItemNeedsReSorting<ItemAttachmentStatusComparator>(mSortOrder->messageSortDirection(),
                                                                          parent->d_ptr,
                                                                          static_cast<MessageItem *>(item))) {
                attachMessageToParent(parent, static_cast<MessageItem *>(item));
            }
        } // else important status changed, but it doesn't match sorting order: no need to re-sort
        break;
    default:
        // this kind of message sorting isn't affected by property changes: nothing to do.
        break;
    }
 
    return true; // parent might be affected too.
}
 
void ModelPrivate::messageDetachedUpdateParentProperties(Item *oldParent, MessageItem *mi)
{
    Q_ASSERT(oldParent);
    Q_ASSERT(mi);
    Q_ASSERT(oldParent != mRootItem);
 
    // oldParent might have its properties changed because of the child removal.
    // propagate the changes up.
    for (;;) {
        // pParent is not the root item now. This is assured by how we enter this loop
        // and by the fact that handleItemPropertyChanges returns false when grandParent
        // is Item::InvisibleRoot. We could actually assert it here...
 
        // Check if its dates need an update.
        int propertyChangeMask;
 
        if ((mi->maxDate() == oldParent->maxDate()) && oldParent->recomputeMaxDate()) {
            propertyChangeMask = MaxDateChanged;
        } else {
            break; // from the for(;;) loop
        }
 
        // One of the oldParent properties has changed for sure
 
        Item *grandParent = oldParent->parent();
 
        // If there is no grandParent then oldParent isn't attached to the view.
        // Re-sorting / re-grouping isn't needed for sure.
        if (!grandParent) {
            break; // from the for(;;) loop
        }
 
        // The following function will return true if grandParent may be affected by the change.
        // If the grandParent isn't affected, we stop climbing.
        if (!handleItemPropertyChanges(propertyChangeMask, grandParent, oldParent)) {
            break; // from the for(;;) loop
        }
 
        // Now we need to climb up one level and check again.
        oldParent = grandParent;
    } // for(;;) loop
 
    // If the last message was removed from a group header then this group will need an update
    // for sure. We will need to remove it (unless a message is attached back to it)
    if (oldParent->type() == Item::GroupHeader) {
        if (oldParent->childItemCount() == 0) {
            mGroupHeadersThatNeedUpdate.insert(static_cast<GroupHeaderItem *>(oldParent), static_cast<GroupHeaderItem *>(oldParent));
        }
    }
}
 
void ModelPrivate::propagateItemPropertiesToParent(Item *item)
{
    Item *pParent = item->parent();
    Q_ASSERT(pParent);
    Q_ASSERT(pParent != mRootItem);
 
    for (;;) {
        // pParent is not the root item now. This is assured by how we enter this loop
        // and by the fact that handleItemPropertyChanges returns false when grandParent
        // is Item::InvisibleRoot. We could actually assert it here...
 
        // Check if its dates need an update.
        int propertyChangeMask;
 
        if (item->maxDate() > pParent->maxDate()) {
            pParent->setMaxDate(item->maxDate());
            propertyChangeMask = MaxDateChanged;
        } else {
            // No parent dates have changed: no further work is needed. Stop climbing here.
            break; // from the for(;;) loop
        }
 
        // One of the pParent properties has changed.
 
        Item *grandParent = pParent->parent();
 
        // If there is no grandParent then pParent isn't attached to the view.
        // Re-sorting / re-grouping isn't needed for sure.
        if (!grandParent) {
            break; // from the for(;;) loop
        }
 
        // The following function will return true if grandParent may be affected by the change.
        // If the grandParent isn't affected, we stop climbing.
        if (!handleItemPropertyChanges(propertyChangeMask, grandParent, pParent)) {
            break; // from the for(;;) loop
        }
 
        // Now we need to climb up one level and check again.
        pParent = grandParent;
    } // for(;;)
}
 
void ModelPrivate::attachMessageToParent(Item *pParent, MessageItem *mi, AttachOptions attachOptions)
{
    Q_ASSERT(pParent);
    Q_ASSERT(mi);
 
    // This function may be called to do a simple "re-sort" of the item inside the parent.
    // In that case mi->parent() is equal to pParent.
    bool oldParentWasTheSame;
 
    if (mi->parent()) {
        Item *oldParent = mi->parent();
 
        // The item already had a parent and this means that we're moving it.
        oldParentWasTheSame = oldParent == pParent; // just re-sorting ?
 
        if (mi->isViewable()) { // is actually
            // The message is actually attached to the viewable root
 
            // Unfortunately we need to hack the model/view architecture
            // since it's somewhat flawed in this. At the moment of writing
            // there is simply no way to atomically move a subtree.
            // We must detach, call beginRemoveRows()/endRemoveRows(),
            // save the expanded state, save the selection, save the current item,
            // save the view position (YES! As we are removing items the view
            // will hopelessly jump around so we're just FORCED to break
            // the isolation from the view)...
            // ...*then* reattach, restore the expanded state, restore the selection,
            // restore the current item, restore the view position and pray
            // that nothing will fail in the (rather complicated) process....
 
            // Yet more unfortunately, while saving the expanded state might stop
            // at a certain (unexpanded) point in the tree, saving the selection
            // is hopelessly recursive down to the bare leafs.
 
            // Furthermore the expansion of items is a common case while selection
            // in the subtree is rare, so saving it would be a huge cost with
            // a low revenue.
 
            // This is why we just let the selection screw up. I hereby refuse to call
            // yet another expensive recursive function here :D
 
            // The current item saving can be somewhat optimized doing it once for
            // a single job step...
 
            if (((mi)->childItemCount() > 0) // has children
                && mModelForItemFunctions // the UI is not actually disconnected
                && mView->isExpanded(q->index(mi, 0)) // is actually expanded
            ) {
                saveExpandedStateOfSubtree(mi);
            }
        }
 
        // If the parent is viewable (so mi was viewable too) then the beginRemoveRows()
        // and endRemoveRows() functions of this model will be called too.
        oldParent->takeChildItem(mModelForItemFunctions, mi);
 
        if ((!oldParentWasTheSame) && (oldParent != mRootItem)) {
            messageDetachedUpdateParentProperties(oldParent, mi);
        }
    } else {
        // The item had no parent yet.
        oldParentWasTheSame = false;
    }
 
    // Take care of perfect / imperfect threading.
    // Items that are now perfectly threaded, but already have a different parent
    // might have been imperfectly threaded before. Remove them from the caches.
    // Items that are now imperfectly threaded must be added to the caches.
    //
    // If we're just re-sorting the item inside the same parent then the threading
    // caches don't need to be updated (since they actually depend on the parent).
 
    if (!oldParentWasTheSame) {
        switch (mi->threadingStatus()) {
        case MessageItem::PerfectParentFound:
            if (!mi->inReplyToIdMD5().isEmpty()) {
                mThreadingCacheMessageInReplyToIdMD5ToMessageItem.remove(mi->inReplyToIdMD5(), mi);
            }
            if (attachOptions == StoreInCache && pParent->type() == Item::Message) {
                mThreadingCache.updateParent(mi, static_cast<MessageItem *>(pParent));
            }
            break;
        case MessageItem::ImperfectParentFound:
        case MessageItem::ParentMissing: // may be: temporary or just fallback assignment
            if (!mi->inReplyToIdMD5().isEmpty()) {
                if (!mThreadingCacheMessageInReplyToIdMD5ToMessageItem.contains(mi->inReplyToIdMD5(), mi)) {
                    mThreadingCacheMessageInReplyToIdMD5ToMessageItem.insert(mi->inReplyToIdMD5(), mi);
                }
            }
            break;
        case MessageItem::NonThreadable: // this also happens when we do no threading at all
            // make gcc happy
            Q_ASSERT(!mThreadingCacheMessageInReplyToIdMD5ToMessageItem.contains(mi->inReplyToIdMD5(), mi));
            break;
        }
    }
 
    // Set the new parent
    mi->setParent(pParent);
 
    // Propagate watched and ignored status
    if ((pParent->status().toQInt32() & mCachedWatchedOrIgnoredStatusBits) // unlikely
        && (pParent->type() == Item::Message) // likely
    ) {
        // the parent is either watched or ignored: propagate to the child
        if (pParent->status().isWatched()) {
            int row = mInvariantRowMapper->modelInvariantIndexToModelIndexRow(mi);
            mi->setStatus(Akonadi::MessageStatus::statusWatched());
            mStorageModel->setMessageItemStatus(mi, row, Akonadi::MessageStatus::statusWatched());
        } else if (pParent->status().isIgnored()) {
            int row = mInvariantRowMapper->modelInvariantIndexToModelIndexRow(mi);
            mi->setStatus(Akonadi::MessageStatus::statusIgnored());
            mStorageModel->setMessageItemStatus(mi, row, Akonadi::MessageStatus::statusIgnored());
        }
    }
 
    // And insert into its child list
 
    // If pParent is viewable then the insert/append functions will call this model's
    // beginInsertRows() and endInsertRows() functions. This is EXTREMELY
    // expensive and ugly but it's the only way with the Qt4 imposed Model/View method.
    // Dude... (citation from Lost, if it wasn't clear).
 
    // I'm using a macro since it does really improve readability.
    // I'm NOT using a helper function since gcc will refuse to inline some of
    // the calls because they make this function grow too much.
#define INSERT_MESSAGE_WITH_COMPARATOR(_ItemComparator)                                                                                                        \
    if ((mSortOrder->messageSortDirection() == SortOrder::Ascending) || (pParent->type() == Item::Message)) {                                                  \
        pParent->d_ptr->insertChildItem<_ItemComparator, true>(mModelForItemFunctions, mi);                                                                    \
    } else {                                                                                                                                                   \
        pParent->d_ptr->insertChildItem<_ItemComparator, false>(mModelForItemFunctions, mi);                                                                   \
    }
 
    // If pParent is viewable then the insertion call will also set the child state to viewable.
    // Since mi MAY have children, then this call may make them viewable.
    switch (mSortOrder->messageSorting()) {
    case SortOrder::SortMessagesByDateTime:
        INSERT_MESSAGE_WITH_COMPARATOR(ItemDateComparator)
        break;
    case SortOrder::SortMessagesByDateTimeOfMostRecent:
        INSERT_MESSAGE_WITH_COMPARATOR(ItemMaxDateComparator)
        break;
    case SortOrder::SortMessagesBySize:
        INSERT_MESSAGE_WITH_COMPARATOR(ItemSizeComparator)
        break;
    case SortOrder::SortMessagesBySenderOrReceiver:
        INSERT_MESSAGE_WITH_COMPARATOR(ItemSenderOrReceiverComparator)
        break;
    case SortOrder::SortMessagesBySender:
        INSERT_MESSAGE_WITH_COMPARATOR(ItemSenderComparator)
        break;
    case SortOrder::SortMessagesByReceiver:
        INSERT_MESSAGE_WITH_COMPARATOR(ItemReceiverComparator)
        break;
    case SortOrder::SortMessagesBySubject:
        INSERT_MESSAGE_WITH_COMPARATOR(ItemSubjectComparator)
        break;
    case SortOrder::SortMessagesByActionItemStatus:
        INSERT_MESSAGE_WITH_COMPARATOR(ItemActionItemStatusComparator)
        break;
    case SortOrder::SortMessagesByUnreadStatus:
        INSERT_MESSAGE_WITH_COMPARATOR(ItemUnreadStatusComparator)
        break;
    case SortOrder::SortMessagesByImportantStatus:
        INSERT_MESSAGE_WITH_COMPARATOR(ItemImportantStatusComparator)
        break;
    case SortOrder::SortMessagesByAttachmentStatus:
        INSERT_MESSAGE_WITH_COMPARATOR(ItemAttachmentStatusComparator)
        break;
    case SortOrder::NoMessageSorting:
        pParent->appendChildItem(mModelForItemFunctions, mi);
        break;
    default: // should never happen
        pParent->appendChildItem(mModelForItemFunctions, mi);
        break;
    }
 
    // Decide if we need to expand parents
    bool childNeedsExpanding = (mi->initialExpandStatus() == Item::ExpandNeeded);
 
    if (pParent->initialExpandStatus() == Item::NoExpandNeeded) {
        switch (mAggregation->threadExpandPolicy()) {
        case Aggregation::NeverExpandThreads:
            // just do nothing unless this child has children and is already marked for expansion
            if (childNeedsExpanding) {
                pParent->setInitialExpandStatus(Item::ExpandNeeded);
            }
            break;
        case Aggregation::ExpandThreadsWithNewMessages: // No more new status. fall through to unread if it exists in config
        case Aggregation::ExpandThreadsWithUnreadMessages:
            // expand only if unread (or it has children marked for expansion)
            if (childNeedsExpanding || !mi->status().isRead()) {
                pParent->setInitialExpandStatus(Item::ExpandNeeded);
            }
            break;
        case Aggregation::ExpandThreadsWithUnreadOrImportantMessages:
            // expand only if unread, important or todo (or it has children marked for expansion)
            // FIXME: Wouldn't it be nice to be able to test for bitmasks in MessageStatus ?
            if (childNeedsExpanding || !mi->status().isRead() || mi->status().isImportant() || mi->status().isToAct()) {
                pParent->setInitialExpandStatus(Item::ExpandNeeded);
            }
            break;
        case Aggregation::AlwaysExpandThreads:
            // expand everything
            pParent->setInitialExpandStatus(Item::ExpandNeeded);
            break;
        default:
            // BUG
            break;
        }
    } // else it's already marked for expansion or expansion has been already executed
 
    // expand parent first, if possible
    if (pParent->initialExpandStatus() == Item::ExpandNeeded) {
        // If UI is not disconnected and parent is viewable, go up and expand
        if (mModelForItemFunctions && pParent->isViewable()) {
            // Now expand parents as needed
            Item *parentToExpand = pParent;
            while (parentToExpand) {
                if (parentToExpand == mRootItem) {
                    break; // no need to set it expanded
                }
                // parentToExpand is surely viewable (because this item is)
                if (parentToExpand->initialExpandStatus() == Item::ExpandExecuted) {
                    break;
                }
 
                mView->expand(q->index(parentToExpand, 0));
 
                parentToExpand->setInitialExpandStatus(Item::ExpandExecuted);
                parentToExpand = parentToExpand->parent();
            }
        } else {
            // It isn't viewable or UI is disconnected: climb up marking only
            Item *parentToExpand = pParent->parent();
            while (parentToExpand) {
                if (parentToExpand == mRootItem) {
                    break; // no need to set it expanded
                }
                parentToExpand->setInitialExpandStatus(Item::ExpandNeeded);
                parentToExpand = parentToExpand->parent();
            }
        }
    }
 
    if (mi->isViewable()) {
        // mi is now viewable
 
        // sync subtree expanded status
        if (childNeedsExpanding) {
            if (mi->childItemCount() > 0) {
                if (mModelForItemFunctions) { // the UI is not disconnected
                    syncExpandedStateOfSubtree(mi); // sync the real state in the view
                }
            }
        }
 
        // apply the filter, if needed
        if (mFilter) {
            Q_ASSERT(mModelForItemFunctions); // the UI must be NOT disconnected here
 
            // apply the filter to subtree
            if (applyFilterToSubtree(mi, q->index(pParent, 0))) {
                // mi matched, expand parents (unconditionally)
                mView->ensureDisplayedWithParentsExpanded(mi);
            }
        }
    }
 
    // Now we need to propagate the property changes the upper levels.
 
    // If we have just inserted a message inside the root then no work needs to be done:
    // no grouping is in effect and the message is already in the right place.
    if (pParent == mRootItem) {
        return;
    }
 
    // If we have just removed the item from this parent and re-inserted it
    // then this operation was a simple re-sort. The code above didn't update
    // the properties when removing the item so we don't actually need
    // to make the updates back.
    if (oldParentWasTheSame) {
        return;
    }
 
    // FIXME: OPTIMIZE THIS: First propagate changes THEN syncExpandedStateOfSubtree()
    //        and applyFilterToSubtree... (needs some thinking though).
 
    // Time to propagate up.
    propagateItemPropertiesToParent(mi);
 
    // Aaah.. we're done. Time for a thea ? :)
}
 
// FIXME: ThreadItem ?
//
// Foo Bar, Joe Thommason, Martin Rox ... Eddie Maiden                    <date of the thread>
// Title                                      <number of messages>, Last by xxx <inner status>
//
// When messages are added, mark it as dirty only (?)
 
ModelPrivate::ViewItemJobResult ModelPrivate::viewItemJobStepInternalForJobPass5(ViewItemJob *job, QElapsedTimer elapsedTimer)
{
    // In this pass we scan the group headers that are in mGroupHeadersThatNeedUpdate.
    // Empty groups get deleted while the other ones are re-sorted.
 
    int curIndex = job->currentIndex();
 
    auto it = mGroupHeadersThatNeedUpdate.begin();
    auto end = mGroupHeadersThatNeedUpdate.end();
 
    while (it != end) {
        if ((*it)->childItemCount() == 0) {
            // group with no children, kill it
            (*it)->parent()->takeChildItem(mModelForItemFunctions, *it);
            mGroupHeaderItemHash.remove((*it)->label());
 
            // If we were going to restore its position after the job step, well.. we can't do it anymore.
            if (mCurrentItemToRestoreAfterViewItemJobStep == (*it)) {
                mCurrentItemToRestoreAfterViewItemJobStep = nullptr;
            }
 
            // bye bye
            delete *it;
        } else {
            // Group with children: probably needs re-sorting.
 
            // Re-sorting here is an expensive operation.
            // In fact groups have been put in the QHash above on the assumption
            // that re-sorting *might* be needed but no real (expensive) check
            // has been done yet. Also by sorting a single group we might actually
            // put the others in the right place.
            // So finally check if re-sorting is *really* needed.
            bool needsReSorting;
 
            // A macro really improves readability here.
#define CHECK_IF_GROUP_NEEDS_RESORTING(_ItemDateComparator)                                                                                                    \
    switch (mSortOrder->groupSortDirection()) {                                                                                                                \
    case SortOrder::Ascending:                                                                                                                                 \
        needsReSorting = (*it)->parent()->d_ptr->childItemNeedsReSorting<_ItemDateComparator, true>(*it);                                                      \
        break;                                                                                                                                                 \
    case SortOrder::Descending:                                                                                                                                \
        needsReSorting = (*it)->parent()->d_ptr->childItemNeedsReSorting<_ItemDateComparator, false>(*it);                                                     \
        break;                                                                                                                                                 \
    default: /* should never happen */                                                                                                                         \
        needsReSorting = false;                                                                                                                                \
        break;                                                                                                                                                 \
    }
 
            switch (mSortOrder->groupSorting()) {
            case SortOrder::SortGroupsByDateTime:
                CHECK_IF_GROUP_NEEDS_RESORTING(ItemDateComparator)
                break;
            case SortOrder::SortGroupsByDateTimeOfMostRecent:
                CHECK_IF_GROUP_NEEDS_RESORTING(ItemMaxDateComparator)
                break;
            case SortOrder::SortGroupsBySenderOrReceiver:
                CHECK_IF_GROUP_NEEDS_RESORTING(ItemSenderOrReceiverComparator)
                break;
            case SortOrder::SortGroupsBySender:
                CHECK_IF_GROUP_NEEDS_RESORTING(ItemSenderComparator)
                break;
            case SortOrder::SortGroupsByReceiver:
                CHECK_IF_GROUP_NEEDS_RESORTING(ItemReceiverComparator)
                break;
            case SortOrder::NoGroupSorting:
                needsReSorting = false;
                break;
            default:
                // Should never happen... just assume re-sorting is not needed
                needsReSorting = false;
                break;
            }
 
            if (needsReSorting) {
                attachGroup(*it); // it will first detach and then re-attach in the proper place
            }
        }
 
        it = mGroupHeadersThatNeedUpdate.erase(it);
 
        curIndex++;
 
        // FIXME: In fact a single update is likely to manipulate
        //        a subtree with a LOT of messages inside. If interactivity is favored
        //        we should check the time really more often.
        if ((curIndex % mViewItemJobStepMessageCheckCount) == 0) {
            if (elapsedTimer.elapsed() > mViewItemJobStepChunkTimeout) {
                if (it != mGroupHeadersThatNeedUpdate.end()) {
                    job->setCurrentIndex(curIndex);
                    return ViewItemJobInterrupted;
                }
            }
        }
    }
 
    return ViewItemJobCompleted;
}
 
ModelPrivate::ViewItemJobResult ModelPrivate::viewItemJobStepInternalForJobPass4(ViewItemJob *job, QElapsedTimer elapsedTimer)
{
    // In this pass we scan mUnassignedMessageListForPass4 which now
    // contains both items with parents and items without parents.
    // We scan mUnassignedMessageList for messages without parent (the ones that haven't been
    // attached to the viewable tree yet) and find a suitable group for them. Then we simply
    // clear mUnassignedMessageList.
 
    // We call this pass "Grouping"
 
    int curIndex = job->currentIndex();
    int endIndex = job->endIndex();
 
    while (curIndex <= endIndex) {
        MessageItem *mi = mUnassignedMessageListForPass4[curIndex];
        if (!mi->parent()) {
            // Unassigned item: thread leader, insert into the proper group.
            // Locate the group (or root if no grouping requested)
            attachMessageToGroupHeader(mi);
        } else {
            // A parent was already assigned in Pass3: we have nothing to do here
        }
        curIndex++;
 
        // FIXME: In fact a single call to attachMessageToGroupHeader() is likely to manipulate
        //        a subtree with a LOT of messages inside. If interactivity is favored
        //        we should check the time really more often.
        if ((curIndex % mViewItemJobStepMessageCheckCount) == 0) {
            if (elapsedTimer.elapsed() > mViewItemJobStepChunkTimeout) {
                if (curIndex <= endIndex) {
                    job->setCurrentIndex(curIndex);
                    return ViewItemJobInterrupted;
                }
            }
        }
    }
 
    mUnassignedMessageListForPass4.clear();
    return ViewItemJobCompleted;
}
 
ModelPrivate::ViewItemJobResult ModelPrivate::viewItemJobStepInternalForJobPass3(ViewItemJob *job, QElapsedTimer elapsedTimer)
{
    // In this pass we scan the mUnassignedMessageListForPass3 and try to do construct the threads
    // by using subject based threading. If subject based threading is not in effect then
    // this pass turns to a nearly-no-op: at the end of Pass2 we have swapped the lists
    // and mUnassignedMessageListForPass3 is actually empty.
 
    // We don't shrink the mUnassignedMessageListForPass3 for two reasons:
    // - It would mess up this chunked algorithm by shifting indexes
    // - mUnassignedMessageList is a QList which is basically an array. It's faster
    //   to traverse an array of N entries than to remove K>0 entries one by one and
    //   to traverse the remaining N-K entries.
 
    int curIndex = job->currentIndex();
    int endIndex = job->endIndex();
 
    while (curIndex <= endIndex) {
        // If we're here, then threading is requested for sure.
        auto mi = mUnassignedMessageListForPass3[curIndex];
        if ((!mi->parent()) || (mi->threadingStatus() == MessageItem::ParentMissing)) {
            // Parent is missing (either "physically" with the item being not attached or "logically"
            // with the item being attached to a group or directly to the root.
            if (mi->subjectIsPrefixed()) {
                // We can try to guess it
                auto mparent = guessMessageParent(mi);
 
                if (mparent) {
                    // imperfect parent found
                    if (mi->isViewable()) {
                        // mi was already viewable, we're just trying to re-parent it better...
                        attachMessageToParent(mparent, mi);
                        if (!mparent->isViewable()) {
                            // re-attach it immediately (so current item is not lost)
                            auto topmost = mparent->topmostMessage();
                            Q_ASSERT(!topmost->parent()); // groups are always viewable!
                            topmost->setThreadingStatus(MessageItem::ParentMissing);
                            attachMessageToGroupHeader(topmost);
                        }
                    } else {
                        // mi wasn't viewable yet.. no need to attach parent
                        attachMessageToParent(mparent, mi);
                    }
                    // and we're done for now
                } else {
                    // so parent not found, (threadingStatus() is either MessageItem::ParentMissing or MessageItem::NonThreadable)
                    Q_ASSERT((mi->threadingStatus() == MessageItem::ParentMissing) || (mi->threadingStatus() == MessageItem::NonThreadable));
                    mUnassignedMessageListForPass4.append(mi); // this is ~O(1)
                    // and wait for Pass4
                }
            } else {
                // can't guess the parent as the subject isn't prefixed
                Q_ASSERT((mi->threadingStatus() == MessageItem::ParentMissing) || (mi->threadingStatus() == MessageItem::NonThreadable));
                mUnassignedMessageListForPass4.append(mi); // this is ~O(1)
                // and wait for Pass4
            }
        } else {
            // Has a parent: either perfect parent already found or non threadable.
            // Since we don't end here if mi has status of parent missing then mi must not have imperfect parent.
            Q_ASSERT(mi->threadingStatus() != MessageItem::ImperfectParentFound);
            Q_ASSERT(mi->isViewable());
        }
 
        curIndex++;
 
        // FIXME: In fact a single call to attachMessageToGroupHeader() is likely to manipulate
        //        a subtree with a LOT of messages inside. If interactivity is favored
        //        we should check the time really more often.
        if ((curIndex % mViewItemJobStepMessageCheckCount) == 0) {
            if (elapsedTimer.elapsed() > mViewItemJobStepChunkTimeout) {
                if (curIndex <= endIndex) {
                    job->setCurrentIndex(curIndex);
                    return ViewItemJobInterrupted;
                }
            }
        }
    }
 
    mUnassignedMessageListForPass3.clear();
    return ViewItemJobCompleted;
}
 
ModelPrivate::ViewItemJobResult ModelPrivate::viewItemJobStepInternalForJobPass2(ViewItemJob *job, QElapsedTimer elapsedTimer)
{
    // In this pass we scan the mUnassignedMessageList and try to do construct the threads.
    // If some thread leader message got attached to the viewable tree in Pass1Fill then
    // we'll also attach all of its children too. The thread leaders we were unable
    // to attach in Pass1Fill and their children (which we find here) will make it to the small Pass3
 
    // We don't shrink the mUnassignedMessageList for two reasons:
    // - It would mess up this chunked algorithm by shifting indexes
    // - mUnassignedMessageList is a QList which is basically an array. It's faster
    //   to traverse an array of N entries than to remove K>0 entries one by one and
    //   to traverse the remaining N-K entries.
 
    // We call this pass "Threading"
 
    int curIndex = job->currentIndex();
    int endIndex = job->endIndex();
 
    while (curIndex <= endIndex) {
        // If we're here, then threading is requested for sure.
        auto mi = mUnassignedMessageListForPass2[curIndex];
        // The item may or may not have a parent.
        // If it has no parent or it has a temporary one (mi->parent() && mi->threadingStatus() == MessageItem::ParentMissing)
        // then we attempt to (re-)thread it. Otherwise we just do nothing (the job has already been done by the previous steps).
        if ((!mi->parent()) || (mi->threadingStatus() == MessageItem::ParentMissing)) {
            qint64 parentId;
            auto mparent = mThreadingCache.parentForItem(mi, parentId);
            if (mparent && !mparent->hasAncestor(mi)) {
                mi->setThreadingStatus(MessageItem::PerfectParentFound);
                attachMessageToParent(mparent, mi, SkipCacheUpdate);
            } else {
                if (parentId > 0) {
                    // In second pass we have all available Items in mThreadingCache already. If
                    // mThreadingCache.parentForItem() returns null, but returns valid parentId then
                    // the Item was removed from Akonadi and our threading cache is out-of-date.
                    mThreadingCache.expireParent(mi);
                    mparent = findMessageParent(mi);
                } else if (parentId < 0) {
                    mparent = findMessageParent(mi);
                } else {
                    // parentId = 0: this message is a thread leader so don't
                    // bother resolving parent, it will be moved directly to
                    // Pass4 in the code below
                }
 
                if (mparent) {
                    // parent found, either perfect or imperfect
                    if (mi->isViewable()) {
                        // mi was already viewable, we're just trying to re-parent it better...
                        attachMessageToParent(mparent, mi);
                        if (!mparent->isViewable()) {
                            // re-attach it immediately (so current item is not lost)
                            auto topmost = mparent->topmostMessage();
                            Q_ASSERT(!topmost->parent()); // groups are always viewable!
                            topmost->setThreadingStatus(MessageItem::ParentMissing);
                            attachMessageToGroupHeader(topmost);
                        }
                    } else {
                        // mi wasn't viewable yet.. no need to attach parent
                        attachMessageToParent(mparent, mi);
                    }
                    // and we're done for now
                } else {
                    // so parent not found, (threadingStatus() is either MessageItem::ParentMissing or MessageItem::NonThreadable)
                    switch (mi->threadingStatus()) {
                    case MessageItem::ParentMissing:
                        if (mAggregation->threading() == Aggregation::PerfectReferencesAndSubject) {
                            // parent missing but still can be found in Pass3
                            mUnassignedMessageListForPass3.append(mi); // this is ~O(1)
                        } else {
                            // We're not doing subject based threading: will never be threaded, go straight to Pass4
                            mUnassignedMessageListForPass4.append(mi); // this is ~O(1)
                        }
                        break;
                    case MessageItem::NonThreadable:
                        // will never be threaded, go straight to Pass4
                        mUnassignedMessageListForPass4.append(mi); // this is ~O(1)
                        break;
                    default:
                        // a bug for sure
                        qCWarning(MESSAGELIST_LOG) << "ERROR: Invalid message threading status returned by findMessageParent()!";
                        Q_ASSERT(false);
                        break;
                    }
                }
            }
        } else {
            // Has a parent: either perfect parent already found or non threadable.
            // Since we don't end here if mi has status of parent missing then mi must not have imperfect parent.
            Q_ASSERT(mi->threadingStatus() != MessageItem::ImperfectParentFound);
            if (!mi->isViewable()) {
                qCWarning(MESSAGELIST_LOG) << "Non viewable message " << mi << " subject " << mi->subject().toUtf8().data();
                Q_ASSERT(mi->isViewable());
            }
        }
 
        curIndex++;
 
        // FIXME: In fact a single call to attachMessageToGroupHeader() is likely to manipulate
        //        a subtree with a LOT of messages inside. If interactivity is favored
        //        we should check the time really more often.
        if ((curIndex % mViewItemJobStepMessageCheckCount) == 0) {
            if (elapsedTimer.elapsed() > mViewItemJobStepChunkTimeout) {
                if (curIndex <= endIndex) {
                    job->setCurrentIndex(curIndex);
                    return ViewItemJobInterrupted;
                }
            }
        }
    }
 
    mUnassignedMessageListForPass2.clear();
    return ViewItemJobCompleted;
}
 
ModelPrivate::ViewItemJobResult ModelPrivate::viewItemJobStepInternalForJobPass1Fill(ViewItemJob *job, QElapsedTimer elapsedTimer)
{
    // In this pass we scan the a contiguous region of the underlying storage (that is
    // assumed to be FLAT) and create the corresponding MessageItem objects.
    // The deal is to show items to the user as soon as possible so in this pass we
    // *TRY* to attach them to the viewable tree (which is rooted on mRootItem).
    // Messages we're unable to attach for some reason (mainly due to threading) get appended
    // to mUnassignedMessageList and wait for Pass2.
 
    // We call this pass "Processing"
 
    // Should we use the receiver or the sender field for sorting ?
    bool bUseReceiver = mStorageModelContainsOutboundMessages;
 
    // The begin storage index of our work
    int curIndex = job->currentIndex();
    // The end storage index of our work.
    int endIndex = job->endIndex();
 
    unsigned long msgToSelect = mPreSelectionMode == PreSelectLastSelected ? mStorageModel->preSelectedMessage() : 0;
 
    MessageItem *mi = nullptr;
 
    while (curIndex <= endIndex) {
        // Create the message item with no parent: we'll set it later
        if (!mi) {
            mi = new MessageItem();
        } else {
            // a MessageItem discarded by a previous iteration: reuse it.
            Q_ASSERT(mi->parent() == nullptr);
        }
 
        if (!mStorageModel->initializeMessageItem(mi, curIndex, bUseReceiver)) {
            // ugh
            qCWarning(MESSAGELIST_LOG) << "Fill of the MessageItem at storage row index " << curIndex << " failed";
            curIndex++;
            continue;
        }
 
        // If we're supposed to pre-select a specific message, check if it's this one.
        if (msgToSelect != 0 && msgToSelect == mi->uniqueId()) {
            // Found, it's this one.
            // But actually it's not viewable (so not selectable). We must wait
            // until the end of the job to be 100% sure. So here we just translate
            // the unique id to a MessageItem pointer and wait.
            mLastSelectedMessageInFolder = mi;
            msgToSelect = 0; // already found, don't bother checking anymore
        }
 
        // Update the newest/oldest message, since we might be supposed to select those later
        if (mi->date() != static_cast<uint>(-1)) {
            if (!mOldestItem || mOldestItem->date() > mi->date()) {
                mOldestItem = mi;
            }
            if (!mNewestItem || mNewestItem->date() < mi->date()) {
                mNewestItem = mi;
            }
        }
 
        // Ok.. it passed the initial checks: we will not be discarding it.
        // Make this message item an invariant index to the underlying model storage.
        mInvariantRowMapper->createModelInvariantIndex(curIndex, mi);
 
        // Attempt to do threading as soon as possible (to display items to the user)
        if (mAggregation->threading() != Aggregation::NoThreading) {
            // Threading is requested
 
            // Fetch the data needed for proper threading
            // Add the item to the threading caches
 
            switch (mAggregation->threading()) {
            case Aggregation::PerfectReferencesAndSubject:
                mStorageModel->fillMessageItemThreadingData(mi, curIndex, StorageModel::PerfectThreadingReferencesAndSubject);
 
                // We also need to build the subject/reference-based threading cache
                addMessageToReferencesBasedThreadingCache(mi);
                addMessageToSubjectBasedThreadingCache(mi);
                break;
            case Aggregation::PerfectAndReferences:
                mStorageModel->fillMessageItemThreadingData(mi, curIndex, StorageModel::PerfectThreadingPlusReferences);
                addMessageToReferencesBasedThreadingCache(mi);
                break;
            default:
                mStorageModel->fillMessageItemThreadingData(mi, curIndex, StorageModel::PerfectThreadingOnly);
                break;
            }
 
            // Perfect/References threading cache
            mThreadingCacheMessageIdMD5ToMessageItem.insert(mi->messageIdMD5(), mi);
 
            // Register the current item into the threading cache
            mThreadingCache.addItemToCache(mi);
 
            // First of all look into the persistent cache
            qint64 parentId;
            Item *pParent = mThreadingCache.parentForItem(mi, parentId);
            if (pParent) {
                // We already have the parent MessageItem. Attach current message
                // to it and mark it as perfect
                mi->setThreadingStatus(MessageItem::PerfectParentFound);
                attachMessageToParent(pParent, mi);
            } else if (parentId > 0) {
                // We don't have the parent MessageItem yet, but we do know the
                // parent: delay for pass 2 when we will have the parent MessageItem
                // for sure.
                mi->setThreadingStatus(MessageItem::ParentMissing);
                mUnassignedMessageListForPass2.append(mi);
            } else if (parentId == 0) {
                // Message is a thread leader, skip straight to Pass4
                mi->setThreadingStatus(MessageItem::NonThreadable);
                mUnassignedMessageListForPass4.append(mi);
            } else {
                // Check if this item is a perfect parent for some imperfectly threaded
                // message (that is actually attached to it, but not necessarily to the
                // viewable root). If it is, then remove the imperfect child from its
                // current parent rebuild the hierarchy on the fly.
                bool needsImmediateReAttach = false;
 
                if (!mThreadingCacheMessageInReplyToIdMD5ToMessageItem.isEmpty()) { // unlikely
                    const auto lImperfectlyThreaded = mThreadingCacheMessageInReplyToIdMD5ToMessageItem.values(mi->messageIdMD5());
                    for (const auto it : lImperfectlyThreaded) {
                        Q_ASSERT(it->parent());
                        Q_ASSERT(it->parent() != mi);
 
                        if (!((it->threadingStatus() == MessageItem::ImperfectParentFound) || (it->threadingStatus() == MessageItem::ParentMissing))) {
                            qCritical() << "Got message " << it << " with threading status" << it->threadingStatus();
                            Q_ASSERT_X(false, "ModelPrivate::viewItemJobStepInternalForJobPass1Fill", "Wrong threading status");
                        }
 
                        // If the item was already attached to the view then
                        // re-attach it immediately. This will avoid a message
                        // being displayed for a short while in the view and then
                        // disappear until a perfect parent isn't found.
                        if (it->isViewable()) {
                            needsImmediateReAttach = true;
                        }
 
                        it->setThreadingStatus(MessageItem::PerfectParentFound);
                        attachMessageToParent(mi, it);
                    }
                }
 
                // FIXME: Might look by "References" too, here... (?)
 
                // Attempt to do threading with anything we already have in caches until now
                // Note that this is likely to work since thread-parent messages tend
                // to come before thread-children messages in the folders (simply because of
                // date of arrival).
 
                // First of all try to find a "perfect parent", that is the message for that
                // we have the ID in the "In-Reply-To" field. This is actually done by using
                // MD5 caches of the message ids because of speed. Collisions are very unlikely.
 
                const QByteArray md5 = mi->inReplyToIdMD5();
                if (!md5.isEmpty()) {
                    // Have an In-Reply-To field MD5.
                    // In well behaved mailing lists 70% of the threadable messages get a parent here :)
                    pParent = mThreadingCacheMessageIdMD5ToMessageItem.value(md5, nullptr);
 
                    if (pParent) { // very likely
                        // Take care of self-referencing (which is always possible)
                        // and circular In-Reply-To reference loops which are possible
                        // in case this item was found to be a perfect parent for some
                        // imperfectly threaded message just above.
                        if ((mi == pParent) // self referencing message
                            || ((mi->childItemCount() > 0) // mi already has children, this is fast to determine
                                && pParent->hasAncestor(mi) // pParent is in the mi's children tree
                                )) {
                            // Bad, bad message.. it has In-Reply-To equal to Message-Id
                            // or it's in a circular In-Reply-To reference loop.
                            // Will wait for Pass2 with References-Id only
                            qCWarning(MESSAGELIST_LOG) << "Circular In-Reply-To reference loop detected in the message tree";
                            mUnassignedMessageListForPass2.append(mi);
                        } else {
                            // wow, got a perfect parent for this message!
                            mi->setThreadingStatus(MessageItem::PerfectParentFound);
                            attachMessageToParent(pParent, mi);
                            // we're done with this message (also for Pass2)
                        }
                    } else {
                        // got no parent
                        // will have to wait Pass2
                        mUnassignedMessageListForPass2.append(mi);
                    }
                } else {
                    // No In-Reply-To header.
 
                    bool mightHaveOtherMeansForThreading;
 
                    switch (mAggregation->threading()) {
                    case Aggregation::PerfectReferencesAndSubject:
                        mightHaveOtherMeansForThreading = mi->subjectIsPrefixed() || !mi->referencesIdMD5().isEmpty();
                        break;
                    case Aggregation::PerfectAndReferences:
                        mightHaveOtherMeansForThreading = !mi->referencesIdMD5().isEmpty();
                        break;
                    case Aggregation::PerfectOnly:
                        mightHaveOtherMeansForThreading = false;
                        break;
                    default:
                        // BUG: there shouldn't be other values (NoThreading is excluded in an upper branch)
                        Q_ASSERT(false);
                        mightHaveOtherMeansForThreading = false; // make gcc happy
                        break;
                    }
 
                    if (mightHaveOtherMeansForThreading) {
                        // We might have other means for threading this message, wait until Pass2
                        mUnassignedMessageListForPass2.append(mi);
                    } else {
                        // No other means for threading this message. This is either
                        // a standalone message or a thread leader.
                        // If there is no grouping in effect or thread leaders are just the "topmost"
                        // messages then we might be done with this one.
                        if ((mAggregation->grouping() == Aggregation::NoGrouping) || (mAggregation->threadLeader() == Aggregation::TopmostMessage)) {
                            // We're done with this message: it will be surely either toplevel (no grouping in effect)
                            // or a thread leader with a well defined group. Do it :)
                            // qCDebug(MESSAGELIST_LOG) << "Setting message status from " << mi->threadingStatus() << " to non threadable (1) " << mi;
                            mi->setThreadingStatus(MessageItem::NonThreadable);
                            // Locate the parent group for this item
                            attachMessageToGroupHeader(mi);
                            // we're done with this message (also for Pass2)
                        } else {
                            // Threads belong to the most recent message in the thread. This means
                            // that we have to wait until Pass2 or Pass3 to assign a group.
                            mUnassignedMessageListForPass2.append(mi);
                        }
                    }
                }
 
                if (needsImmediateReAttach && !mi->isViewable()) {
                    // The item gathered previously viewable children. They must be immediately
                    // re-shown. So this item must currently be attached to the view.
                    // This is a temporary measure: it will be probably still moved.
                    MessageItem *topmost = mi->topmostMessage();
                    Q_ASSERT(topmost->threadingStatus() == MessageItem::ParentMissing);
                    attachMessageToGroupHeader(topmost);
                }
            }
        } else {
            // else no threading requested: we don't even need Pass2
            // set not threadable status (even if it might be not true, but in this mode we don't care)
            // qCDebug(MESSAGELIST_LOG) << "Setting message status from " << mi->threadingStatus() << " to non threadable (2) " << mi;
            mi->setThreadingStatus(MessageItem::NonThreadable);
            // locate the parent group for this item
            if (mAggregation->grouping() == Aggregation::NoGrouping) {
                attachMessageToParent(mRootItem, mi); // no groups requested, attach directly to root
            } else {
                attachMessageToGroupHeader(mi);
            }
            // we're done with this message (also for Pass2)
        }
 
        mi = nullptr; // this item was pushed somewhere, create a new one at next iteration
        curIndex++;
 
        if ((curIndex % mViewItemJobStepMessageCheckCount) == 0) {
            if (elapsedTimer.elapsed() > mViewItemJobStepChunkTimeout) {
                if (curIndex <= endIndex) {
                    job->setCurrentIndex(curIndex);
                    return ViewItemJobInterrupted;
                }
            }
        }
    }
 
    if (mi) {
        delete mi;
    }
    return ViewItemJobCompleted;
}
 
ModelPrivate::ViewItemJobResult ModelPrivate::viewItemJobStepInternalForJobPass1Cleanup(ViewItemJob *job, QElapsedTimer elapsedTimer)
{
    Q_ASSERT(mModelForItemFunctions); // UI must be not disconnected here
    // In this pass we remove the MessageItem objects that are present in the job
    // and put their children in the unassigned message list.
 
    // Note that this list in fact contains MessageItem objects (we need dynamic_cast<>).
    QList<ModelInvariantIndex *> *invalidatedMessages = job->invariantIndexList();
 
    // We don't shrink the invalidatedMessages because it's basically an array.
    // It's faster to traverse an array of N entries than to remove K>0 entries
    // one by one and to traverse the remaining N-K entries.
 
    // The begin index of our work
    int curIndex = job->currentIndex();
    // The end index of our work.
    int endIndex = job->endIndex();
 
    if (curIndex == job->startIndex()) {
        Q_ASSERT(mOrphanChildrenHash.isEmpty());
    }
 
    while (curIndex <= endIndex) {
        // Get the underlying storage message data...
        auto dyingMessage = dynamic_cast<MessageItem *>(invalidatedMessages->at(curIndex));
        // This MUST NOT be null (otherwise we have a bug somewhere in this file).
        Q_ASSERT(dyingMessage);
 
        // If we were going to pre-select this message but we were interrupted
        // *before* it was actually made viewable, we just clear the pre-selection pointer
        // and unique id (abort pre-selection).
        if (dyingMessage == mLastSelectedMessageInFolder) {
            mLastSelectedMessageInFolder = nullptr;
            mPreSelectionMode = PreSelectNone;
        }
 
        // remove the message from any pending user job
        if (mPersistentSetManager) {
            mPersistentSetManager->removeMessageItemFromAllSets(dyingMessage);
            if (mPersistentSetManager->setCount() < 1) {
                delete mPersistentSetManager;
                mPersistentSetManager = nullptr;
            }
        }
 
        // Remove the message from threading cache before we start moving up the
        // children, so that they don't get mislead by the cache
        mThreadingCache.expireParent(dyingMessage);
 
        if (dyingMessage->parent()) {
            // Handle saving the current selection: if this item was the current before the step
            // then zero it out. We have killed it and it's OK for the current item to change.
 
            if (dyingMessage == mCurrentItemToRestoreAfterViewItemJobStep) {
                Q_ASSERT(dyingMessage->isViewable());
                // Try to select the item below the removed one as it helps in doing a "readon" of emails:
                // you read a message, decide to delete it and then go to the next.
                // Qt tends to select the message above the removed one instead (this is a hardcoded logic in
                // QItemSelectionModelPrivate::_q_rowsAboutToBeRemoved()).
                mCurrentItemToRestoreAfterViewItemJobStep = mView->messageItemAfter(dyingMessage, MessageTypeAny, false);
 
                if (!mCurrentItemToRestoreAfterViewItemJobStep) {
                    // There is no item below. Try the item above.
                    // We still do it better than qt which tends to find the *thread* above
                    // instead of the item above.
                    mCurrentItemToRestoreAfterViewItemJobStep = mView->messageItemBefore(dyingMessage, MessageTypeAny, false);
                }
 
                Q_ASSERT((!mCurrentItemToRestoreAfterViewItemJobStep) || mCurrentItemToRestoreAfterViewItemJobStep->isViewable());
            }
 
            if (dyingMessage->isViewable() && ((dyingMessage)->childItemCount() > 0) // has children
                && mView->isExpanded(q->index(dyingMessage, 0)) // is actually expanded
            ) {
                saveExpandedStateOfSubtree(dyingMessage);
            }
 
            auto oldParent = dyingMessage->parent();
            oldParent->takeChildItem(q, dyingMessage);
 
            // FIXME: This can generate many message movements.. it would be nicer
            //        to start from messages that are higher in the hierarchy so
            //        we would need to move less stuff above.
 
            if (oldParent != mRootItem) {
                messageDetachedUpdateParentProperties(oldParent, dyingMessage);
            }
 
            // We might have already removed its parent from the view, so it
            // might already be in the orphan child hash...
            if (dyingMessage->threadingStatus() == MessageItem::ParentMissing) {
                mOrphanChildrenHash.remove(dyingMessage); // this can turn to a no-op (dyingMessage not present in fact)
            }
        } else {
            // The dying message had no parent: this should happen only if it's already an orphan
 
            Q_ASSERT(dyingMessage->threadingStatus() == MessageItem::ParentMissing);
            Q_ASSERT(mOrphanChildrenHash.contains(dyingMessage));
            Q_ASSERT(dyingMessage != mCurrentItemToRestoreAfterViewItemJobStep);
 
            mOrphanChildrenHash.remove(dyingMessage);
        }
 
        if (mAggregation->threading() != Aggregation::NoThreading) {
            // Threading is requested: remove the message from threading caches.
 
            // Remove from the cache of potential parent items
            mThreadingCacheMessageIdMD5ToMessageItem.remove(dyingMessage->messageIdMD5());
 
            // If we also have a cache for subject/reference-based threading then remove the message from there too
            if (mAggregation->threading() == Aggregation::PerfectReferencesAndSubject) {
                removeMessageFromReferencesBasedThreadingCache(dyingMessage);
                removeMessageFromSubjectBasedThreadingCache(dyingMessage);
            } else if (mAggregation->threading() == Aggregation::PerfectAndReferences) {
                removeMessageFromReferencesBasedThreadingCache(dyingMessage);
            }
 
            // If this message wasn't perfectly parented then it might still be in another cache.
            switch (dyingMessage->threadingStatus()) {
            case MessageItem::ImperfectParentFound:
            case MessageItem::ParentMissing:
                if (!dyingMessage->inReplyToIdMD5().isEmpty()) {
                    mThreadingCacheMessageInReplyToIdMD5ToMessageItem.remove(dyingMessage->inReplyToIdMD5());
                }
                break;
            default:
                Q_ASSERT(!mThreadingCacheMessageInReplyToIdMD5ToMessageItem.contains(dyingMessage->inReplyToIdMD5(), dyingMessage));
                // make gcc happy
                break;
            }
        }
 
        while (auto childItem = dyingMessage->firstChildItem()) {
            auto childMessage = dynamic_cast<MessageItem *>(childItem);
            Q_ASSERT(childMessage);
 
            dyingMessage->takeChildItem(q, childMessage);
 
            if (mAggregation->threading() != Aggregation::NoThreading) {
                if (childMessage->threadingStatus() == MessageItem::PerfectParentFound) {
                    // If the child message was perfectly parented then now it had
                    // lost its perfect parent. Add to the cache of imperfectly parented.
                    if (!childMessage->inReplyToIdMD5().isEmpty()) {
                        Q_ASSERT(!mThreadingCacheMessageInReplyToIdMD5ToMessageItem.contains(childMessage->inReplyToIdMD5(), childMessage));
                        mThreadingCacheMessageInReplyToIdMD5ToMessageItem.insert(childMessage->inReplyToIdMD5(), childMessage);
                    }
                }
            }
 
            // Parent is gone
            childMessage->setThreadingStatus(MessageItem::ParentMissing);
 
            // If the child (or any message in its subtree) is going to be selected,
            // then we must immediately reattach it to a temporary group in order for the
            // selection to be preserved across multiple steps. Otherwise we could end
            // with the child-to-be-selected being non viewable at the end
            // of the view job step. Attach to a temporary group.
            if (
                // child is going to be re-selected
                (childMessage == mCurrentItemToRestoreAfterViewItemJobStep)
                || (
                    // there is a message that is going to be re-selected
                    mCurrentItemToRestoreAfterViewItemJobStep && // that message is in the childMessage subtree
                    mCurrentItemToRestoreAfterViewItemJobStep->hasAncestor(childMessage))) {
                attachMessageToGroupHeader(childMessage);
 
                Q_ASSERT(childMessage->isViewable());
            }
 
            mOrphanChildrenHash.insert(childMessage, childMessage);
        }
 
        if (mNewestItem == dyingMessage) {
            mNewestItem = nullptr;
        }
        if (mOldestItem == dyingMessage) {
            mOldestItem = nullptr;
        }
 
        delete dyingMessage;
 
        curIndex++;
 
        // FIXME: Maybe we should check smaller steps here since the
        //        code above can generate large message tree movements
        //        for each single item we sweep in the invalidatedMessages list.
        if ((curIndex % mViewItemJobStepMessageCheckCount) == 0) {
            if (elapsedTimer.elapsed() > mViewItemJobStepChunkTimeout) {
                if (curIndex <= endIndex) {
                    job->setCurrentIndex(curIndex);
                    return ViewItemJobInterrupted;
                }
            }
        }
    }
 
    // We looped over the entire deleted message list.
 
    job->setCurrentIndex(endIndex + 1);
 
    // A quick last cleaning pass: this is usually very fast so we don't have a real
    // Pass enumeration for it. We just include it as trailer of Pass1Cleanup to be executed
    // when job->currentIndex() > job->endIndex();
 
    // We move all the messages from the orphan child hash to the unassigned message
    // list and get them ready for the standard Pass2.
 
    auto it = mOrphanChildrenHash.begin();
    auto end = mOrphanChildrenHash.end();
 
    curIndex = 0;
 
    while (it != end) {
        mUnassignedMessageListForPass2.append(*it);
 
        it = mOrphanChildrenHash.erase(it);
 
        // This is still interruptible
 
        curIndex++;
 
        // FIXME: We could take "larger" steps here
        if ((curIndex % mViewItemJobStepMessageCheckCount) == 0) {
            if (elapsedTimer.elapsed() > mViewItemJobStepChunkTimeout) {
                if (it != mOrphanChildrenHash.end()) {
                    return ViewItemJobInterrupted;
                }
            }
        }
    }
 
    return ViewItemJobCompleted;
}
 
ModelPrivate::ViewItemJobResult ModelPrivate::viewItemJobStepInternalForJobPass1Update(ViewItemJob *job, QElapsedTimer elapsedTimer)
{
    Q_ASSERT(mModelForItemFunctions); // UI must be not disconnected here
 
    // In this pass we simply update the MessageItem objects that are present in the job.
 
    // Note that this list in fact contains MessageItem objects (we need dynamic_cast<>).
    auto messagesThatNeedUpdate = job->invariantIndexList();
 
    // We don't shrink the messagesThatNeedUpdate because it's basically an array.
    // It's faster to traverse an array of N entries than to remove K>0 entries
    // one by one and to traverse the remaining N-K entries.
 
    // The begin index of our work
    int curIndex = job->currentIndex();
    // The end index of our work.
    int endIndex = job->endIndex();
 
    while (curIndex <= endIndex) {
        // Get the underlying storage message data...
        auto message = dynamic_cast<MessageItem *>(messagesThatNeedUpdate->at(curIndex));
        // This MUST NOT be null (otherwise we have a bug somewhere in this file).
        Q_ASSERT(message);
 
        int row = mInvariantRowMapper->modelInvariantIndexToModelIndexRow(message);
 
        if (row < 0) {
            // Must have been invalidated (so it's basically about to be deleted)
            Q_ASSERT(!message->isValid());
            // Skip it here.
            curIndex++;
            continue;
        }
 
        time_t prevDate = message->date();
        time_t prevMaxDate = message->maxDate();
        bool toDoStatus = message->status().isToAct();
        bool prevUnreadStatus = !message->status().isRead();
        bool prevImportantStatus = message->status().isImportant();
 
        // The subject/reference based threading cache is sorted by date: we must remove
        // the item and re-insert it since updateMessageItemData() may change the date too.
        if (mAggregation->threading() == Aggregation::PerfectReferencesAndSubject) {
            removeMessageFromReferencesBasedThreadingCache(message);
            removeMessageFromSubjectBasedThreadingCache(message);
        } else if (mAggregation->threading() == Aggregation::PerfectAndReferences) {
            removeMessageFromReferencesBasedThreadingCache(message);
        }
 
        // Do update
        mStorageModel->updateMessageItemData(message, row);
        const QModelIndex idx = q->index(message, 0);
        Q_EMIT q->dataChanged(idx, idx);
 
        // Reinsert the item to the cache, if needed
        if (mAggregation->threading() == Aggregation::PerfectReferencesAndSubject) {
            addMessageToReferencesBasedThreadingCache(message);
            addMessageToSubjectBasedThreadingCache(message);
        } else if (mAggregation->threading() == Aggregation::PerfectAndReferences) {
            addMessageToReferencesBasedThreadingCache(message);
        }
 
        int propertyChangeMask = 0;
 
        if (prevDate != message->date()) {
            propertyChangeMask |= DateChanged;
        }
        if (prevMaxDate != message->maxDate()) {
            propertyChangeMask |= MaxDateChanged;
        }
        if (toDoStatus != message->status().isToAct()) {
            propertyChangeMask |= ActionItemStatusChanged;
        }
        if (prevUnreadStatus != (!message->status().isRead())) {
            propertyChangeMask |= UnreadStatusChanged;
        }
        if (prevImportantStatus != (!message->status().isImportant())) {
            propertyChangeMask |= ImportantStatusChanged;
        }
 
        if (propertyChangeMask) {
            // Some message data has changed
            // now we need to handle the changes that might cause re-grouping/re-sorting
            // and propagate them to the parents.
 
            Item *pParent = message->parent();
 
            if (pParent && (pParent != mRootItem)) {
                // The following function will return true if itemParent may be affected by the change.
                // If the itemParent isn't affected, we stop climbing.
                if (handleItemPropertyChanges(propertyChangeMask, pParent, message)) {
                    Q_ASSERT(message->parent()); // handleItemPropertyChanges() must never leave an item detached
 
                    // Note that actually message->parent() may be different than pParent since
                    // handleItemPropertyChanges() may have re-grouped it.
 
                    // Time to propagate up.
                    propagateItemPropertiesToParent(message);
                }
            } // else there is no parent so the item isn't attached to the view: re-grouping/re-sorting not needed.
        } // else message data didn't change an there is nothing interesting to do
 
        // (re-)apply the filter, if needed
        if (mFilter && message->isViewable()) {
            // In all the other cases we (re-)apply the filter to the topmost subtree that this message is in.
            Item *pTopMostNonRoot = message->topmostNonRoot();
 
            Q_ASSERT(pTopMostNonRoot);
            Q_ASSERT(pTopMostNonRoot != mRootItem);
            Q_ASSERT(pTopMostNonRoot->parent() == mRootItem);
 
            // FIXME: The call below works, but it's expensive when we are updating
            //        a lot of items with filtering enabled. This is because the updated
            //        items are likely to be in the same subtree which we then filter multiple times.
            //        A point for us is that when filtering there shouldn't be really many
            //        items in the view so the user isn't going to update a lot of them at once...
            //        Well... anyway, the alternative would be to write yet another
            //        specialized routine that would update only the "message" item
            //        above and climb up eventually hiding parents (without descending the sibling subtrees again).
            //        If people complain about performance in this particular case I'll consider that solution.
 
            applyFilterToSubtree(pTopMostNonRoot, QModelIndex());
        } // otherwise there is no filter or the item isn't viewable: very likely
          // left detached while propagating property changes. Will filter it
          // on reattach.
 
        // Done updating this message
 
        curIndex++;
 
        // FIXME: Maybe we should check smaller steps here since the
        //        code above can generate large message tree movements
        //        for each single item we sweep in the messagesThatNeedUpdate list.
        if ((curIndex % mViewItemJobStepMessageCheckCount) == 0) {
            if (elapsedTimer.elapsed() > mViewItemJobStepChunkTimeout) {
                if (curIndex <= endIndex) {
                    job->setCurrentIndex(curIndex);
                    return ViewItemJobInterrupted;
                }
            }
        }
    }
 
    return ViewItemJobCompleted;
}
 
ModelPrivate::ViewItemJobResult ModelPrivate::viewItemJobStepInternalForJob(ViewItemJob *job, QElapsedTimer elapsedTimer)
{
    // This function does a timed chunk of work for a single Fill View job.
    // It attempts to process messages until a timeout forces it to return to the caller.
 
    // A macro would improve readability here but since this is a good point
    // to place debugger breakpoints then we need it explicitly.
    // A (template) helper would need to pass many parameters and would not be inlined...
 
    if (job->currentPass() == ViewItemJob::Pass1Fill) {
        // We're in Pass1Fill of the job.
        switch (viewItemJobStepInternalForJobPass1Fill(job, elapsedTimer)) {
        case ViewItemJobInterrupted:
            // current job interrupted by timeout: propagate status to caller
            return ViewItemJobInterrupted;
            break;
        case ViewItemJobCompleted:
            // pass 1 has been completed
            // # TODO: Refactor this, make it virtual or whatever, but switch == bad, code duplication etc
            job->setCurrentPass(ViewItemJob::Pass2);
            job->setStartIndex(0);
            job->setEndIndex(mUnassignedMessageListForPass2.count() - 1);
            // take care of small jobs which never timeout by themselves because
            // of a small number of messages. At the end of each job check
            // the time used and if we're timeoutting and there is another job
            // then interrupt.
            if (elapsedTimer.elapsed() > mViewItemJobStepChunkTimeout) {
                return ViewItemJobInterrupted;
            } // else proceed with the next pass
            break;
        default:
            // This is *really* a BUG
            qCWarning(MESSAGELIST_LOG) << "ERROR: returned an invalid result";
            Q_ASSERT(false);
            break;
        }
    } else if (job->currentPass() == ViewItemJob::Pass1Cleanup) {
        // We're in Pass1Cleanup of the job.
        switch (viewItemJobStepInternalForJobPass1Cleanup(job, elapsedTimer)) {
        case ViewItemJobInterrupted:
            // current job interrupted by timeout: propagate status to caller
            return ViewItemJobInterrupted;
            break;
        case ViewItemJobCompleted:
            // pass 1 has been completed
            job->setCurrentPass(ViewItemJob::Pass2);
            job->setStartIndex(0);
            job->setEndIndex(mUnassignedMessageListForPass2.count() - 1);
            // take care of small jobs which never timeout by themselves because
            // of a small number of messages. At the end of each job check
            // the time used and if we're timeoutting and there is another job
            // then interrupt.
            if (elapsedTimer.elapsed() > mViewItemJobStepChunkTimeout) {
                return ViewItemJobInterrupted;
            } // else proceed with the next pass
            break;
        default:
            // This is *really* a BUG
            qCWarning(MESSAGELIST_LOG) << "ERROR: returned an invalid result";
            Q_ASSERT(false);
            break;
        }
    } else if (job->currentPass() == ViewItemJob::Pass1Update) {
        // We're in Pass1Update of the job.
        switch (viewItemJobStepInternalForJobPass1Update(job, elapsedTimer)) {
        case ViewItemJobInterrupted:
            // current job interrupted by timeout: propagate status to caller
            return ViewItemJobInterrupted;
            break;
        case ViewItemJobCompleted:
            // pass 1 has been completed
            // Since Pass2, Pass3 and Pass4 are empty for an Update operation
            // we simply skip them. (TODO: Triple-verify this assertion...).
            job->setCurrentPass(ViewItemJob::Pass5);
            job->setStartIndex(0);
            job->setEndIndex(mGroupHeadersThatNeedUpdate.count() - 1);
            // take care of small jobs which never timeout by themselves because
            // of a small number of messages. At the end of each job check
            // the time used and if we're timeoutting and there is another job
            // then interrupt.
            if (elapsedTimer.elapsed() > mViewItemJobStepChunkTimeout) {
                return ViewItemJobInterrupted;
            } // else proceed with the next pass
            break;
        default:
            // This is *really* a BUG
            qCWarning(MESSAGELIST_LOG) << "ERROR: returned an invalid result";
            Q_ASSERT(false);
            break;
        }
    }
 
    // Pass1Fill/Pass1Cleanup/Pass1Update has been already completed.
 
    if (job->currentPass() == ViewItemJob::Pass2) {
        // We're in Pass2 of the job.
        switch (viewItemJobStepInternalForJobPass2(job, elapsedTimer)) {
        case ViewItemJobInterrupted:
            // current job interrupted by timeout: propagate status to caller
            return ViewItemJobInterrupted;
            break;
        case ViewItemJobCompleted:
            // pass 2 has been completed
            job->setCurrentPass(ViewItemJob::Pass3);
            job->setStartIndex(0);
            job->setEndIndex(mUnassignedMessageListForPass3.count() - 1);
            // take care of small jobs which never timeout by themselves because
            // of a small number of messages. At the end of each job check
            // the time used and if we're timeoutting and there is another job
            // then interrupt.
            if (elapsedTimer.elapsed() > mViewItemJobStepChunkTimeout) {
                return ViewItemJobInterrupted;
            }
            // else proceed with the next pass
            break;
        default:
            // This is *really* a BUG
            qCWarning(MESSAGELIST_LOG) << "ERROR: returned an invalid result";
            Q_ASSERT(false);
            break;
        }
    }
 
    if (job->currentPass() == ViewItemJob::Pass3) {
        // We're in Pass3 of the job.
        switch (viewItemJobStepInternalForJobPass3(job, elapsedTimer)) {
        case ViewItemJobInterrupted:
            // current job interrupted by timeout: propagate status to caller
            return ViewItemJobInterrupted;
        case ViewItemJobCompleted:
            // pass 3 has been completed
            job->setCurrentPass(ViewItemJob::Pass4);
            job->setStartIndex(0);
            job->setEndIndex(mUnassignedMessageListForPass4.count() - 1);
            // take care of small jobs which never timeout by themselves because
            // of a small number of messages. At the end of each job check
            // the time used and if we're timeoutting and there is another job
            // then interrupt.
            if (elapsedTimer.elapsed() > mViewItemJobStepChunkTimeout) {
                return ViewItemJobInterrupted;
            }
            // else proceed with the next pass
            break;
        default:
            // This is *really* a BUG
            qCWarning(MESSAGELIST_LOG) << "ERROR: returned an invalid result";
            Q_ASSERT(false);
            break;
        }
    }
 
    if (job->currentPass() == ViewItemJob::Pass4) {
        // We're in Pass4 of the job.
        switch (viewItemJobStepInternalForJobPass4(job, elapsedTimer)) {
        case ViewItemJobInterrupted:
            // current job interrupted by timeout: propagate status to caller
            return ViewItemJobInterrupted;
        case ViewItemJobCompleted:
            // pass 4 has been completed
            job->setCurrentPass(ViewItemJob::Pass5);
            job->setStartIndex(0);
            job->setEndIndex(mGroupHeadersThatNeedUpdate.count() - 1);
            // take care of small jobs which never timeout by themselves because
            // of a small number of messages. At the end of each job check
            // the time used and if we're timeoutting and there is another job
            // then interrupt.
            if (elapsedTimer.elapsed() > mViewItemJobStepChunkTimeout) {
                return ViewItemJobInterrupted;
            }
            // else proceed with the next pass
            break;
        default:
            // This is *really* a BUG
            qCWarning(MESSAGELIST_LOG) << "ERROR: returned an invalid result";
            Q_ASSERT(false);
            break;
        }
    }
 
    // Pass4 has been already completed. Proceed to Pass5.
    return viewItemJobStepInternalForJobPass5(job, elapsedTimer);
}
 
#ifdef KDEPIM_FOLDEROPEN_PROFILE
 
// Namespace to collect all the vars and functions for KDEPIM_FOLDEROPEN_PROFILE
namespace Stats
{
// Number of existing jobs/passes
static const int numberOfPasses = ViewItemJob::LastIndex;
 
// The pass in the last call of viewItemJobStepInternal(), used to detect when
// a new pass starts
static int lastPass = -1;
 
// Total number of messages in the folder
static int totalMessages;
 
// Per-Job data
static int numElements[numberOfPasses];
static int totalTime[numberOfPasses];
static int chunks[numberOfPasses];
 
// Time, in msecs for some special operations
static int expandingTreeTime;
static int layoutChangeTime;
 
// Descriptions of the job, for nicer debug output
static const char *jobDescription[numberOfPasses] = {"Creating items from messages and simple threading",
                                                     "Removing messages",
                                                     "Updating messages",
                                                     "Additional Threading",
                                                     "Subject-Based threading",
                                                     "Grouping",
                                                     "Group resorting + cleanup"};
 
// Timer to track time between start of first job and end of last job
static QTime firstStartTime;
 
// Timer to track time the current job takes
static QTime currentJobStartTime;
 
// Zeros the stats, to be called when the first job starts
static void resetStats()
{
    totalMessages = 0;
    layoutChangeTime = 0;
    expandingTreeTime = 0;
    lastPass = -1;
    for (int i = 0; i < numberOfPasses; ++i) {
        numElements[i] = 0;
        totalTime[i] = 0;
        chunks[i] = 0;
    }
}
} // namespace Stats
 
void ModelPrivate::printStatistics()
{
    using namespace Stats;
    int totalTotalTime = 0;
    int completeTime = firstStartTime.elapsed();
    for (int i = 0; i < numberOfPasses; ++i) {
        totalTotalTime += totalTime[i];
    }
 
    float msgPerSecond = totalMessages / (totalTotalTime / 1000.0f);
    float msgPerSecondComplete = totalMessages / (completeTime / 1000.0f);
 
    int messagesWithSameSubjectAvg = 0;
    int messagesWithSameSubjectMax = 0;
    for (const auto messages : std::as_const(mThreadingCacheMessageSubjectMD5ToMessageItem)) {
        if (messages->size() > messagesWithSameSubjectMax) {
            messagesWithSameSubjectMax = messages->size();
        }
        messagesWithSameSubjectAvg += messages->size();
    }
    messagesWithSameSubjectAvg = messagesWithSameSubjectAvg / (float)mThreadingCacheMessageSubjectMD5ToMessageItem.size();
 
    int totalThreads = 0;
    if (!mGroupHeaderItemHash.isEmpty()) {
        for (const GroupHeaderItem *groupHeader : std::as_const(mGroupHeaderItemHash)) {
            totalThreads += groupHeader->childItemCount();
        }
    } else {
        totalThreads = mRootItem->childItemCount();
    }
 
    qCDebug(MESSAGELIST_LOG) << "Finished filling the view with" << totalMessages << "messages";
    qCDebug(MESSAGELIST_LOG) << "That took" << totalTotalTime << "msecs inside the model and" << completeTime << "in total.";
    qCDebug(MESSAGELIST_LOG) << (totalTotalTime / (float)completeTime) * 100.0f << "percent of the time was spent in the model.";
    qCDebug(MESSAGELIST_LOG) << "Time for layoutChanged(), in msecs:" << layoutChangeTime << "(" << (layoutChangeTime / (float)totalTotalTime) * 100.0f
                             << "percent )";
    qCDebug(MESSAGELIST_LOG) << "Time to expand tree, in msecs:" << expandingTreeTime << "(" << (expandingTreeTime / (float)totalTotalTime) * 100.0f
                             << "percent )";
    qCDebug(MESSAGELIST_LOG) << "Number of messages per second in the model:" << msgPerSecond;
    qCDebug(MESSAGELIST_LOG) << "Number of messages per second in total:" << msgPerSecondComplete;
    qCDebug(MESSAGELIST_LOG) << "Number of threads:" << totalThreads;
    qCDebug(MESSAGELIST_LOG) << "Number of groups:" << mGroupHeaderItemHash.size();
    qCDebug(MESSAGELIST_LOG) << "Messages per thread:" << totalMessages / (float)totalThreads;
    qCDebug(MESSAGELIST_LOG) << "Threads per group:" << totalThreads / (float)mGroupHeaderItemHash.size();
    qCDebug(MESSAGELIST_LOG) << "Messages with the same subject:"
                             << "Max:" << messagesWithSameSubjectMax << "Avg:" << messagesWithSameSubjectAvg;
    qCDebug(MESSAGELIST_LOG);
    qCDebug(MESSAGELIST_LOG) << "Now follows a breakdown of the jobs.";
    qCDebug(MESSAGELIST_LOG);
    for (int i = 0; i < numberOfPasses; ++i) {
        if (totalTime[i] == 0) {
            continue;
        }
        float elementsPerSecond = numElements[i] / (totalTime[i] / 1000.0f);
        float percent = totalTime[i] / (float)totalTotalTime * 100.0f;
        qCDebug(MESSAGELIST_LOG) << "----------------------------------------------";
        qCDebug(MESSAGELIST_LOG) << "Job" << i + 1 << "(" << jobDescription[i] << ")";
        qCDebug(MESSAGELIST_LOG) << "Share of complete time:" << percent << "percent";
        qCDebug(MESSAGELIST_LOG) << "Time in msecs:" << totalTime[i];
        qCDebug(MESSAGELIST_LOG) << "Number of elements:" << numElements[i]; // TODO: map of element string
        qCDebug(MESSAGELIST_LOG) << "Elements per second:" << elementsPerSecond;
        qCDebug(MESSAGELIST_LOG) << "Number of chunks:" << chunks[i];
        qCDebug(MESSAGELIST_LOG);
    }
 
    qCDebug(MESSAGELIST_LOG) << "==========================================================";
    resetStats();
}
 
#endif
 
ModelPrivate::ViewItemJobResult ModelPrivate::viewItemJobStepInternal()
{
    // This function does a timed chunk of work in our View Fill operation.
    // It attempts to do processing until it either runs out of jobs
    // to be done or a timeout forces it to interrupt and jump back to the caller.
 
    QElapsedTimer elapsedTimer;
    elapsedTimer.start();
 
    while (!mViewItemJobs.isEmpty()) {
        // Have a job to do.
        ViewItemJob *job = mViewItemJobs.constFirst();
 
#ifdef KDEPIM_FOLDEROPEN_PROFILE
 
        // Here we check if an old job has just completed or if we are at the start of the
        // first job. We then initialize job data stuff and timers based on this.
 
        const int currentPass = job->currentPass();
        const bool firstChunk = currentPass != Stats::lastPass;
        if (currentPass != Stats::lastPass && Stats::lastPass != -1) {
            Stats::totalTime[Stats::lastPass] = Stats::currentJobStartTime.elapsed();
        }
        const bool firstJob = job->currentPass() == ViewItemJob::Pass1Fill && firstChunk;
        const int elements = job->endIndex() - job->startIndex();
        if (firstJob) {
            Stats::resetStats();
            Stats::totalMessages = elements;
            Stats::firstStartTime.restart();
        }
        if (firstChunk) {
            Stats::numElements[currentPass] = elements;
            Stats::currentJobStartTime.restart();
        }
        Stats::chunks[currentPass]++;
        Stats::lastPass = currentPass;
 
#endif
 
        mViewItemJobStepIdleInterval = job->idleInterval();
        mViewItemJobStepChunkTimeout = job->chunkTimeout();
        mViewItemJobStepMessageCheckCount = job->messageCheckCount();
 
        if (job->disconnectUI()) {
            mModelForItemFunctions = nullptr; // disconnect the UI for this job
            Q_ASSERT(mLoading); // this must be true in the first job
            // FIXME: Should assert yet more that this is the very first job for this StorageModel
            //        Asserting only mLoading is not enough as we could be using a two-jobs loading strategy
            //        or this could be a job enqueued before the first job has completed.
        } else {
            // With a connected UI we need to avoid the view to update the scrollbars at EVERY insertion or expansion.
            // QTreeViewPrivate::updateScrollBars() is very expensive as it loops through ALL the items in the view every time.
            // We can't disable the function directly as it's hidden in the private data object of QTreeView
            // but we can disable the parent QTreeView::updateGeometries() instead.
            // We will trigger it "manually" at the end of the step.
            mView->ignoreUpdateGeometries(true);
 
            // Ok.. I know that this seems unbelieveable but disabling updates actually
            // causes a (significant) performance loss in most cases. This is probably because QTreeView
            // uses delayed layouts when updates are disabled which should be delayed but in
            // fact are "forced" by next item insertions. The delayed layout algorithm, then
            // is probably slower than the non-delayed one.
            // Disabling the paintEvent() doesn't seem to work either.
            // mView->setUpdatesEnabled( false );
        }
 
        switch (viewItemJobStepInternalForJob(job, elapsedTimer)) {
        case ViewItemJobInterrupted:
            // current job interrupted by timeout: will propagate status to caller
            // but before this, give some feedback to the user
 
            // FIXME: This is now inaccurate, think of something else
            switch (job->currentPass()) {
            case ViewItemJob::Pass1Fill:
            case ViewItemJob::Pass1Cleanup:
            case ViewItemJob::Pass1Update:
                Q_EMIT q->statusMessage(i18np("Processed 1 Message of %2",
                                              "Processed %1 Messages of %2",
                                              job->currentIndex() - job->startIndex(),
                                              job->endIndex() - job->startIndex() + 1));
                break;
            case ViewItemJob::Pass2:
                Q_EMIT q->statusMessage(i18np("Threaded 1 Message of %2",
                                              "Threaded %1 Messages of %2",
                                              job->currentIndex() - job->startIndex(),
                                              job->endIndex() - job->startIndex() + 1));
                break;
            case ViewItemJob::Pass3:
                Q_EMIT q->statusMessage(i18np("Threaded 1 Message of %2",
                                              "Threaded %1 Messages of %2",
                                              job->currentIndex() - job->startIndex(),
                                              job->endIndex() - job->startIndex() + 1));
                break;
            case ViewItemJob::Pass4:
                Q_EMIT q->statusMessage(i18np("Grouped 1 Thread of %2",
                                              "Grouped %1 Threads of %2",
                                              job->currentIndex() - job->startIndex(),
                                              job->endIndex() - job->startIndex() + 1));
                break;
            case ViewItemJob::Pass5:
                Q_EMIT q->statusMessage(i18np("Updated 1 Group of %2",
                                              "Updated %1 Groups of %2",
                                              job->currentIndex() - job->startIndex(),
                                              job->endIndex() - job->startIndex() + 1));
                break;
            default:
                break;
            }
 
            if (!job->disconnectUI()) {
                mView->ignoreUpdateGeometries(false);
                // explicit call to updateGeometries() here
                mView->updateGeometries();
            }
 
            return ViewItemJobInterrupted;
            break;
        case ViewItemJobCompleted:
 
            // If this job worked with a disconnected UI, Q_EMIT layoutChanged()
            // to reconnect it. We go back to normal operation now.
            if (job->disconnectUI()) {
                mModelForItemFunctions = q;
                // This call would destroy the expanded state of items.
                // This is why when mModelForItemFunctions was 0 we didn't actually expand them
                // but we just set a "ExpandNeeded" mark...
#ifdef KDEPIM_FOLDEROPEN_PROFILE
                QTime layoutChangedTimer;
                layoutChangedTimer.start();
#endif
                mView->modelAboutToEmitLayoutChanged();
                Q_EMIT q->layoutChanged();
                mView->modelEmittedLayoutChanged();
 
#ifdef KDEPIM_FOLDEROPEN_PROFILE
                Stats::layoutChangeTime = layoutChangedTimer.elapsed();
                QTime expandingTime;
                expandingTime.start();
#endif
 
                // expand all the items that need it in a single sweep
 
                // FIXME: This takes quite a lot of time, it could be made an interruptible job
 
                auto rootChildItems = mRootItem->childItems();
                if (rootChildItems) {
                    for (const auto it : std::as_const(*rootChildItems)) {
                        if (it->initialExpandStatus() == Item::ExpandNeeded) {
                            syncExpandedStateOfSubtree(it);
                        }
                    }
                }
#ifdef KDEPIM_FOLDEROPEN_PROFILE
                Stats::expandingTreeTime = expandingTime.elapsed();
#endif
            } else {
                mView->ignoreUpdateGeometries(false);
                // explicit call to updateGeometries() here
                mView->updateGeometries();
            }
 
            // this job has been completed
            delete mViewItemJobs.takeFirst();
 
#ifdef KDEPIM_FOLDEROPEN_PROFILE
            // Last job finished!
            Stats::totalTime[currentPass] = Stats::currentJobStartTime.elapsed();
            printStatistics();
#endif
 
            // take care of small jobs which never timeout by themselves because
            // of a small number of messages. At the end of each job check
            // the time used and if we're timeoutting and there is another job
            // then interrupt.
            if ((elapsedTimer.elapsed() > mViewItemJobStepChunkTimeout) || (elapsedTimer.elapsed() < 0)) {
                if (!mViewItemJobs.isEmpty()) {
                    return ViewItemJobInterrupted;
                }
                // else it's completed in fact
            } // else proceed with the next job
 
            break;
        default:
            // This is *really* a BUG
            qCWarning(MESSAGELIST_LOG) << "ERROR: returned an invalid result";
            Q_ASSERT(false);
            break;
        }
    }
 
    // no more jobs
 
    Q_EMIT q->statusMessage(i18nc("@info:status Finished view fill", "Ready"));
 
    return ViewItemJobCompleted;
}
 
void ModelPrivate::viewItemJobStep()
{
    // A single step in the View Fill operation.
    // This function wraps viewItemJobStepInternal() which does the step job
    // and either completes it or stops because of a timeout.
    // If the job is stopped then we start a zero-msecs timer to call us
    // back and resume the job. Otherwise we're just done.
 
    mViewItemJobStepStartTime = ::time(nullptr);
 
    if (mFillStepTimer.isActive()) {
        mFillStepTimer.stop();
    }
 
    if (!mStorageModel) {
        return; // nothing more to do
    }
 
    // Save the current item in the view as our process may
    // cause items to be reparented (and QTreeView will forget the current item in the meantime).
    // This machinery is also needed when we're about to remove items from the view in
    // a cleanup job: we'll be trying to set as current the item after the one removed.
 
    QModelIndex currentIndexBeforeStep = mView->currentIndex();
    Item *currentItemBeforeStep = currentIndexBeforeStep.isValid() ? static_cast<Item *>(currentIndexBeforeStep.internalPointer()) : nullptr;
 
    // mCurrentItemToRestoreAfterViewItemJobStep will be zeroed out if it's killed
    mCurrentItemToRestoreAfterViewItemJobStep = currentItemBeforeStep;
 
    // Save the current item position in the viewport as QTreeView fails to keep
    // the current item in the sample place when items are added or removed...
    QRect rectBeforeViewItemJobStep;
 
    const bool lockView = mView->isScrollingLocked();
 
    // This is generally SLOW AS HELL... (so we avoid it if we lock the view and thus don't need it)
    if (mCurrentItemToRestoreAfterViewItemJobStep && (!lockView)) {
        rectBeforeViewItemJobStep = mView->visualRect(currentIndexBeforeStep);
    }
 
    // FIXME: If the current item is NOT in the view, preserve the position
    //        of the top visible item. This will make the view move yet less.
 
    // Insulate the View from (very likely spurious) "currentChanged()" signals.
    mView->ignoreCurrentChanges(true);
 
    // And go to real work.
    switch (viewItemJobStepInternal()) {
    case ViewItemJobInterrupted:
        // Operation timed out, need to resume in a while
        if (!mInLengthyJobBatch) {
            mInLengthyJobBatch = true;
        }
        mFillStepTimer.start(mViewItemJobStepIdleInterval); // this is a single shot timer connected to viewItemJobStep()
        // and go dealing with current/selection out of the switch.
        break;
    case ViewItemJobCompleted:
        // done :)
 
        Q_ASSERT(mModelForItemFunctions); // UI must be no (longer) disconnected in this state
 
        // Ask the view to remove the eventual busy indications
        if (mInLengthyJobBatch) {
            mInLengthyJobBatch = false;
        }
 
        if (mLoading) {
            mLoading = false;
            mView->modelFinishedLoading();
            slotApplyFilter();
        }
 
        // Apply pre-selection, if any
        if (mPreSelectionMode != PreSelectNone) {
            mView->ignoreCurrentChanges(false);
 
            bool bSelectionDone = false;
 
            switch (mPreSelectionMode) {
            case PreSelectLastSelected:
                // fall down
                break;
            case PreSelectFirstUnreadCentered:
                bSelectionDone = mView->selectFirstMessageItem(MessageTypeUnreadOnly, true); // center
                break;
            case PreSelectOldestCentered:
                mView->setCurrentMessageItem(mOldestItem, true /* center */);
                bSelectionDone = true;
                break;
            case PreSelectNewestCentered:
                mView->setCurrentMessageItem(mNewestItem, true /* center */);
                bSelectionDone = true;
                break;
            case PreSelectNone:
                // deal with selection below
                break;
            default:
                qCWarning(MESSAGELIST_LOG) << "ERROR: Unrecognized pre-selection mode " << static_cast<int>(mPreSelectionMode);
                break;
            }
 
            if ((!bSelectionDone) && (mPreSelectionMode != PreSelectNone)) {
                // fallback to last selected, if possible
                if (mLastSelectedMessageInFolder) { // we found it in the loading process: select and jump out
                    mView->setCurrentMessageItem(mLastSelectedMessageInFolder);
                    bSelectionDone = true;
                }
            }
 
            if (bSelectionDone) {
                mLastSelectedMessageInFolder = nullptr;
                mPreSelectionMode = PreSelectNone;
                return; // already taken care of current / selection
            }
        }
        // deal with current/selection out of the switch
 
        break;
    default:
        // This is *really* a BUG
        qCWarning(MESSAGELIST_LOG) << "ERROR: returned an invalid result";
        Q_ASSERT(false);
        break;
    }
 
    // Everything else here deals with the selection
 
    // If UI is disconnected then we don't have anything else to do here
    if (!mModelForItemFunctions) {
        mView->ignoreCurrentChanges(false);
        return;
    }
 
    // Restore current/selection and/or scrollbar position
 
    if (mCurrentItemToRestoreAfterViewItemJobStep) {
        bool stillIgnoringCurrentChanges = true;
 
        // If the assert below fails then the previously current item got detached
        // and didn't get reattached in the step: this should never happen.
        Q_ASSERT(mCurrentItemToRestoreAfterViewItemJobStep->isViewable());
 
        // Check if the current item changed
        QModelIndex currentIndexAfterStep = mView->currentIndex();
        Item *currentAfterStep = currentIndexAfterStep.isValid() ? static_cast<Item *>(currentIndexAfterStep.internalPointer()) : nullptr;
 
        if (mCurrentItemToRestoreAfterViewItemJobStep != currentAfterStep) {
            // QTreeView lost the current item...
            if (mCurrentItemToRestoreAfterViewItemJobStep != currentItemBeforeStep) {
                // Some view job code expects us to actually *change* the current item.
                // This is done by the cleanup step which removes items and tries
                // to set as current the item *after* the removed one, if possible.
                // We need the view to handle the change though.
                stillIgnoringCurrentChanges = false;
                mView->ignoreCurrentChanges(false);
            } else {
                // we just have to restore the old current item. The code
                // outside shouldn't have noticed that we lost it (e.g. the message viewer
                // still should have the old message opened). So we don't need to
                // actually notify the view of the restored setting.
            }
            // Restore it
            qCDebug(MESSAGELIST_LOG) << "Gonna restore current here" << mCurrentItemToRestoreAfterViewItemJobStep->subject();
            mView->setCurrentIndex(q->index(mCurrentItemToRestoreAfterViewItemJobStep, 0));
        } else {
            // The item we're expected to set as current is already current
            if (mCurrentItemToRestoreAfterViewItemJobStep != currentItemBeforeStep) {
                // But we have changed it in the job step.
                // This means that: we have deleted the current item and chosen a
                // new candidate as current but Qt also has chosen it as candidate
                // and already made it current. The problem is that (as of Qt 4.4)
                // it probably didn't select it.
                if (!mView->selectionModel()->hasSelection()) {
                    stillIgnoringCurrentChanges = false;
                    mView->ignoreCurrentChanges(false);
 
                    qCDebug(MESSAGELIST_LOG) << "Gonna restore selection here" << mCurrentItemToRestoreAfterViewItemJobStep->subject();
 
                    QItemSelection selection;
                    selection.append(QItemSelectionRange(q->index(mCurrentItemToRestoreAfterViewItemJobStep, 0)));
                    mView->selectionModel()->select(selection, QItemSelectionModel::Select | QItemSelectionModel::Rows);
                }
            }
        }
 
        // FIXME: If it was selected before the change, then re-select it (it may happen that it's not)
        if (!lockView) {
            // we prefer to keep the currently selected item steady in the view
            QRect rectAfterViewItemJobStep = mView->visualRect(q->index(mCurrentItemToRestoreAfterViewItemJobStep, 0));
            if (rectBeforeViewItemJobStep.y() != rectAfterViewItemJobStep.y()) {
                // QTreeView lost its position...
                mView->verticalScrollBar()->setValue(mView->verticalScrollBar()->value() + rectAfterViewItemJobStep.y() - rectBeforeViewItemJobStep.y());
            }
        }
 
        // and kill the insulation, if not yet done
        if (stillIgnoringCurrentChanges) {
            mView->ignoreCurrentChanges(false);
        }
 
        return;
    }
 
    // Either there was no current item before, or it was lost in a cleanup step and another candidate for
    // current item couldn't be found (possibly empty view)
    mView->ignoreCurrentChanges(false);
 
    if (currentItemBeforeStep) {
        // lost in a cleanup..
        // tell the view that we have a new current, this time with no insulation
        mView->slotSelectionChanged(QItemSelection(), QItemSelection());
    }
}
 
void ModelPrivate::slotStorageModelRowsInserted(const QModelIndex &parent, int from, int to)
{
    if (parent.isValid()) {
        return; // ugh... should never happen
    }
 
    Q_ASSERT(from <= to);
 
    int count = (to - from) + 1;
 
    mInvariantRowMapper->modelRowsInserted(from, count);
 
    // look if no current job is in the middle
 
    int jobCount = mViewItemJobs.count();
 
    for (int idx = 0; idx < jobCount; idx++) {
        ViewItemJob *job = mViewItemJobs.at(idx);
 
        if (job->currentPass() != ViewItemJob::Pass1Fill) {
            // The job is a cleanup or in a later pass: the storage has been already accessed
            // and the messages created... no need to care anymore: the invariant row mapper will do the job.
            continue;
        }
 
        if (job->currentIndex() > job->endIndex()) {
            // The job finished the Pass1Fill but still waits for the pass indicator to be
            // changed. This is unlikely but still may happen if the job has been interrupted
            // and then a call to slotStorageModelRowsRemoved() caused it to be forcibly completed.
            continue;
        }
 
        //
        // The following cases are possible:
        //
        //               from  to
        //                 |    |                              -> shift up job
        //               from             to
        //                 |              |                    -> shift up job
        //               from                            to
        //                 |                             |     -> shift up job
        //                           from   to
        //                             |     |                 -> split job
        //                           from                to
        //                             |                 |     -> split job
        //                                     from      to
        //                                       |       |     -> job unaffected
        //
        //
        // FOLDER
        // |-------------------------|---------|--------------|
        // 0                   currentIndex endIndex         count
        //                           +-- job --+
        //
 
        if (from > job->endIndex()) {
            // The change is completely above the job, the job is not affected
            continue;
        }
 
        if (from > job->currentIndex()) { // and from <= job->endIndex()
            // The change starts in the middle of the job in a way that it must be split in two.
            // The first part is unaffected by the shift and ranges from job->currentIndex() to from - 1.
            // The second part ranges from "from" to job->endIndex() that are now shifted up by count steps.
 
            // First add a new job for the second part.
            auto newJob = new ViewItemJob(from + count, job->endIndex() + count, job->chunkTimeout(), job->idleInterval(), job->messageCheckCount());
 
            Q_ASSERT(newJob->currentIndex() <= newJob->endIndex());
 
            idx++; // we can skip this job in the loop, it's already ok
            jobCount++; // and our range increases by one.
            mViewItemJobs.insert(idx, newJob);
 
            // Then limit the original job to the first part
            job->setEndIndex(from - 1);
 
            Q_ASSERT(job->currentIndex() <= job->endIndex());
 
            continue;
        }
 
        // The change starts below (or exactly on the beginning of) the job.
        // The job must be shifted up.
        job->setCurrentIndex(job->currentIndex() + count);
        job->setEndIndex(job->endIndex() + count);
 
        Q_ASSERT(job->currentIndex() <= job->endIndex());
    }
 
    bool newJobNeeded = true;
 
    // Try to attach to an existing fill job, if any.
    // To enforce consistency we can attach only if the Fill job
    // is the last one in the list (might be eventually *also* the first,
    // and even being already processed but we must make sure that there
    // aren't jobs _after_ it).
    if (jobCount > 0) {
        ViewItemJob *job = mViewItemJobs.at(jobCount - 1);
        if (job->currentPass() == ViewItemJob::Pass1Fill) {
            if (
                // The job ends just before the added rows
                (from == (job->endIndex() + 1)) && // The job didn't reach the end of Pass1Fill yet
                (job->currentIndex() <= job->endIndex())) {
                // We can still attach this :)
                job->setEndIndex(to);
                Q_ASSERT(job->currentIndex() <= job->endIndex());
                newJobNeeded = false;
            }
        }
    }
 
    if (newJobNeeded) {
        // FIXME: Should take timing options from aggregation here ?
        auto job = new ViewItemJob(from, to, 100, 50, 10);
        mViewItemJobs.append(job);
    }
 
    if (!mFillStepTimer.isActive()) {
        mFillStepTimer.start(mViewItemJobStepIdleInterval);
    }
}
 
void ModelPrivate::slotStorageModelRowsRemoved(const QModelIndex &parent, int from, int to)
{
    // This is called when the underlying StorageModel emits the rowsRemoved signal.
 
    if (parent.isValid()) {
        return; // ugh... should never happen
    }
 
    // look if no current job is in the middle
 
    Q_ASSERT(from <= to);
 
    const int count = (to - from) + 1;
 
    int jobCount = mViewItemJobs.count();
 
    if (mRootItem && from == 0 && count == mRootItem->childItemCount() && jobCount == 0) {
        clear();
        return;
    }
 
    for (int idx = 0; idx < jobCount; idx++) {
        ViewItemJob *job = mViewItemJobs.at(idx);
 
        if (job->currentPass() != ViewItemJob::Pass1Fill) {
            // The job is a cleanup or in a later pass: the storage has been already accessed
            // and the messages created... no need to care: we will invalidate the messages in a while.
            continue;
        }
 
        if (job->currentIndex() > job->endIndex()) {
            // The job finished the Pass1Fill but still waits for the pass indicator to be
            // changed. This is unlikely but still may happen if the job has been interrupted
            // and then a call to slotStorageModelRowsRemoved() caused it to be forcibly completed.
            continue;
        }
 
        //
        // The following cases are possible:
        //
        //               from  to
        //                 |    |                              -> shift down job
        //               from             to
        //                 |              |                    -> shift down and crop job
        //               from                            to
        //                 |                             |     -> kill job
        //                           from   to
        //                             |     |                 -> split job, crop and shift
        //                           from                to
        //                             |                 |     -> crop job
        //                                     from      to
        //                                       |       |     -> job unaffected
        //
        //
        // FOLDER
        // |-------------------------|---------|--------------|
        // 0                   currentIndex endIndex         count
        //                           +-- job --+
        //
 
        if (from > job->endIndex()) {
            // The change is completely above the job, the job is not affected
            continue;
        }
 
        if (from > job->currentIndex()) { // and from <= job->endIndex()
            // The change starts in the middle of the job and ends in the middle or after the job.
            // The first part is unaffected by the shift and ranges from job->currentIndex() to from - 1
            // We use the existing job for this.
            job->setEndIndex(from - 1); // stop before the first removed row
 
            Q_ASSERT(job->currentIndex() <= job->endIndex());
 
            if (to < job->endIndex()) {
                // The change ends inside the job and a part of it can be completed.
 
                // We create a new job for the shifted remaining part. It would actually
                // range from to + 1 up to job->endIndex(), but we need to shift it down by count.
                // since count = ( to - from ) + 1 so from = to + 1 - count
 
                auto newJob = new ViewItemJob(from, job->endIndex() - count, job->chunkTimeout(), job->idleInterval(), job->messageCheckCount());
 
                Q_ASSERT(newJob->currentIndex() < newJob->endIndex());
 
                idx++; // we can skip this job in the loop, it's already ok
                jobCount++; // and our range increases by one.
                mViewItemJobs.insert(idx, newJob);
            } // else the change includes completely the end of the job and no other part of it can be completed.
 
            continue;
        }
 
        // The change starts below (or exactly on the beginning of) the job. ( from <= job->currentIndex() )
        if (to >= job->endIndex()) {
            // The change completely covers the job: kill it
 
            // We don't delete the job since we want the other passes to be completed
            // This is because the Pass1Fill may have already filled mUnassignedMessageListForPass2
            // and may have set mOldestItem and mNewestItem. We *COULD* clear the unassigned
            // message list with clearUnassignedMessageLists() but mOldestItem and mNewestItem
            // could be still dangling pointers. So we just move the current index of the job
            // after the end (so storage model scan terminates) and let it complete spontaneously.
            job->setCurrentIndex(job->endIndex() + 1);
 
            continue;
        }
 
        if (to >= job->currentIndex()) {
            // The change partially covers the job. Only a part of it can be completed
            // and it must be shifted down. It would actually
            // range from to + 1 up to job->endIndex(), but we need to shift it down by count.
            // since count = ( to - from ) + 1 so from = to + 1 - count
            job->setCurrentIndex(from);
            job->setEndIndex(job->endIndex() - count);
 
            Q_ASSERT(job->currentIndex() <= job->endIndex());
 
            continue;
        }
 
        // The change is completely below the job: it must be shifted down.
        job->setCurrentIndex(job->currentIndex() - count);
        job->setEndIndex(job->endIndex() - count);
    }
 
    // This will invalidate the ModelInvariantIndex-es that have been removed and return
    // them all in a nice list that we can feed to a view removal job.
    auto invalidatedIndexes = mInvariantRowMapper->modelRowsRemoved(from, count);
 
    if (invalidatedIndexes) {
        // Try to attach to an existing cleanup job, if any.
        // To enforce consistency we can attach only if the Cleanup job
        // is the last one in the list (might be eventually *also* the first,
        // and even being already processed but we must make sure that there
        // aren't jobs _after_ it).
        if (jobCount > 0) {
            ViewItemJob *job = mViewItemJobs.at(jobCount - 1);
            if (job->currentPass() == ViewItemJob::Pass1Cleanup) {
                if ((job->currentIndex() <= job->endIndex()) && job->invariantIndexList()) {
                    // qCDebug(MESSAGELIST_LOG) << "Appending " << invalidatedIndexes->count() << " invalidated indexes to existing cleanup job";
                    // We can still attach this :)
                    *(job->invariantIndexList()) += *invalidatedIndexes;
                    job->setEndIndex(job->endIndex() + invalidatedIndexes->count());
                    delete invalidatedIndexes;
                    invalidatedIndexes = nullptr;
                }
            }
        }
 
        if (invalidatedIndexes) {
            // Didn't append to any existing cleanup job.. create a new one
 
            // qCDebug(MESSAGELIST_LOG) << "Creating new cleanup job for " << invalidatedIndexes->count() << " invalidated indexes";
            // FIXME: Should take timing options from aggregation here ?
            auto job = new ViewItemJob(ViewItemJob::Pass1Cleanup, invalidatedIndexes, 100, 50, 10);
            mViewItemJobs.append(job);
        }
 
        if (!mFillStepTimer.isActive()) {
            mFillStepTimer.start(mViewItemJobStepIdleInterval);
        }
    }
}
 
void ModelPrivate::slotStorageModelLayoutChanged()
{
    qCDebug(MESSAGELIST_LOG) << "Storage model layout changed";
    // need to reset everything...
    q->setStorageModel(mStorageModel);
    qCDebug(MESSAGELIST_LOG) << "Storage model layout changed done";
}
 
void ModelPrivate::slotStorageModelDataChanged(const QModelIndex &fromIndex, const QModelIndex &toIndex)
{
    Q_ASSERT(mStorageModel); // must exist (and be the sender of the signal connected to this slot)
 
    int from = fromIndex.row();
    int to = toIndex.row();
 
    Q_ASSERT(from <= to);
 
    int count = (to - from) + 1;
 
    int jobCount = mViewItemJobs.count();
 
    // This will find out the ModelInvariantIndex-es that need an update and will return
    // them all in a nice list that we can feed to a view removal job.
    auto indexesThatNeedUpdate = mInvariantRowMapper->modelIndexRowRangeToModelInvariantIndexList(from, count);
 
    if (indexesThatNeedUpdate) {
        // Try to attach to an existing update job, if any.
        // To enforce consistency we can attach only if the Update job
        // is the last one in the list (might be eventually *also* the first,
        // and even being already processed but we must make sure that there
        // aren't jobs _after_ it).
        if (jobCount > 0) {
            ViewItemJob *job = mViewItemJobs.at(jobCount - 1);
            if (job->currentPass() == ViewItemJob::Pass1Update) {
                if ((job->currentIndex() <= job->endIndex()) && job->invariantIndexList()) {
                    // We can still attach this :)
                    *(job->invariantIndexList()) += *indexesThatNeedUpdate;
                    job->setEndIndex(job->endIndex() + indexesThatNeedUpdate->count());
                    delete indexesThatNeedUpdate;
                    indexesThatNeedUpdate = nullptr;
                }
            }
        }
 
        if (indexesThatNeedUpdate) {
            // Didn't append to any existing update job.. create a new one
            // FIXME: Should take timing options from aggregation here ?
            auto job = new ViewItemJob(ViewItemJob::Pass1Update, indexesThatNeedUpdate, 100, 50, 10);
            mViewItemJobs.append(job);
        }
 
        if (!mFillStepTimer.isActive()) {
            mFillStepTimer.start(mViewItemJobStepIdleInterval);
        }
    }
}
 
void ModelPrivate::slotStorageModelHeaderDataChanged(Qt::Orientation, int, int)
{
    if (mStorageModelContainsOutboundMessages != mStorageModel->containsOutboundMessages()) {
        mStorageModelContainsOutboundMessages = mStorageModel->containsOutboundMessages();
        Q_EMIT q->headerDataChanged(Qt::Horizontal, 0, q->columnCount());
    }
}
 
Qt::ItemFlags Model::flags(const QModelIndex &index) const
{
    if (!index.isValid()) {
        return Qt::NoItemFlags;
    }
 
    Q_ASSERT(d->mModelForItemFunctions); // UI must be connected if a valid index was queried
 
    Item *it = static_cast<Item *>(index.internalPointer());
 
    Q_ASSERT(it);
 
    if (it->type() == Item::GroupHeader) {
        return Qt::ItemIsEnabled;
    }
 
    Q_ASSERT(it->type() == Item::Message);
 
    if (!static_cast<MessageItem *>(it)->isValid()) {
        return Qt::NoItemFlags; // not enabled, not selectable
    }
 
    if (static_cast<MessageItem *>(it)->aboutToBeRemoved()) {
        return Qt::NoItemFlags; // not enabled, not selectable
    }
 
    if (static_cast<MessageItem *>(it)->status().isDeleted()) {
        return Qt::NoItemFlags; // not enabled, not selectable
    }
 
    return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}
 
QMimeData *MessageList::Core::Model::mimeData(const QModelIndexList &indexes) const
{
    QList<MessageItem *> msgs;
    for (const QModelIndex &idx : indexes) {
        if (idx.isValid()) {
            Item *item = static_cast<Item *>(idx.internalPointer());
            if (item->type() == MessageList::Core::Item::Message) {
                msgs << static_cast<MessageItem *>(idx.internalPointer());
            }
        }
    }
    return storageModel()->mimeData(msgs);
}
 
Item *Model::rootItem() const
{
    return d->mRootItem;
}
 
bool Model::isLoading() const
{
    return d->mLoading;
}
 
MessageItem *Model::messageItemByStorageRow(int row) const
{
    if (!d->mStorageModel) {
        return nullptr;
    }
    auto idx = d->mInvariantRowMapper->modelIndexRowToModelInvariantIndex(row);
    if (!idx) {
        return nullptr;
    }
 
    return static_cast<MessageItem *>(idx);
}
 
MessageItemSetReference Model::createPersistentSet(const QList<MessageItem *> &items)
{
    if (!d->mPersistentSetManager) {
        d->mPersistentSetManager = new MessageItemSetManager();
    }
 
    MessageItemSetReference ref = d->mPersistentSetManager->createSet();
    for (const auto mi : items) {
        d->mPersistentSetManager->addMessageItem(ref, mi);
    }
 
    return ref;
}
 
QList<MessageItem *> Model::persistentSetCurrentMessageItemList(MessageItemSetReference ref)
{
    if (d->mPersistentSetManager) {
        return d->mPersistentSetManager->messageItems(ref);
    }
    return {};
}
 
void Model::deletePersistentSet(MessageItemSetReference ref)
{
    if (!d->mPersistentSetManager) {
        return;
    }
 
    d->mPersistentSetManager->removeSet(ref);
 
    if (d->mPersistentSetManager->setCount() < 1) {
        delete d->mPersistentSetManager;
        d->mPersistentSetManager = nullptr;
    }
}
 
#include "moc_model.cpp"