src/data/chatmodel.cpp - develop - s5z6/telegraf

src/data/chatmodel.cpp
757 строк30 KB
mbarashkov
Продолжаем рефакторинг зависимостей
04 июн 2025, 14:54
04 июн 2025, 14:549121009
#include "chatmodel.h"
#include "messagedata.h"

#include <QListIterator>
#include <QByteArray>
#include <QBitArray>

#include "../debuglog.h"

ChatModel* ChatModel::instance;

namespace {
    const char ID[] = "id";
    const char CONTENT[] = "content";
    const char CHAT_ID[] = "chat_id";
    const char PHOTO[] = "photo";
    const char SMALL[] = "small";
    const char LAST_READ_INBOX_MESSAGE_ID[] = "last_read_inbox_message_id";
    const char LAST_READ_OUTBOX_MESSAGE_ID[] = "last_read_outbox_message_id";
    const char MESSAGE_ID[] = "message_id";
    const char PINNED_MESSAGE_ID[] = "pinned_message_id";
    const char _TYPE[] = "@type";
    const char MEDIA_ALBUM_ID[] = "media_album_id";
    const char TYPE_SPONSORED_MESSAGE[] = "sponsoredMessage";
}

ChatModel::ChatModel() :
    chatId(0),
    inReload(false),
    inIncrementalUpdate(false),
    searchModeActive(false)
{    
    connect(TDLibResponseHandler::getInstance(), SIGNAL(messagePropertiesReceived(qlonglong,bool,bool,bool)), this, SLOT(handleMessagePropertiesReceived(qlonglong,bool,bool,bool)));
    connect(TDLibResponseHandler::getInstance(), SIGNAL(messagesReceived(QVariantList,int)), this, SLOT(handleMessagesReceived(QVariantList,int)));
    connect(TDLibResponseHandler::getInstance(), SIGNAL(sponsoredMessageReceived(qlonglong,QVariantMap)), this, SLOT(handleSponsoredMessageReceived(qlonglong,QVariantMap)));
    connect(TDLibResponseHandler::getInstance(), SIGNAL(newMessageReceived(qlonglong,QVariantMap)), this, SLOT(handleNewMessageReceived(qlonglong,QVariantMap)));
    connect(TDLibResponseHandler::getInstance(), SIGNAL(receivedMessage(qlonglong,qlonglong,QVariantMap)), this, SLOT(handleMessageReceived(qlonglong,qlonglong,QVariantMap)));
    connect(TDLibResponseHandler::getInstance(), SIGNAL(chatReadInboxUpdated(QString,QString,int)), this, SLOT(handleChatReadInboxUpdated(QString,QString,int)));
    connect(TDLibResponseHandler::getInstance(), SIGNAL(chatReadOutboxUpdated(QString,QString)), this, SLOT(handleChatReadOutboxUpdated(QString,QString)));
    connect(TDLibResponseHandler::getInstance(), SIGNAL(messageSendSucceeded(qlonglong,qlonglong,QVariantMap)), this, SLOT(handleMessageSendSucceeded(qlonglong,qlonglong,QVariantMap)));
    connect(TDLibResponseHandler::getInstance(), SIGNAL(chatNotificationSettingsUpdated(QString,QVariantMap)), this, SLOT(handleChatNotificationSettingsUpdated(QString,QVariantMap)));
    connect(TDLibResponseHandler::getInstance(), SIGNAL(chatPhotoUpdated(qlonglong,QVariantMap)), this, SLOT(handleChatPhotoUpdated(qlonglong,QVariantMap)));
    connect(TDLibResponseHandler::getInstance(), SIGNAL(chatPinnedMessageUpdated(qlonglong,qlonglong)), this, SLOT(handleChatPinnedMessageUpdated(qlonglong,qlonglong)));
    connect(TDLibResponseHandler::getInstance(), SIGNAL(messageContentUpdated(qlonglong,qlonglong,QVariantMap)), this, SLOT(handleMessageContentUpdated(qlonglong,qlonglong,QVariantMap)));
    connect(TDLibResponseHandler::getInstance(), SIGNAL(messageEditedUpdated(qlonglong,qlonglong,QVariantMap)), this, SLOT(handleMessageEditedUpdated(qlonglong,qlonglong,QVariantMap)));
    connect(TDLibResponseHandler::getInstance(), SIGNAL(messageInteractionInfoUpdated(qlonglong,qlonglong,QVariantMap)), this, SLOT(handleMessageInteractionInfoUpdated(qlonglong,qlonglong,QVariantMap)));
    connect(TDLibResponseHandler::getInstance(), SIGNAL(messagesDeleted(qlonglong,QList<qlonglong>)), this, SLOT(handleMessagesDeleted(qlonglong,QList<qlonglong>)));
    ChatModel::instance = this;
}

