src/tdlibwrapper.cpp - develop - NeoChapay/telegraf

src/tdlibwrapper.cpp
2 906 строк100 KB
mbarashkov
Ещё ворнинги
28 дек 2024, 20:01
28 дек 2024, 20:014473647
#include "tdlibwrapper.h"
#include "tdlibsecrets.h"
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QGuiApplication>
#include <QLocale>
#include <QProcess>
#include <QSysInfo>
#include <QJsonDocument>
#include <QStandardPaths>
#include <QDBusConnection>
#include <QDBusInterface>
#include <QRegularExpression>
#include <QRegularExpressionMatch>
#include <QRegularExpressionMatchIterator>
#include <td/telegram/td_json_client.h>
#include <td/telegram/Client.h>
#include <td/telegram/td_api.h>

#define DEBUG_MODULE TDLibWrapper
#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 CHAT_ID[] = "chat_id";
    const char CHAT_FOLDER_ID[] = "chat_folder_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 USERNAMES[] = "usernames";
    const char EDITABLE_USERNAME[] = "editable_username";
    const char THREAD_ID[] = "thread_id";
    const char VALUE[] = "value";
    const char CHAT_LIST_TYPE[] = "chat_list_type";
    const char REPLY_TO_MESSAGE_ID[] = "reply_to_message_id";
    const char REPLY_TO[] = "reply_to";
    const char _TYPE[] = "@type";
    const char _EXTRA[] = "@extra";
    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[] = "reaction_type";
    const char REACTION_TYPE_EMOJI[] = "reactionTypeEmoji";
    const char EMOJI[] = "emoji";
    // const char TYPE_MESSAGE_REPLY_TO_MESSAGE[] = "messageReplyToMessage";
    const char TYPE_INPUT_MESSAGE_REPLY_TO_MESSAGE[] = "inputMessageReplyToMessage";
    const char ME_URL_PREFIX[] = "t_me_url";
    const char MY_ID_OPTION[] = "my_id";

}

TDLibWrapper::TDLibWrapper(AppSettings *settings, MceInterface *mce, QObject *parent)
    : QObject(parent),
      _tdLibClientId(td_create_client_id()),
      _manager(new QNetworkAccessManager(this)),
      _networkConfigurationManager(new QNetworkConfigurationManager(this)),
      _appSettings(settings),
      _mceInterface(mce),
      _authorizationState(AuthorizationState::Closed),
      _versionNumber(0),
      _joinChatRequested(false),
      _loggingOut(false)
{
    LOG("Initializing TD Lib...");

    initializeTDLibReceiver();
    QString tdLibDatabaseDirectoryPath = getApplicationDataPath() + "/tdlib";
    QDir tdLibDatabaseDirectory(tdLibDatabaseDirectoryPath);

    if (!tdLibDatabaseDirectory.exists())
    {
        tdLibDatabaseDirectory.mkpath(tdLibDatabaseDirectoryPath);
    }

    _dbusInterface = new DBusInterface(this);
    _appSettings->getUseOpenWith() ? initializeOpenWith() : removeOpenWith();

    connect(&_emojiSearchWorker, SIGNAL(searchCompleted(QString,QVariantList)),
            this, SLOT(handleEmojiSearchCompleted(QString,QVariantList)));

    connect(_appSettings, SIGNAL(useOpenWithChanged()), this, SLOT(handleOpenWithChanged()));
    connect(_appSettings, SIGNAL(storageOptimizerChanged()), this, SLOT(handleStorageOptimizerChanged()));
    connect(_networkConfigurationManager, SIGNAL(configurationChanged(QNetworkConfiguration)),
            this, SLOT(handleNetworkConfigurationChanged(QNetworkConfiguration)));

    setLogVerbosityLevel();
    setOptionInteger("notification_group_count_max", 5);
}

TDLibWrapper::~TDLibWrapper()
{
    LOG("Destroying TD Lib...");
    _tdLibReceiver->setActive(false);

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

    qDeleteAll(_basicGroups);
    qDeleteAll(_superGroups);
}

void TDLibWrapper::initializeTDLibReceiver()
{
    _tdLibReceiver = new TDLibReceiver(_tdLibClientId, 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)));

    _tdLibReceiver->start();
}

void TDLibWrapper::sendRequest(const QVariantMap &requestObject)
{
    if (_loggingOut)
    {
        LOG("Sending request to TD Lib skipped as logging out is in progress, object type name:" << requestObject.value(_TYPE).toString());
        return;
    }

    LOG("Sending request to TD Lib, object type name:" << requestObject.value(_TYPE).toString());

    QJsonDocument requestDocument = QJsonDocument::fromVariant(requestObject);

    VERBOSE(requestDocument.toJson().constData());
    //qDebug() << "Sender request string: " << requestDocument.toJson().constData();
    td_send(_tdLibClientId, requestDocument.toJson().constData());
}

QString TDLibWrapper::getVersion()
{
    return _versionString;
}

TDLibWrapper::AuthorizationState TDLibWrapper::getAuthorizationState()
{
    return _authorizationState;
}

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

TDLibWrapper::ConnectionState TDLibWrapper::getConnectionState()
{
    return _connectionState;
}

void TDLibWrapper::setAuthenticationPhoneNumber(const QString &phoneNumber)
{
    LOG("Set authentication phone number " << phoneNumber);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setAuthenticationPhoneNumber");
    requestObject.insert("phone_number", phoneNumber);

    QVariantMap phoneNumberSettings;

    phoneNumberSettings.insert("allow_flash_call", false);
    phoneNumberSettings.insert("is_current_phone_number", true);
    requestObject.insert("settings", phoneNumberSettings);
    sendRequest(requestObject);
}

void TDLibWrapper::setAuthenticationCode(const QString &authenticationCode)
{
    LOG("Set authentication code " << authenticationCode);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "checkAuthenticationCode");
    requestObject.insert("code", authenticationCode);
    sendRequest(requestObject);
}

void TDLibWrapper::setAuthenticationPassword(const QString &authenticationPassword)
{
    LOG("Set authentication password " << authenticationPassword);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "checkAuthenticationPassword");
    requestObject.insert("password", authenticationPassword);
    sendRequest(requestObject);
}

void TDLibWrapper::registerUser(const QString &firstName, const QString &lastName)
{
    LOG("Register User " << firstName << lastName);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "registerUser");
    requestObject.insert(FIRST_NAME, firstName);
    requestObject.insert(LAST_NAME, lastName);
    sendRequest(requestObject);
}

void TDLibWrapper::logout()
{
    LOG("Logging out");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "logOut");
    sendRequest(requestObject);
    _loggingOut = true;
}

void TDLibWrapper::getChats(const int limit)
{
    LOG("Getting chats");
    QVariantMap requestObject;
    requestObject.insert(_TYPE, "loadChats");
    requestObject.insert("limit", limit);
    sendRequest(requestObject);
}

void TDLibWrapper::chatListMain(const int limit)
{
    this->getChats(limit);
}


void TDLibWrapper::chatListArchive(const int limit)
{
    QVariantMap requestObject;
    requestObject.insert(_TYPE, "loadChats");
    QVariantMap chatListType;
    chatListType.insert(_TYPE, "chatListArchive");
    requestObject.insert("chat_list", chatListType);
    requestObject.insert("limit", limit);
    requestObject.insert(_EXTRA, "chatListArchive_extra_marker");
    sendRequest(requestObject);
}

void TDLibWrapper::chatListFolder(const qlonglong chatFolderId, const int limit)
{
    QVariantMap requestObject;
    requestObject.insert(_TYPE, "loadChats");
    QVariantMap chatListType;
    chatListType.insert(_TYPE, "chatListFolder");
    if (chatFolderId != 0)
        chatListType.insert("chat_folder_id", chatFolderId);

    requestObject.insert("chat_list", chatListType);
    requestObject.insert("limit", limit);
    requestObject.insert(_EXTRA, "chatListFilter_extra_marker");
    sendRequest(requestObject);
}
void TDLibWrapper::downloadFile(int fileId)
{
    LOG("Downloading file " << fileId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "downloadFile");
    requestObject.insert("file_id", fileId);
    requestObject.insert("synchronous", false);
    requestObject.insert("offset", 0);
    requestObject.insert("limit", 0);
    requestObject.insert("priority", 1);
    sendRequest(requestObject);
}

void TDLibWrapper::openChat(const QString &chatId)
{
    LOG("Opening chat " << chatId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "openChat");
    requestObject.insert(CHAT_ID, chatId);
    sendRequest(requestObject);
}

void TDLibWrapper::closeChat(const QString &chatId)
{
    LOG("Closing chat " << chatId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "closeChat");
    requestObject.insert(CHAT_ID, chatId);
    sendRequest(requestObject);
}

void TDLibWrapper::joinChat(const QString &chatId)
{
    LOG("Joining chat " << chatId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "joinChat");
    requestObject.insert(CHAT_ID, chatId);
    _joinChatRequested = true;
    sendRequest(requestObject);
}

void TDLibWrapper::leaveChat(const QString &chatId)
{
    LOG("Leaving chat " << chatId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "leaveChat");
    requestObject.insert(CHAT_ID, chatId);
    sendRequest(requestObject);
}

void TDLibWrapper::deleteChat(qlonglong chatId)
{
    LOG("Deleting chat " << chatId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "deleteChat");
    requestObject.insert(CHAT_ID, chatId);
    sendRequest(requestObject);
}

void TDLibWrapper::getChatFolder(qlonglong folderID)
{
    LOG("Getting chats for folder  " << folderID);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getChatFolder");
    requestObject.insert(CHAT_FOLDER_ID, folderID);
    sendRequest(requestObject);
}

