/******************************************************************************
 *
 *  SPDX-FileCopyrightText: 2008 Szymon Tomasz Stefanek <pragma@kvirc.net>
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *
 *******************************************************************************/

#include "core/widgetbase.h"
#include "config-messagelist.h"
#include "core/aggregation.h"
#include "core/filter.h"
#include "core/filtersavedmanager.h"
#include "core/manager.h"
#include "core/messageitem.h"
#include "core/model.h"
#include "core/optionset.h"
#include "core/storagemodelbase.h"
#include "core/theme.h"
#include "core/view.h"
#include "core/widgets/quicksearchwarning.h"
#if !FORCE_DISABLE_AKONADI_SEARCH
#include "core/widgets/searchcollectionindexingwarning.h"
#endif
#include "core/widgets/tablockedwarning.h"
#include "messagelistsettings.h"
#include "widgets/searchlinestatus.h"

#include "utils/configureaggregationsdialog.h"
#include "utils/configurethemesdialog.h"

#include <QActionGroup>
#include <QHeaderView>
#include <QPointer>
#include <QTimer>
#include <QVBoxLayout>
#include <QVariant>

#include "messagelist_debug.h"
#include <KLocalizedString>
#include <KMessageBox>
#include <QAction>
#include <QComboBox>
#include <QMenu>

#include "core/widgets/filternamedialog.h"
#include <Akonadi/Collection>
#include <Akonadi/MessageStatus>
#include <chrono>

#include "core/widgets/searchlinecommand.h"
using namespace std::chrono_literals;

using namespace MessageList::Core;

class Widget::WidgetPrivate
{
public:
    explicit WidgetPrivate(Widget *owner)
        : q(owner)
    {
    }

    /**
     * Small helper for switching SortOrder::MessageSorting and SortOrder::SortDirection
     * on the fly.
     * After doing this, the sort indicator in the header is updated.
     */
    void switchMessageSorting(SortOrder::MessageSorting messageSorting, SortOrder::SortDirection sortDirection, int logicalHeaderColumnIndex);

    /**
     * Check if our sort order can still be used with this aggregation.
     * This can happen if the global aggregation changed, for example we can now
     * have "most recent in subtree" sorting with an aggregation without threading.
     * If this happens, reset to the default sort order and don't use the global sort
     * order.
     */
    void checkSortOrder(const StorageModel *storageModel);

    void setDefaultAggregationForStorageModel(const StorageModel *storageModel);
    void setDefaultThemeForStorageModel(const StorageModel *storageModel);
    void setDefaultSortOrderForStorageModel(const StorageModel *storageModel);
    void applyFilter();

    Widget *const q;

    QuickSearchWarning *quickSearchWarning = nullptr;
#if !FORCE_DISABLE_AKONADI_SEARCH
    SearchCollectionIndexingWarning *searchCollectionIndexingWarning = nullptr;
#endif
    TabLockedWarning *tabLockedWarning = nullptr;
    QuickSearchLine *quickSearchLine = nullptr;
    View *mView = nullptr;
    QString mLastAggregationId;
    QString mLastThemeId;
    QTimer *mSearchTimer = nullptr;
    StorageModel *mStorageModel = nullptr; ///< The currently displayed storage. The storage itself
    ///  is owned by MessageList::Widget.
    Aggregation *mAggregation = nullptr; ///< The currently set aggregation mode, a deep copy
    Theme *mTheme = nullptr; ///< The currently set theme, a deep copy
    SortOrder mSortOrder; ///< The currently set sort order
    Filter *mFilter = nullptr; ///< The currently applied filter, owned by us.
    bool mStorageUsesPrivateTheme = false; ///< true if the current folder does not use the global theme
    bool mStorageUsesPrivateAggregation = false; ///< true if the current folder does not use the global aggregation
    bool mStorageUsesPrivateSortOrder = false; ///< true if the current folder does not use the global sort order
    Akonadi::Collection mCurrentFolder; ///< The current folder
    int mCurrentStatusFilterIndex = 0;
    bool mStatusFilterComboPopulationInProgress = false;
    bool mLockTab = false;
};