ChatModel::~ChatModel()
{
    qDeleteAll(messages);
}

QHash<int,QByteArray> ChatModel::roleNames() const
{
    QHash<int,QByteArray> roles;
    roles.insert(MessageData::RoleDisplay, "display");
    roles.insert(MessageData::RoleMessageId, "message_id");
    roles.insert(MessageData::RoleMessageThreadId, "message_thread_id");
    roles.insert(MessageData::RoleMessageContentType, "content_type");
    roles.insert(MessageData::RoleMessageViewCount, "view_count");
    roles.insert(MessageData::RoleMessageReactions, "reactions");
    roles.insert(MessageData::RoleMessageAlbumEntryFilter, "album_entry_filter");
    roles.insert(MessageData::RoleMessageAlbumMessageIds, "album_message_ids");
    roles.insert(MessageData::RoleCanBeEdited, "can_be_edited");
    roles.insert(MessageData::RoleCanBePinned, "can_be_pinned");
    roles.insert(MessageData::RoleCanBeDeleted, "can_be_deleted");
    return roles;
}

int ChatModel::rowCount(const QModelIndex &) const
{
    return messages.size();
}

QVariant ChatModel::data(const QModelIndex &index, int role) const
{
    const int row = index.row();
    if (row >= 0 && row < messages.size()) {
        const MessageData *message = messages.at(row);
        switch ((MessageData::Role)role) {
        case MessageData::RoleDisplay: return message->messageData;
        case MessageData::RoleMessageId: return message->messageId;
        case MessageData::RoleMessageThreadId: return message->messageThreadId;
        case MessageData::RoleMessageContentType: return message->messageContentType;
        case MessageData::RoleMessageViewCount: return message->viewCount;
        case MessageData::RoleMessageReactions: return message->reactions;
        case MessageData::RoleMessageAlbumEntryFilter: return message->albumEntryFilter;
        case MessageData::RoleMessageAlbumMessageIds: return message->albumMessageIds;
        case MessageData::RoleCanBeEdited: return message->canBeEdited;
        case MessageData::RoleCanBePinned: return message->canBePinned;
        case MessageData::RoleCanBeDeleted: return message->canBeDeleted;
        }
    }
    return QVariant();
}

void ChatModel::clear(bool contentOnly)
{
    inReload = false;
    inIncrementalUpdate = false;
    searchModeActive = false;
    searchQuery.clear();
    if (!messages.isEmpty()) {
        beginResetModel();
        qDeleteAll(messages);
        messages.clear();
        messageIndexMap.clear();
        albumMessageMap.clear();
        endResetModel();
    }

    if (!contentOnly) {
        if (!chatInformation.isEmpty()) {
            chatInformation.clear();
            emit smallPhotoChanged();
        }
        if (chatId) {
            chatId = 0;
            emit chatIdChanged();
        }
    }
}

void ChatModel::initialize(const QVariantMap &chatInformation)
{
    const qlonglong chatId = chatInformation.value(ID).toLongLong();
    beginResetModel();
    qDeleteAll(messages);
    this->chatInformation = chatInformation;
    this->chatId = chatId;
    this->messages.clear();
    this->messageIndexMap.clear();
    this->albumMessageMap.clear();
    this->searchQuery.clear();
    endResetModel();
    emit chatIdChanged();
    emit smallPhotoChanged();
    TDLibRequestSender::getInstance()->callGetChatHistory(chatId, this->chatInformation.value(LAST_READ_INBOX_MESSAGE_ID).toLongLong());
}

