src/tdlib/tdlibreceiver.cpp - develop - lmaxyz/telegraf

src/tdlib/tdlibreceiver.cpp
914 строк40 KB
Nikolay Sinyov
- Добавление логики для работы с комментариеями в канале
16 сен 2025, 14:15
16 сен 2025, 14:1547faecf
#include "tdlibreceiver.h"
#include <QJsonArray>
#include <td/telegram/td_json_client.h>
#include "tdlibdataparsingutils.h"
#include "../debuglog.h"

namespace
{
    const char ID[] = "id";
    const char LIST[] = "list";
    const char CHAT_ID[] = "chat_id";
    const char USER_ID[] = "user_id";
    const char OLD_MESSAGE_ID[] = "old_message_id";
    const char MESSAGE_ID[] = "message_id";
    const char MESSAGE_IDS[] = "message_ids";
    const char MESSAGE[] = "message";
    const char MESSAGES[] = "messages";
    const char TITLE[] = "title";
    const char NAME[] = "name";
    const char VALUE[] = "value";
    const char POSITION[] = "position";
    const char POSITIONS[] = "positions";
    const char PHOTO[] = "photo";

    const char ORDER[] = "order";
    const char IS_PINNED[] = "is_pinned";
    const char BASIC_GROUP[] = "basic_group";
    const char SUPERGROUP[] = "supergroup";
    const char LAST_MESSAGE[] = "last_message";
    const char TOTAL_COUNT[] = "total_count";
    const char UNREAD_COUNT[] = "unread_count";
    const char UNREAD_UNMUTED_COUNT[] = "unread_unmuted_count";
    const char UNREAD_MENTION_COUNT[] = "unread_mention_count";
    const char UNREAD_REACTION_COUNT[] = "unread_reaction_count";
    const char AVAILABLE_REACTIONS[] = "available_reactions";
    const char TEXT[] = "text";

    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 SECRET_CHAT[] = "secret_chat";
    const char INTERACTION_INFO[] = "interaction_info";
    const char STICKERS[] = "stickers";

    const char NEW_CONTENT[] = "new_content";
    const char SETS[] = "sets";
    const char EMOJIS[] = "emojis";
    const char DRAFT_MESSAGE[] = "draft_message";
    const char CHAT_FOLDERS[] = "chat_folders";
    const char MAIN_CHAT_LIST_POSITION_IN_FOLDERS[] = "main_chat_list_position";

    const char _TYPE[] = "@type";
    const char _EXTRA[] = "@extra";
    const char TYPE_CHAT_POSITION[] = "chatPosition";
    const char TYPE_CHAT_LIST_MAIN[] = "chatListMain";
    const char TYPE_CHAT_LIST_ARCHIVE[] = "chatListArchive";
    const char TYPE_CHAT_LIST_FOLDER[] = "chatListFolder";
}