void TDLibWrapper::getChatHistory(qlonglong chatId, qlonglong fromMessageId, int offset, int limit, bool onlyLocal)
{
    LOG("Retrieving chat history" << chatId << fromMessageId << offset << limit << onlyLocal);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getChatHistory");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("from_message_id", fromMessageId);
    requestObject.insert("offset", offset);
    requestObject.insert("limit", limit);
    requestObject.insert("only_local", onlyLocal);
    sendRequest(requestObject);
}

void TDLibWrapper::viewMessage(qlonglong chatId, qlonglong messageId, bool force)
{
    LOG("Mark message as viewed" << chatId << messageId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "viewMessages");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("force_read", force);

    QVariantList messageIds;

    messageIds.append(messageId);
    requestObject.insert("message_ids", messageIds);
    sendRequest(requestObject);
}

void TDLibWrapper::pinMessage(const QString &chatId, const QString &messageId, bool disableNotification)
{
    LOG("Pin message to chat" << chatId << messageId << disableNotification);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "pinChatMessage");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    requestObject.insert("disable_notification", disableNotification);
    sendRequest(requestObject);
}

void TDLibWrapper::unpinMessage(const QString &chatId, const QString &messageId)
{
    LOG("Unpin message from chat" << chatId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "unpinChatMessage");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    requestObject.insert(_EXTRA, "unpinChatMessage:" + chatId);
    sendRequest(requestObject);
}

static bool compareReplacements(const QVariant &replacement1, const QVariant &replacement2)
{
    const QVariantMap replacementMap1 = replacement1.toMap();
    const QVariantMap replacementMap2 = replacement2.toMap();

    return replacementMap1.value("startIndex").toInt() < replacementMap2.value("startIndex").toInt();
}

QVariantMap TDLibWrapper::newSendMessageRequest(qlonglong chatId, qlonglong replyToMessageId)
{
    QVariantMap request;

    request.insert(_TYPE, "sendMessage");
    request.insert(CHAT_ID, chatId);

    if (replyToMessageId)
    {
        QVariantMap replyTo;

        replyTo.insert(_TYPE, TYPE_INPUT_MESSAGE_REPLY_TO_MESSAGE);
        replyTo.insert(MESSAGE_ID, replyToMessageId);
        request.insert(REPLY_TO, replyTo);
    }

    return request;
}

void TDLibWrapper::sendTextMessage(qlonglong chatId, const QString &message, qlonglong replyToMessageId)
{
    LOG("Sending text message" << chatId << message << replyToMessageId);

    QVariantMap requestObject(newSendMessageRequest(chatId, replyToMessageId));
    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessageText");

    // Postprocess message (e.g. for @-mentioning)
    QString processedMessage = message;
    QVariantList replacements;
    QRegularExpression atMentionIdRegex("\\@(\\d+)\\(([^\\)]+)\\)");
    QRegularExpressionMatchIterator atMentionIdMatchIterator = atMentionIdRegex.globalMatch(processedMessage);

    while (atMentionIdMatchIterator.hasNext())
    {
        QRegularExpressionMatch nextAtMentionId = atMentionIdMatchIterator.next();

        LOG("@Mentioning with user ID! Start Index: " << nextAtMentionId.capturedStart(0) << ", length: " << nextAtMentionId.capturedLength(0) << ", user ID: " << nextAtMentionId.captured(1) << ", plain text: " << nextAtMentionId.captured(2));

        QVariantMap replacement;

        replacement.insert("startIndex", nextAtMentionId.capturedStart(0));
        replacement.insert("length", nextAtMentionId.capturedLength(0));
        replacement.insert("userId", nextAtMentionId.captured(1));
        replacement.insert("plainText", nextAtMentionId.captured(2));
        replacements.append(replacement);
    }

    QVariantMap formattedText;

    if (!replacements.isEmpty())
    {
        QVariantList entities;
        std::sort(replacements.begin(), replacements.end(), compareReplacements);
        QListIterator<QVariant> replacementsIterator(replacements);
        int offsetCorrection = 0;

        while (replacementsIterator.hasNext())
        {
            QVariantMap nextReplacement = replacementsIterator.next().toMap();
            int replacementStartOffset = nextReplacement.value("startIndex").toInt();
            int replacementLength = nextReplacement.value("length").toInt();
            QString replacementPlainText = nextReplacement.value("plainText").toString();

            processedMessage = processedMessage.replace(replacementStartOffset - offsetCorrection, replacementLength, replacementPlainText);

            QVariantMap entity;

            entity.insert("offset", replacementStartOffset - offsetCorrection);
            entity.insert("length", replacementPlainText.length());

            QVariantMap entityType;

            entityType.insert(_TYPE, "textEntityTypeMentionName");
            entityType.insert("user_id", nextReplacement.value("userId").toString());
            entity.insert(TYPE, entityType);
            entities.append(entity);
            offsetCorrection += replacementLength - replacementPlainText.length();
        }

        formattedText.insert("entities", entities);
    }

    formattedText.insert("text", processedMessage);
    formattedText.insert(_TYPE, "formattedText");
    inputMessageContent.insert("text", formattedText);
    requestObject.insert("input_message_content", inputMessageContent);
    sendRequest(requestObject);
}

void TDLibWrapper::sendPhotoMessage(qlonglong chatId, const QString &filePath, const QString &message, qlonglong replyToMessageId)
{
    LOG("Sending photo message" << chatId << filePath << message << replyToMessageId);
    QVariantMap requestObject(newSendMessageRequest(chatId, replyToMessageId));
    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessagePhoto");

    QVariantMap formattedText;

    formattedText.insert("text", message);
    formattedText.insert(_TYPE, "formattedText");
    inputMessageContent.insert("caption", formattedText);

    QVariantMap photoInputFile;

    photoInputFile.insert(_TYPE, "inputFileLocal");
    photoInputFile.insert("path", filePath);
    inputMessageContent.insert("photo", photoInputFile);
    requestObject.insert("input_message_content", inputMessageContent);
    sendRequest(requestObject);
}

void TDLibWrapper::sendVideoMessage(qlonglong chatId, const QString &filePath, const QString &message, qlonglong replyToMessageId)
{
    LOG("Sending video message" << chatId << filePath << message << replyToMessageId);

    QVariantMap requestObject(newSendMessageRequest(chatId, replyToMessageId));
    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessageVideo");

    QVariantMap formattedText;

    formattedText.insert("text", message);
    formattedText.insert(_TYPE, "formattedText");
    inputMessageContent.insert("caption", formattedText);

    QVariantMap videoInputFile;

    videoInputFile.insert(_TYPE, "inputFileLocal");
    videoInputFile.insert("path", filePath);
    inputMessageContent.insert("video", videoInputFile);
    requestObject.insert("input_message_content", inputMessageContent);
    sendRequest(requestObject);
}

void TDLibWrapper::sendDocumentMessage(qlonglong chatId, const QString &filePath, const QString &message, qlonglong replyToMessageId)
{
    LOG("Sending document message" << chatId << filePath << message << replyToMessageId);

    QVariantMap requestObject(newSendMessageRequest(chatId, replyToMessageId));
    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessageDocument");

    QVariantMap formattedText;

    formattedText.insert("text", message);
    formattedText.insert(_TYPE, "formattedText");
    inputMessageContent.insert("caption", formattedText);

    QVariantMap documentInputFile;

    documentInputFile.insert(_TYPE, "inputFileLocal");
    documentInputFile.insert("path", filePath);
    inputMessageContent.insert("document", documentInputFile);
    requestObject.insert("input_message_content", inputMessageContent);
    sendRequest(requestObject);
}

void TDLibWrapper::sendVoiceNoteMessage(qlonglong chatId, const QString &filePath, const QString &message, qlonglong replyToMessageId)
{
    LOG("Sending voice note message" << chatId << filePath << message << replyToMessageId);

    QVariantMap requestObject(newSendMessageRequest(chatId, replyToMessageId));
    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessageVoiceNote");

    QVariantMap formattedText;

    formattedText.insert("text", message);
    formattedText.insert(_TYPE, "formattedText");
    inputMessageContent.insert("caption", formattedText);

    QVariantMap documentInputFile;

    documentInputFile.insert(_TYPE, "inputFileLocal");
    documentInputFile.insert("path", filePath);
    inputMessageContent.insert("voice_note", documentInputFile);
    requestObject.insert("input_message_content", inputMessageContent);
    sendRequest(requestObject);
}

void TDLibWrapper::sendLocationMessage(qlonglong chatId, double latitude, double longitude, double horizontalAccuracy, qlonglong replyToMessageId)
{
    LOG("Sending location message" << chatId << latitude << longitude << horizontalAccuracy << replyToMessageId);

    QVariantMap requestObject(newSendMessageRequest(chatId, replyToMessageId));
    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessageLocation");

    QVariantMap location;

    location.insert("latitude", latitude);
    location.insert("longitude", longitude);
    location.insert("horizontal_accuracy", horizontalAccuracy);
    location.insert(_TYPE, "location");
    inputMessageContent.insert("location", location);
    inputMessageContent.insert("live_period", 0);
    inputMessageContent.insert("heading", 0);
    inputMessageContent.insert("proximity_alert_radius", 0);
    requestObject.insert("input_message_content", inputMessageContent);
    sendRequest(requestObject);
}

void TDLibWrapper::sendStickerMessage(qlonglong chatId, const QString &fileId, qlonglong replyToMessageId)
{
    LOG("Sending sticker message" << chatId << fileId << replyToMessageId);

    QVariantMap requestObject(newSendMessageRequest(chatId, replyToMessageId));
    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessageSticker");

    QVariantMap stickerInputFile;

    stickerInputFile.insert(_TYPE, "inputFileRemote");
    stickerInputFile.insert(ID, fileId);
    inputMessageContent.insert("sticker", stickerInputFile);
    requestObject.insert("input_message_content", inputMessageContent);
    sendRequest(requestObject);
}