void ChatModel::triggerLoadHistoryForMessage(qlonglong messageId)
{
    if (!inIncrementalUpdate && !messages.isEmpty()) {
        inIncrementalUpdate = true;
        TDLibRequestSender::getInstance()->callGetChatHistory(chatId, messageId);
    }
}

void ChatModel::triggerLoadMoreHistory()
{
    if (!this->inIncrementalUpdate && !messages.isEmpty()) {
        this->inIncrementalUpdate = true;
        if (searchModeActive) {
            TDLibRequestSender::getInstance()->callSearchChatMessages(chatId, searchQuery, messages.first()->messageId);
        } else {
            TDLibRequestSender::getInstance()->callGetChatHistory(chatId, messages.first()->messageId);
        }
    }
}

void ChatModel::triggerLoadMoreFuture()
{
    if (!this->inIncrementalUpdate && !messages.isEmpty() && !searchModeActive) {
        this->inIncrementalUpdate = true;
        TDLibRequestSender::getInstance()->callGetChatHistory(chatId, messages.last()->messageId, -49);
    }
}

QVariantMap ChatModel::getChatInformation()
{
    return this->chatInformation;
}

QVariantMap ChatModel::getMessage(int index)
{
    if (index >= 0 && index < messages.size()) {
        return messages.at(index)->messageData;
    }
    return QVariantMap();
}

int ChatModel::getDisplayedMessageIndex(qlonglong messageId)
{
    if (messages.size() == 0) {
        return -1;
    }
    if (messageIndexMap.contains(messageId)) {
        int rawIndex = messageIndexMap.value(messageId);
        // We need to substract number of albums which are shown before this item, because that's the index it's displayed on screen at.
        int realIndex = rawIndex;
        for(int i = 0; i < rawIndex; i++) {
            MessageData *message = messages.at(i);
            if(message->albumMessageIds.count() > 0) {
                realIndex -= (message->albumMessageIds.count() - 1);
            }
        }
        if(realIndex < -1)
            return -1;
        return realIndex;
    }
    return -1;
}

QVariantList ChatModel::getMessageIdsForAlbum(qlonglong albumId)
{
    QVariantList foundMessages;
    if(albumMessageMap.contains(albumId)) { // there should be only one in here
        QHash< qlonglong,  QVariantList >::iterator i = albumMessageMap.find(albumId);
        return i.value();
    }
    return foundMessages;
}

QVariantList ChatModel::getMessagesForAlbum(qlonglong albumId, int startAt)
{
    QVariantList messageIds = getMessageIdsForAlbum(albumId);
    int count = messageIds.size();
    if ( count == 0) {
        return messageIds;
    }
    QVariantList foundMessages;
    for (int messageNum = startAt; messageNum < count; ++messageNum) {
        const int position = messageIndexMap.value(messageIds.at(messageNum).toLongLong(), -1);
        if(position >= 0 && position < messages.size()) {
            foundMessages.append(messages.at(position)->messageData);
        }
    }
    return foundMessages;
}

int ChatModel::getLastReadMessageIndex()
{
    return this->calculateLastKnownMessageId();
}

void ChatModel::setSearchQuery(const QString newSearchQuery)
{
    if (this->searchQuery != newSearchQuery) {
        this->clear(true);
        this->searchQuery = newSearchQuery;
        this->searchModeActive = !this->searchQuery.isEmpty();
        if (this->searchModeActive) {
            TDLibRequestSender::getInstance()->callSearchChatMessages(this->chatId, this->searchQuery);
        } else {
            TDLibRequestSender::getInstance()->callGetChatHistory(chatId, this->chatInformation.value(LAST_READ_INBOX_MESSAGE_ID).toLongLong());
        }
    }
}

QVariantMap ChatModel::smallPhoto() const
{
    return chatInformation.value(PHOTO).toMap().value(SMALL).toMap();
}

qlonglong ChatModel::getChatId() const
{
    return chatId;
}

