src/tdlib/tdlibresponsehandler.cpp - develop - alexashkin/telegraph

src/tdlib/tdlibresponsehandler.cpp
828 строк35 KB
mbarashkov
Завершение ВЕЛИКОЛЕПНОГО рефакторинга
21 фев 2025, 20:32
21 фев 2025, 20:32b9fcdf4
#include "tdlibresponsehandler.h"
#include "../tdlibsecrets.h"
#include <QLocale>
#include <QSysInfo>
#include <QDir>
#include <QRegularExpression>
#include <td/telegram/td_json_client.h>
#include <td/telegram/Client.h>
#include <td/telegram/td_api.h>

#include "../debuglog.h"

#define VERSION_NUMBER(x, y, z) \
    ((((x) & 0x3ff) << 20) | (((y) & 0x3ff) << 10) | ((z) & 0x3ff))

namespace
{
    const char STATUS[] = "status";
    const char ID[] = "id";
    const char MESSAGE_ID[] = "message_id";
    const char TYPE[] = "type";
    const char LAST_NAME[] = "last_name";
    const char FIRST_NAME[] = "first_name";
    const char USERNAME[] = "username";
    const char CHAT_LIST_TYPE[] = "chat_list_type";
    const char _TYPE[] = "@type";
    const char _EXTRA[] = "@extra";
    const char MESSAGE[] = "message";
    const char CHAT_LIST_MAIN[] = "chatListMain";
    const char CHAT_LIST_FOLDER[] = "chatListFolder";
    const char CHAT_LIST_ARCHIVE[] = "chatListArchive";
    const char CHAT_AVAILABLE_REACTIONS[] = "available_reactions";
    const char CHAT_AVAILABLE_REACTIONS_ALL[] = "chatAvailableReactionsAll";
    const char CHAT_AVAILABLE_REACTIONS_SOME[] = "chatAvailableReactionsSome";
    const char REACTIONS[] = "reactions";
    const char REACTION_TYPE_EMOJI[] = "reactionTypeEmoji";
    const char EMOJI[] = "emoji";
    const char ME_URL_PREFIX[] = "t_me_url";
    const char MY_ID_OPTION[] = "my_id";
}

TDLibResponseHandler::TDLibResponseHandler(AppSettings *settings, TDLibState* tdLibState, TDLibRequestFactory* requestFactory, TDLibRequestService *requestService, TDLibRequestSender *requestSender, QString dbPath, QObject *parent)
    : QObject(parent),
      dbPath(dbPath),
      _appSettings(settings),
      _authorizationState(TDLibConstants::AuthorizationState::Closed),
      _allMainChatsLoaded(false),
      tdLibState(tdLibState),
      requestFactory(requestFactory),
      requestService(requestService),
      requestSender(requestSender)
{
    initializeTDLibReceiver();
}

TDLibResponseHandler::~TDLibResponseHandler()
{
    _tdLibReceiver->setActive(false);

    while (_tdLibReceiver->isRunning())
        QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);

    qDeleteAll(_basicGroups);
    qDeleteAll(_superGroups);
}