void TDLibWrapper::sendPollMessage(qlonglong chatId, const QString &question, const QVariantList &options, bool anonymous, int correctOption, bool multiple, const QString &explanation, qlonglong replyToMessageId)
{
    LOG("Sending poll message" << chatId << question << replyToMessageId);

    QVariantMap requestObject(newSendMessageRequest(chatId, replyToMessageId));
    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessagePoll");

    QVariantMap pollType;

    if (correctOption > -1)
    {
        pollType.insert(_TYPE, "pollTypeQuiz");
        pollType.insert("correct_option_id", correctOption);

        if (!explanation.isEmpty())
        {
            QVariantMap formattedExplanation;

            formattedExplanation.insert("text", explanation);
            pollType.insert("explanation", formattedExplanation);
        }
    }
    else
    {
        pollType.insert(_TYPE, "pollTypeRegular");
        pollType.insert("allow_multiple_answers", multiple);
    }

    inputMessageContent.insert(TYPE, pollType);
    inputMessageContent.insert("question", question);
    inputMessageContent.insert("options", options);
    inputMessageContent.insert("is_anonymous", anonymous);
    requestObject.insert("input_message_content", inputMessageContent);
    sendRequest(requestObject);
}

void TDLibWrapper::forwardMessages(const QString &chatId, const QString &fromChatId, const QVariantList &messageIds, bool sendCopy, bool removeCaption)
{
    LOG("Forwarding messages" << chatId << fromChatId << messageIds);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "forwardMessages");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("from_chat_id", fromChatId);
    requestObject.insert("message_ids", messageIds);
    requestObject.insert("send_copy", sendCopy);
    requestObject.insert("remove_caption", removeCaption);
    sendRequest(requestObject);
}

void TDLibWrapper::getMessage(qlonglong chatId, qlonglong messageId)
{
    LOG("Retrieving message" << chatId << messageId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getMessage");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    requestObject.insert(_EXTRA, QString("getMessage:%1:%2").arg(chatId).arg(messageId));
    sendRequest(requestObject);
}

void TDLibWrapper::getMessageLinkInfo(const QString &url, const QString &extra)
{
    LOG("Retrieving message link info" << url << extra);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getMessageLinkInfo");
    requestObject.insert("url", url);
    requestObject.insert(_EXTRA, extra == "" ? url : url + "|" + extra);
    sendRequest(requestObject);
}

void TDLibWrapper::getExternalLinkInfo(const QString &url, const QString &extra)
{
    LOG("Retrieving external link info" << url << extra);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getExternalLinkInfo");
    requestObject.insert("url", url);
    requestObject.insert(_EXTRA, extra == "" ? url : url + "|" + extra);
    sendRequest(requestObject);
}

void TDLibWrapper::getCallbackQueryAnswer(const QString &chatId, const QString &messageId, const QVariantMap &payload)
{
    LOG("Getting Callback Query Answer" << chatId << messageId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getCallbackQueryAnswer");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    requestObject.insert("payload", payload);
    sendRequest(requestObject);
}

void TDLibWrapper::getChatPinnedMessage(qlonglong chatId)
{
    LOG("Retrieving pinned message" << chatId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getChatPinnedMessage");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(_EXTRA, "getChatPinnedMessage:" + QString::number(chatId));
    sendRequest(requestObject);
}

void TDLibWrapper::getChatSponsoredMessage(qlonglong chatId)
{
    LOG("Retrieving sponsored message" << chatId);

    QVariantMap requestObject;

    // getChatSponsoredMessage has been replaced with getChatSponsoredMessages
    // between 1.8.7 and 1.8.8
    // See https://github.com/tdlib/td/commit/ec1310a
    requestObject.insert(_TYPE, QString((_versionNumber > VERSION_NUMBER(1, 8, 7)) ? "getChatSponsoredMessages" : "getChatSponsoredMessage"));
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(_EXTRA, chatId); // see TDLibReceiver::processSponsoredMessage
    sendRequest(requestObject);
}

void TDLibWrapper::setOptionInteger(const QString &optionName, int optionValue)
{
    LOG("Setting integer option" << optionName << optionValue);

    setOption(optionName, "optionValueInteger", optionValue);
}

void TDLibWrapper::setOptionBoolean(const QString &optionName, bool optionValue)
{
    LOG("Setting boolean option" << optionName << optionValue);

    setOption(optionName, "optionValueBoolean", optionValue);
}

void TDLibWrapper::setOption(const QString &name, const QString &type, const QVariant &value)
{
    QVariantMap optionValue;

    optionValue.insert(_TYPE, type);
    optionValue.insert(VALUE, value);

    QVariantMap request;

    request.insert(_TYPE, "setOption");
    request.insert("name", name);
    request.insert(VALUE, optionValue);
    sendRequest(request);
}

void TDLibWrapper::setChatNotificationSettings(const QString &chatId, const QVariantMap &notificationSettings)
{
    LOG("Notification settings for chat " << chatId << notificationSettings);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setChatNotificationSettings");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("notification_settings", notificationSettings);
    sendRequest(requestObject);
}

void TDLibWrapper::editMessageText(const QString &chatId, const QString &messageId, const QString &message)
{
    LOG("Editing message text" << chatId << messageId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "editMessageText");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);

    QVariantMap inputMessageContent;

    inputMessageContent.insert(_TYPE, "inputMessageText");

    QVariantMap formattedText;

    formattedText.insert("text", message);
    inputMessageContent.insert("text", formattedText);
    requestObject.insert("input_message_content", inputMessageContent);
    sendRequest(requestObject);
}

void TDLibWrapper::deleteMessages(const QString &chatId, const QVariantList messageIds)
{
    LOG("Deleting some messages" << chatId << messageIds);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "deleteMessages");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("message_ids", messageIds);
    requestObject.insert("revoke", true);
    sendRequest(requestObject);
}

void TDLibWrapper::getMapThumbnailFile(const QString &chatId, double latitude, double longitude, int width, int height, const QString &extra)
{
    LOG("Getting Map Thumbnail File" << chatId);

    QVariantMap location;

    location.insert("latitude", latitude);
    location.insert("longitude", longitude);

    // ensure dimensions are in bounds (16 - 1024)
    int boundsWidth = std::min(std::max(width, 16), 1024);
    int boundsHeight = std::min(std::max(height, 16), 1024);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getMapThumbnailFile");
    requestObject.insert("location", location);
    requestObject.insert("zoom", 17); // 13-20
    requestObject.insert("width", boundsWidth);
    requestObject.insert("height", boundsHeight);
    requestObject.insert("scale", 1); // 1-3
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(_EXTRA, extra);
    sendRequest(requestObject);
}

void TDLibWrapper::getRecentStickers()
{
    LOG("Retrieving recent stickers");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getRecentStickers");
    sendRequest(requestObject);
}

void TDLibWrapper::getInstalledStickerSets()
{
    LOG("Retrieving installed sticker sets");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getInstalledStickerSets");
    sendRequest(requestObject);
}

void TDLibWrapper::getStickerSet(const QString &setId)
{
    LOG("Retrieving sticker set" << setId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getStickerSet");
    requestObject.insert("set_id", setId);
    sendRequest(requestObject);
}
void TDLibWrapper::getSupergroupMembers(const QString &groupId, int limit, int offset)
{
    LOG("Retrieving SupergroupMembers");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getSupergroupMembers");
    requestObject.insert(_EXTRA, groupId);
    requestObject.insert("supergroup_id", groupId);
    requestObject.insert("offset", offset);
    requestObject.insert("limit", limit);
    sendRequest(requestObject);
}

void TDLibWrapper::getGroupFullInfo(const QString &groupId, bool isSuperGroup)
{
    LOG("Retrieving GroupFullInfo");

    QVariantMap requestObject;

    if (isSuperGroup)
    {
        requestObject.insert(_TYPE, "getSupergroupFullInfo");
        requestObject.insert("supergroup_id", groupId);
    }
    else
    {
        requestObject.insert(_TYPE, "getBasicGroupFullInfo");
        requestObject.insert("basic_group_id", groupId);
    }

    requestObject.insert(_EXTRA, groupId);
    sendRequest(requestObject);
}

void TDLibWrapper::getUserFullInfo(const QString &userId)
{
    LOG("Retrieving UserFullInfo" << userId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getUserFullInfo");
    requestObject.insert(_EXTRA, userId);
    requestObject.insert("user_id", userId);
    sendRequest(requestObject);
}

void TDLibWrapper::createPrivateChat(const QString &userId, const QString &extra)
{
    LOG("Creating Private Chat");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "createPrivateChat");
    requestObject.insert("user_id", userId);
    requestObject.insert(_EXTRA, extra); //"openDirectly"/"openAndSendStartToBot:[optional parameter]" gets matched in qml
    sendRequest(requestObject);
}

void TDLibWrapper::createNewSecretChat(const QString &userId, const QString &extra)
{
    LOG("Creating new secret chat");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "createNewSecretChat");
    requestObject.insert("user_id", userId);
    requestObject.insert(_EXTRA, extra); //"openDirectly" gets matched in qml
    sendRequest(requestObject);
}

void TDLibWrapper::createSupergroupChat(const QString &supergroupId, const QString &extra)
{
    LOG("Creating Supergroup Chat");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "createSupergroupChat");
    requestObject.insert("supergroup_id", supergroupId);
    requestObject.insert(_EXTRA, extra); //"openDirectly" gets matched in qml
    sendRequest(requestObject);
}

void TDLibWrapper::createBasicGroupChat(const QString &basicGroupId, const QString &extra)
{
    LOG("Creating Basic Group Chat");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "createBasicGroupChat");
    requestObject.insert("basic_group_id", basicGroupId);
    requestObject.insert(_EXTRA, extra); //"openDirectly"/"openAndSend:*" gets matched in qml
    sendRequest(requestObject);
}

