matrixion/src/timeline/RoomlistModel.h

// SPDX-FileCopyrightText: 2021 Nheko Contributors
//
// SPDX-License-Identifier: GPL-3.0-or-later

#pragma once

#include <CacheStructs.h>
#include <QAbstractListModel>
#include <QHash>
#include <QSharedPointer>
#include <QSortFilterProxyModel>
#include <QString>

#include <mtx/responses/sync.hpp>

class TimelineModel;
class TimelineViewManager;

class RoomlistModel : public QAbstractListModel
{
        Q_OBJECT
public:
        enum Roles
        {
                AvatarUrl = Qt::UserRole,
                RoomName,
                RoomId,
                LastMessage,
                Time,
                Timestamp,
                HasUnreadMessages,
                HasLoudNotification,
                NotificationCount,
                IsInvite,
                IsSpace,
        };

        RoomlistModel(TimelineViewManager *parent = nullptr);
        QHash<int, QByteArray> roleNames() const override;
        int rowCount(const QModelIndex &parent = QModelIndex()) const override
        {
                (void)parent;
                return (int)roomids.size();
        }
        QVariant data(const QModelIndex &index, int role) const override;
        QSharedPointer<TimelineModel> getRoomById(QString id) const
        {
                if (models.contains(id))
                        return models.value(id);
                else
                        return {};
        }

public slots:
        void initializeRooms();
        void sync(const mtx::responses::Rooms &rooms);
        void clear();
        int roomidToIndex(QString roomid)
        {
                for (int i = 0; i < (int)roomids.size(); i++) {
                        if (roomids[i] == roomid)
                                return i;
                }

                return -1;
        }
        void acceptInvite(QString roomid);
        void declineInvite(QString roomid);

private slots:
        void updateReadStatus(const std::map<QString, bool> roomReadStatus_);

signals:
        void totalUnreadMessageCountUpdated(int unreadMessages);

private:
        void addRoom(const QString &room_id, bool suppressInsertNotification = false);

        TimelineViewManager *manager = nullptr;
        std::vector<QString> roomids;
        QHash<QString, RoomInfo> invites;
        QHash<QString, QSharedPointer<TimelineModel>> models;
        std::map<QString, bool> roomReadStatus;

        friend class FilteredRoomlistModel;
};

class FilteredRoomlistModel : public QSortFilterProxyModel
{
        Q_OBJECT
public:
        FilteredRoomlistModel(RoomlistModel *model, QObject *parent = nullptr);
        bool lessThan(const QModelIndex &left, const QModelIndex &right) const override;

public slots:
        int roomidToIndex(QString roomid)
        {
                return mapFromSource(roomlistmodel->index(roomlistmodel->roomidToIndex(roomid)))
                  .row();
        }
        void acceptInvite(QString roomid) { roomlistmodel->acceptInvite(roomid); }
        void declineInvite(QString roomid) { roomlistmodel->declineInvite(roomid); }

private:
        short int calculateImportance(const QModelIndex &idx) const;
        RoomlistModel *roomlistmodel;
        bool sortByImportance = true;
};