void TDLibResponseHandler::initializeTDLibReceiver()
{
    _tdLibReceiver = new TDLibReceiver(tdLibState->getClientId(), this);
    connect(_tdLibReceiver, SIGNAL(versionDetected(QString)),
            this, SLOT(handleVersionDetected(QString)));
    connect(_tdLibReceiver, SIGNAL(authorizationStateChanged(QString,QVariantMap)),
            this, SLOT(handleAuthorizationStateChanged(QString,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(optionUpdated(QString,QVariant)), this, SLOT(handleOptionUpdated(QString,QVariant)));
    connect(_tdLibReceiver, SIGNAL(connectionStateChanged(QString)), this, SLOT(handleConnectionStateChanged(QString)));
    connect(_tdLibReceiver, SIGNAL(userUpdated(QVariantMap)), this, SLOT(handleUserUpdated(QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(userStatusUpdated(qlonglong,QVariantMap)),
            this, SLOT(handleUserStatusUpdated(qlonglong,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(fileUpdated(QVariantMap)), this, SLOT(handleFileUpdated(QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(newChatDiscovered(QVariantMap)), this, SLOT(handleNewChatDiscovered(QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(updateChatFolders(QVariantList,qlonglong)),
            this, SLOT(handleChatFolders(QVariantList,qlonglong)));
    connect(_tdLibReceiver, SIGNAL(updateChatInArchive(qlonglong)), this, SIGNAL(chatInArchive(qlonglong)));
    connect(_tdLibReceiver, SIGNAL(unreadMessageCountUpdated(QVariantMap)),
            this, SLOT(handleUnreadMessageCountUpdated(QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(unreadChatCountUpdated(QVariantMap)), this, SLOT(handleUnreadChatCountUpdated(QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(chatLastMessageUpdated(QString,QString,QVariantMap)),
            this, SIGNAL(chatLastMessageUpdated(QString,QString,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(chatOrderUpdated(QString,QString,QString)),
            this, SIGNAL(chatOrderUpdated(QString,QString,QString)));
    connect(_tdLibReceiver, SIGNAL(chatReadInboxUpdated(QString,QString,int)),
            this, SIGNAL(chatReadInboxUpdated(QString,QString,int)));
    connect(_tdLibReceiver, SIGNAL(chatReadOutboxUpdated(QString,QString)),
            this, SIGNAL(chatReadOutboxUpdated(QString,QString)));
    connect(_tdLibReceiver, SIGNAL(chatAvailableReactionsUpdated(qlonglong,QVariantMap)),
            this, SLOT(handleAvailableReactionsUpdated(qlonglong,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(basicGroupUpdated(qlonglong,QVariantMap)),
            this, SLOT(handleBasicGroupUpdated(qlonglong,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(superGroupUpdated(qlonglong,QVariantMap)),
            this, SLOT(handleSuperGroupUpdated(qlonglong,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(chatOnlineMemberCountUpdated(QString,int)),
            this, SIGNAL(chatOnlineMemberCountUpdated(QString,int)));
    connect(_tdLibReceiver, SIGNAL(messagesReceived(QVariantList,int)), this, SIGNAL(messagesReceived(QVariantList,int)));
    connect(_tdLibReceiver, SIGNAL(sponsoredMessageReceived(qlonglong,QVariantMap)),
            this, SLOT(handleSponsoredMessage(qlonglong,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(messageLinkInfoReceived(QString,QVariantMap,QString)),
            this, SIGNAL(messageLinkInfoReceived(QString,QVariantMap,QString)));
    connect(_tdLibReceiver, SIGNAL(newMessageReceived(qlonglong,QVariantMap)),
            this, SIGNAL(newMessageReceived(qlonglong,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(messageInformation(qlonglong,qlonglong,QVariantMap)),
            this, SLOT(handleMessageInformation(qlonglong,qlonglong,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(messageSendSucceeded(qlonglong,qlonglong,QVariantMap)),
            this, SIGNAL(messageSendSucceeded(qlonglong,qlonglong,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(activeNotificationsUpdated(QVariantList)),
            this, SIGNAL(activeNotificationsUpdated(QVariantList)));
    connect(_tdLibReceiver, SIGNAL(notificationGroupUpdated(QVariantMap)), this, SIGNAL(notificationGroupUpdated(QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(notificationUpdated(QVariantMap)), this, SIGNAL(notificationUpdated(QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(chatNotificationSettingsUpdated(QString,QVariantMap)),
            this, SIGNAL(chatNotificationSettingsUpdated(QString,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(messageContentUpdated(qlonglong,qlonglong,QVariantMap)),
            this, SIGNAL(messageContentUpdated(qlonglong,qlonglong,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(messagesDeleted(qlonglong,QList<qlonglong>)),
            this, SIGNAL(messagesDeleted(qlonglong,QList<qlonglong>)));
    connect(_tdLibReceiver, SIGNAL(chats(QVariantMap)), this, SIGNAL(chatsReceived(QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(chat(QVariantMap)), this, SLOT(handleChatReceived(QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(secretChat(qlonglong,QVariantMap)),
            this, SLOT(handleSecretChatReceived(qlonglong,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(secretChatUpdated(qlonglong,QVariantMap)),
            this, SLOT(handleSecretChatUpdated(qlonglong,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(recentStickersUpdated(QVariantList)), this, SIGNAL(recentStickersUpdated(QVariantList)));
    connect(_tdLibReceiver, SIGNAL(stickers(QVariantList)), this, SIGNAL(stickersReceived(QVariantList)));
    connect(_tdLibReceiver, SIGNAL(installedStickerSetsUpdated(QVariantList)),
            this, SIGNAL(installedStickerSetsUpdated(QVariantList)));
    connect(_tdLibReceiver, SIGNAL(stickerSets(QVariantList)), this, SLOT(handleStickerSets(QVariantList)));
    connect(_tdLibReceiver, SIGNAL(stickerSet(QVariantMap)), this, SIGNAL(stickerSetReceived(QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(chatMembers(QString,QVariantList,int)),
            this, SIGNAL(chatMembersReceived(QString,QVariantList,int)));
    connect(_tdLibReceiver, SIGNAL(userFullInfo(QVariantMap)), this, SIGNAL(userFullInfoReceived(QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(userFullInfoUpdated(QString,QVariantMap)),
            this, SIGNAL(userFullInfoUpdated(QString,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(basicGroupFullInfo(QString,QVariantMap)),
            this, SIGNAL(basicGroupFullInfoReceived(QString,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(basicGroupFullInfoUpdated(QString,QVariantMap)),
            this, SIGNAL(basicGroupFullInfoUpdated(QString,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(supergroupFullInfo(QString,QVariantMap)),
            this, SIGNAL(supergroupFullInfoReceived(QString,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(supergroupFullInfoUpdated(QString,QVariantMap)),
            this, SIGNAL(supergroupFullInfoUpdated(QString,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(userProfilePhotos(QString,QVariantList,int)),
            this, SIGNAL(userProfilePhotosReceived(QString,QVariantList,int)));
    connect(_tdLibReceiver, SIGNAL(chatPermissionsUpdated(QString,QVariantMap)),
            this, SIGNAL(chatPermissionsUpdated(QString,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(chatPhotoUpdated(qlonglong,QVariantMap)),
            this, SIGNAL(chatPhotoUpdated(qlonglong,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(chatTitleUpdated(QString,QString)), this, SIGNAL(chatTitleUpdated(QString,QString)));
    connect(_tdLibReceiver, SIGNAL(chatPinnedUpdated(qlonglong,bool,QString)),
            this, SIGNAL(chatPinnedUpdated(qlonglong,bool,QString)));
    connect(_tdLibReceiver, SIGNAL(chatPinnedMessageUpdated(qlonglong,qlonglong)),
            this, SIGNAL(chatPinnedMessageUpdated(qlonglong,qlonglong)));
    connect(_tdLibReceiver, SIGNAL(messageIsPinnedUpdated(qlonglong,qlonglong,bool)),
            this, SLOT(handleMessageIsPinnedUpdated(qlonglong,qlonglong,bool)));
    connect(_tdLibReceiver, SIGNAL(usersReceived(QString,QVariantList,int)),
            this, SIGNAL(usersReceived(QString,QVariantList,int)));
    connect(_tdLibReceiver, SIGNAL(messageSendersReceived(QString,QVariantList,int)),
            this, SIGNAL(messageSendersReceived(QString,QVariantList,int)));
    connect(_tdLibReceiver, SIGNAL(errorReceived(int,QString,QString)), this, SLOT(handleErrorReceived(int,QString,QString)));
    connect(_tdLibReceiver, SIGNAL(contactsImported(QVariantList,QVariantList)),
            this, SIGNAL(contactsImported(QVariantList,QVariantList)));
    connect(_tdLibReceiver, SIGNAL(messageEditedUpdated(qlonglong,qlonglong,QVariantMap)),
            this, SIGNAL(messageEditedUpdated(qlonglong,qlonglong,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(chatIsMarkedAsUnreadUpdated(qlonglong,bool)),
            this, SIGNAL(chatIsMarkedAsUnreadUpdated(qlonglong,bool)));
    connect(_tdLibReceiver, SIGNAL(chatDraftMessageUpdated(qlonglong,QVariantMap,QString)),
            this, SIGNAL(chatDraftMessageUpdated(qlonglong,QVariantMap,QString)));
    connect(_tdLibReceiver, SIGNAL(inlineQueryResults(QString,QString,QVariantList,QString,QString,QString)),
            this, SIGNAL(inlineQueryResults(QString,QString,QVariantList,QString,QString,QString)));
    connect(_tdLibReceiver, SIGNAL(callbackQueryAnswer(QString,bool,QString)),
            this, SIGNAL(callbackQueryAnswer(QString,bool,QString)));
    connect(_tdLibReceiver, SIGNAL(userPrivacySettingRules(QVariantMap)), this, SLOT(handleUserPrivacySettingRules(QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(userPrivacySettingRulesUpdated(QVariantMap)),
            this, SLOT(handleUpdatedUserPrivacySettingRules(QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(messageInteractionInfoUpdated(qlonglong,qlonglong,QVariantMap)),
            this, SIGNAL(messageInteractionInfoUpdated(qlonglong,qlonglong,QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(okReceived(QString)), this, SIGNAL(okReceived(QString)));
    connect(_tdLibReceiver, SIGNAL(sessionsReceived(int,QVariantList)), this, SIGNAL(sessionsReceived(int,QVariantList)));
    connect(_tdLibReceiver, SIGNAL(availableReactionsReceived(qlonglong,QStringList)),
            this, SIGNAL(availableReactionsReceived(qlonglong,QStringList)));
    connect(_tdLibReceiver, SIGNAL(chatUnreadMentionCountUpdated(qlonglong,int)),
            this, SIGNAL(chatUnreadMentionCountUpdated(qlonglong,int)));
    connect(_tdLibReceiver, SIGNAL(chatUnreadReactionCountUpdated(qlonglong,int)),
            this, SIGNAL(chatUnreadReactionCountUpdated(qlonglong,int)));
    connect(_tdLibReceiver, SIGNAL(activeEmojiReactionsUpdated(QStringList)),
            this, SLOT(handleActiveEmojiReactionsUpdated(QStringList)));
    connect(_tdLibReceiver, SIGNAL(gotChatFolder(QVariantMap)), this, SLOT(handleChatFolder(QVariantMap)));
    connect(_tdLibReceiver, SIGNAL(responseOkOrErrorReceived(QJsonObject)), this, SLOT(handleOkOrErrorReceived(QJsonObject)));
    _tdLibReceiver->start();
}

void TDLibResponseHandler::handleOkOrErrorReceived(const QJsonObject &jsonResponse)
{
    const QString extra = jsonResponse.value(_EXTRA).toString();
    const QString message = jsonResponse.value(MESSAGE).toString();
    const QString type = jsonResponse.value(_TYPE).toString();
    int code = jsonResponse.value("code").toInt();

    if (type == "ok") {
        if (extra.contains("chatListMain") && !_allMainChatsLoaded) {
            if (!requestService->isRequestTimerActive())
                requestSender->callGetChatListMain(100);
            return;
        }

        if (extra.contains("chatListFolder") || extra.contains("chatListArchive")) {
            if (!requestService->isRequestTimerActive())
                requestService->callProcessNextRequest();
            return;
        }
    }

    if (type == "error") {
        if (code == 420) { // FLOOD_WAIT
            QRegularExpression re("FLOOD_WAIT_(\\d+)");
            auto match = re.match(message);
            if (match.hasMatch()) {
                tdLibState->floodWait = true;
                int waitSeconds = match.captured(1).toInt();
                int waitMs = (waitSeconds + 1) * 1000;
                QTimer::singleShot(waitMs, this, [this]() {
                    tdLibState->floodWait = false;
                    if (!requestService->isRequestTimerActive())
                        requestService->callProcessNextRequest();
                });
            }
        } else if (code == 404) {
            if(extra.contains("chatListMain")) {
                _allMainChatsLoaded = true;
            }
        } else {
            // Для других ошибок продолжаем обработку
            if (!requestService->isRequestTimerActive())
                requestService->callProcessNextRequest();
        }
    }
}

QString TDLibResponseHandler::getVersion()
{
    return tdLibState->getTdLibVersion();
}

TDLibConstants::AuthorizationState TDLibResponseHandler::getAuthorizationState()
{
    return _authorizationState;
}

QVariantMap TDLibResponseHandler::getAuthorizationStateData()
{
    return _authorizationStateData;
}

TDLibConstants::ConnectionState TDLibResponseHandler::getConnectionState()
{
    return _connectionState;
}

qlonglong TDLibResponseHandler::getMyUserId() {
    return tdLibState->getMyUserId();
}

QVariantMap TDLibResponseHandler::getMyUserInformation()
{
    return tdLibState->getMyUserInformation();
}

QVariantMap TDLibResponseHandler::getUserInformation(const qlonglong userId)
{
    return cache.getUserById(userId);
}

QString TDLibResponseHandler::getUserName(const qlonglong userId)
{
    QString userName;
    if(cache.containsUserNameById(userId)) {
        userName = cache.getUserName(userId);
    } else {
        auto userInformation = cache.getUserById(userId);
        auto firstName = userInformation.value(FIRST_NAME).toString();
        auto lastName = userInformation.value(LAST_NAME).toString();
        userName = (firstName + " " + lastName).trimmed();
        cache.putUserName(userId, userName);
    }
    return userName;
}

bool TDLibResponseHandler::hasUserInformation(const qlonglong userId)
{
    return cache.containsUserById(userId);
}

QVariantMap TDLibResponseHandler::getUserInformationByName(const QString &userName)
{
    return cache.getUserByName(userName);
}

TDLibConstants::UserPrivacySettingRule TDLibResponseHandler::getUserPrivacySettingRule(TDLibConstants::UserPrivacySetting userPrivacySetting)
{
    return tdLibState->getUserPrivacySettingRule(userPrivacySetting);
}

QVariantMap TDLibResponseHandler::getUnreadMessageInformation()
{
    return _unreadMessageInformation;
}

QVariantMap TDLibResponseHandler::getUnreadChatInformation()
{
    return _unreadChatInformation;
}

QVariantMap TDLibResponseHandler::getBasicGroup(qlonglong groupId) const
{
    const Group *group = _basicGroups.value(groupId);

    if (group)
    {
        return group->groupInfo;
    }
    else
    {
        return QVariantMap();
    }
}

QVariantMap TDLibResponseHandler::getSuperGroup(qlonglong groupId) const
{
    const Group *group = _superGroups.value(groupId);

    if (group)
    {
        return group->groupInfo;
    }
    else
    {
        return QVariantMap();
    }
}

QVariantMap TDLibResponseHandler::getChat(const qlonglong chatId) const
{
    return cache.getChat(chatId);
}

QStringList TDLibResponseHandler::getChatReactions(const qlonglong chatId) const
{
    const QVariant available_reactions(cache.getChat(chatId).value(CHAT_AVAILABLE_REACTIONS));
    const QVariantMap map(available_reactions.toMap());
    const QString reactions_type(map.value(_TYPE).toString());

    if (reactions_type == CHAT_AVAILABLE_REACTIONS_ALL)
    {
        return _activeEmojiReactions;
    }
    else if (reactions_type == CHAT_AVAILABLE_REACTIONS_SOME)
    {
        const QVariantList reactions(map.value(REACTIONS).toList());
        const int n = reactions.count();
        QStringList emojis;

        // "available_reactions": {
        //     "@type": "chatAvailableReactionsSome",
        //     "reactions": [
        //         {
        //             "@type": "reactionTypeEmoji",
        //             "emoji": "..."
        //         },
        emojis.reserve(n);

        for (int i = 0; i < n; i++)
        {
            const QVariantMap reaction(reactions.at(i).toMap());

            if (reaction.value(_TYPE).toString() == REACTION_TYPE_EMOJI)
            {
                const QString emoji(reaction.value(EMOJI).toString());

                if (!emoji.isEmpty())
                    emojis.append(emoji);
            }
        }

        return emojis;
    }
    else if (reactions_type.isEmpty())
    {
        return available_reactions.toStringList();
    }
    else
    {
        return QStringList();
    }
}

QVariantMap TDLibResponseHandler::getSecretChatFromCache(qlonglong secretChatId)
{
    return _secretChats.value(secretChatId);
}

QString TDLibResponseHandler::getUrlPrefix() const
{
    return _options.value(ME_URL_PREFIX).toString();
}

bool TDLibResponseHandler::getJoinChatRequested()
{
    return tdLibState->joinChatRequested;
}

void TDLibResponseHandler::registerJoinChat()
{
    tdLibState->joinChatRequested = false;
}

void TDLibResponseHandler::handleVersionDetected(const QString &version)
{
    tdLibState->setTdLibVersion(version);
    emit versionDetected(version);
}

void TDLibResponseHandler::handleAuthorizationStateChanged(const QString &authorizationState, const QVariantMap authorizationStateData)
{
    if (authorizationState == "authorizationStateClosed")
        _authorizationState = TDLibConstants::AuthorizationState::Closed;
    else if (authorizationState == "authorizationStateClosing")
        _authorizationState = TDLibConstants::AuthorizationState::Closing;
    else if (authorizationState == "authorizationStateLoggingOut")
        _authorizationState = TDLibConstants::AuthorizationState::LoggingOut;
    else if (authorizationState == "authorizationStateReady")
        _authorizationState = TDLibConstants::AuthorizationState::AuthorizationReady;
    else if (authorizationState == "authorizationStateWaitCode")
        _authorizationState = TDLibConstants::AuthorizationState::WaitCode;
    else if (authorizationState == "authorizationStateWaitEncryptionKey")
    {
        requestService->sendRequest(requestFactory->setEncryptionKeyRequest());
        _authorizationState = TDLibConstants::AuthorizationState::WaitEncryptionKey;
    }
    else if (authorizationState == "authorizationStateWaitOtherDeviceConfirmation")
        _authorizationState = TDLibConstants::AuthorizationState::WaitOtherDeviceConfirmation;
    else if (authorizationState == "authorizationStateWaitPassword")
        _authorizationState = TDLibConstants::AuthorizationState::WaitPassword;
    else if (authorizationState == "authorizationStateWaitPhoneNumber")
        _authorizationState = TDLibConstants::AuthorizationState::WaitPhoneNumber;
    else if (authorizationState == "authorizationStateWaitRegistration")
        _authorizationState = TDLibConstants::AuthorizationState::WaitRegistration;
    else if (authorizationState == "authorizationStateWaitTdlibParameters")
    {
        requestService->sendRequest(requestFactory->setTdLibParametersRequest(dbPath));
        _authorizationState = TDLibConstants::AuthorizationState::WaitTdlibParameters;
    }
    else if (authorizationState == "authorizationStateLoggingOut")
        _authorizationState = TDLibConstants::AuthorizationState::AuthorizationStateLoggingOut;

    if (authorizationState == "authorizationStateClosed")
    {
        _authorizationState = TDLibConstants::AuthorizationState::AuthorizationStateClosed;
        _basicGroups.clear();
        _superGroups.clear();
        cache.clear();
        _tdLibReceiver->setActive(false);

        while (_tdLibReceiver->isRunning())
            QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);

        _tdLibReceiver->terminate();

        QDir appPath(dbPath);

        appPath.removeRecursively();
        initializeTDLibReceiver();
        tdLibState->loggingOut = false;
    }

    _authorizationStateData = authorizationStateData;
    emit authorizationStateChanged(_authorizationState, _authorizationStateData);
}

void TDLibResponseHandler::handleOptionUpdated(const QString &optionName, const QVariant &optionValue)
{
    if(optionName != MY_ID_OPTION && optionName != ME_URL_PREFIX)
    {
        return;
    }
    _options.insert(optionName, optionValue);
    if (optionName == MY_ID_OPTION)
    {
        const qlonglong ownUserId = optionValue.toLongLong();
        tdLibState->setMyUserIdAndInformation(ownUserId, getUserInformation(ownUserId));
        emit ownUserIdFound(ownUserId);
    }
}

void TDLibResponseHandler::handleConnectionStateChanged(const QString &connectionState)
{
    if (connectionState == "connectionStateConnecting")
        _connectionState = TDLibConstants::ConnectionState::Connecting;
    else if (connectionState == "connectionStateConnectingToProxy")
        _connectionState = TDLibConstants::ConnectionState::ConnectingToProxy;
    else if (connectionState == "connectionStateReady")
        _connectionState = TDLibConstants::ConnectionState::ConnectionReady;
    else if (connectionState == "connectionStateUpdating")
        _connectionState = TDLibConstants::ConnectionState::Updating;
    else if (connectionState == "connectionStateWaitingForNetwork")
        _connectionState = TDLibConstants::ConnectionState::WaitingForNetwork;

    emit connectionStateChanged(_connectionState);
}

void TDLibResponseHandler::handleUserUpdated(const QVariantMap &updatedUserInformation)
{
    const qlonglong updatedUserId = updatedUserInformation.value(ID).toLongLong();

    if (updatedUserId == _options.value(MY_ID_OPTION).toLongLong())
    {
        tdLibState->setMyUserIdAndInformation(updatedUserId, updatedUserInformation);
        emit myUserUpdated(updatedUserInformation);
    }
    updateUserInformation(updatedUserId, updatedUserInformation);
    emit userUpdated(updatedUserId, updatedUserInformation);
}

void TDLibResponseHandler::handleUserStatusUpdated(const qlonglong userId, const QVariantMap &userStatusInformation)
{
    if (userId == _options.value(MY_ID_OPTION).toLongLong())
    {
        tdLibState->setMyUserInformationStatus(userStatusInformation);
    }

    QVariantMap updatedUserInformation = cache.getUserById(userId);

    if (updatedUserInformation[STATUS] == userStatusInformation)
    {
        return;
    }

    updatedUserInformation.insert(STATUS, userStatusInformation);
    updateUserInformation(userId, updatedUserInformation);
    emit userUpdated(userId, updatedUserInformation);
}

void TDLibResponseHandler::updateUserInformation(const qlonglong userId, const QVariantMap &userInformation)
{
    cache.putUser(userId, userInformation);
}

void TDLibResponseHandler::handleFileUpdated(const QVariantMap &fileInformation)
{
    emit fileUpdated(fileInformation.value(ID).toInt(), fileInformation);
}

void TDLibResponseHandler::handleNewChatDiscovered(const QVariantMap &chatInformation)
{
    cache.putChat(chatInformation);
    QString chatId = chatInformation.value(ID).toString();
    emit newChatDiscovered(chatId, chatInformation);
}

void TDLibResponseHandler::handleChatFolders(const QVariantList &foldersInformation, qlonglong mainChatlistPosition)
{
    for (const auto &folder : foldersInformation)
    {
        requestSender->callGetChatFolder(folder.toMap().value("id").toLongLong());
    }

    emit chatFolders(foldersInformation, mainChatlistPosition);
}

void TDLibResponseHandler::handleChatFolder(const QVariantMap &chatFolderInformation)
{
    emit chatFolder(chatFolderInformation);
}

void TDLibResponseHandler::handleChatReceived(const QVariantMap &chatInformation)
{
    emit chatReceived(chatInformation);

    if (!tdLibState->activeChatSearchName.isEmpty())
    {
        QVariantMap chatType = chatInformation.value(TYPE).toMap();
        TDLibConstants::ChatType receivedChatType = TDLibConstants::chatTypeFromString(chatType.value(_TYPE).toString());

        if (receivedChatType == TDLibConstants::ChatTypeBasicGroup)
        {
            tdLibState->activeChatSearchName.clear();
            requestSender->callCreateBasicGroupChat(chatType.value("basic_group_id").toString(), "openDirectly");
        }

        if (receivedChatType == TDLibConstants::ChatTypeSuperGroup)
        {
            tdLibState->activeChatSearchName.clear();
            requestSender->callCreateSupergroupChat(chatType.value("supergroup_id").toString(), "openDirectly");
        }
    }
}

void TDLibResponseHandler::handleUnreadMessageCountUpdated(const QVariantMap &messageCountInformation)
{
    if (messageCountInformation.value(CHAT_LIST_TYPE).toString() == CHAT_LIST_MAIN)
    {
        _unreadMessageInformation = messageCountInformation;
        emit unreadMessageCountUpdated(messageCountInformation);
    }

    if (messageCountInformation.value(CHAT_LIST_TYPE).toString() == CHAT_LIST_FOLDER) {
        emit unreadFolderMessageCountUpdated(messageCountInformation);
    }

    if (messageCountInformation.value(CHAT_LIST_TYPE).toString() == CHAT_LIST_ARCHIVE) {
        emit unreadArchiveMessageCountUpdated(messageCountInformation);
    }
}

void TDLibResponseHandler::handleUnreadChatCountUpdated(const QVariantMap &chatCountInformation)
{
    if (chatCountInformation.value(CHAT_LIST_TYPE).toString() == CHAT_LIST_MAIN)
    {
        _unreadChatInformation = chatCountInformation;
    }
    emit unreadChatCountUpdated(chatCountInformation);

}

void TDLibResponseHandler::handleAvailableReactionsUpdated(qlonglong chatId, const QVariantMap &availableReactions)
{
    QVariantMap chatInformation = getChat(chatId);

    chatInformation.insert(CHAT_AVAILABLE_REACTIONS, availableReactions);
    cache.putChat(chatInformation);
    emit chatAvailableReactionsUpdated(chatId, availableReactions);
}

void TDLibResponseHandler::handleBasicGroupUpdated(qlonglong groupId, const QVariantMap &groupInformation)
{
    emit basicGroupUpdated(updateGroup(groupId, groupInformation, &_basicGroups)->groupId);

    if (!(tdLibState->activeChatSearchName.isEmpty()) && tdLibState->activeChatSearchName == groupInformation.value(USERNAME).toString())
    {
        tdLibState->activeChatSearchName.clear();
        requestSender->callCreateBasicGroupChat(groupInformation.value(ID).toString(), "openDirectly");
    }
}

void TDLibResponseHandler::handleSuperGroupUpdated(qlonglong groupId, const QVariantMap &groupInformation)
{
    emit superGroupUpdated(updateGroup(groupId, groupInformation, &_superGroups)->groupId);

    if (!tdLibState->activeChatSearchName.isEmpty() && tdLibState->activeChatSearchName == groupInformation.value(USERNAME).toString())
    {
        tdLibState->activeChatSearchName.clear();
        requestSender->callCreateSupergroupChat(groupInformation.value(ID).toString(), "openDirectly");
    }
}

void TDLibResponseHandler::handleStickerSets(const QVariantList &stickerSets)
{
    QListIterator<QVariant> stickerSetIterator(stickerSets);

    while (stickerSetIterator.hasNext())
    {
        QVariantMap stickerSet = stickerSetIterator.next().toMap();

        requestSender->callGetStickerSet(stickerSet.value(ID).toString());
    }

    emit stickerSetsReceived(stickerSets);
}

void TDLibResponseHandler::handleSecretChatReceived(qlonglong secretChatId, const QVariantMap &secretChat)
{
    _secretChats.insert(secretChatId, secretChat);
    emit secretChatReceived(secretChatId, secretChat);
}

void TDLibResponseHandler::handleSecretChatUpdated(qlonglong secretChatId, const QVariantMap &secretChat)
{
    _secretChats.insert(secretChatId, secretChat);
    emit secretChatUpdated(secretChatId, secretChat);
}

void TDLibResponseHandler::handleErrorReceived(int code, const QString &message, const QString &extra)
{
    if (!extra.isEmpty())
    {
        QStringList parts(extra.split(':'));

        if (parts.size() == 3 && parts.at(0) == QStringLiteral("getMessage"))
            emit messageNotFound(parts.at(1).toLongLong(), parts.at(2).toLongLong());
    }

    emit errorReceived(code, message, extra);
}

void TDLibResponseHandler::handleMessageInformation(qlonglong chatId, qlonglong messageId, const QVariantMap &receivedInformation)
{
    QString extraInformation = receivedInformation.value(_EXTRA).toString();

    if (extraInformation.startsWith("getChatPinnedMessage:"))
        emit chatPinnedMessageUpdated(chatId, messageId);

    emit receivedMessage(chatId, messageId, receivedInformation);
}

void TDLibResponseHandler::handleMessageIsPinnedUpdated(qlonglong chatId, qlonglong messageId, bool isPinned)
{
    if (isPinned)
    {
        emit chatPinnedMessageUpdated(chatId, messageId);
    }
    else
    {
        emit chatPinnedMessageUpdated(chatId, 0);
        requestSender->callGetChatPinnedMessage(chatId);
    }
}

void TDLibResponseHandler::handleUserPrivacySettingRules(const QVariantMap &rules)
{
    QVariantList newGivenRules = rules.value("rules").toList();
    // If nothing (or something unsupported is sent out) it is considered to be restricted completely
    auto newAppliedRule = TDLibConstants::UserPrivacySettingRule::RuleRestrictAll;
    QListIterator<QVariant> givenRulesIterator(newGivenRules);

    while (givenRulesIterator.hasNext())
    {
        QString givenRule = givenRulesIterator.next().toMap().value(_TYPE).toString();

        if (givenRule == "userPrivacySettingRuleAllowContacts")
            newAppliedRule = TDLibConstants::UserPrivacySettingRule::RuleAllowContacts;
        else if (givenRule == "userPrivacySettingRuleAllowAll")
            newAppliedRule = TDLibConstants::UserPrivacySettingRule::RuleAllowAll;
    }

    auto usedSetting = static_cast<TDLibConstants::UserPrivacySetting>(rules.value(_EXTRA).toInt());

    tdLibState->setUserPrivacySettingRule(usedSetting, newAppliedRule);
    emit userPrivacySettingUpdated(usedSetting, newAppliedRule);
}

void TDLibResponseHandler::handleUpdatedUserPrivacySettingRules(const QVariantMap &updatedRules)
{
    QString rawSetting = updatedRules.value("setting").toMap().value(_TYPE).toString();
    auto usedSetting = TDLibConstants::UserPrivacySetting::SettingUnknown;

    if (rawSetting == "userPrivacySettingAllowChatInvites")
        usedSetting = TDLibConstants::UserPrivacySetting::SettingAllowChatInvites;
    else if (rawSetting == "userPrivacySettingAllowFindingByPhoneNumber")
        usedSetting = TDLibConstants::UserPrivacySetting::SettingAllowFindingByPhoneNumber;
    else if (rawSetting == "userPrivacySettingShowLinkInForwardedMessages")
        usedSetting = TDLibConstants::UserPrivacySetting::SettingShowLinkInForwardedMessages;
    else if (rawSetting == "userPrivacySettingShowPhoneNumber")
        usedSetting = TDLibConstants::UserPrivacySetting::SettingShowPhoneNumber;
    else if (rawSetting == "userPrivacySettingShowProfilePhoto")
        usedSetting = TDLibConstants::UserPrivacySetting::SettingShowProfilePhoto;
    else if (rawSetting == "userPrivacySettingShowStatus")
        usedSetting = TDLibConstants::UserPrivacySetting::SettingShowStatus;
    if (usedSetting != TDLibConstants::UserPrivacySetting::SettingUnknown)
    {
        QVariantMap rawRules = updatedRules.value("rules").toMap();

        rawRules.insert(_EXTRA, usedSetting);
        handleUserPrivacySettingRules(rawRules);
    }
}

void TDLibResponseHandler::handleSponsoredMessage(qlonglong chatId, const QVariantMap &message)
{
    switch (_appSettings->getSponsoredMess())
    {
    case AppSettings::SponsoredMessHandle:
        emit sponsoredMessageReceived(chatId, message);
        break;
    case AppSettings::SponsoredMessAutoView:
        requestSender->callViewMessage(chatId, message.value(MESSAGE_ID).toULongLong(), false);
        break;
    case AppSettings::SponsoredMessIgnore:
        break;
    }
}

void TDLibResponseHandler::handleActiveEmojiReactionsUpdated(const QStringList &emojis)
{
    if (_activeEmojiReactions != emojis)
    {
        _activeEmojiReactions = emojis;
        emit reactionsUpdated();
    }
}

const TDLibResponseHandler::Group *TDLibResponseHandler::updateGroup(qlonglong groupId, const QVariantMap &groupInfo, QHash<qlonglong, Group *> *groups)
{
    Group *group = groups->value(groupId);

    if (!group)
    {
        group = new Group(groupId);
        groups->insert(groupId, group);
    }

    group->groupInfo = groupInfo;

    return group;
}

const TDLibResponseHandler::Group *TDLibResponseHandler::getGroup(qlonglong groupId) const
{
    if (groupId)
    {
        const Group *group = _superGroups.value(groupId);
        return group ? group : _basicGroups.value(groupId);
    }

    return Q_NULLPTR;
}

TDLibConstants::ChatMemberStatus TDLibResponseHandler::Group::chatMemberStatus() const
{
    const QString statusType(groupInfo.value(STATUS).toMap().value(_TYPE).toString());

    return statusType.isEmpty() ? TDLibConstants::ChatMemberStatusUnknown : TDLibConstants::chatMemberStatusFromString(statusType);
}