TDLibReceiver::TDLibReceiver(int tdLibClientId, QObject *parent) :
    QThread(parent),
    _tdLibClientId(tdLibClientId),
    _active(true)
{
    _handlers.insert("updateOption", &TDLibReceiver::processUpdateOption);
    _handlers.insert("updateAuthorizationState", &TDLibReceiver::processUpdateAuthorizationState);
    _handlers.insert("updateConnectionState", &TDLibReceiver::processUpdateConnectionState);
    _handlers.insert("updateUser", &TDLibReceiver::processUpdateUser);
    _handlers.insert("updateUserStatus", &TDLibReceiver::processUpdateUserStatus);
    _handlers.insert("updateFile", &TDLibReceiver::processUpdateFile);
    _handlers.insert("file", &TDLibReceiver::processFile);
    _handlers.insert("user", &TDLibReceiver::processUser);
    _handlers.insert("updateNewChat", &TDLibReceiver::processUpdateNewChat);
    _handlers.insert("updateUnreadMessageCount", &TDLibReceiver::processUpdateUnreadMessageCount);
    _handlers.insert("updateUnreadChatCount", &TDLibReceiver::processUpdateUnreadChatCount);
    _handlers.insert("updateChatFolders", &TDLibReceiver::processUpdateChatFolders);
    _handlers.insert("updateChatAddedToList", &TDLibReceiver::processUpdateChatAddedToList);
    _handlers.insert("updateChatLastMessage", &TDLibReceiver::processUpdateChatLastMessage);
    _handlers.insert("updateChatOrder", &TDLibReceiver::processUpdateChatOrder);
    _handlers.insert("updateChatPosition", &TDLibReceiver::processUpdateChatPosition);
    _handlers.insert("updateChatReadInbox", &TDLibReceiver::processUpdateChatReadInbox);
    _handlers.insert("updateChatReadOutbox", &TDLibReceiver::processUpdateChatReadOutbox);
    _handlers.insert("updateChatAvailableReactions", &TDLibReceiver::processUpdateChatAvailableReactions);
    _handlers.insert("updateBasicGroup", &TDLibReceiver::processUpdateBasicGroup);
    _handlers.insert("updateSupergroup", &TDLibReceiver::processUpdateSuperGroup);
    _handlers.insert("updateChatOnlineMemberCount", &TDLibReceiver::processChatOnlineMemberCountUpdated);
    _handlers.insert("messages", &TDLibReceiver::processMessages);
    _handlers.insert("foundChatMessages", &TDLibReceiver::processFoundChatMessages);
    _handlers.insert("sponsoredMessages", &TDLibReceiver::processSponsoredMessages);
    _handlers.insert("updateNewMessage", &TDLibReceiver::processUpdateNewMessage);
    _handlers.insert("message", &TDLibReceiver::processMessage);
    _handlers.insert("messageThreadInfo", &TDLibReceiver::processMessageThreadInfo);
    _handlers.insert("messageLinkInfo", &TDLibReceiver::processMessageLinkInfo);
    _handlers.insert("updateMessageSendSucceeded", &TDLibReceiver::processMessageSendSucceeded);
    _handlers.insert("updateActiveNotifications", &TDLibReceiver::processUpdateActiveNotifications);
    _handlers.insert("updateNotificationGroup", &TDLibReceiver::processUpdateNotificationGroup);
    _handlers.insert("updateChatNotificationSettings", &TDLibReceiver::processUpdateChatNotificationSettings);
    _handlers.insert("updateMessageContent", &TDLibReceiver::processUpdateMessageContent);
    _handlers.insert("updateDeleteMessages", &TDLibReceiver::processUpdateDeleteMessages);
    _handlers.insert("chats", &TDLibReceiver::processChats);
    _handlers.insert("chat", &TDLibReceiver::processChat);
    _handlers.insert("updateRecentStickers", &TDLibReceiver::processUpdateRecentStickers);
    _handlers.insert("stickers", &TDLibReceiver::processStickers);
    _handlers.insert("updateInstalledStickerSets", &TDLibReceiver::processUpdateInstalledStickerSets);
    _handlers.insert("stickerSets", &TDLibReceiver::processStickerSets);
    _handlers.insert("stickerSet", &TDLibReceiver::processStickerSet);
    _handlers.insert("chatMembers", &TDLibReceiver::processChatMembers);
    _handlers.insert("chatFolder", &TDLibReceiver::processChatFolder);
    _handlers.insert("userFullInfo", &TDLibReceiver::processUserFullInfo);
    _handlers.insert("updateUserFullInfo", &TDLibReceiver::processUpdateUserFullInfo);
    _handlers.insert("basicGroupFullInfo", &TDLibReceiver::processBasicGroupFullInfo);
    _handlers.insert("updateBasicGroupFullInfo", &TDLibReceiver::processUpdateBasicGroupFullInfo);
    _handlers.insert("supergroupFullInfo", &TDLibReceiver::processSupergroupFullInfo);
    _handlers.insert("updateSupergroupFullInfo", &TDLibReceiver::processUpdateSupergroupFullInfo);
    _handlers.insert("chatPhotos", &TDLibReceiver::processUserProfilePhotos);
    _handlers.insert("updateChatPermissions", &TDLibReceiver::processUpdateChatPermissions);
    _handlers.insert("updateChatPhoto", &TDLibReceiver::processUpdateChatPhoto);
    _handlers.insert("updateChatTitle", &TDLibReceiver::processUpdateChatTitle);
    _handlers.insert("updateChatPinnedMessage", &TDLibReceiver::processUpdateChatPinnedMessage);
    _handlers.insert("updateMessageIsPinned", &TDLibReceiver::processUpdateMessageIsPinned);
    _handlers.insert("users", &TDLibReceiver::processUsers);
    _handlers.insert("messageSenders", &TDLibReceiver::processMessageSenders);
    _handlers.insert("error", &TDLibReceiver::processError);
    _handlers.insert("ok", &TDLibReceiver::processOk);
    _handlers.insert("secretChat", &TDLibReceiver::processSecretChat);
    _handlers.insert("updateSecretChat", &TDLibReceiver::processUpdateSecretChat);
    _handlers.insert("importedContacts", &TDLibReceiver::processImportedContacts);
    _handlers.insert("updateMessageEdited", &TDLibReceiver::processUpdateMessageEdited);
    _handlers.insert("updateChatIsMarkedAsUnread", &TDLibReceiver::processUpdateChatIsMarkedAsUnread);
    _handlers.insert("updateChatDraftMessage", &TDLibReceiver::processUpdateChatDraftMessage);
    _handlers.insert("inlineQueryResults", &TDLibReceiver::processInlineQueryResults);
    _handlers.insert("callbackQueryAnswer", &TDLibReceiver::processCallbackQueryAnswer);
    _handlers.insert("userPrivacySettingRules", &TDLibReceiver::processUserPrivacySettingRules);
    _handlers.insert("updateUserPrivacySettingRules", &TDLibReceiver::processUpdateUserPrivacySettingRules);
    _handlers.insert("updateMessageInteractionInfo", &TDLibReceiver::processUpdateMessageInteractionInfo);
    _handlers.insert("sessions", &TDLibReceiver::processSessions);
    _handlers.insert("availableReactions", &TDLibReceiver::processAvailableReactions);
    _handlers.insert("messageProperties", &TDLibReceiver::processMessageProperties);
    _handlers.insert("updateMessageMentionRead", &TDLibReceiver::processUpdateChatUnreadMentionCount);
    _handlers.insert("updateChatUnreadMentionCount", &TDLibReceiver::processUpdateChatUnreadMentionCount);
    _handlers.insert("updateChatUnreadReactionCount", &TDLibReceiver::processUpdateChatUnreadReactionCount);
    _handlers.insert("updateActiveEmojiReactions", &TDLibReceiver::processUpdateActiveEmojiReactions);
    _handlers.insert("forumTopics", &TDLibReceiver::processForumTopics);
    _handlers.insert("updateForumTopicInfo", &TDLibReceiver::processUpdateForumTopicInfo);
    _handlers.insert("updateForumTopic", &TDLibReceiver::processUpdateForumTopic);
    _handlers.insert("storageStatisticsFast", &TDLibReceiver::processStorageStatisticsFast);
    _handlers.insert("storageStatistics", &TDLibReceiver::processStorageStatistics);
#ifdef QT_DEBUG
    //_debugHandlers.append("updateChatFolders");
    //_debugHandlers.append("chatFolder");
    //_debugHandlers.append("updateChatLastMessage");
//    _debugHandlers.append("forumTopics");
//    _debugHandlers.append("updateForumTopicInfo");
//    _debugHandlers.append("updateForumTopic");
//    _debugHandlers.append("updateSupergroup");
//    _debugHandlers.append("supergroupFullInfo");
//    _debugHandlers.append("updateSupergroupFullInfo");
#endif
}