void TDLibWrapper::getGroupsInCommon(const QString &userId, int limit, int offset)
{
    LOG("Retrieving Groups in Common");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getGroupsInCommon");
    requestObject.insert(_EXTRA, userId);
    requestObject.insert("user_id", userId);
    requestObject.insert("offset", offset);
    requestObject.insert("limit", limit);
    sendRequest(requestObject);
}

void TDLibWrapper::getUserProfilePhotos(const QString &userId, int limit, int offset)
{
    LOG("Retrieving User Profile Photos");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getUserProfilePhotos");
    requestObject.insert(_EXTRA, userId);
    requestObject.insert("user_id", userId);
    requestObject.insert("offset", offset);
    requestObject.insert("limit", limit);
    sendRequest(requestObject);
}

void TDLibWrapper::setChatPermissions(const QString &chatId, const QVariantMap &chatPermissions)
{
    LOG("Setting Chat Permissions");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setChatPermissions");
    requestObject.insert(_EXTRA, chatId);
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("permissions", chatPermissions);
    sendRequest(requestObject);
}

void TDLibWrapper::setChatSlowModeDelay(const QString &chatId, int delay)
{

    LOG("Setting Chat Slow Mode Delay");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setChatSlowModeDelay");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("slow_mode_delay", delay);
    sendRequest(requestObject);
}

void TDLibWrapper::setChatDescription(const QString &chatId, const QString &description)
{
    LOG("Setting Chat Description");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setChatDescription");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("description", description);
    sendRequest(requestObject);
}

void TDLibWrapper::setChatTitle(const QString &chatId, const QString &title)
{
    LOG("Setting Chat Title");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setChatTitle");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("title", title);
    sendRequest(requestObject);
}

void TDLibWrapper::setBio(const QString &bio)
{
    LOG("Setting Bio");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setBio");
    requestObject.insert("bio", bio);
    sendRequest(requestObject);
}

void TDLibWrapper::toggleSupergroupIsAllHistoryAvailable(const QString &groupId, bool isAllHistoryAvailable)
{
    LOG("Toggling SupergroupIsAllHistoryAvailable");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "toggleSupergroupIsAllHistoryAvailable");
    requestObject.insert("supergroup_id", groupId);
    requestObject.insert("is_all_history_available", isAllHistoryAvailable);
    sendRequest(requestObject);
}

void TDLibWrapper::setPollAnswer(const QString &chatId, qlonglong messageId, QVariantList optionIds)
{
    LOG("Setting Poll Answer");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setPollAnswer");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    requestObject.insert("option_ids", optionIds);
    sendRequest(requestObject);
}

void TDLibWrapper::stopPoll(const QString &chatId, qlonglong messageId)
{
    LOG("Stopping Poll");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "stopPoll");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    sendRequest(requestObject);
}

void TDLibWrapper::getPollVoters(const QString &chatId, qlonglong messageId, int optionId, int limit, int offset, const QString &extra)
{
    LOG("Retrieving Poll Voters");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getPollVoters");
    requestObject.insert(_EXTRA, extra);
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    requestObject.insert("option_id", optionId);
    requestObject.insert("offset", offset);
    requestObject.insert("limit", limit); // max 50
    sendRequest(requestObject);
}

void TDLibWrapper::searchPublicChat(const QString &userName, bool doOpenOnFound)
{
    LOG("Search public chat" << userName);

    if (doOpenOnFound)
        _activeChatSearchName = userName;

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "searchPublicChat");
    requestObject.insert(_EXTRA, "searchPublicChat:" + userName);
    requestObject.insert(USERNAME, userName);
    sendRequest(requestObject);
}

void TDLibWrapper::joinChatByInviteLink(const QString &inviteLink)
{
    LOG("Join chat by invite link" << inviteLink);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "joinChatByInviteLink");
    requestObject.insert("invite_link", inviteLink);
    _joinChatRequested = true;
    sendRequest(requestObject);
}

void TDLibWrapper::getDeepLinkInfo(const QString &link)
{
    LOG("Resolving TG deep link" << link);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getDeepLinkInfo");
    requestObject.insert("link", link);
    sendRequest(requestObject);
}

void TDLibWrapper::getContacts()
{
    LOG("Retrieving contacts");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getContacts");
    requestObject.insert(_EXTRA, "contactsRequested");
    sendRequest(requestObject);
}

void TDLibWrapper::getSecretChat(qlonglong secretChatId)
{
    LOG("Getting detailed information about secret chat" << secretChatId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getSecretChat");
    requestObject.insert("secret_chat_id", secretChatId);
    sendRequest(requestObject);
}

void TDLibWrapper::closeSecretChat(qlonglong secretChatId)
{
    LOG("Closing secret chat" << secretChatId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "closeSecretChat");
    requestObject.insert("secret_chat_id", secretChatId);
    sendRequest(requestObject);
}

void TDLibWrapper::importContacts(const QVariantList &contacts)
{
    LOG("Importing contacts");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "importContacts");
    requestObject.insert("contacts", contacts);
    sendRequest(requestObject);
}

void TDLibWrapper::searchChatMessages(qlonglong chatId, const QString &query, qlonglong fromMessageId)
{
    LOG("Searching for messages" << chatId << query << fromMessageId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "searchChatMessages");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("query", query);
    requestObject.insert("from_message_id", fromMessageId);
    requestObject.insert("offset", 0);
    requestObject.insert("limit", 50);
    requestObject.insert(_EXTRA, "searchChatMessages");
    sendRequest(requestObject);
}

void TDLibWrapper::searchPublicChats(const QString &query)
{
    LOG("Searching public chats" << query);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "searchPublicChats");
    requestObject.insert("query", query);
    requestObject.insert(_EXTRA, "searchPublicChats");
    sendRequest(requestObject);
}

void TDLibWrapper::readAllChatMentions(qlonglong chatId)
{
    LOG("Read all chat mentions" << chatId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "readAllChatMentions");
    requestObject.insert(CHAT_ID, chatId);
    sendRequest(requestObject);
}

void TDLibWrapper::readAllChatReactions(qlonglong chatId)
{
    LOG("Read all chat reactions" << chatId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "readAllChatReactions");
    requestObject.insert(CHAT_ID, chatId);
    sendRequest(requestObject);
}

void TDLibWrapper::toggleChatIsMarkedAsUnread(qlonglong chatId, bool isMarkedAsUnread)
{
    LOG("Toggle chat is marked as unread" << chatId << isMarkedAsUnread);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "toggleChatIsMarkedAsUnread");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("is_marked_as_unread", isMarkedAsUnread);
    sendRequest(requestObject);
}

void TDLibWrapper::toggleChatIsPinned(qlonglong chatId, bool isPinned, QString folder, qlonglong folderId)
{
    LOG("Toggle chat is pinned" << chatId << isPinned);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "toggleChatIsPinned");

    QVariantMap chatListMap;

    if (folder.contains(CHAT_LIST_MAIN)) {
        chatListMap.insert(_TYPE, CHAT_LIST_MAIN);
    }

    if (folder.contains(CHAT_LIST_ARCHIVE)) {
        chatListMap.insert(_TYPE, CHAT_LIST_ARCHIVE);
    }

    if (folder.contains(CHAT_LIST_FOLDER)) {
        chatListMap.insert(_TYPE, CHAT_LIST_FOLDER);
        if (folderId != 0)
            chatListMap.insert("chat_folder_id", folderId);
    }

    requestObject.insert("chat_list", chatListMap);
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("is_pinned", isPinned);

    //requestObject.insert("is_marked_as_unread", isPinned);

    sendRequest(requestObject);
}

void TDLibWrapper::setChatDraftMessage(qlonglong chatId, qlonglong threadId, qlonglong replyToMessageId, const QString &draft)
{
    LOG("Set Draft Message" << chatId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setChatDraftMessage");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(THREAD_ID, threadId);

    QVariantMap draftMessage;
    QVariantMap inputMessageContent;
    QVariantMap formattedText;

    formattedText.insert("text", draft);
    formattedText.insert("clear_draft", draft.isEmpty());
    formattedText.insert(_TYPE, "formattedText");
    inputMessageContent.insert(_TYPE, "inputMessageText");
    inputMessageContent.insert("text", formattedText);
    draftMessage.insert(_TYPE, "draftMessage");
    draftMessage.insert("input_message_text", inputMessageContent);

    if (_versionNumber > VERSION_NUMBER(1, 8, 20))
    {
        QVariantMap replyTo;

        replyTo.insert(_TYPE, TYPE_INPUT_MESSAGE_REPLY_TO_MESSAGE);
        replyTo.insert(CHAT_ID, chatId);
        replyTo.insert(MESSAGE_ID, replyToMessageId);
        draftMessage.insert(REPLY_TO, replyTo);
    }
    else
        draftMessage.insert(REPLY_TO_MESSAGE_ID, replyToMessageId);

    requestObject.insert("draft_message", draftMessage);
    sendRequest(requestObject);
}

void TDLibWrapper::getInlineQueryResults(qlonglong botUserId, qlonglong chatId, const QVariantMap &userLocation, const QString &query, const QString &offset, const QString &extra)
{
    LOG("Get Inline Query Results" << chatId << query);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getInlineQueryResults");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("bot_user_id", botUserId);

    if (!userLocation.isEmpty())
        requestObject.insert("user_location", userLocation);

    requestObject.insert("query", query);
    requestObject.insert("offset", offset);
    requestObject.insert(_EXTRA, extra);
    sendRequest(requestObject);
}

void TDLibWrapper::sendInlineQueryResultMessage(qlonglong chatId, qlonglong threadId, qlonglong replyToMessageId, const QString &queryId, const QString &resultId)
{

    LOG("Send Inline Query Result Message" << chatId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "sendInlineQueryResultMessage");
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("message_thread_id", threadId);
    requestObject.insert("reply_to_message_id", replyToMessageId);
    requestObject.insert("query_id", queryId);
    requestObject.insert("result_id", resultId);
    sendRequest(requestObject);
}

void TDLibWrapper::sendBotStartMessage(qlonglong botUserId, qlonglong chatId, const QString &parameter, const QString &extra)
{
    LOG("Send Bot Start Message" << botUserId << chatId << parameter << extra);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "sendBotStartMessage");
    requestObject.insert("bot_user_id", botUserId);
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert("parameter", parameter);
    requestObject.insert(_EXTRA, extra);
    sendRequest(requestObject);
}