void ChatModel::handleMessagePropertiesReceived(qlonglong messageId, bool canBeEdited, bool canBePinned, bool canBeDeleted)
{
    if (messageIndexMap.contains(messageId)) {
        const int position = messageIndexMap.value(messageId);
        // qDebug() << messages[position]->messageData << messageId << canBeEdited;
        auto changedRoles = messages[position]->setProperties(canBeEdited, canBePinned, canBeDeleted);
        if(!changedRoles.empty())
        {
            const QModelIndex messageIndex(index(position));
            emit dataChanged(messageIndex, messageIndex, changedRoles);
        }
    }
}

void ChatModel::handleMessagesReceived(const QVariantList &messages, int totalCount)
{
    if (messages.size() == 0) {
        this->inReload = false;
        int listInboxPosition = this->calculateLastKnownMessageId();
        int listOutboxPosition = this->calculateLastReadSentMessageId();
        listInboxPosition = this->calculateScrollPosition(listInboxPosition);
        if (this->inIncrementalUpdate) {
            this->inIncrementalUpdate = false;
            emit messagesIncrementalUpdate(listInboxPosition, listOutboxPosition);
        } else {
            emit messagesReceived(listInboxPosition, listOutboxPosition, totalCount);
        }
    } else {
        if (this->isMostRecentMessageLoaded() || this->inIncrementalUpdate) {
            QList<MessageData*> messagesToBeAdded;
            QListIterator<QVariant> messagesIterator(messages);

            while (messagesIterator.hasNext()) {
                const QVariantMap messageData = messagesIterator.next().toMap();
                const qlonglong messageId = messageData.value(ID).toLongLong();
                if (messageId && messageData.value(CHAT_ID).toLongLong() == chatId && !messageIndexMap.contains(messageId)) {
                    MessageData* message = new MessageData(messageData, messageId);
                    messagesToBeAdded.append(message);
                }
            }

            std::sort(messagesToBeAdded.begin(), messagesToBeAdded.end(), MessageData::lessThan);

            if (!messagesToBeAdded.isEmpty()) {
                insertMessages(messagesToBeAdded);
                setMessagesAlbum(messagesToBeAdded);
            }

            // First call only returns a few messages, we need to get a little more than that...
            if (!messagesToBeAdded.isEmpty() && (messagesToBeAdded.size() + messages.size()) < 10 && !inReload) {
                this->inReload = true;
                if (this->searchModeActive) {
                    TDLibRequestSender::getInstance()->callSearchChatMessages(chatId, searchQuery, messagesToBeAdded.first()->messageId);
                } else {
                    TDLibRequestSender::getInstance()->callGetChatHistory(chatId, messagesToBeAdded.first()->messageId, 0);
                }
            } else {
                this->inReload = false;
                int listInboxPosition = this->calculateLastKnownMessageId();
                int listOutboxPosition = this->calculateLastReadSentMessageId();
                listInboxPosition = this->calculateScrollPosition(listInboxPosition);
                if (this->inIncrementalUpdate) {
                    this->inIncrementalUpdate = false;
                    emit messagesIncrementalUpdate(listInboxPosition, listOutboxPosition);
                } else {
                    emit messagesReceived(listInboxPosition, listOutboxPosition, totalCount);
                }
            }
        } else {
            this->inReload = false;
            this->inIncrementalUpdate = false;
        }
    }
}

void ChatModel::handleSponsoredMessageReceived(qlonglong, const QVariantMap &sponsoredMessage)
{
    QList<MessageData*> messagesToBeAdded;
    const qlonglong messageId = sponsoredMessage.value(MESSAGE_ID).toLongLong();
    if (messageId && !messageIndexMap.contains(messageId)) {
        messagesToBeAdded.append(new MessageData(sponsoredMessage, messageId));
    }
    appendMessages(messagesToBeAdded);
}