void TDLibReceiver::setActive(bool active)
{
    _active = active;
}

/*!
 * \brief Основной цикл приложения, в котором происходит получение обновлений от tdlib. Выполняется в отдельном потоке.
 */

void TDLibReceiver::receiverLoop()
{
    while (_active)
    {
        const char *result = td_receive(100000);

        if (result)
        {
            const char typeToken[] = "\"@type\":";
            auto typePosition = strstr(result, typeToken);
            Handler handler = nullptr;
            if(typePosition != nullptr) {
                auto nextTokenStart = typePosition + strlen(typeToken);
                auto nextQuote = strstr(nextTokenStart + 1, "\"");
                auto tokenLength = nextQuote - nextTokenStart - 1;
                char* typeToken = new char[tokenLength + 1];
                strncpy(typeToken, nextTokenStart + 1, tokenLength);
                typeToken[tokenLength] = 0;
                handler = _handlers.value(typeToken);

#ifdef QT_DEBUG
                if(handler && _debugHandlers.contains(typeToken)) {
                    LOG_DEBUG(LOG_TDLIB_JSON, "Данные типа: " << typeToken << "; JSON: \n" << result);
                }
#endif
                delete[] typeToken;
            }
            if(handler) {
                QJsonObject object = QJsonDocument::fromJson(QByteArray(result)).object();
                (this->*handler)(object);
            }
        }
    }
}

void TDLibReceiver::processUpdateOption(const QJsonObject &receivedInformation)
{
    const QString currentOption = receivedInformation.value(NAME).toString();
    const QJsonValue value = receivedInformation.value(VALUE).toObject().value(VALUE);

    if (currentOption == "version")
    {
        QString detectedVersion = value.toString();
        emit versionDetected(detectedVersion);
    }
    else
    {
        emit optionUpdated(currentOption, value.toVariant());
    }
}

void TDLibReceiver::processUpdateAuthorizationState(const QJsonObject &receivedInformation)
{
    const QString authorizationState = receivedInformation.value("authorization_state").toObject().value(_TYPE).toString();

    emit authorizationStateChanged(authorizationState, receivedInformation.toVariantMap());
}

void TDLibReceiver::processUpdateConnectionState(const QJsonObject &receivedInformation)
{
    const QString connectionState = receivedInformation.value("state").toObject().value(_TYPE).toString();

    emit connectionStateChanged(connectionState);
}

void TDLibReceiver::processUpdateUser(const QJsonObject &receivedInformation)
{
    const QVariantMap userInformation = receivedInformation.value("user").toObject().toVariantMap();

    emit userUpdated(userInformation);
}

void TDLibReceiver::processUpdateUserStatus(const QJsonObject &receivedInformation)
{
    const qlonglong userId = parseId(receivedInformation.value(USER_ID));
    const QJsonObject userStatusInformation = receivedInformation.value("status").toObject();

    emit userStatusUpdated(userId, userStatusInformation.toVariantMap());
}

void TDLibReceiver::processUpdateFile(const QJsonObject &receivedInformation)
{
    const QJsonObject fileInformation = receivedInformation.value("file").toObject();

    emit fileUpdated(fileInformation.toVariantMap());
}

void TDLibReceiver::processFile(const QJsonObject &receivedInformation)
{
    emit fileUpdated(receivedInformation.toVariantMap());
}

void TDLibReceiver::processUser(const QJsonObject &receivedInformation)
{
    const QVariantMap user = receivedInformation.toVariantMap();
    const qlonglong userId = user.value(ID).toLongLong();

    emit userVerificationStatusUpdated(userId, user);
}

void TDLibReceiver::processUpdateNewChat(const QJsonObject &receivedInformation)
{
    const QJsonObject chatInformation = receivedInformation.value("chat").toObject();
    emit newChatDiscovered(chatInformation.toVariantMap());
}

void TDLibReceiver::processUpdateUnreadMessageCount(const QJsonObject &receivedInformation)
{
    QVariantMap messageCountInformation;

    messageCountInformation.insert("chat_list_type", receivedInformation.value("chat_list").toObject().value(_TYPE).toVariant());
    messageCountInformation.insert(UNREAD_COUNT, receivedInformation.value(UNREAD_COUNT).toVariant());
    messageCountInformation.insert(UNREAD_UNMUTED_COUNT, receivedInformation.value(UNREAD_UNMUTED_COUNT).toVariant());

    emit unreadMessageCountUpdated(messageCountInformation);
}