Widget::Widget(QWidget *pParent)
    : QWidget(pParent)
    , d(new WidgetPrivate(this))
{
    Manager::registerWidget(this);
    connect(Manager::instance(), &Manager::aggregationsChanged, this, &Widget::aggregationsChanged);
    connect(Manager::instance(), &Manager::themesChanged, this, &Widget::themesChanged);

    setAutoFillBackground(true);
    setObjectName(QLatin1StringView("messagelistwidget"));

    auto g = new QVBoxLayout(this);
    g->setContentsMargins({});
    g->setSpacing(0);

    d->quickSearchLine = new QuickSearchLine(this);
    d->quickSearchLine->setObjectName(QLatin1StringView("quicksearchline"));
    connect(d->quickSearchLine, &QuickSearchLine::clearButtonClicked, this, &Widget::searchEditClearButtonClicked);

    connect(d->quickSearchLine, &QuickSearchLine::searchEditTextEdited, this, &Widget::searchEditTextEdited);
    connect(d->quickSearchLine, &QuickSearchLine::searchOptionChanged, this, &Widget::searchEditTextEdited);
    connect(d->quickSearchLine, &QuickSearchLine::statusButtonsClicked, this, &Widget::slotStatusButtonsClicked);
    connect(d->quickSearchLine, &QuickSearchLine::forceLostFocus, this, &Widget::forceLostFocus);
    connect(d->quickSearchLine, &QuickSearchLine::saveFilter, this, &Widget::slotSaveFilter);
    connect(d->quickSearchLine, &QuickSearchLine::activateFilter, this, &Widget::slotActivateFilter);
    g->addWidget(d->quickSearchLine, 0);
    d->quickSearchWarning = new QuickSearchWarning(this);
    g->addWidget(d->quickSearchWarning, 0);
#if !FORCE_DISABLE_AKONADI_SEARCH
    d->searchCollectionIndexingWarning = new SearchCollectionIndexingWarning(this);
    g->addWidget(d->searchCollectionIndexingWarning, 0);
#endif

    d->tabLockedWarning = new TabLockedWarning(this);
    g->addWidget(d->tabLockedWarning, 0);
    connect(d->tabLockedWarning, &TabLockedWarning::unlockTabRequested, this, [this]() {
        setLockTab(false);
        Q_EMIT unlockTabRequested();
        // Fix icon!
    });

    d->mView = new View(this);
    d->mView->setFrameStyle(QFrame::NoFrame);
    d->mView->setSortOrder(&d->mSortOrder);
    d->mView->setObjectName(QLatin1StringView("messagealistview"));
    g->addWidget(d->mView, 1);

    connect(d->mView->header(), &QHeaderView::sectionClicked, this, &Widget::slotViewHeaderSectionClicked);
    d->mSearchTimer = nullptr;
}

Widget::~Widget()
{
    d->mView->setStorageModel(nullptr);

    Manager::unregisterWidget(this);

    delete d->mSearchTimer;
    delete d->mTheme;
    delete d->mAggregation;
    delete d->mFilter;
    delete d->mStorageModel;
}

void Widget::slotActivateFilter(Filter *f)
{
    // setFilter reset filter => get info before to call setFilter
    const auto status = f->status();
    const auto options = f->currentOptions();
    const auto str = f->searchString();
    setFilter(f);
    d->quickSearchLine->searchEdit()->setText(str);
    d->quickSearchLine->setSearchOptions(options);
    d->quickSearchLine->setFilterMessageStatus(status);
}

void Widget::slotSaveFilter()
{
    if (d->mFilter) {
        QPointer<FilterNameDialog> dlg = new FilterNameDialog(this);
        dlg->setExistingFilterNames(FilterSavedManager::self()->existingFilterNames());
        if (dlg->exec()) {
            FilterSavedManager::self()->saveFilter(d->mFilter, dlg->filterName(), dlg->iconName());
        }
        delete dlg;
    } else {
        KMessageBox::information(this, i18n("No filter defined."), i18nc("@title:window", "Create Filter"));
    }
}

void Widget::changeQuicksearchVisibility(bool show)
{
    QLineEdit *const lineEdit = d->quickSearchLine->searchEdit();
    if (!show) {
        // if we hide it we do not want to apply the filter,
        // otherwise someone is maybe stuck with x new emails
        // and cannot read it because of filter
        lineEdit->clear();

        // we focus the message list if we hide the searchbar
        d->mView->setFocus(Qt::OtherFocusReason);
    } else {
        // on show: we focus the lineedit for fast filtering
        lineEdit->setFocus(Qt::OtherFocusReason);
        if (d->mFilter) {
            resetFilter();
        }
    }
    d->quickSearchLine->changeQuicksearchVisibility(show);
    MessageListSettings::self()->setShowQuickSearch(show);
}

void Widget::populateStatusFilterCombo()
{
    if (d->mStatusFilterComboPopulationInProgress) {
        return;
    }
    d->mStatusFilterComboPopulationInProgress = true;
    QComboBox *tagFilterComboBox = d->quickSearchLine->tagFilterComboBox();
    d->mCurrentStatusFilterIndex = (tagFilterComboBox->currentIndex() != -1) ? tagFilterComboBox->currentIndex() : 0;
    disconnect(tagFilterComboBox, &QComboBox::currentIndexChanged, this, &Widget::statusSelected);

    tagFilterComboBox->clear();

    fillMessageTagCombo();
}