void ChatModel::handleNewMessageReceived(qlonglong chatId, const QVariantMap &message)
{
    const qlonglong messageId = message.value(ID).toLongLong();
    if (chatId == this->chatId && !messageIndexMap.contains(messageId)) {
        if (this->isMostRecentMessageLoaded() && !this->searchModeActive) {
            QList<MessageData*> messagesToBeAdded;
            messagesToBeAdded.append(new MessageData(message, messageId));
            insertMessages(messagesToBeAdded);
            setMessagesAlbum(messagesToBeAdded);
            emit newMessageReceived(message);
        }
    }
}

void ChatModel::handleMessageReceived(qlonglong chatId, qlonglong messageId, const QVariantMap &message)
{
    if (chatId == this->chatId && messageIndexMap.contains(messageId)) {
        const int position = messageIndexMap.value(messageId);
        const QVector<int> changedRoles(messages.at(position)->setMessageData(message));
        const QModelIndex messageIndex(index(position));
        emit dataChanged(messageIndex, messageIndex, changedRoles);
    }
}

void ChatModel::handleChatReadInboxUpdated(const QString &id, const QString &lastReadInboxMessageId, int unreadCount)
{
    if (id.toLongLong() == chatId) {
        this->chatInformation.insert("unread_count", unreadCount);
        this->chatInformation.insert(LAST_READ_INBOX_MESSAGE_ID, lastReadInboxMessageId);
        emit unreadCountUpdated(unreadCount, lastReadInboxMessageId);
    }
}

void ChatModel::handleChatReadOutboxUpdated(const QString &id, const QString &lastReadOutboxMessageId)
{
    if (id.toLongLong() == chatId) {
        this->chatInformation.insert(LAST_READ_OUTBOX_MESSAGE_ID, lastReadOutboxMessageId);
        int sentIndex = calculateLastReadSentMessageId();
        emit lastReadSentMessageUpdated(sentIndex);
    }
}

void ChatModel::handleMessageSendSucceeded(qlonglong messageId, qlonglong oldMessageId, const QVariantMap &message)
{
    if (this->messageIndexMap.contains(oldMessageId)) {
        const int pos = messageIndexMap.take(oldMessageId);
        MessageData* oldMessage = messages.at(pos);
        MessageData* newMessage = new MessageData(message, messageId);
        messages.replace(pos, newMessage);
        messageIndexMap.remove(oldMessageId);
        messageIndexMap.insert(messageId, pos);
        // TODO when we support sending album messages, handle ID change in albumMessageMap
        const QVector<int> changedRoles(newMessage->diff(oldMessage));
        delete oldMessage;
        const QModelIndex messageIndex(index(pos));
        emit dataChanged(messageIndex, messageIndex, changedRoles);
        emit lastReadSentMessageUpdated(calculateLastReadSentMessageId());
        TDLibRequestSender::getInstance()->callViewMessage(this->chatId, messageId, false);
        TDLibRequestSender::getInstance()->callGetMessageProperties(chatId, messageId);
    }
}

void ChatModel::handleChatNotificationSettingsUpdated(const QString &id, const QVariantMap &chatNotificationSettings)
{
    if (id.toLongLong() == chatId) {
        this->chatInformation.insert("notification_settings", chatNotificationSettings);
        emit notificationSettingsUpdated();
    }
}

void ChatModel::handleChatPhotoUpdated(qlonglong id, const QVariantMap &photo)
{
    if (id == chatId) {
        chatInformation.insert(PHOTO, photo);
        emit smallPhotoChanged();
    }
}

void ChatModel::handleChatPinnedMessageUpdated(qlonglong id, qlonglong pinnedMessageId)
{
    if (id == chatId) {
        chatInformation.insert(PINNED_MESSAGE_ID, pinnedMessageId);
        emit pinnedMessageChanged();
    }
}

void ChatModel::handleMessageContentUpdated(qlonglong chatId, qlonglong messageId, const QVariantMap &newContent)
{
    if (chatId == this->chatId && messageIndexMap.contains(messageId)) {
        const int pos = messageIndexMap.value(messageId, -1);
        if (pos >= 0) {
            MessageData* messageData = messages.at(pos);
            const QVector<int> changedRoles(messageData->setContent(newContent));
            const QModelIndex messageIndex(index(pos));
            emit dataChanged(messageIndex, messageIndex, changedRoles);
            emit messageUpdated(pos);
        }
    }
}