void TDLibReceiver::processUpdateUnreadChatCount(const QJsonObject &receivedInformation)
{
    QVariantMap chatCountInformation;
    chatCountInformation.insert("chat_list_type", receivedInformation.value("chat_list").toObject().value(_TYPE).toVariant());
    if(chatCountInformation["chat_list_type"].toString() == TYPE_CHAT_LIST_FOLDER) {
        chatCountInformation.insert("chat_folder_id", receivedInformation.value("chat_list").toObject().value("chat_folder_id").toVariant());
    }
    else
    {
        chatCountInformation.insert("chat_folder_id", QVariant("-1"));
    }
    chatCountInformation.insert("marked_as_unread_count", receivedInformation.value("marked_as_unread_count").toVariant());
    chatCountInformation.insert("marked_as_unread_unmuted_count", receivedInformation.value("marked_as_unread_unmuted_count").toVariant());
    chatCountInformation.insert(TOTAL_COUNT, receivedInformation.value(TOTAL_COUNT).toVariant());
    chatCountInformation.insert(UNREAD_COUNT, receivedInformation.value(UNREAD_COUNT).toVariant());
    chatCountInformation.insert(UNREAD_UNMUTED_COUNT, receivedInformation.value(UNREAD_UNMUTED_COUNT).toVariant());

    emit unreadChatCountUpdated(chatCountInformation);
}

void TDLibReceiver::processUpdateChatFolders(const QJsonObject &receivedInformation)
{
    const qlonglong mainChatPosition = receivedInformation.value(MAIN_CHAT_LIST_POSITION_IN_FOLDERS).toVariant().toLongLong();
    const QVariantList folders = receivedInformation.value(CHAT_FOLDERS).toArray().toVariantList();
    emit updateChatFolders(folders, mainChatPosition);
}

void TDLibReceiver::processUpdateChatAddedToList(const QJsonObject &receivedInformation)
{
    QString chatType;
    qlonglong chatID;
    chatType = receivedInformation.value("chat_list").toObject().value(_TYPE).toVariant().toString();

    if(chatType.contains(TYPE_CHAT_LIST_ARCHIVE)) {
        chatID = parseNumberOrString(receivedInformation.value(CHAT_ID)).toLongLong();
        emit updateChatInArchive(chatID);
    }
}

void TDLibReceiver::processChatFolder(const QJsonObject &chatFolderInformation)
{
    emit gotChatFolder(chatFolderInformation.toVariantMap());
}

void TDLibReceiver::processUpdateChatLastMessage(const QJsonObject &receivedInformation)
{
    const QString chatId = parseNumberOrString(receivedInformation.value(CHAT_ID));
    const QString order = receivedInformation.contains(POSITIONS)
                              ? findChatPositionOrder(receivedInformation.value(POSITIONS).toArray().toVariantList())
                              : parseNumberOrString(receivedInformation.value(ORDER));

    const QJsonObject lastMessage = receivedInformation.value(LAST_MESSAGE).toObject();
    //todo: сделать обработку сообщений в форуме и топиках

    emit chatLastMessageUpdated(chatId, order, TDLibDataParsingUtils::cleanupMap(lastMessage).toVariantMap());
    //todo: сигнал на обновление сообщения в отображение топика внутри форума
}

void TDLibReceiver::processUpdateChatOrder(const QJsonObject &receivedInformation)
{

    const QString chatId = parseNumberOrString(receivedInformation.value(CHAT_ID));
    const QString order = parseNumberOrString(receivedInformation.value(ORDER));
    const QString chatListType(receivedInformation.value(POSITION).toObject().toVariantMap().value(LIST).toMap().value(_TYPE).toString());

    emit chatOrderUpdated(chatId, order, chatListType);
}

void TDLibReceiver::processUpdateChatPosition(const QJsonObject &receivedInformation)
{
    const QJsonObject positionObject = receivedInformation.value(POSITION).toObject();
    const QString updateForChatList = positionObject.value(LIST).toObject().value(_TYPE).toString();
    // We are only processing main chat list updates at the moment...
    if ((updateForChatList == "chatListMain") || (updateForChatList == "chatListArchive"))
    {
        const QString chatId = parseNumberOrString(receivedInformation.value(CHAT_ID));
        const QString order = parseNumberOrString(positionObject.value(ORDER));
        bool pinned = positionObject.value(IS_PINNED).toBool();
        emit chatOrderUpdated(chatId, order, updateForChatList);
        emit chatPinnedUpdated(chatId.toLongLong(), pinned, updateForChatList);
    }
}

void TDLibReceiver::processUpdateChatReadInbox(const QJsonObject &receivedInformation)
{
    const QString chatId = parseNumberOrString(receivedInformation.value(CHAT_ID));
    const int unreadCount = receivedInformation.value(UNREAD_COUNT).toInt();

    emit chatReadInboxUpdated(chatId, parseNumberOrString(receivedInformation.value(LAST_READ_INBOX_MESSAGE_ID)), unreadCount);
}

void TDLibReceiver::processUpdateChatReadOutbox(const QJsonObject &receivedInformation)
{
    const QString chatId = parseNumberOrString(receivedInformation.value(CHAT_ID));
    const QString lastReadOutboxMessageId = parseNumberOrString(receivedInformation.value(LAST_READ_OUTBOX_MESSAGE_ID));

    emit chatReadOutboxUpdated(chatId, lastReadOutboxMessageId);
}

void TDLibReceiver::processUpdateChatAvailableReactions(const QJsonObject &receivedInformation)
{
    const qlonglong chatId = receivedInformation.value(CHAT_ID).toVariant().toLongLong();
    const QVariantMap availableReactions = receivedInformation.value(AVAILABLE_REACTIONS).toObject().toVariantMap();

    emit chatAvailableReactionsUpdated(chatId, availableReactions);
}

void TDLibReceiver::processUpdateBasicGroup(const QJsonObject &receivedInformation)
{
    const QVariantMap basicGroup = receivedInformation.value(BASIC_GROUP).toObject().toVariantMap();
    const qlonglong basicGroupId = basicGroup.value(ID).toLongLong();

    emit basicGroupUpdated(basicGroupId, basicGroup);
}