void Widget::addMessageTagItem(const QPixmap &icon, const QString &text, const QVariant &data)
{
    d->quickSearchLine->tagFilterComboBox()->addItem(icon, text, data);
}

void Widget::setCurrentStatusFilterItem()
{
    d->quickSearchLine->updateComboboxVisibility();
    connect(d->quickSearchLine->tagFilterComboBox(), &QComboBox::currentIndexChanged, this, &Widget::statusSelected);
    d->quickSearchLine->tagFilterComboBox()->setCurrentIndex(
        d->mCurrentStatusFilterIndex >= d->quickSearchLine->tagFilterComboBox()->count() ? 0 : d->mCurrentStatusFilterIndex);
    d->mStatusFilterComboPopulationInProgress = false;
}

MessageItem *Widget::currentMessageItem() const
{
    return view()->currentMessageItem();
}

MessageList::Core::SearchMessageByButtons::SearchOptions Widget::currentOptions() const
{
    return d->quickSearchLine->searchOptions();
}

QList<Akonadi::MessageStatus> Widget::currentFilterStatus() const
{
    if (d->mFilter) {
        return d->mFilter->status();
    }
    return {};
}

QList<SearchLineCommand::SearchLineInfo> Widget::searchLineCommands() const
{
    if (d->mFilter) {
        return d->mFilter->searchLineCommands();
    }
    return {};
}

QString Widget::currentFilterSearchString() const
{
    if (d->mFilter) {
        return d->mFilter->searchString();
    }
    return {};
}

void Widget::WidgetPrivate::setDefaultAggregationForStorageModel(const StorageModel *storageModel)
{
    const Aggregation *opt = Manager::instance()->aggregationForStorageModel(storageModel, &mStorageUsesPrivateAggregation);

    Q_ASSERT(opt);

    delete mAggregation;
    mAggregation = new Aggregation(*opt);

    mView->setAggregation(mAggregation);

    mLastAggregationId = opt->id();
}

void Widget::WidgetPrivate::setDefaultThemeForStorageModel(const StorageModel *storageModel)
{
    const Theme *opt = Manager::instance()->themeForStorageModel(storageModel, &mStorageUsesPrivateTheme);

    Q_ASSERT(opt);

    delete mTheme;
    mTheme = new Theme(*opt);

    mView->setTheme(mTheme);

    mLastThemeId = opt->id();
}

void Widget::WidgetPrivate::checkSortOrder(const StorageModel *storageModel)
{
    if (storageModel && mAggregation && !mSortOrder.validForAggregation(mAggregation)) {
        qCDebug(MESSAGELIST_LOG) << "Could not restore sort order for folder" << storageModel->id();
        mSortOrder = SortOrder::defaultForAggregation(mAggregation, mSortOrder);

        // Change the global sort order if the sort order didn't fit the global aggregation.
        // Otherwise, if it is a per-folder aggregation, make the sort order per-folder too.
        if (mStorageUsesPrivateAggregation) {
            mStorageUsesPrivateSortOrder = true;
        }
        if (mStorageModel) {
            Manager::instance()->saveSortOrderForStorageModel(storageModel, mSortOrder, mStorageUsesPrivateSortOrder);
        }
        switchMessageSorting(mSortOrder.messageSorting(), mSortOrder.messageSortDirection(), -1);
    }
}

void Widget::WidgetPrivate::setDefaultSortOrderForStorageModel(const StorageModel *storageModel)
{
    // Load the sort order from config and update column headers
    mSortOrder = Manager::instance()->sortOrderForStorageModel(storageModel, &mStorageUsesPrivateSortOrder);
    switchMessageSorting(mSortOrder.messageSorting(), mSortOrder.messageSortDirection(), -1);
    checkSortOrder(storageModel);
}

void Widget::saveCurrentSelection()
{
    if (d->mStorageModel) {
        // Save the current selection
        MessageItem *lastSelectedMessageItem = d->mView->currentMessageItem(false);
        if (lastSelectedMessageItem) {
            d->mStorageModel->savePreSelectedMessage(lastSelectedMessageItem->uniqueId());
        }
    }
}