void ChatModel::handleMessageInteractionInfoUpdated(qlonglong chatId, qlonglong messageId, const QVariantMap &updatedInfo)
{
    if (chatId == this->chatId && messageIndexMap.contains(messageId)) {
        const int pos = messageIndexMap.value(messageId, -1);
        if (pos >= 0) {
            const QVector<int> changedRoles(messages.at(pos)->setInteractionInfo(updatedInfo));
            const QModelIndex messageIndex(index(pos));
            emit dataChanged(messageIndex, messageIndex, changedRoles);
        }
    }
}

void ChatModel::handleMessageEditedUpdated(qlonglong chatId, qlonglong messageId, const QVariantMap &replyMarkup)
{
    if (chatId == this->chatId && messageIndexMap.contains(messageId)) {
        const int pos = messageIndexMap.value(messageId, -1);
        if (pos >= 0) {
            MessageData* messageData = messages.at(pos);
            const QVector<int> changedRoles(messageData->setReplyMarkup(replyMarkup));
            const QModelIndex messageIndex(index(pos));
            emit dataChanged(messageIndex, messageIndex, changedRoles);
            emit messageUpdated(pos);
        }
    }
}

void ChatModel::handleMessagesDeleted(qlonglong chatId, const QList<qlonglong> &messageIds)
{
    if (chatId == this->chatId) {
        const int count = messageIds.size();

        int firstPosition = count, lastPosition = count;
        for (int i = (count - 1); i > -1; i--) {
            const int position = messageIndexMap.value(messageIds.at(i), -1);
            if (position >= 0) {
                // We found at least one message in our list that needs to be deleted
                if (lastPosition == count) {
                    lastPosition = position;
                }
                if (firstPosition == count) {
                    firstPosition = position;
                }
                if (position < (firstPosition - 1)) {
                    // Some gap in between, can remove previous range and reset positions
                    removeRange(firstPosition, lastPosition);
                    firstPosition = lastPosition = position;
                } else {
                    // No gap in between, extend the range and continue loop
                    firstPosition = position;
                }
            }
        }
        // After all elements have been processed, there may be one last range to remove
        // But only if we found at least one item to remove
        if (firstPosition != count && lastPosition != count) {
            removeRange(firstPosition, lastPosition);
        }
    }
}


void ChatModel::removeRange(int firstDeleted, int lastDeleted)
{
    if (firstDeleted >= 0 && firstDeleted <= lastDeleted) {
        beginRemoveRows(QModelIndex(), firstDeleted, lastDeleted);
        QList<qlonglong> rescanAlbumIds;
        for (int i = firstDeleted; i <= lastDeleted; i++) {
            MessageData *message = messages.at(i);
            messageIndexMap.remove(message->messageId);

            qlonglong albumId = message->messageData.value(MEDIA_ALBUM_ID).toLongLong();
            if(albumId != 0 && albumMessageMap.contains(albumId)) {
                rescanAlbumIds.append(albumId);
            }
            delete message;
        }
        messages.erase(messages.begin() + firstDeleted, messages.begin() + (lastDeleted + 1));
        // rebuild following messageIndexMap
        for(int i = firstDeleted; i < messages.size(); ++i) {
            messageIndexMap.insert(messages.at(i)->messageId, i);
        }
        endRemoveRows();

        updateAlbumMessages(rescanAlbumIds, true);
    }
}

void ChatModel::insertMessages(const QList<MessageData*> newMessages)
{
    // Caller ensures that newMessages is not empty
    if (messages.isEmpty()) {
        appendMessages(newMessages);
    } else if (!newMessages.isEmpty()) {
        // There is only an append or a prepend, tertium non datur! (probably ;))
        qlonglong lastKnownId = -1;
        for (int i = (messages.size() - 1); i >= 0; i-- ) {
            const MessageData* message = messages.at(i);
            if (message->messageType != TYPE_SPONSORED_MESSAGE) {
                lastKnownId = message->messageId;
            }
            //
        }
        const qlonglong firstNewId = newMessages.first()->messageId;
        if (lastKnownId < firstNewId) {
            appendMessages(newMessages);
        } else {
            prependMessages(newMessages);
        }        
    }
    for (int i = 0; i < newMessages.size(); i++ ) {
        TDLibRequestSender::getInstance()->callGetMessageProperties(chatId, newMessages[i]->messageId);
    }
}