void TDLibReceiver::processUpdateSuperGroup(const QJsonObject &receivedInformation)
{
    const QVariantMap supergroup = receivedInformation.value(SUPERGROUP).toObject().toVariantMap();
    const qlonglong superGroupId = supergroup.value(ID).toLongLong();
    emit superGroupUpdated(superGroupId, supergroup);
}

void TDLibReceiver::processChatOnlineMemberCountUpdated(const QJsonObject &receivedInformation)
{
    const QString chatId = parseNumberOrString(receivedInformation.value(CHAT_ID));

    emit chatOnlineMemberCountUpdated(chatId, receivedInformation.value("online_member_count").toInt());
}

void TDLibReceiver::processMessages(const QJsonObject &receivedInformation)
{
    const int totalCount = receivedInformation.value(TOTAL_COUNT).toInt();
    const QJsonArray messagesArray = receivedInformation.value(MESSAGES).toArray();

    emit messagesReceived(TDLibDataParsingUtils::cleanupList(messagesArray).toVariantList(), totalCount);
}

void TDLibReceiver::processFoundChatMessages(const QJsonObject &receivedInformation)
{
    const int totalCount = receivedInformation.value(TOTAL_COUNT).toInt();
    const QString extra = receivedInformation.value(_EXTRA).toString();

    // Check if this is a search for pinned messages
    if (extra.startsWith("searchChatPinnedMessages:")) {
        QStringList parts = extra.split(":");
        if (parts.size() >= 2) {
            qlonglong chatId = parts[1].toLongLong();
            qlonglong topicId = (parts.size() >= 3) ? parts[2].toLongLong() : 0;
            emit pinnedMessagesReceived(chatId, topicId, TDLibDataParsingUtils::cleanupList(receivedInformation.value(MESSAGES).toArray()).toVariantList());
            return;
        }
    }

    // Default behavior for regular message searches
    emit messagesReceived(TDLibDataParsingUtils::cleanupList(receivedInformation.value(MESSAGES).toArray()).toVariantList(), totalCount);
}

void TDLibReceiver::processSponsoredMessages(const QJsonObject &receivedInformation)
{
    const qlonglong chatId = receivedInformation.value(_EXTRA).toVariant().toLongLong(); // See TDLibResponseHandler::getChatSponsoredMessage
    const QVariantList messages = receivedInformation.value(MESSAGES).toArray().toVariantList();
    QListIterator<QVariant> it(messages);

    while (it.hasNext())
        emit sponsoredMessageReceived(chatId, it.next().toMap());
}

void TDLibReceiver::processUpdateNewMessage(const QJsonObject &receivedInformation)
{
    const QJsonObject message = receivedInformation.value(MESSAGE).toObject();
    const qlonglong chatId = message.value(CHAT_ID).toVariant().toLongLong();
    emit newMessageReceived(chatId, TDLibDataParsingUtils::cleanupMap(message).toVariantMap());
}

void TDLibReceiver::processMessage(const QJsonObject &receivedInformation)
{
    const qlonglong chatId = receivedInformation.value(CHAT_ID).toVariant().toLongLong();
    const qlonglong messageId = receivedInformation.value(ID).toVariant().toLongLong();
    emit messageInformation(chatId, messageId, TDLibDataParsingUtils::cleanupMap(receivedInformation).toVariantMap());
}

void TDLibReceiver::processMessageThreadInfo(const QJsonObject &receivedInformation)
{
    const qlonglong chatId = receivedInformation.value(CHAT_ID).toVariant().toLongLong();
    const qlonglong messageThreadId = receivedInformation.value("message_thread_id").toVariant().toLongLong();
    emit messageThreadInfo(chatId, messageThreadId, TDLibDataParsingUtils::cleanupMap(receivedInformation).toVariantMap());
}

void TDLibReceiver::processMessageLinkInfo(const QJsonObject &receivedInformation)
{
    const QVariantMap data = receivedInformation.toVariantMap();
    const QString oldExtra = data.value(_EXTRA).toString();
    QString url = "";
    QString extra = "";

    if (oldExtra.contains("|"))
    {
        const int midIndex = oldExtra.indexOf("|");

        url = oldExtra.left(midIndex);
        extra = oldExtra.mid(midIndex + 1);
    }
    else
    {
        url = oldExtra;
    }

    emit messageLinkInfoReceived(url, data, extra);
}

void TDLibReceiver::processMessageSendSucceeded(const QJsonObject &receivedInformation)
{
    const qlonglong oldMessageId = receivedInformation.value(OLD_MESSAGE_ID).toVariant().toLongLong();
    const QJsonObject message = receivedInformation.value(MESSAGE).toObject();
    const qlonglong messageId = message.value(ID).toVariant().toLongLong();
    emit messageSendSucceeded(messageId, oldMessageId, TDLibDataParsingUtils::cleanupMap(message).toVariantMap());
}

void TDLibReceiver::processUpdateActiveNotifications(const QJsonObject &receivedInformation)
{
    emit activeNotificationsUpdated(receivedInformation.value("groups").toArray().toVariantList());
}

void TDLibReceiver::processUpdateNotificationGroup(const QJsonObject &receivedInformation)
{
    emit notificationGroupUpdated(receivedInformation.toVariantMap());
}

void TDLibReceiver::processUpdateNotification(const QJsonObject &receivedInformation)
{
    emit notificationUpdated(receivedInformation.toVariantMap());
}

void TDLibReceiver::processUpdateChatNotificationSettings(const QJsonObject &receivedInformation)
{
    const QString chatId = parseNumberOrString(receivedInformation.value(CHAT_ID));
    emit chatNotificationSettingsUpdated(chatId, receivedInformation.value("notification_settings").toObject().toVariantMap());
}