void Widget::setStorageModel(StorageModel *storageModel, PreSelectionMode preSelectionMode)
{
    if (storageModel == d->mStorageModel) {
        return; // nothing to do here
    }

    d->setDefaultAggregationForStorageModel(storageModel);
    d->setDefaultThemeForStorageModel(storageModel);
    d->setDefaultSortOrderForStorageModel(storageModel);

    const bool isLocked = d->quickSearchLine->searchEdit()->locked();
    // qDebug() << " isLocked " << isLocked;
    if (!isLocked) {
        if (d->mSearchTimer) {
            d->mSearchTimer->stop();
            delete d->mSearchTimer;
            d->mSearchTimer = nullptr;
        }

        d->quickSearchLine->searchEdit()->clear();

        if (d->mFilter) {
            resetFilter();
        }
    } else {
        searchTimerFired();
    }
    StorageModel *oldModel = d->mStorageModel;

    d->mStorageModel = storageModel;
    d->mView->setStorageModel(d->mStorageModel, preSelectionMode);

    delete oldModel;

    d->quickSearchLine->tagFilterComboBox()->setEnabled(d->mStorageModel);
    d->quickSearchLine->searchEdit()->setEnabled(d->mStorageModel);
    d->quickSearchLine->setContainsOutboundMessages(d->mStorageModel->containsOutboundMessages());
}

StorageModel *Widget::storageModel() const
{
    return d->mStorageModel;
}

QLineEdit *Widget::quickSearch() const
{
    return d->quickSearchLine->searchEdit();
}

View *Widget::view() const
{
    return d->mView;
}

void Widget::themeMenuAboutToShow()
{
    if (!d->mStorageModel) {
        return;
    }

    auto menu = qobject_cast<QMenu *>(sender());
    if (!menu) {
        return;
    }
    themeMenuAboutToShow(menu);
}

void Widget::themeMenuAboutToShow(QMenu *menu)
{
    menu->clear();

    menu->addSection(i18n("Theme"));

    auto grp = new QActionGroup(menu);

    QList<Theme *> sortedThemes = Manager::instance()->themes().values();

    QAction *act;

    std::sort(sortedThemes.begin(), sortedThemes.end(), MessageList::Core::Theme::compareName);

    for (const auto theme : std::as_const(sortedThemes)) {
        act = menu->addAction(theme->name());
        act->setCheckable(true);
        grp->addAction(act);
        act->setChecked(d->mLastThemeId == theme->id());
        act->setData(QVariant(theme->id()));
        connect(act, &QAction::triggered, this, &Widget::themeSelected);
    }

    menu->addSeparator();

    act = menu->addAction(i18n("Configure..."));
    connect(act, &QAction::triggered, this, &Widget::configureThemes);
}

void Widget::setPrivateSortOrderForStorage()
{
    if (!d->mStorageModel) {
        return;
    }

    d->mStorageUsesPrivateSortOrder = !d->mStorageUsesPrivateSortOrder;

    Manager::instance()->saveSortOrderForStorageModel(d->mStorageModel, d->mSortOrder, d->mStorageUsesPrivateSortOrder);
}

void Widget::configureThemes()
{
    auto dialog = new Utils::ConfigureThemesDialog(window());
    dialog->selectTheme(d->mLastThemeId);
    dialog->show();
}

void Widget::themeSelected(bool)
{
    if (!d->mStorageModel) {
        return; // nuthin to do
    }

    auto act = qobject_cast<QAction *>(sender());
    if (!act) {
        return;
    }

    QVariant v = act->data();
    const QString id = v.toString();

    if (id.isEmpty()) {
        return;
    }

    const Theme *opt = Manager::instance()->theme(id);

    delete d->mTheme;
    d->mTheme = new Theme(*opt);

    d->mView->setTheme(d->mTheme);

    d->mLastThemeId = opt->id();

    // mStorageUsesPrivateTheme = false;

    Manager::instance()->saveThemeForStorageModel(d->mStorageModel, opt->id(), d->mStorageUsesPrivateTheme);

    d->mView->reload();
}

void Widget::aggregationMenuAboutToShow()
{
    auto menu = qobject_cast<QMenu *>(sender());
    if (!menu) {
        return;
    }
    aggregationMenuAboutToShow(menu);
}

void Widget::aggregationMenuAboutToShow(QMenu *menu)
{
    menu->clear();

    menu->addSection(i18n("Aggregation"));

    auto grp = new QActionGroup(menu);

    QList<Aggregation *> sortedAggregations = Manager::instance()->aggregations().values();

    QAction *act;

    std::sort(sortedAggregations.begin(), sortedAggregations.end(), MessageList::Core::Aggregation::compareName);

    for (const auto agg : std::as_const(sortedAggregations)) {
        act = menu->addAction(agg->name());
        act->setCheckable(true);
        grp->addAction(act);
        act->setChecked(d->mLastAggregationId == agg->id());
        act->setData(QVariant(agg->id()));
        connect(act, &QAction::triggered, this, &Widget::aggregationSelected);
    }

    menu->addSeparator();

    act = menu->addAction(i18n("Configure..."));
    act->setData(QVariant(QString()));
    connect(act, &QAction::triggered, this, &Widget::aggregationSelected);
}