void ChatModel::appendMessages(const QList<MessageData*> newMessages)
{
    const int oldSize = messages.size();
    const int count = newMessages.size();

    beginInsertRows(QModelIndex(), oldSize, oldSize + count - 1);
    messages.append(newMessages);
    for (int i = 0; i < count; i++) {
        // Append new indices to the map
        messageIndexMap.insert(newMessages.at(i)->messageId, oldSize + i);
    }
    endInsertRows();
}

void ChatModel::prependMessages(const QList<MessageData*> newMessages)
{
    const int insertCount = newMessages.size();
    const int totalCount = messages.size() + insertCount;

    beginInsertRows(QModelIndex(), 0, insertCount - 1);
    // Too bad there's no bulk insert
    messages.reserve(totalCount);
    int i;
    for (i = 0; i < insertCount; i++) {
        MessageData* message = newMessages.at(i);
        messages.insert(i, message);
        messageIndexMap.insert(message->messageId, i);
    }
    // The rest of the map has been damaged too
    for (; i < totalCount; i++) {
        messageIndexMap.insert(messages.at(i)->messageId, i);
    }
    endInsertRows();
}

void ChatModel::updateAlbumMessages(qlonglong albumId, bool checkDeleted)
{
    if(albumMessageMap.contains(albumId)) {
        const QVariantList empty;
        QHash< qlonglong,  QVariantList >::iterator album = albumMessageMap.find(albumId);
        QVariantList messageIds = album.value();
        std::sort(messageIds.begin(), messageIds.end());
        int count;
        // first: clear deleted messageIds:
        if(checkDeleted) {
            QVariantList::iterator it = messageIds.begin();
            while (it != messageIds.end()) {
              if (!messageIndexMap.contains(it->toLongLong())) {
                it = messageIds.erase(it);
              }
              else {
                ++it;
              }
            }
        }
        // second: remaining ones still exist
        count = messageIds.size();
        if(count == 0) {
            albumMessageMap.remove(albumId);
        } else {
            for (int i = 0; i < count; i++) {
                const int position = messageIndexMap.value(messageIds.at(i).toLongLong(), -1);
                if(position > -1) {
                    // set list for first entry, empty for all others
                    QVector<int> changedRolesFilter;
                    QVector<int> changedRolesIds;

                    QModelIndex messageIndex(index(position));
                    if(i == 0) {
                        changedRolesFilter = messages.at(position)->setAlbumEntryFilter(false);
                        changedRolesIds = messages.at(position)->setAlbumEntryMessageIds(messageIds);
                    } else {
                        changedRolesFilter = messages.at(position)->setAlbumEntryFilter(true);
                        changedRolesIds = messages.at(position)->setAlbumEntryMessageIds(empty);
                    }
                    emit dataChanged(messageIndex, messageIndex, changedRolesIds);
                    emit dataChanged(messageIndex, messageIndex, changedRolesFilter);
                }
            }
        }
        albumMessageMap.insert(albumId, messageIds);
    }
}

void ChatModel::updateAlbumMessages(QList<qlonglong> albumIds, bool checkDeleted)
{
    const int albumsCount = albumIds.size();
    for (int i = 0; i < albumsCount; i++) {
        updateAlbumMessages(albumIds.at(i), checkDeleted);
    }
}

void ChatModel::setMessagesAlbum(const QList<MessageData *> newMessages)
{
    const int count = newMessages.size();
    for (int i = 0; i < count; i++) {
        setMessagesAlbum(newMessages.at(i));
    }
}