void TDLibReceiver::processUpdateMessageContent(const QJsonObject &receivedInformation)
{
    const qlonglong chatId = receivedInformation.value(CHAT_ID).toVariant().toLongLong();
    const qlonglong messageId = receivedInformation.value(MESSAGE_ID).toVariant().toLongLong();
    emit messageContentUpdated(chatId, messageId, TDLibDataParsingUtils::cleanupMap(receivedInformation.value(NEW_CONTENT).toObject()).toVariantMap());
}

void TDLibReceiver::processUpdateDeleteMessages(const QJsonObject &receivedInformation)
{
    const qlonglong chatId = receivedInformation.value(CHAT_ID).toVariant().toLongLong();
    const QJsonArray messageIds = receivedInformation.value(MESSAGE_IDS).toArray();
    QList<qlonglong> ids;
    const int n = messageIds.size();

    ids.reserve(n);

    for (auto it = messageIds.begin(); it != messageIds.end(); ++it)
    {
        ids.append(it->toVariant().toLongLong());
    }

    emit messagesDeleted(chatId, ids);
}

void TDLibReceiver::processChats(const QJsonObject &receivedInformation)
{
    emit chats(receivedInformation.toVariantMap());
}

void TDLibReceiver::processChat(const QJsonObject &receivedInformation)
{
    emit chat(receivedInformation.toVariantMap());
}

void TDLibReceiver::processUpdateRecentStickers(const QJsonObject &receivedInformation)
{
    emit recentStickersUpdated(receivedInformation.value("sticker_ids").toArray().toVariantList());
}

void TDLibReceiver::processStickers(const QJsonObject &receivedInformation)
{
    emit stickers(TDLibDataParsingUtils::cleanupList(receivedInformation.value(STICKERS).toArray()).toVariantList());
}

void TDLibReceiver::processUpdateInstalledStickerSets(const QJsonObject &receivedInformation)
{
    emit installedStickerSetsUpdated(receivedInformation.value("sticker_set_ids").toArray().toVariantList());
}

void TDLibReceiver::processStickerSets(const QJsonObject &receivedInformation)
{
    emit stickerSets(TDLibDataParsingUtils::cleanupList(receivedInformation.value(SETS).toArray()).toVariantList());
}

void TDLibReceiver::processStickerSet(const QJsonObject &receivedInformation)
{
    emit stickerSet(TDLibDataParsingUtils::cleanupMap(receivedInformation).toVariantMap());
}

void TDLibReceiver::processChatMembers(const QJsonObject &receivedInformation)
{
    const QString extra = parseNumberOrString(receivedInformation.value(_EXTRA));

    emit chatMembers(extra, receivedInformation.value("members").toArray().toVariantList(), receivedInformation.value(TOTAL_COUNT).toInt());
}

void TDLibReceiver::processUserFullInfo(const QJsonObject &receivedInformation)
{
    emit userFullInfo(receivedInformation.toVariantMap());
}

void TDLibReceiver::processUpdateUserFullInfo(const QJsonObject &receivedInformation)
{
    const QString userId = parseNumberOrString(receivedInformation.value(USER_ID));
    emit userFullInfoUpdated(userId, receivedInformation.value("user_full_info").toObject().toVariantMap());
}

void TDLibReceiver::processBasicGroupFullInfo(const QJsonObject &receivedInformation)
{
    const QVariantMap data = receivedInformation.toVariantMap();
    const QString groupId = receivedInformation.value(_EXTRA).toString();

    emit basicGroupFullInfo(groupId, data);
}

void TDLibReceiver::processUpdateBasicGroupFullInfo(const QJsonObject &receivedInformation)
{
    const QString groupId = parseNumberOrString(receivedInformation.value("basic_group_id"));

    emit basicGroupFullInfoUpdated(groupId, receivedInformation.value("basic_group_full_info").toObject().toVariantMap());
}

void TDLibReceiver::processSupergroupFullInfo(const QJsonObject &receivedInformation)
{
    QVariantMap data = receivedInformation.toVariantMap();
    const QString groupId = data.value(_EXTRA).toString();

    emit supergroupFullInfo(groupId, data);
}

void TDLibReceiver::processUpdateSupergroupFullInfo(const QJsonObject &receivedInformation)
{
    const QString groupId = parseNumberOrString(receivedInformation.value("supergroup_id")); // int64_t

    emit supergroupFullInfoUpdated(groupId, receivedInformation.value("supergroup_full_info").toObject().toVariantMap());
}

void TDLibReceiver::processUserProfilePhotos(const QJsonObject &receivedInformation)
{
    const QString extra = parseNumberOrString(receivedInformation.value(_EXTRA)); // int64

    emit userProfilePhotos(extra, receivedInformation.value("photos").toArray().toVariantList(),
                           receivedInformation.value(TOTAL_COUNT).toInt());
}

void TDLibReceiver::processUpdateChatPermissions(const QJsonObject &receivedInformation)
{
    const QString chatId = parseNumberOrString(receivedInformation.value(CHAT_ID));

    emit chatPermissionsUpdated(chatId, receivedInformation.value("permissions").toObject().toVariantMap());
}

void TDLibReceiver::processUpdateChatPhoto(const QJsonObject &receivedInformation)
{
    const qlonglong chatId = receivedInformation.value(CHAT_ID).toVariant().toLongLong();

    emit chatPhotoUpdated(chatId, receivedInformation.value(PHOTO).toObject().toVariantMap());
}