void Widget::aggregationSelected(bool)
{
    auto act = qobject_cast<QAction *>(sender());
    if (!act) {
        return;
    }

    QVariant v = act->data();
    QString id = v.toString();

    if (id.isEmpty()) {
        auto dialog = new Utils::ConfigureAggregationsDialog(window());
        dialog->selectAggregation(d->mLastAggregationId);
        dialog->show();
        return;
    }

    if (!d->mStorageModel) {
        return; // nuthin to do
    }

    const Aggregation *opt = Manager::instance()->aggregation(id);

    delete d->mAggregation;
    d->mAggregation = new Aggregation(*opt);

    d->mView->setAggregation(d->mAggregation);

    d->mLastAggregationId = opt->id();

    // mStorageUsesPrivateAggregation = false;

    Manager::instance()->saveAggregationForStorageModel(d->mStorageModel, opt->id(), d->mStorageUsesPrivateAggregation);

    // The sort order might not be valid anymore for this aggregation
    d->checkSortOrder(d->mStorageModel);

    d->mView->reload();
}

void Widget::sortOrderMenuAboutToShow()
{
    if (!d->mAggregation) {
        return;
    }

    auto menu = qobject_cast<QMenu *>(sender());
    if (!menu) {
        return;
    }
    sortOrderMenuAboutToShow(menu);
}

void Widget::sortOrderMenuAboutToShow(QMenu *menu)
{
    menu->clear();

    menu->addSection(i18n("Message Sort Order"));

    QActionGroup *grp;
    QAction *act;
    QList<QPair<QString, int>> options;

    grp = new QActionGroup(menu);

    options = SortOrder::enumerateMessageSortingOptions(d->mAggregation->threading());
    for (const auto &opt : std::as_const(options)) {
        act = menu->addAction(opt.first);
        act->setCheckable(true);
        grp->addAction(act);
        act->setChecked(d->mSortOrder.messageSorting() == opt.second);
        act->setData(QVariant(opt.second));
    }

    connect(grp, &QActionGroup::triggered, this, &Widget::messageSortingSelected);

    options = SortOrder::enumerateMessageSortDirectionOptions(d->mSortOrder.messageSorting());

    if (options.size() >= 2) {
        menu->addSection(i18n("Message Sort Direction"));

        grp = new QActionGroup(menu);
        for (const auto &opt : std::as_const(options)) {
            act = menu->addAction(opt.first);
            act->setCheckable(true);
            grp->addAction(act);
            act->setChecked(d->mSortOrder.messageSortDirection() == opt.second);
            act->setData(QVariant(opt.second));
        }

        connect(grp, &QActionGroup::triggered, this, &Widget::messageSortDirectionSelected);
    }

    options = SortOrder::enumerateGroupSortingOptions(d->mAggregation->grouping());

    if (options.size() >= 2) {
        menu->addSection(i18n("Group Sort Order"));

        grp = new QActionGroup(menu);
        for (const auto &opt : std::as_const(options)) {
            act = menu->addAction(opt.first);
            act->setCheckable(true);
            grp->addAction(act);
            act->setChecked(d->mSortOrder.groupSorting() == opt.second);
            act->setData(QVariant(opt.second));
        }

        connect(grp, &QActionGroup::triggered, this, &Widget::groupSortingSelected);
    }

    options = SortOrder::enumerateGroupSortDirectionOptions(d->mAggregation->grouping(), d->mSortOrder.groupSorting());

    if (options.size() >= 2) {
        menu->addSection(i18n("Group Sort Direction"));

        grp = new QActionGroup(menu);
        for (const auto &opt : std::as_const(options)) {
            act = menu->addAction(opt.first);
            act->setCheckable(true);
            grp->addAction(act);
            act->setChecked(d->mSortOrder.groupSortDirection() == opt.second);
            act->setData(QVariant(opt.second));
        }

        connect(grp, &QActionGroup::triggered, this, &Widget::groupSortDirectionSelected);
    }

    menu->addSeparator();
    act = menu->addAction(i18n("Folder Always Uses This Sort Order"));
    act->setCheckable(true);
    act->setChecked(d->mStorageUsesPrivateSortOrder);
    connect(act, &QAction::triggered, this, &Widget::setPrivateSortOrderForStorage);
}