void TDLibWrapper::cancelDownloadFile(int fileId)
{
    LOG("Cancel Download File" << fileId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "cancelDownloadFile");
    requestObject.insert("file_id", fileId);
    requestObject.insert("only_if_pending", false);
    sendRequest(requestObject);
}

void TDLibWrapper::cancelUploadFile(int fileId)
{
    LOG("Cancel Upload File" << fileId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "cancelUploadFile");
    requestObject.insert("file_id", fileId);
    sendRequest(requestObject);
}

void TDLibWrapper::deleteFile(int fileId)
{
    LOG("Delete cached File" << fileId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "deleteFile");
    requestObject.insert("file_id", fileId);
    sendRequest(requestObject);
}

void TDLibWrapper::setName(const QString &firstName, const QString &lastName)
{
    LOG("Set name of current user" << firstName << lastName);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setName");
    requestObject.insert("first_name", firstName);
    requestObject.insert("last_name", lastName);
    sendRequest(requestObject);
}

void TDLibWrapper::setUsername(const QString &userName)
{
    LOG("Set username of current user" << userName);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setUsername");
    requestObject.insert("username", userName);
    sendRequest(requestObject);
}

void TDLibWrapper::setUserPrivacySettingRule(TDLibWrapper::UserPrivacySetting setting, TDLibWrapper::UserPrivacySettingRule rule)
{
    LOG("Set user privacy setting rule of current user" << setting << rule);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setUserPrivacySettingRules");

    QVariantMap settingMap;

    switch (setting)
    {
    case SettingShowStatus:
        settingMap.insert(_TYPE, "userPrivacySettingShowStatus");
        break;
    case SettingShowPhoneNumber:
        settingMap.insert(_TYPE, "userPrivacySettingShowPhoneNumber");
        break;
    case SettingAllowChatInvites:
        settingMap.insert(_TYPE, "userPrivacySettingAllowChatInvites");
        break;
    case SettingShowProfilePhoto:
        settingMap.insert(_TYPE, "userPrivacySettingShowProfilePhoto");
        break;
    case SettingAllowFindingByPhoneNumber:
        settingMap.insert(_TYPE, "userPrivacySettingAllowFindingByPhoneNumber");
        break;
    case SettingShowLinkInForwardedMessages:
        settingMap.insert(_TYPE, "userPrivacySettingShowLinkInForwardedMessages");
        break;
    case SettingUnknown:
        return;
    }

    requestObject.insert("setting", settingMap);

    QVariantMap ruleMap;

    switch (rule)
    {
    case RuleAllowAll:
        ruleMap.insert(_TYPE, "userPrivacySettingRuleAllowAll");
        break;
    case RuleAllowContacts:
        ruleMap.insert(_TYPE, "userPrivacySettingRuleAllowContacts");
        break;
    case RuleRestrictAll:
        ruleMap.insert(_TYPE, "userPrivacySettingRuleRestrictAll");
        break;
    }

    QVariantList ruleMaps;

    ruleMaps.append(ruleMap);

    QVariantMap encapsulatedRules;

    encapsulatedRules.insert(_TYPE, "userPrivacySettingRules");
    encapsulatedRules.insert("rules", ruleMaps);
    requestObject.insert("rules", encapsulatedRules);
    sendRequest(requestObject);
}

void TDLibWrapper::getUserPrivacySettingRules(TDLibWrapper::UserPrivacySetting setting)
{
    LOG("Getting user privacy setting rules of current user" << setting);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getUserPrivacySettingRules");
    requestObject.insert(_EXTRA, setting);

    QVariantMap settingMap;

    switch (setting)
    {
    case SettingShowStatus:
        settingMap.insert(_TYPE, "userPrivacySettingShowStatus");
        break;
    case SettingShowPhoneNumber:
        settingMap.insert(_TYPE, "userPrivacySettingShowPhoneNumber");
        break;
    case SettingAllowChatInvites:
        settingMap.insert(_TYPE, "userPrivacySettingAllowChatInvites");
        break;
    case SettingShowProfilePhoto:
        settingMap.insert(_TYPE, "userPrivacySettingShowProfilePhoto");
        break;
    case SettingAllowFindingByPhoneNumber:
        settingMap.insert(_TYPE, "userPrivacySettingAllowFindingByPhoneNumber");
        break;
    case SettingShowLinkInForwardedMessages:
        settingMap.insert(_TYPE, "userPrivacySettingShowLinkInForwardedMessages");
        break;
    case SettingUnknown:
        return;
    }

    requestObject.insert("setting", settingMap);
    sendRequest(requestObject);
}

void TDLibWrapper::setProfilePhoto(const QString &filePath)
{
    LOG("Set a profile photo" << filePath);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setProfilePhoto");
    requestObject.insert(_EXTRA, "setProfilePhoto");

    QVariantMap inputChatPhoto;

    inputChatPhoto.insert(_TYPE, "inputChatPhotoStatic");

    QVariantMap inputFile;

    inputFile.insert(_TYPE, "inputFileLocal");
    inputFile.insert("path", filePath);
    inputChatPhoto.insert("photo", inputFile);
    requestObject.insert("photo", inputChatPhoto);
    sendRequest(requestObject);
}

void TDLibWrapper::deleteProfilePhoto(const QString &profilePhotoId)
{
    LOG("Delete a profile photo" << profilePhotoId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "deleteProfilePhoto");
    requestObject.insert(_EXTRA, "deleteProfilePhoto");
    requestObject.insert("profile_photo_id", profilePhotoId);
    sendRequest(requestObject);
}

void TDLibWrapper::changeStickerSet(const QString &stickerSetId, bool isInstalled)
{
    LOG("Change sticker set" << stickerSetId << isInstalled);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "changeStickerSet");
    requestObject.insert(_EXTRA, isInstalled ? "installStickerSet" : "removeStickerSet");
    requestObject.insert("set_id", stickerSetId);
    requestObject.insert("is_installed", isInstalled);
    sendRequest(requestObject);
}

void TDLibWrapper::getActiveSessions()
{
    LOG("Get active sessions");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getActiveSessions");
    sendRequest(requestObject);
}

void TDLibWrapper::terminateSession(const QString &sessionId)
{
    LOG("Terminate session" << sessionId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "terminateSession");
    requestObject.insert(_EXTRA, "terminateSession");
    requestObject.insert("session_id", sessionId);
    sendRequest(requestObject);
}

void TDLibWrapper::getMessageAvailableReactions(qlonglong chatId, qlonglong messageId)
{
    LOG("Get available reactions for message" << chatId << messageId);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "getMessageAvailableReactions");
    requestObject.insert(_EXTRA, QString::number(messageId));
    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    sendRequest(requestObject);
}

void TDLibWrapper::getPageSource(const QString &address)
{
    QUrl url = QUrl(address);
    QNetworkRequest request(url);

    request.setAttribute(QNetworkRequest::FollowRedirectsAttribute, true);
    request.setHeader(QNetworkRequest::UserAgentHeader, "Telegraf Bot (Aurora OS)");
    request.setRawHeader(QByteArray("Accept"), QByteArray("text/html,application/xhtml+xml"));
    request.setRawHeader(QByteArray("Accept-Charset"), QByteArray("utf-8"));
    request.setRawHeader(QByteArray("Connection"), QByteArray("close"));
    request.setRawHeader(QByteArray("Cache-Control"), QByteArray("max-age=0"));

    QNetworkReply *reply = _manager->get(request);

    connect(reply, SIGNAL(finished()), this, SLOT(handleGetPageSourceFinished()));
}

void TDLibWrapper::addMessageReaction(qlonglong chatId, qlonglong messageId, const QString &reaction)
{
    QVariantMap requestObject;

    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);
    requestObject.insert("is_big", false);

    if (_versionNumber > VERSION_NUMBER(1, 8, 5))
    {
        // "reaction_type": {
        //     "@type": "reactionTypeEmoji",
        //     "emoji": "..."
        // }
        QVariantMap reactionType;

        reactionType.insert(_TYPE, REACTION_TYPE_EMOJI);
        reactionType.insert(EMOJI, reaction);
        requestObject.insert(REACTION_TYPE, reactionType);
        requestObject.insert(_TYPE, "addMessageReaction");

        LOG("Add message reaction" << chatId << messageId << reaction);
    }
    else
    {
        requestObject.insert("reaction", reaction);
        requestObject.insert(_TYPE, "setMessageReaction");

        LOG("Toggle message reaction" << chatId << messageId << reaction);
    }

    sendRequest(requestObject);
}

void TDLibWrapper::removeMessageReaction(qlonglong chatId, qlonglong messageId, const QString &reaction)
{
    QVariantMap requestObject;

    requestObject.insert(CHAT_ID, chatId);
    requestObject.insert(MESSAGE_ID, messageId);

    if (_versionNumber > VERSION_NUMBER(1, 8, 5))
    {
        // "reaction_type": {
        //     "@type": "reactionTypeEmoji",
        //     "emoji": "..."
        // }
        QVariantMap reactionType;

        reactionType.insert(_TYPE, REACTION_TYPE_EMOJI);
        reactionType.insert(EMOJI, reaction);
        requestObject.insert(REACTION_TYPE, reactionType);
        requestObject.insert(_TYPE, "removeMessageReaction");

        LOG("Remove message reaction" << chatId << messageId << reaction);
    }
    else
    {
        requestObject.insert("reaction", reaction);
        requestObject.insert(_TYPE, "setMessageReaction");

        LOG("Toggle message reaction" << chatId << messageId << reaction);
    }

    sendRequest(requestObject);
}