void TDLibReceiver::processUpdateChatTitle(const QJsonObject &receivedInformation)
{
    const QString chatId = parseNumberOrString(receivedInformation.value(CHAT_ID));
    const QString title = receivedInformation.value(TITLE).toString();

    emit chatTitleUpdated(chatId, title);
}

void TDLibReceiver::processUpdateChatPinnedMessage(const QJsonObject &receivedInformation)
{
    emit chatPinnedMessageUpdated(receivedInformation.value(CHAT_ID).toVariant().toLongLong(),
                                  receivedInformation.value("pinned_message_id").toVariant().toLongLong());
}

void TDLibReceiver::processUpdateMessageIsPinned(const QJsonObject &receivedInformation)
{
    emit messageIsPinnedUpdated(receivedInformation.value(CHAT_ID).toVariant().toLongLong(),
                                receivedInformation.value(MESSAGE_ID).toVariant().toLongLong(),
                                receivedInformation.value("is_pinned").toBool());
}

void TDLibReceiver::processUsers(const QJsonObject &receivedInformation)
{
    emit usersReceived(receivedInformation.value(_EXTRA).toString(), // string
                       receivedInformation.value("user_ids").toArray().toVariantList(),
                       receivedInformation.value(TOTAL_COUNT).toInt());
}

void TDLibReceiver::processMessageSenders(const QJsonObject &receivedInformation)
{
    const QString extra = parseNumberOrString(receivedInformation.value(_EXTRA));

    emit messageSendersReceived(extra, receivedInformation.value("senders").toArray().toVariantList(),
                                receivedInformation.value(TOTAL_COUNT).toInt());
}

void TDLibReceiver::processError(const QJsonObject &receivedInformation)
{
    const QString extra = receivedInformation.value(_EXTRA).toString();
    const QString message = receivedInformation.value(MESSAGE).toString();
    emit responseOkOrErrorReceived(receivedInformation);
    emit errorReceived(receivedInformation.value("code").toInt(), message, extra);
}

void TDLibReceiver::processOk(const QJsonObject &receivedInformation)
{
    emit responseOkOrErrorReceived(receivedInformation);
    if (receivedInformation.contains(_EXTRA))
    {
        emit okReceived(parseNumberOrString(receivedInformation.value(_EXTRA)));
    }
}

void TDLibReceiver::processSecretChat(const QJsonObject &receivedInformation)
{
    emit secretChat(receivedInformation.value(ID).toVariant().toLongLong(), receivedInformation.toVariantMap());
}

void TDLibReceiver::processUpdateSecretChat(const QJsonObject &receivedInformation)
{
    QVariantMap updatedSecretChat = receivedInformation.value(SECRET_CHAT).toObject().toVariantMap();
    emit secretChatUpdated(updatedSecretChat.value(ID).toLongLong(), updatedSecretChat);
}

void TDLibReceiver::processUpdateMessageEdited(const QJsonObject &receivedInformation)
{
    const qlonglong chatId = receivedInformation.value(CHAT_ID).toVariant().toLongLong();
    const qlonglong messageId = receivedInformation.value(MESSAGE_ID).toVariant().toLongLong();
    emit messageEditedUpdated(chatId, messageId, receivedInformation.value("reply_markup").toObject().toVariantMap());
}

void TDLibReceiver::processImportedContacts(const QJsonObject &receivedInformation)
{
    emit contactsImported(receivedInformation.value("importer_count").toArray().toVariantList(),
                          receivedInformation.value("user_ids").toArray().toVariantList());
}

void TDLibReceiver::processUpdateChatIsMarkedAsUnread(const QJsonObject &receivedInformation)
{
    emit chatIsMarkedAsUnreadUpdated(receivedInformation.value(CHAT_ID).toVariant().toLongLong(),
                                     receivedInformation.value("is_marked_as_unread").toBool());
}

void TDLibReceiver::processUpdateChatDraftMessage(const QJsonObject &receivedInformation)
{
    emit chatDraftMessageUpdated(receivedInformation.value(CHAT_ID).toVariant().toLongLong(),
                                 TDLibDataParsingUtils::cleanupMap(receivedInformation.value(DRAFT_MESSAGE).toObject()).toVariantMap(),
                                 findChatPositionOrder(receivedInformation.value(POSITIONS).toArray().toVariantList()));
}

void TDLibReceiver::processInlineQueryResults(const QJsonObject &receivedInformation)
{
    const QString inlineQueryId = parseNumberOrString(receivedInformation.value("inline_query_id"));
    const QString nextOffset = parseNumberOrString(receivedInformation.value("next_offset"));
    const QString switchPmText = parseNumberOrString(receivedInformation.value("switch_pm_text"));
    const QString switchPmParameter = parseNumberOrString(receivedInformation.value("switch_pm_parameter"));
    const QString extra = parseNumberOrString(receivedInformation.value(_EXTRA));

    emit inlineQueryResults(inlineQueryId, nextOffset, receivedInformation.value("results").toArray().toVariantList(),
                            switchPmText, switchPmParameter, extra);
}

void TDLibReceiver::processCallbackQueryAnswer(const QJsonObject &receivedInformation)
{
    emit callbackQueryAnswer(receivedInformation.value(TEXT).toString(),
                             receivedInformation.value("alert").toBool(),
                             receivedInformation.value("url").toString());
}

void TDLibReceiver::processUserPrivacySettingRules(const QJsonObject &receivedInformation)
{
    emit userPrivacySettingRules(receivedInformation.toVariantMap());
}

void TDLibReceiver::processUpdateUserPrivacySettingRules(const QJsonObject &receivedInformation)
{
    emit userPrivacySettingRulesUpdated(receivedInformation.toVariantMap());
}