void Widget::WidgetPrivate::switchMessageSorting(SortOrder::MessageSorting messageSorting, SortOrder::SortDirection sortDirection, int logicalHeaderColumnIndex)
{
    mSortOrder.setMessageSorting(messageSorting);
    mSortOrder.setMessageSortDirection(sortDirection);

    // If the logicalHeaderColumnIndex was specified then we already know which
    // column we should set the sort indicator to. If it wasn't specified (it's -1)
    // then we need to find it out in the theme.

    if (logicalHeaderColumnIndex == -1) {
        // try to find the specified message sorting in the theme columns
        const auto columns = mTheme->columns();
        int idx = 0;

        // First try with a well defined message sorting.

        for (const auto column : std::as_const(columns)) {
            if (!mView->header()->isSectionHidden(idx)) {
                if (column->messageSorting() == messageSorting) {
                    // found a visible column with this message sorting
                    logicalHeaderColumnIndex = idx;
                    break;
                }
            }
            ++idx;
        }

        // if still not found, try again with a wider range
        if (logicalHeaderColumnIndex == -1) {
            idx = 0;
            for (const auto column : std::as_const(columns)) {
                if (!mView->header()->isSectionHidden(idx)) {
                    if (((column->messageSorting() == SortOrder::SortMessagesBySenderOrReceiver)
                         || (column->messageSorting() == SortOrder::SortMessagesByReceiver) || (column->messageSorting() == SortOrder::SortMessagesBySender))
                        && ((messageSorting == SortOrder::SortMessagesBySenderOrReceiver) || (messageSorting == SortOrder::SortMessagesByReceiver)
                            || (messageSorting == SortOrder::SortMessagesBySender))) {
                        // found a visible column with this message sorting
                        logicalHeaderColumnIndex = idx;
                        break;
                    }
                }
                ++idx;
            }
        }
    }

    if (logicalHeaderColumnIndex == -1) {
        // not found: either not a column-based sorting or the related column is hidden
        mView->header()->setSortIndicatorShown(false);
        return;
    }

    mView->header()->setSortIndicatorShown(true);

    if (sortDirection == SortOrder::Ascending) {
        mView->header()->setSortIndicator(logicalHeaderColumnIndex, Qt::AscendingOrder);
    } else {
        mView->header()->setSortIndicator(logicalHeaderColumnIndex, Qt::DescendingOrder);
    }
}

void Widget::messageSortingSelected(QAction *action)
{
    if (!d->mAggregation) {
        return;
    }
    if (!action) {
        return;
    }

    if (!d->mStorageModel) {
        return;
    }

    bool ok;
    auto ord = static_cast<SortOrder::MessageSorting>(action->data().toInt(&ok));

    if (!ok) {
        return;
    }

    d->switchMessageSorting(ord, d->mSortOrder.messageSortDirection(), -1);
    Manager::instance()->saveSortOrderForStorageModel(d->mStorageModel, d->mSortOrder, d->mStorageUsesPrivateSortOrder);

    d->mView->reload();
}

void Widget::messageSortDirectionSelected(QAction *action)
{
    if (!d->mAggregation) {
        return;
    }
    if (!action) {
        return;
    }
    if (!d->mStorageModel) {
        return;
    }

    bool ok;
    auto ord = static_cast<SortOrder::SortDirection>(action->data().toInt(&ok));

    if (!ok) {
        return;
    }

    d->switchMessageSorting(d->mSortOrder.messageSorting(), ord, -1);
    Manager::instance()->saveSortOrderForStorageModel(d->mStorageModel, d->mSortOrder, d->mStorageUsesPrivateSortOrder);

    d->mView->reload();
}

void Widget::groupSortingSelected(QAction *action)
{
    if (!d->mAggregation) {
        return;
    }
    if (!action) {
        return;
    }

    if (!d->mStorageModel) {
        return;
    }

    bool ok;
    auto ord = static_cast<SortOrder::GroupSorting>(action->data().toInt(&ok));

    if (!ok) {
        return;
    }

    d->mSortOrder.setGroupSorting(ord);
    Manager::instance()->saveSortOrderForStorageModel(d->mStorageModel, d->mSortOrder, d->mStorageUsesPrivateSortOrder);

    d->mView->reload();
}

void Widget::groupSortDirectionSelected(QAction *action)
{
    if (!d->mAggregation) {
        return;
    }
    if (!action) {
        return;
    }
    if (!d->mStorageModel) {
        return;
    }

    bool ok;
    auto ord = static_cast<SortOrder::SortDirection>(action->data().toInt(&ok));

    if (!ok) {
        return;
    }

    d->mSortOrder.setGroupSortDirection(ord);
    Manager::instance()->saveSortOrderForStorageModel(d->mStorageModel, d->mSortOrder, d->mStorageUsesPrivateSortOrder);

    d->mView->reload();
}