void TDLibWrapper::setNetworkType(NetworkType networkType)
{
    LOG("Set network type" << networkType);

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setNetworkType");
    requestObject.insert(_EXTRA, "setNetworkType");

    QVariantMap networkTypeObject;

    switch (networkType)
    {
    case Mobile:
        networkTypeObject.insert(_TYPE, "networkTypeMobile");
        break;
    case MobileRoaming:
        networkTypeObject.insert(_TYPE, "networkTypeMobileRoaming");
        break;
    case None:
        networkTypeObject.insert(_TYPE, "networkTypeNone");
        break;
    case Other:
        networkTypeObject.insert(_TYPE, "networkTypeOther");
        break;
    case WiFi:
        networkTypeObject.insert(_TYPE, "networkTypeWiFi");
        break;
    default:
        networkTypeObject.insert(_TYPE, "networkTypeOther");
        break;
    }

    requestObject.insert(TYPE, networkTypeObject);
    sendRequest(requestObject);
}

void TDLibWrapper::setInactiveSessionTtl(int days)
{
    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setInactiveSessionTtl");
    requestObject.insert("inactive_session_ttl_days", days);
    sendRequest(requestObject);
}

void TDLibWrapper::searchEmoji(const QString &queryString)
{
    LOG("Searching emoji" << queryString);

    while (_emojiSearchWorker.isRunning())
        _emojiSearchWorker.requestInterruption();

    _emojiSearchWorker.setParameters(queryString);
    _emojiSearchWorker.start();
}

qlonglong TDLibWrapper::getMyUserId() {
    if(myUserId == 0) {
        myUserId = _userInformation.value(ID).toLongLong();
    }
    return myUserId;
}

QVariantMap TDLibWrapper::getUserInformation()
{
    return _userInformation;
}

QVariantMap TDLibWrapper::getUserInformation(const qlonglong userId)
{
    return _usersById.value(userId).toMap();
}

QString TDLibWrapper::getUserName(const qlonglong userId)
{
    QString res;
    if(_userNamesById.contains(userId)) {
        res = _userNamesById.value(userId);
    } else {
        auto userInformation = _usersById.value(userId).toMap();
        auto firstName = userInformation.value(FIRST_NAME).toString();
        auto lastName = userInformation.value(LAST_NAME).toString();
        res = (firstName + " " + lastName).trimmed();
        _userNamesById.insert(userId, res);
    }
    return res;
}

bool TDLibWrapper::hasUserInformation(const qlonglong userId)
{
    return _usersById.contains(userId);
}

QVariantMap TDLibWrapper::getUserInformationByName(const QString &userName)
{
    return _usersByName.value(userName).toMap();
}

TDLibWrapper::UserPrivacySettingRule TDLibWrapper::getUserPrivacySettingRule(TDLibWrapper::UserPrivacySetting userPrivacySetting)
{
    return _userPrivacySettingRules.value(userPrivacySetting, UserPrivacySettingRule::RuleAllowAll);
}

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

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

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

    if (group)
    {
        LOG("Returning basic group information for ID" << groupId);

        return group->groupInfo;
    }
    else
    {
        LOG("No super group information for ID" << groupId);

        return QVariantMap();
    }
}

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

    if (group)
    {
        LOG("Returning super group information for ID" << groupId);

        return group->groupInfo;
    }
    else
    {
        LOG("No super group information for ID" << groupId);

        return QVariantMap();
    }
}

QVariantMap TDLibWrapper::getChat(const QString &chatId)
{
    LOG("Returning chat information for ID" << chatId);

    return _chats.value(chatId).toMap();
}

QStringList TDLibWrapper::getChatReactions(const QString &chatId)
{
    LOG("Obtaining chat reactions for chat" << chatId);

    const QVariant available_reactions(_chats.value(chatId).toMap().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)
    {
        LOG("Chat uses all available reactions, currently available number" << _activeEmojiReactions.size());
        return _activeEmojiReactions;
    }
    else if (reactions_type == CHAT_AVAILABLE_REACTIONS_SOME)
    {
        LOG("Chat uses reduced set of reactions");

        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);
            }
        }

        LOG("Found emojis for this chat" << emojis.size());

        return emojis;
    }
    else if (reactions_type.isEmpty())
    {
        LOG("No chat reaction type specified, using all reactions");

        return available_reactions.toStringList();
    }
    else
    {
        LOG("Unknown chat reaction type" << reactions_type);

        return QStringList();
    }
}

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

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

void TDLibWrapper::copyFileToDownloads(const QString &filePath, bool openAfterCopy)
{
    LOG("Copy file to downloads" << filePath << openAfterCopy);

    QFileInfo fileInfo(filePath);

    if (fileInfo.exists())
    {

        QString downloadFilePath = QStandardPaths::writableLocation(QStandardPaths::DownloadLocation) + "/" + fileInfo.fileName();

        if (QFile::exists(downloadFilePath))
        {
            if (openAfterCopy)
                openFileOnDevice(downloadFilePath);
            else
                emit copyToDownloadsSuccessful(fileInfo.fileName(), downloadFilePath);
        }
        else
        {
            if (QFile::copy(filePath, downloadFilePath))
            {
                if (openAfterCopy)
                    openFileOnDevice(downloadFilePath);
                else
                    emit copyToDownloadsSuccessful(fileInfo.fileName(), downloadFilePath);
            }
            else
                emit copyToDownloadsError(fileInfo.fileName(), downloadFilePath);
        }
    }
    else
        emit copyToDownloadsError(fileInfo.fileName(), filePath);
}

void TDLibWrapper::openFileOnDevice(const QString &filePath)
{
    LOG("Open file on device:" << filePath);

    emit openFileExternally(filePath);
}

void TDLibWrapper::controlScreenSaver(bool enabled)
{
    enabled ? _mceInterface->displayCancelBlankingPause() : _mceInterface->displayBlankingPause();
}

bool TDLibWrapper::getJoinChatRequested()
{
    return _joinChatRequested;
}

void TDLibWrapper::registerJoinChat()
{
    _joinChatRequested = false;
}

DBusAdaptor *TDLibWrapper::getDBusAdaptor()
{
    return _dbusInterface->getDBusAdaptor();
}

void TDLibWrapper::handleVersionDetected(const QString &version)
{
    _versionString = version;

    const QStringList parts(version.split('.'));
    uint major, minor, release;
    bool ok;

    if (parts.count() >= 3 &&
        (major = parts.at(0).toInt(&ok), ok) &&
        (minor = parts.at(1).toInt(&ok), ok) &&
        (release = parts.at(2).toInt(&ok), ok))
    {
        _versionNumber = VERSION_NUMBER(major, minor, release);
    }

    emit versionDetected(version);
}

void TDLibWrapper::handleAuthorizationStateChanged(const QString &authorizationState, const QVariantMap authorizationStateData)
{
    if (authorizationState == "authorizationStateClosed")
        _authorizationState = AuthorizationState::Closed;
    else if (authorizationState == "authorizationStateClosing")
        _authorizationState = AuthorizationState::Closing;
    else if (authorizationState == "authorizationStateLoggingOut")
        _authorizationState = AuthorizationState::LoggingOut;
    else if (authorizationState == "authorizationStateReady")
        _authorizationState = AuthorizationState::AuthorizationReady;
    else if (authorizationState == "authorizationStateWaitCode")
        _authorizationState = AuthorizationState::WaitCode;
    else if (authorizationState == "authorizationStateWaitEncryptionKey")
    {
        setEncryptionKey();
        _authorizationState = AuthorizationState::WaitEncryptionKey;
    }
    else if (authorizationState == "authorizationStateWaitOtherDeviceConfirmation")
        _authorizationState = AuthorizationState::WaitOtherDeviceConfirmation;
    else if (authorizationState == "authorizationStateWaitPassword")
        _authorizationState = AuthorizationState::WaitPassword;
    else if (authorizationState == "authorizationStateWaitPhoneNumber")
        _authorizationState = AuthorizationState::WaitPhoneNumber;
    else if (authorizationState == "authorizationStateWaitRegistration")
        _authorizationState = AuthorizationState::WaitRegistration;
    else if (authorizationState == "authorizationStateWaitTdlibParameters")
    {
        setInitialParameters();
        _authorizationState = AuthorizationState::WaitTdlibParameters;
    }
    else if (authorizationState == "authorizationStateLoggingOut")
        _authorizationState = AuthorizationState::AuthorizationStateLoggingOut;

    if (authorizationState == "authorizationStateClosed")
    {
        _authorizationState = AuthorizationState::AuthorizationStateClosed;
        LOG("Reloading TD Lib...");
        _basicGroups.clear();
        _superGroups.clear();
        _usersById.clear();
        _usersByName.clear();
        _tdLibReceiver->setActive(false);

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

        _tdLibReceiver->terminate();

        QDir appPath(getApplicationDataPath());

        appPath.removeRecursively();
        initializeTDLibReceiver();
        _loggingOut = false;
    }

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

void TDLibWrapper::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();

        _userInformation = getUserInformation(ownUserId);
        emit ownUserIdFound(ownUserId);
    }
}

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

    emit connectionStateChanged(_connectionState);
}

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

    if (updatedUserId == _options.value(MY_ID_OPTION).toLongLong())
    {
        LOG("Own user information updated :)");
        _userInformation = updatedUserInformation;
        emit ownUserUpdated(updatedUserInformation);
    }

    //LOG("User information updated:" << updatedUserInformation.value(USERNAMES).toMap().value(EDITABLE_USERNAME).toString() << updatedUserInformation.value(FIRST_NAME).toString() << updatedUserInformation.value(LAST_NAME).toString());
    updateUserInformation(updatedUserId, updatedUserInformation);
    emit userUpdated(updatedUserId, updatedUserInformation);
}