void TDLibReceiver::processUpdateMessageInteractionInfo(const QJsonObject &receivedInformation)
{
    const qlonglong chatId = receivedInformation.value(CHAT_ID).toVariant().toLongLong();
    const qlonglong messageId = receivedInformation.value(MESSAGE_ID).toVariant().toLongLong();

    emit messageInteractionInfoUpdated(chatId, messageId, receivedInformation.value(INTERACTION_INFO).toObject().toVariantMap());
}

void TDLibReceiver::processSessions(const QJsonObject &receivedInformation)
{
    const int inactiveSessionTtlDays = receivedInformation.value("inactive_session_ttl_days").toInt();
    const QVariantList sessions = receivedInformation.value("sessions").toArray().toVariantList();

    emit sessionsReceived(inactiveSessionTtlDays, sessions);
}

void TDLibReceiver::processAvailableReactions(const QJsonObject &receivedInformation)
{
    const qlonglong messageId = receivedInformation.value(_EXTRA).toVariant().toLongLong();
    const QJsonArray jsonReactions = receivedInformation.value("reactions").toArray();

    if (!jsonReactions.isEmpty())
    {
        QStringList reactions;

        reactions.reserve(jsonReactions.size());

        for (auto it = jsonReactions.begin(); it != jsonReactions.end(); ++it)
        {
            reactions.append(it->toString());
        }

        emit availableReactionsReceived(messageId, reactions);
    }
}

void TDLibReceiver::processMessageProperties(const QJsonObject &receivedInformation)
{
    const qlonglong messageId = receivedInformation.value(_EXTRA).toVariant().toLongLong();
    const bool canBeDeleted = receivedInformation.value("can_be_deleted_for_all_users").toBool();
    const bool canBeEdited = receivedInformation.value("can_be_edited").toBool();
    const bool canBePinned = receivedInformation.value("can_be_pinned").toBool();
    const bool canGetMessageThread = receivedInformation.value("can_get_message_thread").toBool();
    emit messagePropertiesReceived(messageId, canBeEdited, canBePinned, canBeDeleted, canGetMessageThread);
}

void TDLibReceiver::processUpdateChatUnreadMentionCount(const QJsonObject &receivedInformation)
{
    // Handles both updateMessageMentionRead and updateChatUnreadMentionCount
    // They both have chat_id and unread_mention_count which is all we need
    const qlonglong chatId = receivedInformation.value(CHAT_ID).toVariant().toLongLong();
    const int unreadMentionCount = receivedInformation.value(UNREAD_MENTION_COUNT).toInt();

    emit chatUnreadMentionCountUpdated(chatId, unreadMentionCount);
}

void TDLibReceiver::processUpdateChatUnreadReactionCount(const QJsonObject &receivedInformation)
{
    const qlonglong chatId = receivedInformation.value(CHAT_ID).toVariant().toLongLong();
    const int unreadReactionCount = receivedInformation.value(UNREAD_REACTION_COUNT).toInt();

    emit chatUnreadReactionCountUpdated(chatId, unreadReactionCount);
}

void TDLibReceiver::processUpdateActiveEmojiReactions(const QJsonObject &receivedInformation)
{
    // updateActiveEmojiReactions was introduced between 1.8.5 and 1.8.6
    // See https://github.com/tdlib/td/commit/d29d367
    const QJsonArray jsonEmojis = receivedInformation.value(EMOJIS).toArray();
    QStringList emojis;

    emojis.reserve(jsonEmojis.size());

    for (auto it = jsonEmojis.begin(); it != jsonEmojis.end(); ++it)
    {
        emojis.append(it->toString());
    }

    emit activeEmojiReactionsUpdated(emojis);
}

void TDLibReceiver::processForumTopics(const QJsonObject &receivedInformation)
{
     QVariantMap forumTopics = receivedInformation.toVariantMap();
     emit forumTopicsReceived(forumTopics);
}

void TDLibReceiver::processUpdateForumTopicInfo(const QJsonObject &receivedInformation)
{
     QVariantMap forumTopicInfo = receivedInformation.toVariantMap();
     emit updateForumTopicInfoReceived(forumTopicInfo);
}

void TDLibReceiver::processUpdateForumTopic(const QJsonObject &receivedInformation)
{
     QVariantMap forumTopic = receivedInformation.toVariantMap();
     emit forumTopicReceived(forumTopic);
}

void TDLibReceiver::processStorageStatisticsFast(const QJsonObject &receivedInformation)
{
     emit storageStatisticsFastReceived(receivedInformation.toVariantMap());
}

void TDLibReceiver::processStorageStatistics(const QJsonObject &)
{
     emit storageStatisticsReceived();
}

QString TDLibReceiver::getChatPositionOrder(const QVariantMap &position) const
{
    if (position.value(_TYPE).toString() == TYPE_CHAT_POSITION &&
        position.value(LIST).toMap().value(_TYPE) == TYPE_CHAT_LIST_MAIN)
    {
        return position.value(ORDER).toString();
    }
    return QString();
}

QString TDLibReceiver::findChatPositionOrder(const QVariantList &positions) const
{
    const int n = positions.count();
    for (int i = 0; i < n; i++)
    {
        const QString order = getChatPositionOrder(positions.at(i).toMap());
        if (!order.isEmpty())
        {
            return order;
        }
    }
    return QString();
}

QString TDLibReceiver::parseNumberOrString(const QJsonValue &id) const
{
    return id.isString() ? id.toString() : id.toVariant().toString();
}

qlonglong TDLibReceiver::parseId(const QJsonValue &id) const
{
    return id.toVariant().toLongLong();
}