void ChatModel::setMessagesAlbum(MessageData *message)
{
    qlonglong albumId = message->messageData.value(MEDIA_ALBUM_ID).toLongLong();
    if (albumId > 0 && (message->messageContentType != "messagePhoto" || message->messageContentType != "messageVideo")) {
        qlonglong messageId = message->messageId;

        if(albumMessageMap.contains(albumId)) {
            // find message id within album:
            QHash< qlonglong,  QVariantList >::iterator i = albumMessageMap.find(albumId);
            if(!i.value().contains(messageId)) {
                i.value().append(messageId);
            }
        } else { // new album id
            albumMessageMap.insert(albumId, QVariantList() << messageId);
        }
        updateAlbumMessages(albumId, false);
    }
}

QVariantMap ChatModel::enhanceMessage(const QVariantMap &message)
{
    QVariantMap enhancedMessage = message;
    if (enhancedMessage.value(CONTENT).toMap().value(_TYPE).toString() == "messageVoiceNote" ) {
        QVariantMap contentMap = enhancedMessage.value(CONTENT).toMap();
        QVariantMap voiceNoteMap = contentMap.value("voice_note").toMap();
        QByteArray waveBytes = QByteArray::fromBase64(voiceNoteMap.value("waveform").toByteArray());
        QBitArray waveBits(waveBytes.count() * 8);

        for (int i = 0; i < waveBytes.count(); i++) {
            for (int b = 0; b < 8; b++) {
                waveBits.setBit( i * 8 + b, waveBytes.at(i) & (1 << (7 - b)) );
            }
        }
        int waveSize = 10;
        int waveformSets = waveBits.size() / waveSize;
        QVariantList decodedWaveform;
        for (int i = 0; i < waveformSets; i++) {
            int waveformHeight = 0;
            for (int j = 0; j < waveSize; j++) {
                waveformHeight = waveformHeight + ( waveBits.at(i * waveSize + j) * (2 ^ (j)) );
            }
            decodedWaveform.append(waveformHeight);
        }
        voiceNoteMap.insert("decoded_voice_note", decodedWaveform);
        contentMap.insert("voice_note", voiceNoteMap);
        enhancedMessage.insert(CONTENT, contentMap);
    }
    return enhancedMessage;
}

int ChatModel::calculateLastKnownMessageId()
{
    const qlonglong lastKnownMessageId = this->chatInformation.value(LAST_READ_INBOX_MESSAGE_ID).toLongLong();
    const qlonglong myUserId = TDLibState::getInstance()->getMyUserId();
    qlonglong lastOwnMessageId = 0;
    for (int i = (messages.size() - 1); i >= 0; i--) {
        MessageData *currentMessage = messages.at(i);
        if (currentMessage->senderUserId() == myUserId) {
            lastOwnMessageId = currentMessage->messageId;
            break;
        }
    }
    int listInboxPosition = messageIndexMap.value(lastKnownMessageId, messages.size() - 1);
    int listOwnPosition = messageIndexMap.value(lastOwnMessageId, -1);
    if (listInboxPosition > this->messages.size() - 1 ) {
        listInboxPosition = this->messages.size() - 1;
    }
    if (listOwnPosition > this->messages.size() - 1 ) {
        listOwnPosition = -1;
    }
    return (listInboxPosition > listOwnPosition) ? listInboxPosition : listOwnPosition;
}

int ChatModel::calculateLastReadSentMessageId()
{
    const qlonglong lastReadSentMessageId = this->chatInformation.value(LAST_READ_OUTBOX_MESSAGE_ID).toLongLong();
    const int listOutboxPosition = messageIndexMap.value(lastReadSentMessageId, -1);
    emit lastReadSentMessageUpdated(listOutboxPosition);
    return listOutboxPosition;
}

int ChatModel::calculateScrollPosition(int listInboxPosition)
{
    if ((this->messages.size() - 1) > listInboxPosition) {
        return listInboxPosition + 1;
    } else {
        return listInboxPosition;
    }
}

bool ChatModel::isMostRecentMessageLoaded()
{
    // Need to check if we can actually add messages (only possible if the previously latest messages are loaded)
    // Trying with half of the size of an initial list to ensure that everything is there...
    return this->getLastReadMessageIndex() >= this->messages.size() - 25;
}