void Widget::setFilter(Filter *filter)
{
    resetFilter();
    d->mFilter = filter;
    d->mView->model()->setFilter(d->mFilter);
}

void Widget::resetFilter()
{
    delete d->mFilter;
    d->mFilter = nullptr;
    d->mView->model()->setFilter(nullptr);
    d->quickSearchLine->resetFilter();
    d->quickSearchWarning->animatedHide();
}

void Widget::slotViewHeaderSectionClicked(int logicalIndex)
{
    if (!d->mTheme) {
        return;
    }

    if (!d->mAggregation) {
        return;
    }

    if (logicalIndex >= d->mTheme->columns().count()) {
        return;
    }

    if (!d->mStorageModel) {
        return;
    }

    auto column = d->mTheme->column(logicalIndex);
    if (!column) {
        return; // should never happen...
    }

    if (column->messageSorting() == SortOrder::NoMessageSorting) {
        return; // this is a null op.
    }

    if (d->mSortOrder.messageSorting() == column->messageSorting()) {
        // switch sort direction
        if (d->mSortOrder.messageSortDirection() == SortOrder::Ascending) {
            d->switchMessageSorting(d->mSortOrder.messageSorting(), SortOrder::Descending, logicalIndex);
        } else {
            d->switchMessageSorting(d->mSortOrder.messageSorting(), SortOrder::Ascending, logicalIndex);
        }
    } else {
        // keep sort direction but switch sort order
        d->switchMessageSorting(column->messageSorting(), d->mSortOrder.messageSortDirection(), logicalIndex);
    }
    Manager::instance()->saveSortOrderForStorageModel(d->mStorageModel, d->mSortOrder, d->mStorageUsesPrivateSortOrder);

    d->mView->reload();
}

void Widget::themesChanged()
{
    d->setDefaultThemeForStorageModel(d->mStorageModel);

    d->mView->reload();
}

void Widget::aggregationsChanged()
{
    d->setDefaultAggregationForStorageModel(d->mStorageModel);
    d->checkSortOrder(d->mStorageModel);

    d->mView->reload();
}

void Widget::fillMessageTagCombo()
{
    // nothing here: must be overridden in derived classes
    setCurrentStatusFilterItem();
}

void Widget::tagIdSelected(const QVariant &data)
{
    const QString tagId = data.toString();

    if (tagId.isEmpty()) {
        if (d->mFilter) {
            if (d->mFilter->isEmpty()) {
                resetFilter();
                return;
            }
        }
    } else {
        if (!d->mFilter) {
            d->mFilter = new Filter();
        }
        d->mFilter->setTagId({tagId});
    }

    d->mView->model()->setFilter(d->mFilter);
}

void Widget::setLockTab(bool lock)
{
    d->mLockTab = lock;
    if (lock) {
        d->tabLockedWarning->animatedShow();
    } else {
        d->tabLockedWarning->animatedHide();
    }
}

bool Widget::isLocked() const
{
    return d->mLockTab;
}

void Widget::statusSelected(int index)
{
    if (index == 0) {
        resetFilter();
        return;
    }
    tagIdSelected(d->quickSearchLine->tagFilterComboBox()->itemData(index));
    d->mView->model()->setFilter(d->mFilter);
}

void Widget::searchEditTextEdited()
{
    // This slot is called whenever the user edits the search QLineEdit.
    // Since the user is likely to type more than one character
    // so we start the real search after a short delay in order to catch
    // multiple textEdited() signals.

    if (!d->mSearchTimer) {
        d->mSearchTimer = new QTimer(this);
        connect(d->mSearchTimer, &QTimer::timeout, this, &Widget::searchTimerFired);
    } else {
        d->mSearchTimer->stop(); // eventually
    }

    d->mSearchTimer->setSingleShot(true);
    d->mSearchTimer->start(1s);
}

void Widget::slotStatusButtonsClicked()
{
    // We also arbitrarily set tagId to an empty string, though we *could* allow filtering
    // by status AND tag...
    if (d->mFilter) {
        d->mFilter->setTagId(QStringList());
    }

    auto lst = d->quickSearchLine->status();
    if (lst.isEmpty()) {
        if (d->mFilter) {
            d->mFilter->setStatus(lst);
            if (d->mFilter->isEmpty()) {
                qCDebug(MESSAGELIST_LOG) << " RESET FILTER";
                resetFilter();
                return;
            }
        }
    } else {
        // don't have this status bit
        if (!d->mFilter) {
            d->mFilter = new Filter();
        }
        d->mFilter->setStatus(lst);
    }

    d->mView->model()->setFilter(d->mFilter);
}