void TDLibWrapper::handleUserStatusUpdated(const qlonglong userId, const QVariantMap &userStatusInformation)
{
    if (userId == _options.value(MY_ID_OPTION).toLongLong())
    {
        LOG("Own user status information updated :)");
        _userInformation.insert(STATUS, userStatusInformation);
    }

    QVariantMap updatedUserInformation = _usersById.value(userId).toMap();

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

    LOG("User status information updated:" << userId << userStatusInformation.value(_TYPE).toString());
    updatedUserInformation.insert(STATUS, userStatusInformation);
    updateUserInformation(userId, updatedUserInformation);
    emit userUpdated(userId, updatedUserInformation);
}

void TDLibWrapper::updateUserInformation(const qlonglong userId, const QVariantMap &userInformation)
{
    _usersById.insert(userId, userInformation);
    _usersByName.insert(userInformation.value(USERNAMES).toMap().value(EDITABLE_USERNAME).toString(), userInformation);
}

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

void TDLibWrapper::handleNewChatDiscovered(const QVariantMap &chatInformation)
{
    QString chatId = chatInformation.value(ID).toString();

    _chats.insert(chatId, chatInformation);
    emit newChatDiscovered(chatId, chatInformation);
}

void TDLibWrapper::handleChatFolders(const QVariantList &foldersInformation, qlonglong mainChatlistPosition)
{
    for (const auto &folder : foldersInformation)
    {
        getChatFolder(folder.toMap().value("id").toLongLong());
    }

    emit chatFolders(foldersInformation, mainChatlistPosition);
}

void TDLibWrapper::handleChatFolder(const QVariantMap &chatFolderInformation)
{
    LOG("Got ChatFolder information");
    emit chatFolder(chatFolderInformation);
}

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

    if (!_activeChatSearchName.isEmpty())
    {
        QVariantMap chatType = chatInformation.value(TYPE).toMap();
        ChatType receivedChatType = chatTypeFromString(chatType.value(_TYPE).toString());

        if (receivedChatType == ChatTypeBasicGroup)
        {
            LOG("Found basic group for active search" << _activeChatSearchName);
            _activeChatSearchName.clear();
            createBasicGroupChat(chatType.value("basic_group_id").toString(), "openDirectly");
        }

        if (receivedChatType == ChatTypeSuperGroup)
        {
            LOG("Found supergroup for active search" << _activeChatSearchName);
            _activeChatSearchName.clear();
            createSupergroupChat(chatType.value("supergroup_id").toString(), "openDirectly");
        }
    }
}

void TDLibWrapper::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 TDLibWrapper::handleUnreadChatCountUpdated(const QVariantMap &chatCountInformation)
{
    if (chatCountInformation.value(CHAT_LIST_TYPE).toString() == CHAT_LIST_MAIN)
    {
        _unreadChatInformation = chatCountInformation;
    }
    emit unreadChatCountUpdated(chatCountInformation);

}

void TDLibWrapper::handleAvailableReactionsUpdated(qlonglong chatId, const QVariantMap &availableReactions)
{
    LOG("Updating available reactions for chat" << chatId << availableReactions);

    QString chatIdString = QString::number(chatId);
    QVariantMap chatInformation = getChat(chatIdString);

    chatInformation.insert(CHAT_AVAILABLE_REACTIONS, availableReactions);
    _chats.insert(chatIdString, chatInformation);
    emit chatAvailableReactionsUpdated(chatId, availableReactions);
}

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

    if (!_activeChatSearchName.isEmpty() && _activeChatSearchName == groupInformation.value(USERNAME).toString())
    {
        LOG("Found basic group for active search" << _activeChatSearchName);
        _activeChatSearchName.clear();
        createBasicGroupChat(groupInformation.value(ID).toString(), "openDirectly");
    }
}

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

    if (!_activeChatSearchName.isEmpty() && _activeChatSearchName == groupInformation.value(USERNAME).toString())
    {
        LOG("Found supergroup for active search" << _activeChatSearchName);
        _activeChatSearchName.clear();
        createSupergroupChat(groupInformation.value(ID).toString(), "openDirectly");
    }
}

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

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

        getStickerSet(stickerSet.value(ID).toString());
    }

    emit stickerSetsReceived(stickerSets);
}

void TDLibWrapper::handleEmojiSearchCompleted(const QString&, const QVariantList &resultList)
{
    LOG("Emoji search completed" << queryString);
    emit emojiSearchSuccessful(resultList);
}

void TDLibWrapper::handleOpenWithChanged()
{
    _appSettings->getUseOpenWith() ? initializeOpenWith() : removeOpenWith();
}

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

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

void TDLibWrapper::handleStorageOptimizerChanged()
{
    setOptionBoolean("use_storage_optimizer", _appSettings->storageOptimizer());
}

void TDLibWrapper::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 TDLibWrapper::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 TDLibWrapper::handleMessageIsPinnedUpdated(qlonglong chatId, qlonglong messageId, bool isPinned)
{
    if (isPinned)
    {
        emit chatPinnedMessageUpdated(chatId, messageId);
    }
    else
    {
        emit chatPinnedMessageUpdated(chatId, 0);
        getChatPinnedMessage(chatId);
    }
}

void TDLibWrapper::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
    UserPrivacySettingRule newAppliedRule = UserPrivacySettingRule::RuleRestrictAll;
    QListIterator<QVariant> givenRulesIterator(newGivenRules);

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

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

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

    _userPrivacySettingRules.insert(usedSetting, newAppliedRule);
    emit userPrivacySettingUpdated(usedSetting, newAppliedRule);
}

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

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

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

void TDLibWrapper::handleSponsoredMessage(qlonglong chatId, const QVariantMap &message)
{
    switch (_appSettings->getSponsoredMess())
    {
    case AppSettings::SponsoredMessHandle:
        emit sponsoredMessageReceived(chatId, message);
        break;
    case AppSettings::SponsoredMessAutoView:
        LOG("Auto-viewing sponsored message");
        viewMessage(chatId, message.value(MESSAGE_ID).toULongLong(), false);
        break;
    case AppSettings::SponsoredMessIgnore:
        LOG("Ignoring sponsored message");
        break;
    }
}

void TDLibWrapper::handleActiveEmojiReactionsUpdated(const QStringList &emojis)
{
    if (_activeEmojiReactions != emojis)
    {
        _activeEmojiReactions = emojis;
        LOG(emojis.count() << "reaction(s) available");
        emit reactionsUpdated();
    }
}

void TDLibWrapper::handleNetworkConfigurationChanged(const QNetworkConfiguration&)
{
    LOG("A network configuration changed: " << config.bearerTypeName() << config.state());
    LOG("Checking overall network state...");

    bool wifiFound = false;
    bool mobileFound = false;

    QList<QNetworkConfiguration> activeConfigurations = _networkConfigurationManager->allConfigurations(QNetworkConfiguration::Active);
    QListIterator<QNetworkConfiguration> configurationIterator(activeConfigurations);

    while (configurationIterator.hasNext())
    {
        QNetworkConfiguration activeConfiguration = configurationIterator.next();

        if (activeConfiguration.bearerType() == QNetworkConfiguration::BearerWLAN || activeConfiguration.bearerType() == QNetworkConfiguration::BearerEthernet)
        {
            LOG("Active WiFi found...");
            wifiFound = true;
        }

        if (activeConfiguration.bearerType() == QNetworkConfiguration::Bearer2G || activeConfiguration.bearerType() == QNetworkConfiguration::Bearer3G || activeConfiguration.bearerType() == QNetworkConfiguration::Bearer4G || activeConfiguration.bearerType() == QNetworkConfiguration::BearerCDMA2000 || activeConfiguration.bearerType() == QNetworkConfiguration::BearerEVDO || activeConfiguration.bearerType() == QNetworkConfiguration::BearerHSPA || activeConfiguration.bearerType() == QNetworkConfiguration::BearerLTE || activeConfiguration.bearerType() == QNetworkConfiguration::BearerWCDMA)
        {
            LOG("Active mobile connection found...");
            mobileFound = true;
        }
    }

    if (wifiFound)
    {
        setNetworkType(NetworkType::WiFi);
    }
    else if (mobileFound)
    {
        setNetworkType(NetworkType::Mobile);
    }
    else
    {
        setNetworkType(NetworkType::None);
    }
}

void TDLibWrapper::handleGetPageSourceFinished()
{
    LOG("TDLibWrapper::handleGetPageSourceFinished");

    QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());

    reply->deleteLater();

    if (reply->error() != QNetworkReply::NoError)
    {
        return;
    }

    QVariant contentTypeHeader = reply->header(QNetworkRequest::ContentTypeHeader);

    if (!contentTypeHeader.isValid())
    {
        return;
    }

    LOG("Page source content type header: " + contentTypeHeader.toString());

    if (contentTypeHeader.toString().indexOf("text/html", 0, Qt::CaseInsensitive) == -1)
    {
        LOG(requestAddress + " is not HTML, not searching for TG URL...");

        return;
    }

    QString charset = "UTF-8";
    QRegularExpression charsetRegularExpression("charset\\s*\\=[\\s\\\"\\\']*([^\\s\\\"\\\'\\,>]*)");
    QRegularExpressionMatchIterator matchIterator = charsetRegularExpression.globalMatch(contentTypeHeader.toString());
    QStringList availableCharsets;

    while (matchIterator.hasNext())
    {
        QRegularExpressionMatch nextMatch = matchIterator.next();
        QString currentCharset = nextMatch.captured(1).toUpper();
        LOG("Available page source charset: " << currentCharset);
        availableCharsets.append(currentCharset);
    }

    if (availableCharsets.size() > 0 && !availableCharsets.contains("UTF-8"))
    {
        // If we haven't received the requested UTF-8, we simply use the last one which we received in the header
        charset = availableCharsets.last();
    }

    LOG("Charset for " << requestAddress << ": " << charset);

    QByteArray rawDocument = reply->readAll();
    QTextCodec *codec = QTextCodec::codecForName(charset.toUtf8());

    if (codec == nullptr)
    {
        return;
    }

    QString resultDocument = codec->toUnicode(rawDocument);
    QRegExp urlRegex("href\\=\"(tg\\:[^\"]+)\\\"");

    if (urlRegex.indexIn(resultDocument) != -1)
    {
        LOG("TG URL found: " + urlRegex.cap(1));
        emit tgUrlFound(urlRegex.cap(1));
    }
}