void Widget::searchTimerFired()
{
    // A search is pending.

    if (d->mSearchTimer) {
        d->mSearchTimer->stop();
    }

    if (!d->mFilter) {
        d->mFilter = new Filter();
    }

    const QString text = d->quickSearchLine->searchEdit()->text();
    if (!text.isEmpty()) {
        d->quickSearchLine->addCompletionItem(text);
    }
    d->mFilter->setCurrentFolder(d->mCurrentFolder);
    SearchLineCommand command;
    command.parseSearchLineCommand(text);
    if (command.hasOnlyOneLiteralCommand()) {
        SearchLineCommand commandChanged;
        const SearchMessageByButtons::SearchOptions options = d->quickSearchLine->searchOptions();
        d->mFilter->setOptions(options);
        SearchLineCommand::SearchLineInfo info;
        info.argument = command.searchLineInfo().at(0).argument;
        if (options & SearchMessageByButtons::SearchEveryWhere) {
            info.type = SearchLineCommand::SearchLineType::Literal;
        } else if (options & SearchMessageByButtons::SearchAgainstSubject) {
            info.type = SearchLineCommand::SearchLineType::Subject;
        } else if (options & SearchMessageByButtons::SearchAgainstBody) {
            info.type = SearchLineCommand::SearchLineType::Body;
        } else if (options & SearchMessageByButtons::SearchAgainstFrom) {
            info.type = SearchLineCommand::SearchLineType::From;
        } else if (options & SearchMessageByButtons::SearchAgainstBcc) {
            info.type = SearchLineCommand::SearchLineType::Bcc;
        } else if (options & SearchMessageByButtons::SearchAgainstCc) {
            info.type = SearchLineCommand::SearchLineType::Cc;
        } else if (options & SearchMessageByButtons::SearchAgainstTo) {
            info.type = SearchLineCommand::SearchLineType::To;
        }
        commandChanged.setSearchLineInfo({info});
        command = commandChanged;
    }
    // qDebug() << " text " << text << " command " << command.searchLineInfo();

    d->mFilter->setSearchString(command);
    if (d->mFilter->isEmpty()) {
        resetFilter();
        return;
    }

    d->mView->model()->setFilter(d->mFilter);
}

void Widget::searchEditClearButtonClicked()
{
    if (!d->mFilter) {
        return;
    }

    resetFilter();

    d->mView->scrollTo(d->mView->currentIndex(), QAbstractItemView::PositionAtCenter);
}

void Widget::viewMessageSelected(MessageItem *)
{
}

void Widget::viewMessageActivated(MessageItem *)
{
}

void Widget::viewSelectionChanged()
{
}

void Widget::viewMessageExpanded(MessageItem *)
{
}

void Widget::viewMessageCollapsed(MessageItem *)
{
}

void Widget::viewMessageListContextPopupRequest(const QList<MessageItem *> &, const QPoint &)
{
}

void Widget::viewGroupHeaderContextPopupRequest(GroupHeaderItem *, const QPoint &)
{
}

void Widget::viewDragEnterEvent(QDragEnterEvent *)
{
}

void Widget::viewDragMoveEvent(QDragMoveEvent *)
{
}

void Widget::viewDropEvent(QDropEvent *)
{
}

void Widget::viewStartDragRequest()
{
}

void Widget::viewMessageStatusChangeRequest(MessageItem *msg, Akonadi::MessageStatus set, Akonadi::MessageStatus clear)
{
    Q_UNUSED(msg)
    Q_UNUSED(set)
    Q_UNUSED(clear)
}

void Widget::focusQuickSearch(const QString &selectedText)
{
    d->quickSearchLine->focusQuickSearch(selectedText);
}

bool Widget::isThreaded() const
{
    return d->mView->isThreaded();
}

bool Widget::selectionEmpty() const
{
    return d->mView->selectionEmpty();
}

Akonadi::Collection Widget::currentFolder() const
{
    return d->mCurrentFolder;
}

void Widget::setCurrentFolder(const Akonadi::Collection &collection)
{
    if (!d->mLockTab) {
        d->mCurrentFolder = collection;
#if !FORCE_DISABLE_AKONADI_SEARCH
        d->searchCollectionIndexingWarning->setCollection(collection);
#endif
    }
}

bool Widget::searchEditHasFocus() const
{
    return d->quickSearchLine->searchEdit()->hasFocus();
}

#include "moc_widgetbase.cpp"