QVariantMap &TDLibWrapper::fillTdlibParameters(QVariantMap &parameters)
{
    parameters.insert("api_id", TDLIB_API_ID);
    parameters.insert("api_hash", TDLIB_API_HASH);
    parameters.insert("database_directory", getApplicationDataPath() + "/tdlib");

    bool onlineOnlyMode = _appSettings->onlineOnlyMode();

    parameters.insert("use_file_database", !onlineOnlyMode);
    parameters.insert("use_chat_info_database", !onlineOnlyMode);
    parameters.insert("use_message_database", !onlineOnlyMode);
    parameters.insert("use_secret_chats", true);
    parameters.insert("system_language_code", QLocale::system().name());

    QSettings hardwareSettings("/etc/hw-release", QSettings::NativeFormat);

    parameters.insert("device_model", hardwareSettings.value("NAME", "Unknown Mobile Device").toString());
    parameters.insert("system_version", QSysInfo::prettyProductName());
    parameters.insert("application_version", QCoreApplication::instance()->applicationVersion());
    parameters.insert("enable_storage_optimizer", _appSettings->storageOptimizer());
    // parameters.insert("use_test_dc", true);

    return parameters;
}

void TDLibWrapper::setInitialParameters()
{
    LOG("Sending initial parameters to TD Lib");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setTdlibParameters");

    fillTdlibParameters(requestObject);
    sendRequest(requestObject);
    // qDebug() << "*** setInitialParameters";
}

void TDLibWrapper::setEncryptionKey()
{
    LOG("Setting database encryption key");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "checkDatabaseEncryptionKey");
    // see https://github.com/tdlib/td/issues/188#issuecomment-379536139
    requestObject.insert("encryption_key", "");

    sendRequest(requestObject);
}

void TDLibWrapper::setLogVerbosityLevel()
{
    LOG("Setting log verbosity level to something less chatty");

    QVariantMap requestObject;

    requestObject.insert(_TYPE, "setLogVerbosityLevel");
    requestObject.insert("new_verbosity_level", 2);
    sendRequest(requestObject);
}

void TDLibWrapper::initializeOpenWith()
{
    LOG("Initialize open-with");
    LOG("Checking standard open URL file...");

    const QString applicationsLocation(QStandardPaths::writableLocation(QStandardPaths::ApplicationsLocation));
    const QString openUrlFilePath(applicationsLocation + "/open-url.desktop");

    const QString sailfishBrowserFilePath(applicationsLocation + "/sailfish-browser.desktop");

    if (QFile::exists(sailfishBrowserFilePath))
    {
        LOG("Removing existing local Sailfish browser file, that was not working as expected in 0.10...!");

        QFile::remove(sailfishBrowserFilePath);
        QProcess::startDetached("update-desktop-database " + applicationsLocation);
    }

    if (QFile::exists(openUrlFilePath))
    {
        LOG("Old open URL file exists, that needs to go away...!");

        QFile::remove(openUrlFilePath);
        QProcess::startDetached("update-desktop-database " + applicationsLocation);
    }

    const QString desktopFilePath(applicationsLocation + "/telegraf-open-url.desktop");
    QFile desktopFile(desktopFilePath);

    if (desktopFile.exists())
    {
        LOG("Telegraf open-with file existing, removing...");
        desktopFile.remove();

        QProcess::startDetached("update-desktop-database " + applicationsLocation);
    }

    LOG("Creating Telegraf open-with file at " << desktopFile.fileName());

    if (desktopFile.open(QIODevice::WriteOnly | QIODevice::Text))
    {
        QTextStream fileOut(&desktopFile);

        fileOut.setCodec("UTF-8");
        fileOut << QString("[Desktop Entry]").toUtf8() << "\n";
        fileOut << QString("Type=Application").toUtf8() << "\n";
        fileOut << QString("Name=Telegraf").toUtf8() << "\n";
        fileOut << QString("Icon=ru.telegrafaurora.telegraf").toUtf8() << "\n";
        fileOut << QString("NotShowIn=X-MeeGo;").toUtf8() << "\n";

        fileOut << QString("MimeType=x-url-handler/t.me;x-scheme-handler/tg;").toUtf8() << "\n";

        fileOut << QString("X-Maemo-Service=ru.telegrafaurora.telegraf").toUtf8() << "\n";
        fileOut << QString("X-Maemo-Object-Path=/ru/telegrafaurora/telegraf").toUtf8() << "\n";
        fileOut << QString("X-Maemo-Method=ru.telegrafaurora.telegraf.openUrl").toUtf8() << "\n";
        fileOut << QString("Hidden=true;").toUtf8() << "\n";
        fileOut.flush();
        desktopFile.close();

        QProcess::startDetached("update-desktop-database " + applicationsLocation);
    }

    QString dbusPathName = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/dbus-1/services";
    QDir dbusPath(dbusPathName);

    if (!dbusPath.exists())
    {
        LOG("Creating D-Bus directory" << dbusPathName);
        dbusPath.mkpath(dbusPathName);
    }

    QString dbusServiceFileName = dbusPathName + "/ru.telegrafaurora.telegraf.service";
    QFile dbusServiceFile(dbusServiceFileName);

    if (dbusServiceFile.exists())
    {
        LOG("D-BUS service file existing, removing to ensure proper re-creation...");
        dbusServiceFile.remove();
    }

    LOG("Creating D-Bus service file at" << dbusServiceFile.fileName());

    if (dbusServiceFile.open(QIODevice::WriteOnly | QIODevice::Text))
    {
        QTextStream fileOut(&dbusServiceFile);

        fileOut.setCodec("UTF-8");
        fileOut << QString("[D-BUS Service]").toUtf8() << "\n";
        fileOut << QString("Name=ru.telegrafaurora.telegraf").toUtf8() << "\n";
        fileOut << QString("Exec=sailjail -- /usr/bin/ru.telegrafaurora.telegraf").toUtf8() << "\n";
        fileOut.flush();
        dbusServiceFile.close();
    }
}

void TDLibWrapper::removeOpenWith()
{
    LOG("Remove open-with");

    QFile::remove(QStandardPaths::writableLocation(QStandardPaths::ApplicationsLocation) + "/telegraf-open-url.desktop");
    QProcess::startDetached("update-desktop-database " + QStandardPaths::writableLocation(QStandardPaths::ApplicationsLocation));
}

const TDLibWrapper::Group *TDLibWrapper::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 TDLibWrapper::Group *TDLibWrapper::getGroup(qlonglong groupId) const
{
    if (groupId)
    {
        const Group *group = _superGroups.value(groupId);

        return group ? group : _basicGroups.value(groupId);
    }

    return Q_NULLPTR;
}

TDLibWrapper::ChatType TDLibWrapper::chatTypeFromString(const QString &type)
{
    return (type == QStringLiteral("chatTypePrivate")) ? ChatTypePrivate : (type == QStringLiteral("chatTypeBasicGroup")) ? ChatTypeBasicGroup
                                                                       : (type == QStringLiteral("chatTypeSupergroup"))   ? ChatTypeSuperGroup
                                                                       : (type == QStringLiteral("chatTypeSecret"))       ? ChatTypeSecret
                                                                       : (type == QStringLiteral("userTypeBot"))          ? ChatTypeBot
                                                                                                                          : ChatTypeUnknown;
}

TDLibWrapper::ChatMemberStatus TDLibWrapper::chatMemberStatusFromString(const QString &status)
{
    // Most common ones first
    return (status == QStringLiteral("chatMemberStatusMember")) ? ChatMemberStatusMember : (status == QStringLiteral("chatMemberStatusLeft"))        ? ChatMemberStatusLeft
                                                                                       : (status == QStringLiteral("chatMemberStatusCreator"))       ? ChatMemberStatusCreator
                                                                                       : (status == QStringLiteral("chatMemberStatusAdministrator")) ? ChatMemberStatusAdministrator
                                                                                       : (status == QStringLiteral("chatMemberStatusRestricted"))    ? ChatMemberStatusRestricted
                                                                                       : (status == QStringLiteral("chatMemberStatusBanned"))        ? ChatMemberStatusBanned
                                                                                                                                                     : ChatMemberStatusUnknown;
}

TDLibWrapper::SecretChatState TDLibWrapper::secretChatStateFromString(const QString &state)
{
    return (state == QStringLiteral("secretChatStateClosed")) ? SecretChatStateClosed : (state == QStringLiteral("secretChatStatePending")) ? SecretChatStatePending
                                                                                    : (state == QStringLiteral("secretChatStateReady"))     ? SecretChatStateReady
                                                                                                                                            : SecretChatStateUnknown;
}

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

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

QString TDLibWrapper::getApplicationDataPath() const
{
#ifdef QT_DEBUG
    return QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation) + "/ru.telegrafaurora";
#else
    return QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
#endif
}