//
// Created by wolverindev on 26.01.20.
//

#include <memory>

#include <iostream>
#include <bitset>
#include <algorithm>
#include <openssl/sha.h>
#include "../../build.h"
#include "../ConnectedClient.h"
#include "../InternalClient.h"
#include "../../server/VoiceServer.h"
#include "../voice/VoiceClient.h"
#include "../../InstanceHandler.h"
#include "../../server/QueryServer.h"
#include "../music/MusicClient.h"
#include "../query/QueryClient.h"
#include "../../manager/ConversationManager.h"
#include "../../manager/PermissionNameMapper.h"
#include "../../manager/ActionLogger.h"
#include "../../groups/GroupManager.h"
#include "../../absl/btree/map.h"
#include "../../PermissionCalculator.h"
#include <experimental/filesystem>
#include <cstdint>
#include <StringVariable.h>
#include <misc/digest.h>

#include "helpers.h"

#include <log/LogUtils.h>
#include <misc/sassert.h>
#include <misc/rnd.h>
#include <bbcode/bbcodes.h>

namespace fs = std::experimental::filesystem;
using namespace std::chrono;
using namespace std;
using namespace ts;
using namespace ts::server;
using namespace ts::server::token;

#define QUERY_PASSWORD_LENGTH 12

command_result ConnectedClient::handleCommand(Command &cmd) {
    threads::MutexLock l2(this->command_lock);
    auto command = cmd.command();
    if (command == "servergetvariables") return this->handleCommandServerGetVariables(cmd);
    else if (command == "serverrequestconnectioninfo") return this->handleCommandServerRequestConnectionInfo(cmd);
    else if (command == "getconnectioninfo") return this->handleCommandGetConnectionInfo(cmd);
    else if (command == "setconnectioninfo") return this->handleCommandSetConnectionInfo(cmd);
    else if (command == "clientgetvariables") return this->handleCommandClientGetVariables(cmd);
    else if (command == "serveredit") return this->handleCommandServerEdit(cmd);
    else if (command == "clientedit") return this->handleCommandClientEdit(cmd);
    else if (command == "channelgetdescription") return this->handleCommandChannelGetDescription(cmd);
    else if (command == "connectioninfoautoupdate") return this->handleCommandConnectionInfoAutoUpdate(cmd);
    else if (command == "permissionlist") return this->handleCommandPermissionList(cmd);
    else if (command == "propertylist") return this->handleCommandPropertyList(cmd);

        //Server group
    else if (command == "servergrouplist") return this->handleCommandServerGroupList(cmd);
    else if (command == "servergroupadd") return this->handleCommandServerGroupAdd(cmd);
    else if (command == "servergroupcopy") return this->handleCommandServerGroupCopy(cmd);
    else if (command == "servergroupdel") return this->handleCommandServerGroupDel(cmd);
    else if (command == "servergrouprename") return this->handleCommandServerGroupRename(cmd);
    else if (command == "servergroupclientlist") return this->handleCommandServerGroupClientList(cmd);
    else if (command == "servergroupaddclient" || command == "clientaddservergroup") return this->handleCommandServerGroupAddClient(cmd);
    else if (command == "servergroupdelclient" || command == "clientdelservergroup") return this->handleCommandServerGroupDelClient(cmd);
    else if (command == "servergrouppermlist") return this->handleCommandServerGroupPermList(cmd);
    else if (command == "servergroupaddperm") return this->handleCommandServerGroupAddPerm(cmd);
    else if (command == "servergroupdelperm") return this->handleCommandServerGroupDelPerm(cmd);

    else if (command == "setclientchannelgroup") return this->handleCommandSetClientChannelGroup(cmd);

        //Channel basic actions
    else if (command == "channelcreate") return this->handleCommandChannelCreate(cmd);
    else if (command == "channelmove") return this->handleCommandChannelMove(cmd);
    else if (command == "channeledit") return this->handleCommandChannelEdit(cmd);
    else if (command == "channeldelete") return this->handleCommandChannelDelete(cmd);
        //Find a channel and get informations
    else if (command == "channelfind") return this->handleCommandChannelFind(cmd);
    else if (command == "channelinfo") return this->handleCommandChannelInfo(cmd);
        //Channel perm actions
    else if (command == "channelpermlist") return this->handleCommandChannelPermList(cmd);
    else if (command == "channeladdperm") return this->handleCommandChannelAddPerm(cmd);
    else if (command == "channeldelperm") return this->handleCommandChannelDelPerm(cmd);
        //Channel group actions
    else if (command == "channelgroupadd") return this->handleCommandChannelGroupAdd(cmd);
    else if (command == "channelgroupcopy") return this->handleCommandChannelGroupCopy(cmd);
    else if (command == "channelgrouprename") return this->handleCommandChannelGroupRename(cmd);
    else if (command == "channelgroupdel") return this->handleCommandChannelGroupDel(cmd);
    else if (command == "channelgrouplist") return this->handleCommandChannelGroupList(cmd);
    else if (command == "channelgroupclientlist") return this->handleCommandChannelGroupClientList(cmd);
    else if (command == "channelgrouppermlist") return this->handleCommandChannelGroupPermList(cmd);
    else if (command == "channelgroupaddperm") return this->handleCommandChannelGroupAddPerm(cmd);
    else if (command == "channelgroupdelperm") return this->handleCommandChannelGroupDelPerm(cmd);
        //Channel sub/unsubscribe
    else if (command == "channelsubscribe") return this->handleCommandChannelSubscribe(cmd);
    else if (command == "channelsubscribeall") return this->handleCommandChannelSubscribeAll(cmd);
    else if (command == "channelunsubscribe") return this->handleCommandChannelUnsubscribe(cmd);
    else if (command == "channelunsubscribeall") return this->handleCommandChannelUnsubscribeAll(cmd);
        //manager channel permissions
    else if (command == "channelclientpermlist") return this->handleCommandChannelClientPermList(cmd);
    else if (command == "channelclientaddperm") return this->handleCommandChannelClientAddPerm(cmd);
    else if (command == "channelclientdelperm") return this->handleCommandChannelClientDelPerm(cmd);
        //Client actions
    else if (command == "clientupdate") return this->handleCommandClientUpdate(cmd);
    else if (command == "clientmove") return this->handleCommandClientMove(cmd);
    else if (command == "clientgetids") return this->handleCommandClientGetIds(cmd);
    else if (command == "clientkick") return this->handleCommandClientKick(cmd);
    else if (command == "clientpoke") return this->handleCommandClientPoke(cmd);
    else if (command == "sendtextmessage") return this->handleCommandSendTextMessage(cmd);
    else if (command == "clientchatcomposing") return this->handleCommandClientChatComposing(cmd);
    else if (command == "clientchatclosed") return this->handleCommandClientChatClosed(cmd);

    else if (command == "clientfind") return this->handleCommandClientFind(cmd);
    else if (command == "clientinfo") return this->handleCommandClientInfo(cmd);

    else if (command == "clientaddperm") return this->handleCommandClientAddPerm(cmd);
    else if (command == "clientdelperm") return this->handleCommandClientDelPerm(cmd);
    else if (command == "clientpermlist") return this->handleCommandClientPermList(cmd);
        //File transfare
    else if (command == "ftgetfilelist") return this->handleCommandFTGetFileList(cmd);
    else if (command == "ftcreatedir") return this->handleCommandFTCreateDir(cmd);
    else if (command == "ftdeletefile") return this->handleCommandFTDeleteFile(cmd);
    else if (command == "ftinitupload") {
        auto result = this->handleCommandFTInitUpload(cmd);
        if(result.has_error() && this->getType() == ClientType::CLIENT_TEAMSPEAK) {
            ts::command_builder notify{"notifystatusfiletransfer"};
            notify.put_unchecked(0, "clientftfid", cmd["clientftfid"].string());
            notify.put(0, "size", 0);
            this->writeCommandResult(notify, result, "status");
            this->sendCommand(notify);
            result.release_data();

            return command_result{error::ok};
        }
        return result;
    }
    else if (command == "ftinitdownload") {
        auto result = this->handleCommandFTInitDownload(cmd);
        if(result.has_error() && this->getType() == ClientType::CLIENT_TEAMSPEAK) {
            ts::command_builder notify{"notifystatusfiletransfer"};
            notify.put_unchecked(0, "clientftfid", cmd["clientftfid"].string());
            notify.put(0, "size", 0);
            this->writeCommandResult(notify, result, "status");
            this->sendCommand(notify);
            result.release_data();

            return command_result{error::ok};
        }
        return result;
    }
    else if (command == "ftgetfileinfo") return this->handleCommandFTGetFileInfo(cmd);
    else if (command == "ftrenamefile") return this->handleCommandFTRenameFile(cmd);
    else if (command == "ftlist") return this->handleCommandFTList(cmd);
    else if (command == "ftstop") return this->handleCommandFTStop(cmd);
        //Banlist
    else if (command == "banlist") return this->handleCommandBanList(cmd);
    else if (command == "banadd") return this->handleCommandBanAdd(cmd);
    else if (command == "banedit") return this->handleCommandBanEdit(cmd);
    else if (command == "banclient") return this->handleCommandBanClient(cmd);
    else if (command == "bandel") return this->handleCommandBanDel(cmd);
    else if (command == "bandelall") return this->handleCommandBanDelAll(cmd);
    else if (command == "bantriggerlist") return this->handleCommandBanTriggerList(cmd);
        //Tokens
    else if (command == "tokenactionlist") return this->handleCommandTokenActionList(cmd);
    else if (command == "tokenlist" || command == "privilegekeylist") return this->handleCommandTokenList(cmd);
    else if (command == "tokenadd" || command == "privilegekeyadd") return this->handleCommandTokenAdd(cmd);
    else if (command == "tokenedit") return this->handleCommandTokenEdit(cmd);
    else if (command == "tokenuse" || command == "privilegekeyuse") return this->handleCommandTokenUse(cmd);
    else if (command == "tokendelete" || command == "privilegekeydelete") return this->handleCommandTokenDelete(cmd);

        //DB stuff
    else if (command == "clientdblist") return this->handleCommandClientDbList(cmd);
    else if (command == "clientdbinfo") return this->handleCommandClientDbInfo(cmd);
    else if (command == "clientdbedit") return this->handleCommandClientDBEdit(cmd);
    else if (command == "clientdbfind") return this->handleCommandClientDBFind(cmd);
    else if (command == "clientdbdelete") return this->handleCommandClientDBDelete(cmd);
    else if (command == "plugincmd") return this->handleCommandPluginCmd(cmd);

    else if (command == "clientmute") return this->handleCommandClientMute(cmd);
    else if (command == "clientunmute") return this->handleCommandClientUnmute(cmd);

    else if (command == "clientlist") return this->handleCommandClientList(cmd);
    else if (command == "whoami") return this->handleCommandWhoAmI(cmd);
    else if (command == "servergroupsbyclientid") return this->handleCommandServerGroupsByClientId(cmd);

    else if (command == "clientgetdbidfromuid") return this->handleCommandClientGetDBIDfromUID(cmd);
    else if (command == "clientgetnamefromdbid") return this->handleCommandClientGetNameFromDBID(cmd);
    else if (command == "clientgetnamefromuid") return this->handleCommandClientGetNameFromUid(cmd);
    else if (command == "clientgetuidfromclid") return this->handleCommandClientGetUidFromClid(cmd);


    else if (command == "complainadd") return this->handleCommandComplainAdd(cmd);
    else if (command == "complainlist") return this->handleCommandComplainList(cmd);
    else if (command == "complaindel") return this->handleCommandComplainDel(cmd);
    else if (command == "complaindelall") return this->handleCommandComplainDelAll(cmd);

    else if (command == "version") return this->handleCommandVersion(cmd);

    else if (command == "verifyserverpassword") return this->handleCommandVerifyServerPassword(cmd);
    else if (command == "verifychannelpassword") return this->handleCommandVerifyChannelPassword(cmd);

    else if (command == "messagelist") return this->handleCommandMessageList(cmd);
    else if (command == "messageadd") return this->handleCommandMessageAdd(cmd);
    else if (command == "messageget") return this->handleCommandMessageGet(cmd);
    else if (command == "messagedel") return this->handleCommandMessageDel(cmd);
    else if (command == "messageupdateflag") return this->handleCommandMessageUpdateFlag(cmd);

    else if (command == "permget") return this->handleCommandPermGet(cmd);
    else if (command == "permfind") return this->handleCommandPermFind(cmd);
    else if (command == "permidgetbyname") return this->handleCommandPermIdGetByName(cmd);
    else if (command == "permoverview") return this->handleCommandPermOverview(cmd);
    else if (command == "permreset") return this->handleCommandPermReset(cmd);

    else if (command == "clientsetserverquerylogin") return this->handleCommandClientSetServerQueryLogin(cmd);

        //Music stuff
    else if (command == "musicbotcreate") return this->handleCommandMusicBotCreate(cmd);
    else if (command == "musicbotdelete") return this->handleCommandMusicBotDelete(cmd);
    else if (command == "musicbotsetsubscription") return this->handleCommandMusicBotSetSubscription(cmd);
    else if (command == "musicbotplayerinfo") return this->handleCommandMusicBotPlayerInfo(cmd);
    else if (command == "musicbotplayeraction") return this->handleCommandMusicBotPlayerAction(cmd);
    else if (command == "musicbotqueuelist") return this->handleCommandMusicBotQueueList(cmd);
    else if (command == "musicbotqueueadd") return this->handleCommandMusicBotQueueAdd(cmd);
    else if (command == "musicbotqueueremove") return this->handleCommandMusicBotQueueRemove(cmd);
    else if (command == "musicbotqueuereorder") return this->handleCommandMusicBotQueueReorder(cmd);
    else if (command == "musicbotplaylistassign") return this->handleCommandMusicBotPlaylistAssign(cmd);

    else if (command == "help") return this->handleCommandHelp(cmd);

    else if (command == "logview") return this->handleCommandLogView(cmd);
    else if (command == "logquery") return this->handleCommandLogQuery(cmd);
    else if (command == "logadd") return this->handleCommandLogAdd(cmd);

    else if (command == "servergroupautoaddperm") return this->handleCommandServerGroupAutoAddPerm(cmd);
    else if (command == "servergroupautodelperm") return this->handleCommandServerGroupAutoDelPerm(cmd);

    else if (command == "updatemytsid") return this->handleCommandUpdateMyTsId(cmd);
    else if (command == "updatemytsdata") return this->handleCommandUpdateMyTsData(cmd);

    else if (command == "querycreate") return this->handleCommandQueryCreate(cmd);
    else if (command == "querydelete") return this->handleCommandQueryDelete(cmd);
    else if (command == "querylist") return this->handleCommandQueryList(cmd);
    else if (command == "queryrename") return this->handleCommandQueryRename(cmd);
    else if (command == "querychangepassword") return this->handleCommandQueryChangePassword(cmd);

    else if (command == "playlistlist") return this->handleCommandPlaylistList(cmd);
    else if (command == "playlistcreate") return this->handleCommandPlaylistCreate(cmd);
    else if (command == "playlistdelete") return this->handleCommandPlaylistDelete(cmd);
    else if (command == "playlistsetsubscription") return this->handleCommandPlaylistSetSubscription(cmd);

    else if (command == "playlistpermlist") return this->handleCommandPlaylistPermList(cmd);
    else if (command == "playlistaddperm") return this->handleCommandPlaylistAddPerm(cmd);
    else if (command == "playlistdelperm") return this->handleCommandPlaylistDelPerm(cmd);
    else if (command == "playlistclientlist") return this->handleCommandPlaylistClientList(cmd);
    else if (command == "playlistclientpermlist") return this->handleCommandPlaylistClientPermList(cmd);
    else if (command == "playlistclientaddperm") return this->handleCommandPlaylistClientAddPerm(cmd);
    else if (command == "playlistclientdelperm") return this->handleCommandPlaylistClientDelPerm(cmd);
    else if (command == "playlistinfo") return this->handleCommandPlaylistInfo(cmd);
    else if (command == "playlistedit") return this->handleCommandPlaylistEdit(cmd);

    else if (command == "playlistsonglist") return this->handleCommandPlaylistSongList(cmd);
    else if (command == "playlistsongsetcurrent") return this->handleCommandPlaylistSongSetCurrent(cmd);
    else if (command == "playlistsongadd") return this->handleCommandPlaylistSongAdd(cmd);
    else if (command == "playlistsongreorder" || command == "playlistsongmove") return this->handleCommandPlaylistSongReorder(cmd);
    else if (command == "playlistsongremove") return this->handleCommandPlaylistSongRemove(cmd);

    else if (command == "dummy_ipchange") return this->handleCommandDummy_IpChange(cmd);
    else if (command == "conversationhistory") return this->handleCommandConversationHistory(cmd);
    else if (command == "conversationfetch") return this->handleCommandConversationFetch(cmd);
    else if (command == "conversationmessagedelete") return this->handleCommandConversationMessageDelete(cmd);

    else if (command == "listfeaturesupport") return this->handleCommandListFeatureSupport(cmd);

    if (this->getType() == ClientType::CLIENT_QUERY)
        return command_result{error::command_not_found}; //Dont log query invalid commands

    if (this->getType() == ClientType::CLIENT_TEAMSPEAK)
        if (command.empty() || command.find_first_not_of(' ') == -1) {
            if (!permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_allow_invalid_packet, this->getChannelId())))
                ((VoiceClient *) this)->disconnect(VREASON_SERVER_KICK, config::messages::kick_invalid_command, this->server ? this->server->serverAdmin : static_pointer_cast<ConnectedClient>(serverInstance->getInitialServerAdmin()), true);
        }

    logError(this->getServerId(), "Missing command '{}'", command);
    return command_result{error::command_not_found};
};

command_result ConnectedClient::handleCommandGetConnectionInfo(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);

    ConnectedLockedClient client{this->server->find_client_by_id(cmd["clid"].as<ClientId>())};
    if (!client) return command_result{error::client_invalid_id};

    bool send_temp{false};
    auto info = client->request_connection_info(this->ref(), send_temp);
    if (info || send_temp) {
        this->notifyConnectionInfo(client.client, info);
    } else if(this->getType() != ClientType::CLIENT_TEAMSPEAK)
        return command_result{error::no_cached_connection_info};

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandSetConnectionInfo(Command &cmd) {
    auto info = std::make_shared<ConnectionInfoData>();
    info->timestamp = chrono::system_clock::now();
    for (const auto &key : cmd[0].keys()) {
        info->properties.insert({key, cmd[key].string()});
    }

    /*
            CONNECTION_FILETRANSFER_BANDWIDTH_SENT,                     //how many bytes per second are currently being sent by file transfers
            CONNECTION_FILETRANSFER_BANDWIDTH_RECEIVED,                 //how many bytes per second are currently being received by file transfers
            CONNECTION_FILETRANSFER_BYTES_RECEIVED_TOTAL,               //how many bytes we received in total through file transfers
            CONNECTION_FILETRANSFER_BYTES_SENT_TOTAL,                   //how many bytes we sent in total through file transfers
     */

    deque<shared_ptr<ConnectedClient>> receivers;
    {
        lock_guard info_lock(this->connection_info.lock);
        for(const auto& weak_receiver : this->connection_info.receiver) {
            auto receiver = weak_receiver.lock();
            if(!receiver) continue;

            receivers.push_back(receiver);
        }
        this->connection_info.receiver.clear();
        this->connection_info.data = info;
        this->connection_info.data_age = system_clock::now();
    }
    for(const auto& receiver : receivers)
        receiver->notifyConnectionInfo(this->ref(), info);
    return command_result{error::ok};
}

//connectioninfoautoupdate connection_server2client_packetloss_speech=0.0000 connection_server2client_packetloss_keepalive=0.0010 connection_server2client_packetloss_control=0.0000 connection_server2client_packetloss_total=0.0009
command_result ConnectedClient::handleCommandConnectionInfoAutoUpdate(Command &cmd) {
    /* FIXME: Reimplement this!
    this->properties()[property::CONNECTION_SERVER2CLIENT_PACKETLOSS_KEEPALIVE] = cmd["connection_server2client_packetloss_keepalive"].as<std::string>();
    this->properties()[property::CONNECTION_SERVER2CLIENT_PACKETLOSS_CONTROL] = cmd["connection_server2client_packetloss_control"].as<std::string>();
    this->properties()[property::CONNECTION_SERVER2CLIENT_PACKETLOSS_SPEECH] = cmd["connection_server2client_packetloss_speech"].as<std::string>();
    this->properties()[property::CONNECTION_SERVER2CLIENT_PACKETLOSS_TOTAL] = cmd["connection_server2client_packetloss_total"].as<std::string>();
    */
    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandPermissionList(Command &cmd) {
    CMD_CHK_AND_INC_FLOOD_POINTS(5);

    static std::string permission_list_string[ClientType::MAX];
    static std::mutex permission_list_string_lock;

    static auto build_permission_list = [](const std::string& command, const ClientType& type) {
        Command list_builder(command);
        int index = 0;
        for (auto group : permission::availableGroups)
            list_builder[index++]["group_id_end"] = group;

        auto avPerms = permission::availablePermissions;
        std::sort(avPerms.begin(), avPerms.end(), [](const std::shared_ptr<permission::PermissionTypeEntry> &a, const std::shared_ptr<permission::PermissionTypeEntry> &b) {
            return a->type < b->type;
        });

        auto mapper = serverInstance->getPermissionMapper();
        for (const auto& permission : avPerms) {
            if (!permission->clientSupported) continue;

            auto &blk = list_builder[index++];

            blk["permname"] = permission->name;
            blk["permname"] = mapper->permission_name(type, permission->type);
            blk["permdesc"] = permission->description;
            blk["permid"] = permission->type;
        }
        return list_builder;
    };

    auto type = this->getType();
    if(type == CLIENT_TEASPEAK || type == CLIENT_TEAMSPEAK || type == CLIENT_QUERY) {
        Command response{this->notify_response_command("notifypermissionlist")};
        {
            lock_guard lock(permission_list_string_lock);
            if(permission_list_string[type].empty())
                permission_list_string[type] = build_permission_list("", type).build();
            response[0][""] = permission_list_string[type];
        }
        this->sendCommand(response);
    } else {
        this->sendCommand(build_permission_list(this->notify_response_command("notifypermissionlist"), type));
    }
    return command_result{error::ok};
}


#define M(ptype)                \
do {                \
    for(const auto& prop : property::list<ptype>()) { \
        if((prop->flags & property::FLAG_INTERNAL) > 0) continue; \
        response[index]["name"] = prop->name; \
        response[index]["flags"] = prop->flags; \
        response[index]["type"] = property::PropertyType_Names[prop->type_property]; \
        response[index]["value"] = prop->default_value; \
        response[index]["value_type"] = property::ValueType_Names[(int) prop->type_value]; \
        index++; \
    } \
} while(0)

command_result ConnectedClient::handleCommandPropertyList(ts::Command& cmd) {
    Command response(this->notify_response_command("notifypropertylist"));

    {
        string pattern;
        for (auto flag_name : property::flag_names) {
            if(flag_name) {
                pattern = flag_name + string("|") + pattern;
            }
        }
        pattern = pattern.substr(0, pattern.length() - 1);
        response["flag_set"] = pattern;
    }

    int index = 0;
    if(cmd.hasParm("all") || cmd.hasParm("server"))
        M(property::VirtualServerProperties);
    if(cmd.hasParm("all") || cmd.hasParm("channel"))
        M(property::ChannelProperties);
    if(cmd.hasParm("all") || cmd.hasParm("client"))
        M(property::ClientProperties);
    if(cmd.hasParm("all") || cmd.hasParm("instance"))
        M(property::InstanceProperties);
    if(cmd.hasParm("all") || cmd.hasParm("connection"))
        M(property::ConnectionProperties);
    if(cmd.hasParm("all") || cmd.hasParm("playlist"))
        M(property::PlaylistProperties);

    this->sendCommand(response);
    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandSetClientChannelGroup(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(25);

    auto target_channel_group_id = cmd["cgid"].as<GroupId>();
    std::shared_ptr<groups::ChannelGroup> target_channel_group{}, default_channel_group{};

    default_channel_group = this->server->default_channel_group();
    if(target_channel_group_id == 0) {
        target_channel_group = default_channel_group;
        if(!target_channel_group) {
            return command_result{error::vs_critical};
        }
    } else {
        target_channel_group = this->server->group_manager()->channel_groups()->find_group(groups::GroupCalculateMode::GLOBAL, cmd["cgid"].as<GroupId>());
        if(!target_channel_group) {
            return command_result{error::group_invalid_id};
        }
    }

    std::shared_lock server_channel_lock{this->server->channel_tree_mutex}; /* ensure we dont get moved or somebody could move us */
    auto channel_id = cmd["cid"].as<ChannelId>();
    auto channel = this->server->channelTree->findChannel(channel_id);
    if (!channel) {
        return command_result{error::channel_invalid_id};
    }

    auto target_cldbid = cmd["cldbid"].as<ClientDbId>();
    {
        auto channel_group_member_add_power = this->calculate_permission(permission::i_channel_group_member_add_power, channel_id);
        if(!target_channel_group->permission_granted(permission::i_channel_group_needed_member_add_power, channel_group_member_add_power, true)) {
            if(target_cldbid != this->getClientDatabaseId()) {
                return command_result{permission::i_channel_group_member_add_power};
            }

            auto channel_group_self_add_power = this->calculate_permission(permission::i_channel_group_self_add_power, channel_id);
            if(!target_channel_group->permission_granted(permission::i_channel_group_needed_member_add_power, channel_group_self_add_power, true)) {
                return command_result{permission::i_channel_group_self_add_power};
            }
        }


        auto client_permission_modify_power = this->calculate_permission(permission::i_client_permission_modify_power, channel_id);
        auto client_needed_permission_modify_power = this->server->calculate_permission(
                permission::i_client_needed_permission_modify_power, target_cldbid, ClientType::CLIENT_TEAMSPEAK, channel_id
        ).zero_if_unset();


        if(client_needed_permission_modify_power.has_value) {
            if(!permission::v2::permission_granted(client_needed_permission_modify_power, client_permission_modify_power)) {
                return command_result{permission::i_client_permission_modify_power};
            }
        }
    }

    auto old_group_id = this->server->group_manager()->assignments().exact_channel_group_of_client(groups::GroupAssignmentCalculateMode::GLOBAL, target_cldbid, channel->channelId());
    std::shared_ptr<groups::ChannelGroup> old_group{};

    if(old_group_id.has_value()) {
        old_group = this->server->group_manager()->channel_groups()->find_group(groups::GroupCalculateMode::GLOBAL, old_group_id->group_id);
        if(old_group) {
            auto channel_group_member_remove_power = this->calculate_permission(permission::i_channel_group_member_remove_power, channel_id);
            if(!old_group->permission_granted(permission::i_channel_group_needed_member_remove_power, channel_group_member_remove_power, true)) {
                if(target_cldbid != this->getClientDatabaseId()) {
                    return command_result{permission::i_channel_group_member_remove_power};
                }

                auto channel_group_self_remove_power = this->calculate_permission(permission::i_channel_group_self_remove_power, channel_id);
                if(!old_group->permission_granted(permission::i_channel_group_needed_member_remove_power, channel_group_self_remove_power, true)) {
                    return command_result{permission::i_channel_group_self_remove_power};
                }
            }
        }
    }

    this->server->group_manager()->assignments().set_channel_group(target_cldbid, target_channel_group->group_id(), channel->channelId(), !target_channel_group->is_permanent());

    std::shared_ptr<ConnectedClient> connected_client{};
    for (const auto &targetClient : this->server->findClientsByCldbId(target_cldbid)) {
        connected_client = targetClient;

        /* Permissions might changed because of group inheritance */
        targetClient->join_state_id++;

        bool channel_group_changed, server_group_changed;
        targetClient->update_displayed_client_groups(server_group_changed, channel_group_changed);

        auto client_channel = targetClient->getChannel();
        if(!client_channel) {
            continue;
        }

        if(channel_group_changed) {
            targetClient->task_update_needed_permissions.enqueue();
            targetClient->task_update_displayed_groups.enqueue();

            std::optional<ts::command_builder> notify{};
            for (const auto &viewer : this->server->getClients()) {
                viewer->notifyClientChannelGroupChanged(
                        notify,
                        this->ref(), targetClient,
                        client_channel->channelId(),
                        targetClient->properties()[property::CLIENT_CHANNEL_GROUP_INHERITED_CHANNEL_ID],
                        targetClient->properties()[property::CLIENT_CHANNEL_GROUP_ID]);
            }
        }
    }

    if(old_group) {
        serverInstance->action_logger()->group_assignment_logger.log_group_assignment_remove(this->getServerId(),
                                                                                             this->ref(), log::GroupTarget::CHANNEL,
                                                                                             old_group->group_id(), old_group->display_name(),
                                                                                             target_cldbid, connected_client ? connected_client->getDisplayName() : ""
        );
    }

    if(target_channel_group != default_channel_group) {
        serverInstance->action_logger()->group_assignment_logger.log_group_assignment_add(this->getServerId(),
                                                                                          this->ref(), log::GroupTarget::CHANNEL,
                                                                                          target_channel_group->group_id(), target_channel_group->display_name(),
                                                                                          target_cldbid, connected_client ? connected_client->getDisplayName() : ""
        );
    }

    return command_result{error::ok};
}

//sendtextmessage targetmode=1 <1 = direct | 2 = channel | 3 = server> msg=asd target=1 <clid>
command_result ConnectedClient::handleCommandSendTextMessage(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);

    auto timestamp = system_clock::now();
    if (cmd["targetmode"].as<ChatMessageMode>() == ChatMessageMode::TEXTMODE_PRIVATE) {
        ConnectedLockedClient target{this->server->find_client_by_id(cmd["target"].as<ClientId>())};
        if (!target) return command_result{error::client_invalid_id};

        bool chat_open{false};
        {

            std::unique_lock self_channel_lock{this->channel_tree_mutex};
            this->open_private_conversations.erase(std::remove_if(this->open_private_conversations.begin(), this->open_private_conversations.end(), [](const weak_ptr<ConnectedClient>& weak) {
                return !weak.lock();
            }), this->open_private_conversations.end());

            for(const auto& entry : this->open_private_conversations) {
                if(entry.lock() == target) {
                    chat_open = true;
                    break;
                }
            }
        }

        if(!chat_open) {
            if(target.client == this) {
                ACTION_REQUIRES_PERMISSION(permission::b_client_even_textmessage_send, 1, this->getChannelId());
            }

            if(!permission::v2::permission_granted(target->calculate_permission(permission::i_client_needed_private_textmessage_power, target->getClientId()), this->calculate_permission(permission::i_client_private_textmessage_power, this->getClientId()))) {
                return command_result{permission::i_client_private_textmessage_power};
            }


            {
                std::unique_lock target_channel_lock{target->get_channel_lock()};
                target->open_private_conversations.push_back(_this);
            }

            {
                std::unique_lock self_channel_lock{this->channel_tree_mutex};
                this->open_private_conversations.push_back(target.client);
            }
        }

        if(this->handleTextMessage(ChatMessageMode::TEXTMODE_PRIVATE, cmd["msg"], target.client)) {
            return command_result{error::ok};
        }

        target->notifyTextMessage(ChatMessageMode::TEXTMODE_PRIVATE, this->ref(), target->getClientId(), 0, timestamp, cmd["msg"].string());
        this->notifyTextMessage(ChatMessageMode::TEXTMODE_PRIVATE, this->ref(), target->getClientId(), 0, timestamp, cmd["msg"].string());
    } else if (cmd["targetmode"] == ChatMessageMode::TEXTMODE_CHANNEL) {
        if(cmd[0].has("cid")) {
            cmd["target"] = cmd["cid"].string();
        }

        if(!cmd[0].has("target")) {
            cmd["target"] = 0;
        }

        RESOLVE_CHANNEL_R(cmd["target"], false);
        auto channel = l_channel ? dynamic_pointer_cast<BasicChannel>(l_channel->entry) : nullptr;
        if(!channel) {
            CMD_REQ_CHANNEL;
            channel = this->currentChannel;
            channel_id = this->currentChannel->channelId();
        }

        if(!permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_channel_textmessage_send, channel_id))) \
            return command_result{permission::b_client_channel_textmessage_send};

        if(channel == this->currentChannel) {
            channel_tree_read_lock.unlock(); //Method may creates a music bot which modifies the channel tree
            if(this->handleTextMessage(ChatMessageMode::TEXTMODE_CHANNEL, cmd["msg"], nullptr)) {
                return command_result{error::ok};
            }
            channel_tree_read_lock.lock();
        }

        auto conversation_mode = channel->properties()[property::CHANNEL_CONVERSATION_MODE].as_unchecked<ChannelConversationMode>();
        if(conversation_mode == ChannelConversationMode::CHANNELCONVERSATIONMODE_NONE) {
            return command_result{error::conversation_not_exists};
        } else if(channel != this->currentChannel) {
            if(conversation_mode == ChannelConversationMode::CHANNELCONVERSATIONMODE_PRIVATE) {
                return command_result{error::conversation_is_private};
            }

            if(auto fail_perm{this->calculate_and_get_join_state(channel)}; fail_perm != permission::ok) {
                return command_result{fail_perm}; /* You're not allowed to send messages :) */
            }
        }

        this->server->send_text_message(channel, this->ref(), cmd["msg"].string());
    } else if (cmd["targetmode"] == ChatMessageMode::TEXTMODE_SERVER) {
        ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_client_server_textmessage_send, 1);

        if(this->handleTextMessage(ChatMessageMode::TEXTMODE_SERVER, cmd["msg"], nullptr)) return command_result{error::ok};
        for(const auto& client : this->server->getClients()) {
            if (client->connectionState() != ConnectionState::CONNECTED)
                continue;

            auto type = client->getType();
            if (type == ClientType::CLIENT_INTERNAL || type == ClientType::CLIENT_MUSIC)
                continue;

            client->notifyTextMessage(ChatMessageMode::TEXTMODE_SERVER, this->ref(), this->getClientId(), 0, timestamp, cmd["msg"].string());
        }

        {
            auto conversations = this->server->conversation_manager();
            auto conversation = conversations->get_or_create(0);
            conversation->register_message(this->getClientDatabaseId(), this->getUid(), this->getDisplayName(), timestamp, cmd["msg"].string());
        }
    } else return command_result{error::parameter_invalid, "invalid target mode"};

    return command_result{error::ok};
}

//notifybanlist banid=3 ip name uid=zbex8X3bFRTIKLI7mzeyJGZsh64= lastnickname=Wolf\sC++\sXXXX created=1510357269 duration=3600 invokername=WolverinDEV invokercldbid=5 invokeruid=xxjnc14LmvTk+Lyrm8OOeo4tOqw= reason=Prefix\sFake\s\p\sName enforcements=3
command_result ConnectedClient::handleCommandBanList(Command &cmd) {
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(25);

    ServerId sid = this->getServerId();
    if (cmd[0].has("sid")) {
        sid = cmd["sid"];
    }

    if (sid == 0) {
        ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_client_ban_list_global, 1);
    } else {
        auto server = serverInstance->getVoiceServerManager()->findServerById(sid);
        if (!server) return command_result{error::parameter_invalid};

        if (!permission::v2::permission_granted(1, server->calculate_permission(permission::b_client_ban_list, this->getClientDatabaseId(), this->getType(), 0))) {
            return command_result{permission::b_client_ban_list};
        }
    }

    //When empty: return command_result{error::database_empty_result};
    auto banList = serverInstance->banManager()->listBans(sid);
    if (banList.empty()) return command_result{error::database_empty_result};

    auto allow_ip = permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_remoteaddress_view, 0));
    Command notify(this->getExternalType() == CLIENT_TEAMSPEAK ? "notifybanlist" : "");
    int index = 0;
    for (const auto &elm : banList) {
        notify[index]["sid"] = elm->serverId;
        notify[index]["banid"] = elm->banId;
        if(allow_ip)
            notify[index]["ip"] = elm->ip;
        else
            notify[index]["ip"] = "hidden";
        notify[index]["name"] = elm->name;
        notify[index]["uid"] = elm->uid;
        notify[index]["hwid"] = elm->hwid;
        notify[index]["lastnickname"] = elm->name; //Maybe update?

        notify[index]["created"] = chrono::duration_cast<chrono::seconds>(elm->created.time_since_epoch()).count();
        if (elm->until.time_since_epoch().count() != 0)
            notify[index]["duration"] = chrono::duration_cast<chrono::seconds>(elm->until - elm->created).count();
        else
            notify[index]["duration"] = 0;

        notify[index]["reason"] = elm->reason;
        notify[index]["enforcements"] = elm->triggered;

        notify[index]["invokername"] = elm->invokerName;
        notify[index]["invokercldbid"] = elm->invokerDbId;
        notify[index]["invokeruid"] = elm->invokerUid;
        index++;
    }
    this->sendCommand(notify);
    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandBanAdd(Command &cmd) {
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(25);

    string ip = cmd[0].has("ip") ? cmd["ip"].string() : "";
    string name = cmd[0].has("name") ? cmd["name"].string() : "";
    string uid = cmd[0].has("uid") ? cmd["uid"].string() : "";
    string hwid = cmd[0].has("hwid") ? cmd["hwid"].string() : "";
    string banreason = cmd[0].has("banreason") ? cmd["banreason"].string() : "No reason set";
    auto time = cmd[0].has("time") ? cmd["time"].as<int64_t>() : 0L;

    ServerId sid = this->getServerId();
    if (cmd[0].has("sid"))
        sid = cmd["sid"];

    if (sid == 0) {
        ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_client_ban_create_global, 1);
    } else {
        auto server = serverInstance->getVoiceServerManager()->findServerById(sid);
        if (!server) return command_result{error::parameter_invalid};
        if (!permission::v2::permission_granted(1, server->calculate_permission(permission::b_client_ban_create, this->getClientDatabaseId(), this->getType(), 0)))
            return command_result{permission::b_client_ban_create};
    }

    auto max_ban_time = this->calculate_permission(permission::i_client_ban_max_bantime, this->getClientDatabaseId());
    if(!max_ban_time.has_value)
        return command_result{permission::i_client_ban_max_bantime};
    if (!max_ban_time.has_infinite_power()) {
        if (max_ban_time.value < time)
            return command_result{permission::i_client_ban_max_bantime};
    }

    chrono::time_point<chrono::system_clock> until = time > 0 ? chrono::system_clock::now() + chrono::seconds(time) : chrono::time_point<chrono::system_clock>();

    auto existing = serverInstance->banManager()->findBanExact(sid, banreason, uid, ip, name, hwid);
    bool banned = false;
    if(existing) {
        if(existing->invokerDbId == this->getClientDatabaseId()) {
            if(existing->until == until) {
                return command_result{error::database_duplicate_entry};
            } else {
                existing->until = until;
                serverInstance->banManager()->updateBan(existing);
                banned = true;
            }
        } else if(!banned) {
            serverInstance->banManager()->unban(existing);
        }
    }
    if(!banned) {
        serverInstance->banManager()->registerBan(sid, this->getClientDatabaseId(), banreason, uid, ip, name, hwid, until);
    }

    for(auto server : (this->server ? std::deque<shared_ptr<VirtualServer>>{this->server} : serverInstance->getVoiceServerManager()->serverInstances()))
        server->testBanStateChange(this->ref());
    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandBanEdit(Command &cmd) {
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(25);

    ServerId sid = this->getServerId();
    if (cmd[0].has("sid"))
        sid = cmd["sid"];

    auto ban = serverInstance->banManager()->findBanById(sid, cmd["banid"].as<uint64_t>());
    if (!ban) return command_result{error::database_empty_result};

    if (sid == 0) {
        ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_client_ban_edit_global, 1);
    } else {
        auto server = serverInstance->getVoiceServerManager()->findServerById(sid);
        if (!server) return command_result{error::parameter_invalid};

        if (!permission::v2::permission_granted(1, server->calculate_permission(permission::b_client_ban_edit, this->getClientDatabaseId(), this->getType(), 0)))
            return command_result{permission::b_client_ban_edit};
    }

    /* ip name uid reason time hwid */
    bool changed = false;
    if (cmd[0].has("ip")) {
        ban->ip = cmd["ip"].as<string>();
        changed |= true;
    }

    if (cmd[0].has("name")) {
        ban->name = cmd["name"].as<string>();
        changed |= true;
    }

    if (cmd[0].has("uid")) {
        ban->uid = cmd["uid"].as<string>();
        changed |= true;
    }

    if (cmd[0].has("reason")) {
        ban->reason = cmd["reason"].as<string>();
        changed |= true;
    }
    if (cmd[0].has("banreason")) {
        ban->reason = cmd["banreason"].as<string>();
        changed |= true;
    }

    if (cmd[0].has("time")) {
        ban->until = ban->created + seconds(cmd["time"].as<size_t>());
        changed |= true;
    }

    if (cmd[0].has("hwid")) {
        ban->hwid = cmd["hwid"].as<string>();
        changed |= true;
    }

    if (changed)
        serverInstance->banManager()->updateBan(ban);
    else return command_result{error::parameter_invalid};

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandBanClient(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(25);

    std::string target_unique_id{};
    ClientDbId target_database_id{0};

    string reason = cmd[0].has("banreason") ? cmd["banreason"].string() : "";
    auto time = cmd[0].has("time") ? cmd["time"].as<uint64_t>() : 0UL;
    chrono::time_point<chrono::system_clock> until = time > 0 ? chrono::system_clock::now() + chrono::seconds(time) : chrono::time_point<chrono::system_clock>();

    const auto no_nickname = cmd.hasParm("no-nickname");
    const auto no_hwid = cmd.hasParm("no-hardware-id");
    const auto no_ip = cmd.hasParm("no-ip");

    std::deque<std::shared_ptr<ConnectedClient>> target_clients;
    if (cmd[0].has("uid")) {
        target_clients = this->server->findClientsByUid(target_unique_id = cmd["uid"].string());
    } else if(cmd[0].has("cldbid")) {
        target_clients = this->server->findClientsByCldbId(target_database_id = cmd["cldbid"].as<ClientDbId>());
    } else {
        target_clients = {this->server->find_client_by_id(cmd["clid"].as<ClientId>())};
        if(!target_clients[0]) {
            return command_result{error::client_invalid_id, "Could not find target client"};
        }
    }

    for(const auto& client : target_clients)
        if(client->getType() == ClientType::CLIENT_MUSIC)
            return command_result{error::client_invalid_id, "You cant ban a music bot!"};

    if(!target_clients.empty()) {
        if(target_unique_id.empty())
            target_unique_id = target_clients.back()->getUid();

        if(!target_database_id)
            target_database_id = target_clients.back()->getClientDatabaseId();
    }
    if(!permission::v2::permission_granted(this->server->calculate_permission(permission::i_client_needed_ban_power, target_database_id, ClientType::CLIENT_TEAMSPEAK, 0).zero_if_unset(), this->calculate_permission(permission::i_client_ban_power, 0)))
        return command_result{permission::i_client_ban_power};

    if (permission::v2::permission_granted(1, this->server->calculate_permission(permission::b_client_ignore_bans, target_database_id, ClientType::CLIENT_TEAMSPEAK, 0)))
        return command_result{permission::b_client_ignore_bans};

    deque<BanId> ban_ids;
    if(!target_unique_id.empty()) {
        auto _id = serverInstance->banManager()->registerBan(this->getServer()->getServerId(), this->getClientDatabaseId(), reason, target_unique_id, "", "", "", until);
        ban_ids.push_back(_id);
    }

    auto b_ban_name = permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_ban_name, 0));
    auto b_ban_ip = permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_ban_ip, 0));
    auto b_ban_hwid = permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_ban_hwid, 0));

    auto max_ban_time = this->calculate_permission(permission::i_client_ban_max_bantime, 0);
    if(!max_ban_time.has_value) return command_result{permission::i_client_ban_max_bantime};
    if (!max_ban_time.has_infinite_power()) {
        if (max_ban_time.value < time)
            return command_result{permission::i_client_ban_max_bantime};
    }

    for (const auto &client : target_clients) {
        if (client->getType() != CLIENT_TEAMSPEAK && client->getType() != CLIENT_QUERY) continue; //Remember if you add new type you have to change stuff here

        this->server->notify_client_ban(client, this->ref(), reason, time);
        client->close_connection(system_clock::now() + seconds(2));

        string entry_name, entry_ip, entry_hardware_id;
        if(b_ban_name && !no_nickname) {
            entry_name = client->getDisplayName();
        }
        if(b_ban_ip && !no_ip && !config::server::disable_ip_saving) {
            entry_ip = client->getPeerIp();
        }
        if(b_ban_hwid && !no_hwid) {
            entry_hardware_id = client->getHardwareId();
        }
        auto exact = serverInstance->banManager()->findBanExact(this->getServer()->getServerId(), reason, "", entry_ip, entry_name, entry_hardware_id);
        if(exact) {
            exact->until = until;
            exact->invokerDbId = this->getClientDatabaseId();
            serverInstance->banManager()->updateBan(exact);
            ban_ids.push_back(exact->banId);
        } else {
            auto id = serverInstance->banManager()->registerBan(this->getServer()->getServerId(), this->getClientDatabaseId(), reason, "", entry_ip, entry_name, entry_hardware_id, until);
            ban_ids.push_back(id);
        }
    }
    this->server->testBanStateChange(this->ref());

    if (this->getType() == CLIENT_QUERY) {
        Command notify("");
        int index = 0;
        for(const auto& ban_id : ban_ids)
            notify[index++]["banid"] = ban_id;
        this->sendCommand(notify);
    }

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandBanDel(Command &cmd) {
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);

    ServerId sid = this->getServerId();
    if (cmd[0].has("sid"))
        sid = cmd["sid"];

    auto ban = serverInstance->banManager()->findBanById(sid, cmd["banid"].as<uint64_t>());
    if (!ban) return command_result{error::database_empty_result};

    if (sid == 0) {
        const auto permission = ban->invokerDbId == this->getClientDatabaseId() ? permission::b_client_ban_delete_own_global : permission::b_client_ban_delete_global;
        ACTION_REQUIRES_GLOBAL_PERMISSION(permission, 1);
    } else {
        auto server = serverInstance->getVoiceServerManager()->findServerById(sid);
        if (!server) return command_result{error::parameter_invalid};

        auto perm = ban->invokerDbId == this->getClientDatabaseId() ? permission::b_client_ban_delete_own : permission::b_client_ban_delete;
        if (!permission::v2::permission_granted(1, server->calculate_permission(perm, this->getClientDatabaseId(), this->getType(), 0)))
            return command_result{perm};
    }
    serverInstance->banManager()->unban(ban);
    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandBanDelAll(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(25);
    ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_client_ban_delete, 1);

    serverInstance->banManager()->deleteAllBans(server->getServerId());
    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandBanTriggerList(ts::Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(25);
    ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_client_ban_trigger_list, 1);

    CMD_REQ_PARM("banid");

    auto record = serverInstance->banManager()->findBanById(this->getServerId(), cmd["banid"]);
    if(!record) return command_result{error::parameter_invalid, "Invalid ban id"};

    Command notify(this->getExternalType() == CLIENT_TEAMSPEAK ? "notifybantriggerlist" : "");
    notify["banid"] = record->banId;
    notify["serverid"] = record->serverId;

    auto allow_ip = permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_remoteaddress_view, 0));
    int index = 0;
    for (auto &entry : serverInstance->banManager()->trigger_list(record, this->getServerId(), cmd[0].has("offset") ? cmd["offset"].as<int64_t>() : 0, cmd[0].has("limit") ? cmd["limit"].as<int64_t>() : -1)) {
        notify[index]["client_unique_identifier"] = entry->unique_id;
        notify[index]["client_hardware_identifier"] = entry->hardware_id;
        notify[index]["client_nickname"] = entry->name;
        if(allow_ip)
            notify[index]["connection_client_ip"] = entry->ip;
        else
            notify[index]["connection_client_ip"] = "hidden";
        notify[index]["timestamp"] = duration_cast<milliseconds>(entry->timestamp.time_since_epoch()).count();
        index++;
    }
    if (index == 0) return command_result{error::database_empty_result};

    this->sendCommand(notify);
    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandTokenList(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);

    auto& token_manager = this->server->getTokenManager();

    size_t offset = cmd[0].has("offset") ? cmd["offset"].as<size_t>() : 0;
    size_t limit = cmd[0].has("limit") ? cmd["limit"].as<int>() : 0;
    if(limit > 2000 || limit < 1) {
        limit = 1000;
    }

    size_t total_tokens{0};
    std::deque<std::shared_ptr<Token>> tokens{};

    auto own_tokens_only = cmd.hasParm("own-only") || !permission::v2::permission_granted(1, this->calculate_permission(permission::b_virtualserver_token_list_all, 0));
    if(own_tokens_only) {
        tokens = token_manager.list_tokens(total_tokens, { offset }, { limit }, { this->getClientDatabaseId() });
    } else {
        tokens = token_manager.list_tokens(total_tokens, { offset }, { limit }, std::nullopt);
    }

    if(tokens.empty()) {
        return ts::command_result{error::database_empty_result};
    }

    auto new_command = cmd.hasParm("new");
    auto own_database_id = this->getClientDatabaseId();

    ts::command_builder notify{this->notify_response_command("notifytokenlist")};
    size_t notify_index{0};
    for(size_t index{0}; index < tokens.size(); index++) {
        auto& token = tokens[index];
        if(own_tokens_only && token->issuer_database_id != own_database_id) {
            continue;
        }

        auto bulk = notify.bulk(notify_index++);
        bulk.put_unchecked("token", token->token);
        bulk.put_unchecked("token_id", token->id);
        bulk.put_unchecked("token_created", std::chrono::duration_cast<std::chrono::seconds>(token->timestamp_created.time_since_epoch()).count());
        bulk.put_unchecked("token_expired", std::chrono::duration_cast<std::chrono::seconds>(token->timestamp_expired.time_since_epoch()).count());
        bulk.put_unchecked("token_use_count", token->use_count);
        bulk.put_unchecked("token_max_uses", token->max_uses);
        bulk.put_unchecked("token_issuer_database_id", token->issuer_database_id);
        bulk.put_unchecked("token_description", token->description);

        if(!new_command) {
            bulk.put_unchecked("token_type", 0);
            bulk.put_unchecked("token_id1", 0);
            bulk.put_unchecked("token_id2", 0);
        }
    }

    if(notify_index == 0) {
        return ts::command_result{error::database_empty_result};
    }

    notify.put_unchecked(0, "token_count", total_tokens);
    this->sendCommand(notify);
    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandTokenActionList(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);

    auto& token_manager = this->server->getTokenManager();
    std::shared_ptr<token::Token> token_info{};
    if(cmd[0].has("token_id")) {
        token_info = this->server->getTokenManager().load_token_by_id(cmd["token_id"].as<token::TokenId>(), true);
    } else if(cmd[0].has("token")) {
        token_info = this->server->getTokenManager().load_token(cmd["token"], true);
    }
    if(!token_info) {
        return ts::command_result{error::token_invalid_id};
    }

    if(token_info->issuer_database_id != this->getClientDatabaseId()) {
        ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_virtualserver_token_list_all, 1);
    }

    std::deque<TokenAction> actions{};
    if(!token_manager.query_token_actions(token_info->id, actions)) {
        return ts::command_result{error::vs_critical};
    }

    ts::command_builder notify{this->notify_response_command("notifytokenactions")};
    for(size_t index{0}; index < actions.size(); index++) {
        auto bulk = notify.bulk(index);
        auto& action = actions[index];

        bulk.put_unchecked("action_type", (uint8_t) action.type);
        bulk.put_unchecked("action_id", action.id);
        bulk.put_unchecked("action_id1", action.id1);
        bulk.put_unchecked("action_id2", action.id2);
        bulk.put_unchecked("action_text", action.text);
    }
    this->sendCommand(notify);
    return command_result{error::ok};
}

/**
 *
 * @param result Should already contain cmd.bulkCount() results
 * @param cmd
 * @param token_description
 * @param max_uses
 * @param timestamp_expired
 * @param actions
 * @return
 */
ts::command_result parseTokenParameters(
        ts::command_result_bulk& result,
        Command &cmd,
        std::optional<std::string>& token_description,
        std::optional<size_t>& max_uses,
        std::optional<std::chrono::system_clock::time_point>& timestamp_expired,
        std::vector<token::TokenAction>& actions
) {
    actions.reserve(cmd.bulkCount());

    /* legacy (should not be provided on token edit) */
    if(cmd[0].has("tokentype")) {
        auto ttype = cmd["tokentype"].as<uint32_t>();
        auto gId = cmd["tokenid1"].as<GroupId>();
        auto cId = cmd["tokenid2"].as<ChannelId>();

        if(ttype == 0) {
            auto& action = actions.emplace_back();
            action.type = token::ActionType::AddServerGroup;
            action.id1 = gId;
        } else if(ttype == 1) {
            auto& action = actions.emplace_back();
            action.type = token::ActionType::SetChannelGroup;
            action.id1 = gId;
            action.id2 = cId;
        } else {
            result.set_result(0, ts::command_result{error::parameter_invalid, "tokentype"});
        }
    } else {
        for(size_t index{0}; index < cmd.bulkCount(); index++) {
            auto& action = actions.emplace_back();
            action.id = cmd[index].has("action_id") ? cmd[index]["action_id"] : 0;

            if(!cmd[index].has("action_type")) {
                if(action.id > 0) {
                    /* we want to delete the action */
                    action.type = token::ActionType::ActionDeleted;
                    continue;
                }

                /* Missing the parameter action type */
                action.type = token::ActionType::ActionIgnore;
                if(index == 0) {
                    /* no actions provided */
                    break;
                } else {
                    result.set_result(index, ts::command_result{error::parameter_missing, "action_type"});
                    continue;
                }
            }

            action.type = cmd[index]["action_type"];
            switch(action.type) {
                case token::ActionType::AddServerGroup:
                case token::ActionType::RemoveServerGroup:
                case token::ActionType::SetChannelGroup:
                case token::ActionType::AllowChannelJoin:
                    break;

                case token::ActionType::ActionSqlFailed:
                case token::ActionType::ActionDeleted:
                case token::ActionType::ActionIgnore:
                default:
                    result.set_result(index, ts::command_result{error::parameter_invalid, "action_type"});
                    continue;
            }

            if(cmd[index].has("action_id1")) {
                action.id1 = cmd[index]["action_id1"];
            }

            if(cmd[index].has("action_id2")) {
                action.id2 = cmd[index]["action_id2"];
            }

            if(cmd[index].has("action_text")) {
                action.text = cmd[index]["action_text"].string();
            }
        }
    }

    if(cmd[0].has("token_description")) {
        token_description = { cmd["token_description"].string() };
    } else if(cmd[0].has("tokendescription")) {
        token_description = { cmd["tokendescription"].string() };
    }

    if(token_description.has_value() && token_description->length() > 255) {
        return ts::command_result{error::parameter_invalid, "token_description"};
    }

    if(cmd[0].has("token_max_uses")) {
        max_uses = { cmd["token_max_uses"].as<size_t>() };
    }

    if(cmd[0].has("token_expired")) {
        auto seconds = cmd["token_expired"].as<uint64_t>();
        timestamp_expired = { std::chrono::system_clock::time_point{} + std::chrono::seconds{seconds} };
    }

    return ts::command_result{error::ok};
}

/**
 * Check if the client has permissions to do such actions.
 * If not the toke will be set to ignored and a proper error will be emplaced
 */
void check_token_action_permissions(const std::shared_ptr<ConnectedClient>& client, ts::command_result_bulk& result, std::vector<token::TokenAction>& actions) {
    for(size_t index{0}; index < actions.size(); index++) {
        auto& action = actions[index];

        switch(action.type) {
            case ActionType::AddServerGroup: {
                auto target_group = client->getServer()->group_manager()->server_groups()->find_group(groups::GroupCalculateMode::GLOBAL, action.id1);
                if(!target_group || target_group->group_type() == groups::GroupType::GROUP_TYPE_TEMPLATE) {
                    action.type = ActionType::ActionIgnore;
                    result.set_result(index, ts::command_result{error::group_invalid_id});
                    break;
                }

                if(!target_group->permission_granted(permission::i_server_group_needed_member_add_power, client->calculate_permission(permission::i_server_group_member_add_power, 0), true)) {
                    action.type = ActionType::ActionIgnore;
                    result.set_result(index, ts::command_result{permission::i_server_group_member_add_power});
                    break;
                }

                break;
            }

            case ActionType::RemoveServerGroup: {
                auto target_group = client->getServer()->group_manager()->channel_groups()->find_group(groups::GroupCalculateMode::GLOBAL, action.id1);
                if(!target_group || target_group->group_type() == groups::GroupType::GROUP_TYPE_TEMPLATE) {
                    action.type = ActionType::ActionIgnore;
                    result.set_result(index, ts::command_result{error::group_invalid_id});
                    break;
                }

                if(!target_group->permission_granted(permission::i_server_group_needed_member_remove_power, client->calculate_permission(permission::i_server_group_member_remove_power, 0), true)) {
                    action.type = ActionType::ActionIgnore;
                    result.set_result(index, ts::command_result{permission::i_server_group_member_remove_power});
                    break;
                }

                break;
            }

            case ActionType::SetChannelGroup: {
                auto target_group = client->getServer()->group_manager()->server_groups()->find_group(groups::GroupCalculateMode::GLOBAL, action.id1);
                if(!target_group || target_group->group_type() == groups::GroupType::GROUP_TYPE_TEMPLATE) {
                    action.type = ActionType::ActionIgnore;
                    result.set_result(index, ts::command_result{error::group_invalid_id});
                    break;
                }

                auto granted_permission = client->calculate_permission(permission::i_channel_group_member_add_power, action.id2);
                if(!target_group->permission_granted(permission::i_channel_group_needed_member_add_power, granted_permission, true)) {
                    action.type = ActionType::ActionIgnore;
                    result.set_result(index, ts::command_result{permission::i_channel_group_member_add_power});
                    break;
                }

                {
                    std::shared_lock tree_lock{client->getServer()->get_channel_tree_lock()};
                    auto target_channel = client->getServer()->getChannelTree()->findChannel(action.id2);
                    tree_lock.unlock();

                    if(!target_channel) {
                        action.type = ActionType::ActionIgnore;
                        result.set_result(index, ts::command_result{error::channel_invalid_id});
                        break;
                    }
                }

                break;
            }

            case ActionType::AllowChannelJoin: {
                std::shared_lock tree_lock{client->getServer()->get_channel_tree_lock()};
                auto target_channel = client->getServer()->getChannelTree()->findChannel(action.id2);

                if(!target_channel) {
                    action.type = ActionType::ActionIgnore;
                    result.set_result(index, ts::command_result{error::channel_invalid_id});
                    break;
                }

                auto join_permission = client->calculate_and_get_join_state(target_channel);
                if(join_permission != permission::ok) {
                    action.type = ActionType::ActionIgnore;
                    result.set_result(index, ts::command_result{join_permission});
                    break;
                }

                if(client->getType() == ClientType::CLIENT_QUERY && !action.text.empty()) {
                    action.text = digest::sha1(action.text);
                }

                if(permission::v2::permission_granted(1, client->calculate_permission(permission::b_channel_join_ignore_password, target_channel->channelId()))) {
                    action.text = "ignore";
                } else if(!target_channel->verify_password(action.text, true)) {
                    action.type = ActionType::ActionIgnore;
                    result.set_result(index, ts::command_result{error::channel_invalid_password});
                    break;
                }
                break;
            }

            case ActionType::ActionSqlFailed:
            case ActionType::ActionIgnore:
            case ActionType::ActionDeleted:
            default:
                continue;
        }
    }
}

command_result ConnectedClient::handleCommandTokenAdd(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);

    auto client_tokens = this->server->tokenManager->client_token_count(this->getClientDatabaseId());
    auto token_limit = this->calculate_permission(permission::i_virtualserver_token_limit, 0);
    if(token_limit.has_value) {
        if(!permission::v2::permission_granted(client_tokens + 1, token_limit)) {
            return ts::command_result{permission::i_virtualserver_token_limit};
        }
    }

    std::vector<token::TokenAction> actions{};
    actions.reserve(cmd.bulkCount());

    std::optional<std::string> token_description{};
    std::optional<size_t> max_uses{};
    std::optional<std::chrono::system_clock::time_point> timestamp_expired{};

    ts::command_result_bulk result{};
    result.emplace_result_n(cmd.bulkCount(), error::ok);

    auto parse_result = parseTokenParameters(
            result,
            cmd,
            token_description,
            max_uses,
            timestamp_expired,
            actions
    );

    if(parse_result.has_error()) {
        return parse_result;
    }
    parse_result.release_data();

    check_token_action_permissions(this->ref(), result, actions);
    auto token = this->server->getTokenManager().create_token(
            this->getClientDatabaseId(),
            token_description.value_or(""),
            max_uses.value_or(0),
            timestamp_expired.value_or(std::chrono::system_clock::time_point{})
    );

    if(!token) {
        return ts::command_result{error::vs_critical};
    }

    ts::command_builder notify{this->notify_response_command("notifytokenadd")};
    if(!actions.empty()) {
        this->server->getTokenManager().add_token_actions(token->id, actions);

        for(size_t index{0}; index < actions.size(); index++) {
            auto& action = actions[index];
            if(action.type == token::ActionType::ActionIgnore || action.type == token::ActionType::ActionDeleted) {
                continue;
            } else if(action.type == token::ActionType::ActionSqlFailed) {
                result.set_result(index, ts::command_result{error::database_constraint});
            } else {
                notify.put_unchecked(index, "action_id", action.id);
            }
        }
    }

    notify.put_unchecked(0, "token", token->token);
    notify.put_unchecked(0, "token_id", token->id);
    this->sendCommand(notify);

    return command_result{std::move(result)};
}

command_result ConnectedClient::handleCommandTokenEdit(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(15);

    std::shared_ptr<token::Token> token{};
    if(cmd[0].has("token_id")) {
        token = this->server->getTokenManager().load_token_by_id(cmd["token_id"].as<token::TokenId>(), true);
    } else if(cmd[0].has("token")) {
        token = this->server->getTokenManager().load_token(cmd["token"], true);
    }

    if(!token) {
        return ts::command_result{error::token_invalid_id};
    }

    if(token->issuer_database_id != this->getClientDatabaseId()) {
        ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_virtualserver_token_edit_all, 1);
    }

    std::vector<token::TokenAction> actions{};
    actions.reserve(cmd.bulkCount());

    std::optional<std::string> token_description{};
    std::optional<size_t> max_uses{};
    std::optional<std::chrono::system_clock::time_point> timestamp_expired{};

    ts::command_result_bulk result{};
    result.emplace_result_n(cmd.bulkCount(), error::ok);

    auto parse_result = parseTokenParameters(
            result,
            cmd,
            token_description,
            max_uses,
            timestamp_expired,
            actions
    );

    if(parse_result.has_error()) {
        return parse_result;
    }
    parse_result.release_data();

    /* filter actions for duplicates etc  */
    {
        std::deque<token::TokenAction> current_actions{};
        if(!this->server->getTokenManager().query_token_actions(token->id, current_actions)) {
            return ts::command_result{error::vs_critical};
        }


        for(const auto& action : actions) {
            if (action.type == ActionType::ActionDeleted) {
                auto index = std::find_if(current_actions.begin(), current_actions.end(), [&](const auto& caction) { return caction.id == action.id; });
                if(index != current_actions.end()) {
                    current_actions.erase(index);
                }
            }
        }

        size_t action_index{0};
        for(auto& action : actions) {
            switch(action.type) {
                case ActionType::AddServerGroup:
                case ActionType::RemoveServerGroup:
                case ActionType::SetChannelGroup:
                case ActionType::AllowChannelJoin: {
                    auto index = std::find_if(current_actions.begin(), current_actions.end(), [&](const TokenAction& caction) {
                        if(caction.type != action.type) {
                            return false;
                        }

                        if(caction.text != action.text) {
                            return false;
                        }

                        if(caction.id1 != action.id1) {
                            return false;
                        }

                        return caction.id2 == action.id2;
                    });

                    if(index != current_actions.end()) {
                        action.type = ActionType::ActionIgnore;
                        result.set_result(action_index, ts::command_result{error::database_no_modifications});
                        break;
                    }

                    current_actions.push_back(action);
                    break;
                }

                case ActionType::ActionSqlFailed:
                case ActionType::ActionIgnore:
                case ActionType::ActionDeleted:
                default:
                    break;
            }

            action_index++;
        }
    }

    check_token_action_permissions(this->ref(), result, actions);

    if(token_description.has_value() || max_uses.has_value() || timestamp_expired.has_value()) {
        token->description = token_description.value_or(token->description);
        token->max_uses = max_uses.value_or(token->max_uses);
        token->timestamp_expired = timestamp_expired.value_or(token->timestamp_expired);

        this->server->getTokenManager().save_token(token);
    }

    if(!actions.empty()) {
        size_t new_actions{0};

        std::vector<token::TokenActionId> actions_removed{};
        actions_removed.reserve(actions.size());
        for(const auto& action : actions) {
            if(action.type == ActionType::ActionDeleted) {
                actions_removed.push_back(action.id);
            } else if(action.type == ActionType::ActionIgnore) {
                /* just ignore the action */
            } else {
                new_actions++;
            }
        }

        if(!actions_removed.empty()) {
            this->server->getTokenManager().delete_token_actions(token->id, actions_removed);
        }

        if(new_actions > 0) {
            this->server->getTokenManager().add_token_actions(token->id, actions);

            ts::command_builder notify{this->notify_response_command("notifytokenedit")};
            for(size_t index{0}; index < actions.size(); index++) {
                auto& action = actions[index];
                if(action.type == token::ActionType::ActionIgnore || action.type == token::ActionType::ActionDeleted) {
                    continue;
                } else if(action.type == token::ActionType::ActionSqlFailed) {
                    result.set_result(0, ts::command_result{error::database_constraint});
                } else {
                    notify.put_unchecked(index, "action_id", action.id);
                }
            }
            this->sendCommand(notify);
        }
    }

    return command_result{std::move(result)};
}

command_result ConnectedClient::handleCommandTokenUse(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);
    //ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_virtualserver_token_use, 1);

    auto& token_manager = this->server->getTokenManager();

    auto token = token_manager.load_token(cmd["token"], true);
    if(!token) {
        return ts::command_result{error::token_invalid_id};
    }

    if(token->is_expired()) {
        return ts::command_result{error::token_expired};
    }

    if(token->use_limit_reached()) {
        return ts::command_result{error::token_use_limit_exceeded};
    }

    this->server->properties()[property::VIRTUALSERVER_ASK_FOR_PRIVILEGEKEY] = false; //TODO test if its the default token
    token_manager.log_token_use(token->id);
    this->useToken(token->id);

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandTokenDelete(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);

    std::shared_ptr<token::Token> token{};
    if(cmd[0].has("token_id")) {
        token = this->server->getTokenManager().load_token_by_id(cmd["token_id"].as<token::TokenId>(), true);
    } else if(cmd[0].has("token")) {
        token = this->server->getTokenManager().load_token(cmd["token"], true);
    }

    if(!token) {
        return ts::command_result{error::token_invalid_id};
    }

    if(token->issuer_database_id != this->getClientDatabaseId()) {
        ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_virtualserver_token_delete_all, 1);
    }

    this->server->getTokenManager().delete_token(token->id);

    if(token->token ==
            this->server->properties()[property::VIRTUALSERVER_AUTOGENERATED_PRIVILEGEKEY].as_unchecked<string>()) {
        this->server->properties()[property::VIRTUALSERVER_AUTOGENERATED_PRIVILEGEKEY] = "";
        this->server->properties()[property::VIRTUALSERVER_ASK_FOR_PRIVILEGEKEY] = false;
        logMessage(this->getServerId(), "{} Deleting the default server token. Don't ask anymore for this a token!", CLIENT_STR_LOG_PREFIX);
    }

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandPluginCmd(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);

    auto mode = cmd["targetmode"].as<PluginTargetMode>();

    if (mode == PluginTargetMode::PLUGINCMD_CURRENT_CHANNEL) {
        CMD_REQ_CHANNEL;
        for (auto &cl : this->server->getClientsByChannel(this->currentChannel))
            cl->notifyPluginCmd(cmd["name"], cmd["data"], this->ref());
    } else if (mode == PluginTargetMode::PLUGINCMD_SUBSCRIBED_CLIENTS) {
        for (auto &cl : this->server->getClients())
            if (cl->isClientVisible(this->ref(), true))
                cl->notifyPluginCmd(cmd["name"], cmd["data"], this->ref());
    } else if (mode == PluginTargetMode::PLUGINCMD_SERVER) {
        for (auto &cl : this->server->getClients())
            cl->notifyPluginCmd(cmd["name"], cmd["data"], this->ref());
    } else if (mode == PluginTargetMode::PLUGINCMD_CLIENT) {
        for (int index = 0; index < cmd.bulkCount(); index++) {
            auto target = cmd[index]["target"].as<ClientId>();
            ConnectedLockedClient cl{this->server->find_client_by_id(target)};
            if (!cl) return command_result{error::client_invalid_id};
            cl->notifyPluginCmd(cmd["name"], cmd["data"], this->ref());
        }
    }

        /*
        else if(mode == PluginTargetMode::PLUGINCMD_SEND_COMMAND) {
            auto target = this->ref();
            if(cmd[0].has("target"))
                target = this->server->findClient(cmd["target"].as<ClientId>());
            if(!target) return command_result{error::client_invalid_id, "invalid target id"};

            target->sendCommand(Command(cmd["command"].string()), cmd[0].has("low") ? cmd["low"] : false);
        }
        */

    else return command_result{error::not_implemented};
    return command_result{error::ok};
}


command_result ConnectedClient::handleCommandWhoAmI(Command &cmd) {
    CMD_RESET_IDLE;

    Command result("");

    if (this->server) {
        result["virtualserver_status"] = ServerState::string(this->getServer()->state);
        result["virtualserver_id"] = this->server->getServerId();
        result["virtualserver_unique_identifier"] = this->server->properties()[property::VIRTUALSERVER_UNIQUE_IDENTIFIER].as_unchecked<string>();
        result["virtualserver_port"] = 0;
        if (this->server->udpVoiceServer) {
            result["virtualserver_port"] = this->server->properties()[property::VIRTUALSERVER_PORT].as_or<uint16_t>(0);
        }
    } else {
        result["virtualserver_status"] = "template";
        result["virtualserver_id"] = "0";
        result["virtualserver_unique_identifier"] = ""; //TODO generate uid
        result["virtualserver_port"] = "0";
    }

    result["client_id"] = this->getClientId();
    result["client_channel_id"] = this->currentChannel ? this->currentChannel->channelId() : 0;
    result["client_nickname"] = this->getDisplayName();
    result["client_database_id"] = this->getClientDatabaseId();
    result["client_login_name"] = this->properties()[property::CLIENT_LOGIN_NAME].as_unchecked<string>();
    result["client_unique_identifier"] = this->getUid();

    {
        auto query = dynamic_cast<QueryClient*>(this);
        if(query) {
            auto account = query->getQueryAccount();
            result["client_origin_server_id"] = account ? account->bound_server : 0;
        } else
            result["client_origin_server_id"] = 0;
    }

    this->sendCommand(result);
    return command_result{error::ok};
}

struct DBFindArgs {
    int index = 0;
    bool full = false;
    bool ip = false;
    Command cmd{""};
};

command_result ConnectedClient::handleCommandVersion(Command &) {
    CMD_RESET_IDLE;

    Command res("");
    res["version"] = build::version()->string(false);
    res["build_count"] = build::buildCount();
    res["build"] = duration_cast<seconds>(build::version()->timestamp.time_since_epoch()).count();
#ifdef WIN32
    res["platform"] = "Windows";
#else
    res["platform"] = "Linux";
#endif
    this->sendCommand(res);
    return command_result{error::ok};
}

//cid=%d password=%s
command_result ConnectedClient::handleCommandVerifyChannelPassword(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);

    std::shared_ptr<BasicChannel> channel = (this->server ? this->server->channelTree : serverInstance->getChannelTree().get())->findChannel(cmd["cid"].as<ChannelId>());
    if (!channel) return command_result{error::channel_invalid_id, "Cant resolve channel"};

    if (!channel->verify_password(cmd["password"].optional_string(), this->getType() != ClientType::CLIENT_QUERY)) return command_result{error::server_invalid_password};
    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandVerifyServerPassword(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);

    std::string password = cmd["password"];
    if (!this->server->verifyServerPassword(password, false)) return command_result{error::server_invalid_password};
    return command_result{error::ok};
}

//msgid=2 cluid=IkBXingb46\/z1Q3hhMvJEweb3lw= subject=The\sSubject timestamp=1512224138 flag_read=0
//notifymessagelist msgid=2 cluid=IkBXingb46\/z1Q3hhMvJEweb3lw= subject=The\sSubject timestamp=1512224138 flag_read=0
command_result ConnectedClient::handleCommandMessageList(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);

    auto msgList = this->server->letters->avariableLetters(this->getUid());
    if (msgList.empty()) return command_result{error::database_empty_result, "no letters available"};

    Command notify(this->getExternalType() == CLIENT_TEAMSPEAK ? "notifymessagelist" : "");

    int index = 0;
    for (const auto &elm : msgList) {
        notify[index]["msgid"] = elm->id;
        notify[index]["cluid"] = elm->sender;
        notify[index]["subject"] = elm->subject;
        notify[index]["timestamp"] = duration_cast<seconds>(elm->created.time_since_epoch()).count();
        notify[index]["flag_read"] = elm->read;
        index++;
    }

    this->sendCommand(notify);
    return command_result{error::ok};
}

//messageadd cluid=ePHuXhcai9nk\/4Fd\/xkxrokvnNk= subject=Test message=Message
command_result ConnectedClient::handleCommandMessageAdd(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(25);
    ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_client_offline_textmessage_send, 1);

    this->server->letters->createLetter(this->getUid(), cmd["cluid"], cmd["subject"], cmd["message"]);
    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandMessageGet(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(10);

    auto letter = this->server->letters->getFullLetter(cmd["msgid"]);

    //msgid=2 cluid=IkBXingb46\/z1Q3hhMvJEweb3lw= subject=The\sSubject message=The\sbody timestamp=1512224138
    Command notify(this->getExternalType() == CLIENT_TEAMSPEAK ? "notifymessage" : "");
    notify["msgid"] = cmd["msgid"];
    notify["cluid"] = letter->sender;
    notify["subject"] = letter->subject;
    notify["message"] = letter->message;
    notify["timestamp"] = duration_cast<seconds>(letter->created.time_since_epoch()).count();
    this->sendCommand(notify);

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandMessageUpdateFlag(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);

    this->server->letters->updateReadFlag(cmd["msgid"], cmd["flag"]);

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandMessageDel(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);

    this->server->letters->deleteLetter(cmd["msgid"]);

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandPermGet(Command &cmd) {
    CMD_RESET_IDLE;
    ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_client_permissionoverview_own, 1);

    Command res("");

    deque<permission::PermissionType> requrested;
    auto permission_mapper = serverInstance->getPermissionMapper();
    auto type = this->getType();
    for (int index = 0; index < cmd.bulkCount(); index++) {
        permission::PermissionType permType = permission::unknown;
        if (cmd[index].has("permid"))
            permType = cmd[index]["permid"].as<permission::PermissionType>();
        else if (cmd[index].has("permsid"))
            permType = permission::resolvePermissionData(cmd[index]["permsid"].as<string>())->type; //TODO: Map the other way around!
        if (permission::resolvePermissionData(permType)->type == permission::PermissionType::unknown) return command_result{error::parameter_invalid, "could not resolve permission"};

        requrested.push_back(permType);
    }

    int index = 0;
    for(const auto& entry : this->calculate_permissions(requrested, this->getChannelId())) {
        if(!entry.second.has_value) continue;

        res[index]["permsid"] = permission_mapper->permission_name(type, entry.first);;
        res[index]["permid"] = entry.first;
        res[index++]["permvalue"] = entry.second.value;
    }
    if(index == 0)
        return command_result{error::database_empty_result};
    this->sendCommand(res);

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandPermIdGetByName(Command &cmd) {
    auto found = permission::resolvePermissionData(cmd["permsid"].as<string>()); //TODO: Map the other way around
    Command res("");
    res["permid"] = found->type;
    this->sendCommand(res);
    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandPermFind(Command &cmd) {
    struct PermissionEntry {
        permission::PermissionType  permission_type;
        permission::PermissionValue permission_value;
        permission::PermissionSqlType type;

        GroupId group_id;
        ChannelId channel_id;
        ClientDbId client_id;

        bool negate;
        bool skip;
    };

    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);
    ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_virtualserver_permission_find, 1);

    std::vector<std::tuple<std::string, permission::PermissionType, bool>> requested_permissions{};
    requested_permissions.reserve(cmd.bulkCount());

    std::shared_ptr<permission::PermissionTypeEntry> permission;
    for(size_t index = 0; index < cmd.bulkCount(); index++) {
        bool granted = false;
        if (cmd[index].has("permid")) {
            permission = permission::resolvePermissionData((permission::PermissionType) (cmd[index]["permid"].as<permission::PermissionType>() & (~PERM_ID_GRANT)));
            granted = (cmd[index]["permid"].as<permission::PermissionType>() & PERM_ID_GRANT) > 0;

            if(permission->type == permission::PermissionType::unknown)
                return command_result{error::parameter_invalid, "could not resolve permission (id=" + cmd[index]["permid"].string() + ")"};
        } else if (cmd[index].has("permsid")) {
            permission = permission::resolvePermissionData(cmd[index]["permsid"].as<string>()); //TODO: Map the other way around
            granted = permission->grant_name == cmd[index]["permsid"].as<string>();

            if(permission->type == permission::PermissionType::unknown)
                return command_result{error::parameter_invalid, "could not resolve permission (id=" + cmd[index]["permid"].string() + ")"};
        } else {
            continue;
        }

        requested_permissions.emplace_back(permission->name, permission->type, granted);
    }

    if(requested_permissions.empty())
        return command_result{error::database_empty_result};

    std::map<std::string, std::tuple<permission::PermissionType, uint8_t>> db_lookup_mapping{};
    std::string query_string{};
    for(const auto& [name, id, as_granted] : requested_permissions) {
        auto& mapping = db_lookup_mapping[name];
        if(std::get<0>(mapping) == 0) {
            std::get<0>(mapping) = id;
            query_string += std::string{query_string.empty() ? "" : " OR "} + "`permId` = '" + name + "'";
        }
        std::get<1>(mapping) |= (1U << as_granted);
    }

    deque<unique_ptr<PermissionEntry>> entries;
    //`serverId` INT NOT NULL, `type` INT, `id` INT, `channelId` INT, `permId` VARCHAR(" UNKNOWN_KEY_LENGTH "), `value` INT, `grant` INT
    sql::command(this->sql, "SELECT `permId`, `type`, `id`, `channelId`, `value`, `grant`, `flag_skip`, `flag_negate` FROM `permissions` WHERE `serverId` = :sid AND (" + query_string + ") AND `type` != :playlist",
                 variable{":sid", this->server->getServerId()},
                 variable{":playlist", permission::SQL_PERM_PLAYLIST}
    ).query([&](int length, string* values, string* columns) {
        permission::PermissionSqlType type{permission::SQL_PERM_GROUP};
        uint64_t id{0};
        ChannelId channel_id{0};
        permission::PermissionValue value{0}, granted_value{0};
        string permission_name{};
        bool negate = false, skip = false;

#if 0
        for (int index = 0; index < length; index++) {
            try {
                if(columns[index] == "type")
                    type = static_cast<permission::PermissionSqlType>(stoll(values[index]));
                else if(columns[index] == "permId")
                    permission_name = values[index];
                else if(columns[index] == "id")
                    id = static_cast<uint64_t>(stoll(values[index]));
                else if(columns[index] == "channelId")
                    channel_id = static_cast<ChannelId>(stoll(values[index]));
                else if(columns[index] == "value")
                    value = static_cast<permission::PermissionValue>(stoll(values[index]));
                else if(columns[index] == "grant")
                    granted_value = static_cast<permission::PermissionValue>(stoll(values[index]));
                else if(columns[index] == "flag_negate")
                    negate = !values[index].empty() && stol(values[index]) == 1;
                else if(columns[index] == "flag_skip")
                    skip = !values[index].empty() && stol(values[index]) == 1;
            } catch(std::exception& ex) {
                debugMessage(this->getServerId(), "[{}] 'permfind' iterates over invalid permission entry. Key: {}, Value: {}, Error: {}", CLIENT_STR_LOG_PREFIX, columns[index], values[index], ex.what());
                return 0;
            }
        }
#else
        assert(length == 8);
        try {
            type = static_cast<permission::PermissionSqlType>(stoll(values[1]));
            permission_name = values[0];
            id = static_cast<uint64_t>(stoll(values[2]));
            channel_id = static_cast<ChannelId>(stoll(values[3]));
            value = static_cast<permission::PermissionValue>(stoll(values[4]));
            granted_value = static_cast<permission::PermissionValue>(stoll(values[5]));
            negate = values[7] == "1";
            skip = values[6] == "1";
        } catch(std::exception& ex) {
            return 0;
        }
#endif

        auto request = db_lookup_mapping.find(permission_name);
        if(request == db_lookup_mapping.end()) return 0; /* shall not happen */

        auto flags = std::get<1>(request->second);
        /* value */
        if((flags & 0x1U) > 0 && value > 0) {
            auto result = make_unique<PermissionEntry>();
            result->permission_type = std::get<0>(request->second);
            result->permission_value = value;
            result->type = type;
            result->channel_id = channel_id;
            result->negate = negate;
            result->skip = skip;
            if (type == permission::SQL_PERM_GROUP) {
                result->group_id = id;
            } else if(type == permission::SQL_PERM_USER) {
                result->client_id = id;
            }

            entries.push_back(std::move(result));
        }

        /* granted */
        if((flags & 0x2U) > 0 && granted_value > 0) {
            auto result = make_unique<PermissionEntry>();
            result->permission_type = (permission::PermissionType) (std::get<0>(request->second) | PERM_ID_GRANT);
            result->permission_value = granted_value;
            result->type = type;
            result->channel_id = channel_id;
            result->negate = negate;
            result->skip = skip;

            if (type == permission::SQL_PERM_GROUP) {
                result->group_id = id;
            } else if(type == permission::SQL_PERM_USER) {
                result->client_id = id;
            }

            entries.push_back(std::move(result));
        }
        return 0;
    });

    if(entries.empty()) {
        return command_result{error::database_empty_result};
    }

    struct CommandPerm {
        permission::PermissionType p;
        permission::PermissionValue v;
        int64_t id1;
        int64_t id2;
        uint8_t t;
    };

    std::vector<CommandPerm> perms;
    perms.resize(entries.size());

    size_t index{0};

    /* 1 := Server | 2 := Channel */
    btree::map<GroupId, int> group_types{};
    for(const auto& s_group : this->server->group_manager()->server_groups()->available_groups(groups::GroupCalculateMode::GLOBAL)) {
        group_types[s_group->group_id()] = 1;
    }
    for(const auto& c_group : this->server->group_manager()->channel_groups()->available_groups(groups::GroupCalculateMode::GLOBAL)) {
        group_types[c_group->group_id()] = 2;
    }

    for(const auto& entry : entries) {
        auto& perm = perms[index++];

#if 0 /* TS3 switched the oder and YatQa as well, to keep compatibility we do it as well */
        if(entry->type == permission::SQL_PERM_USER) {
            if(entry->channel_id > 0) {
                perm.id1 = entry->client_id;
                perm.id2 = entry->channel_id;
                perm.t = 4; /* client channel */
            } else {
                perm.id1 = 0;
                perm.id2 = entry->client_id;
                perm.t = 1; /* client server */
            }
        } else if(entry->type == permission::SQL_PERM_CHANNEL) {
            perm.id1 = 0;
            perm.id2 = entry->channel_id;
            perm.t = 2; /* channel permission */
        } else if(entry->type == permission::SQL_PERM_GROUP) {
            if(entry->channel_id > 0) {
                perm.id1 = entry->group_id;
                perm.id2 = 0;
                perm.t = 3; /* channel group */
            } else {
                perm.id1 = entry->group_id;
                perm.id2 = 0;
                perm.t = 0; /* server group */
            }
        }
#else
        if(entry->type == permission::SQL_PERM_USER) {
            if(entry->channel_id > 0) {
                perm.id1 = entry->channel_id;
                perm.id2 = entry->client_id;
                perm.t = 4; /* client channel */
            } else {
                perm.id1 = entry->client_id;
                perm.id2 = 0;
                perm.t = 1; /* client server */
            }
        } else if(entry->type == permission::SQL_PERM_CHANNEL) {
            perm.id1 = entry->channel_id;
            perm.id2 = 0;
            perm.t = 2; /* channel permission */
        } else if(entry->type == permission::SQL_PERM_GROUP) {
            auto group_type = group_types[entry->group_id];
            switch(group_type) {
                case 1:
                    perm.id1 = entry->group_id;
                    perm.id2 = 0;
                    perm.t = 0; /* server group */
                    break;

                case 2:
                    perm.id1 = 0;
                    perm.id2 = entry->group_id;
                    perm.t = 3; /* channel group */
                    break;

                case 0:
                default:
                    /* unknown group */
                    break;
            }
        }
#endif
        perm.p = entry->permission_type;
        perm.v = entry->permission_value;
    }
    perms.erase(perms.begin() + index, perms.end());


    sort(perms.begin(), perms.end(), [](const CommandPerm& a, const CommandPerm& b) {
        if(a.t < b.t) return true;
        else if(b.t < a.t) return false;

        if(a.id1 < b.id1) return true;
        else if(b.id1 < a.id1) return false;

        if(a.id2 < b.id2) return true;
        else if(b.id2 < a.id2) return false;

        if(a.p < b.p) return true;
        else if(b.p < a.p) return false;

        return &a > &b;
    });

    command_builder result{this->notify_response_command("notifypermfind"), 64, perms.size()};
    index = 0;

    for(const auto& e : perms) {
        auto bulk = result.bulk(index++);
        bulk.put("t", e.t);
        bulk.put("p", (uint16_t) e.p);
        bulk.put("v", e.v);
        bulk.put("id1", e.id1);
        bulk.put("id2", e.id2);
    }
    this->sendCommand(result);

    return command_result{error::ok};
}

/*
 * - Alle rechte der aktuellen server gruppen vom client
 * - Alle client rechte | channel cleint rechte
 * - Alle rechte des channels
 */
command_result ConnectedClient::handleCommandPermOverview(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);

    auto client_dbid = cmd["cldbid"].as<ClientDbId>();
    if(!serverInstance->databaseHelper()->validClientDatabaseId(this->getServer(), client_dbid)) {
        return command_result{error::client_invalid_id};
    }

    if(client_dbid == this->getClientDatabaseId()) {
        ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_client_permissionoverview_own, 1);
    } else {
        ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_client_permissionoverview_view, 1);
    }

    string channel_query, perm_query;

    auto channel = this->server ? this->server->channelTree->findChannel(cmd["cid"]) : serverInstance->getChannelTree()->findChannel(cmd["cid"]);
    if(!channel) {
        return command_result{error::channel_invalid_id};
    }

    auto permission_manager = serverInstance->databaseHelper()->loadClientPermissionManager(this->getServerId(), client_dbid);

    Command result(this->getExternalType() == ClientType::CLIENT_TEAMSPEAK ? "notifypermoverview" : "");
    size_t index = 0;
    result["cldbid"] = client_dbid;
    result["cid"] = channel->channelId();
    if(cmd["return_code"].size() > 0) {
        result["return_code"] = cmd["return_code"].string();
    }

    for(const auto& server_group : this->assignedServerGroups()) {
        auto permission_manager = server_group->permissions();
        for(const auto& permission_data : permission_manager->permissions()) {
            auto& permission = std::get<1>(permission_data);
            if(permission.flags.value_set) {
                result[index]["t"] = 0; /* server group */
                result[index]["id1"] = server_group->group_id();
                result[index]["id2"] = 0;

                result[index]["p"] = std::get<0>(permission_data);
                result[index]["v"] = permission.values.value;
                result[index]["n"] = permission.flags.negate;
                result[index]["s"] = permission.flags.skip;
                index++;
            }
            if(permission.flags.grant_set) {
                result[index]["t"] = 0; /* server group */
                result[index]["id1"] = server_group->group_id();
                result[index]["id2"] = 0;

                result[index]["p"] = (std::get<0>(permission_data) | PERM_ID_GRANT);
                result[index]["v"] = permission.values.grant;
                result[index]["n"] = false;
                result[index]["s"] = false;
                index++;
            }
        }
    }

    {
        for(const auto& permission_data : permission_manager->permissions()) {
            auto& permission = std::get<1>(permission_data);
            if(permission.flags.value_set) {
                result[index]["t"] = 1; /* client */
                result[index]["id1"] = client_dbid;
                result[index]["id2"] = 0;

                result[index]["p"] = std::get<0>(permission_data);
                result[index]["v"] = permission.values.value;
                result[index]["n"] = permission.flags.negate;
                result[index]["s"] = permission.flags.skip;
                index++;
            }
            if(permission.flags.grant_set) {
                result[index]["t"] = 1; /* client */
                result[index]["id1"] = client_dbid;
                result[index]["id2"] = 0;

                result[index]["p"] = (std::get<0>(permission_data) | PERM_ID_GRANT);
                result[index]["v"] = permission.values.grant;
                result[index]["n"] = false;
                result[index]["s"] = false;
                index++;
            }
        }
    }

    {
        auto permission_manager =  channel->permissions();
        for(const auto& permission_data : permission_manager->permissions()) {
            auto& permission = std::get<1>(permission_data);
            if(permission.flags.value_set) {
                result[index]["t"] = 2; /* server channel */
                result[index]["id1"] = channel->channelId();
                result[index]["id2"] = 0;

                result[index]["p"] = std::get<0>(permission_data);
                result[index]["v"] = permission.values.value;
                result[index]["n"] = permission.flags.negate;
                result[index]["s"] = permission.flags.skip;
                index++;
            }
            if(permission.flags.grant_set) {
                result[index]["t"] = 2; /* server channel */
                result[index]["id1"] = channel->channelId();
                result[index]["id2"] = 0;

                result[index]["p"] = (std::get<0>(permission_data) | PERM_ID_GRANT);
                result[index]["v"] = permission.values.grant;
                result[index]["n"] = false;
                result[index]["s"] = false;
                index++;
            }
        }
    }

    auto interited_channel{channel};
    auto channel_group = this->assignedChannelGroup(interited_channel);
    if(channel_group) {
        assert(interited_channel);

        auto permission_manager = channel_group->permissions();
        for(const auto& permission_data : permission_manager->permissions()) {
            auto& permission = std::get<1>(permission_data);
            if(permission.flags.value_set) {
                result[index]["t"] = 3; /* channel group */
                result[index]["id1"] = interited_channel->channelId();
                result[index]["id2"] = channel_group->group_id();

                result[index]["p"] = std::get<0>(permission_data);
                result[index]["v"] = permission.values.value;
                result[index]["n"] = permission.flags.negate;
                result[index]["s"] = permission.flags.skip;
                index++;
            }
            if(permission.flags.grant_set) {
                result[index]["t"] = 3; /* channel group */
                result[index]["id1"] = interited_channel->channelId();
                result[index]["id2"] = channel_group->group_id();

                result[index]["p"] = (std::get<0>(permission_data) | PERM_ID_GRANT);
                result[index]["v"] = permission.values.grant;
                result[index]["n"] = false;
                result[index]["s"] = false;
                index++;
            }
        }
    }

    {
        for(const auto& permission_data : permission_manager->channel_permissions()) {
            auto& permission = std::get<2>(permission_data);
            if(permission.flags.value_set) {
                result[index]["t"] = 4; /* client channel */
                result[index]["id1"] = std::get<1>(permission_data);
                result[index]["id2"] = client_dbid;

                result[index]["p"] = std::get<0>(permission_data);
                result[index]["v"] = permission.values.value;
                result[index]["n"] = permission.flags.negate;
                result[index]["s"] = permission.flags.skip;
                index++;
            }
            if(permission.flags.grant_set) {
                result[index]["t"] = 1; /* client */
                result[index]["id1"] = std::get<1>(permission_data);
                result[index]["id2"] = client_dbid;

                result[index]["p"] = (std::get<0>(permission_data) | PERM_ID_GRANT);
                result[index]["v"] = permission.values.grant;
                result[index]["n"] = false;
                result[index]["s"] = false;
                index++;
            }
        }
    }

    if (index == 0) return command_result{error::database_empty_result};
    this->sendCommand(result);

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandComplainAdd(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(25);

    ClientDbId target = cmd["tcldbid"];
    std::string msg = cmd["message"];

    auto cl = this->server->findClientsByCldbId(target);
    if (cl.empty()) return command_result{error::client_invalid_id};
    ACTION_REQUIRES_GLOBAL_PERMISSION(permission::i_client_complain_power, cl[0]->calculate_permission(permission::i_client_needed_complain_power, 0));

    /*
    if(!serverInstance->databaseHelper()->validClientDatabaseId(target))
        return command_result{error::client_invalid_id, "invalid database id"};
    */

    for (const auto &elm : this->server->complains->findComplainsFromTarget(target))
        if (elm->invoker == this->getClientDatabaseId())
            return command_result{error::database_duplicate_entry, "you already send a complain"};

    if (!this->server->complains->createComplain(target, this->getClientDatabaseId(), msg)) return command_result{error::vs_critical, "could not create complains"};
    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandComplainList(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(25);
    ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_client_complain_list, 1);

    ClientDbId id = cmd[0].has("tcldbid") ? cmd["tcldbid"].as<ClientDbId>() : 0;
    auto list = id == 0 ? this->server->complains->complains() : this->server->complains->findComplainsFromTarget(id);
    if (list.empty()) return command_result{error::database_empty_result};

    deque<ClientDbId> nameQuery;
    for (const auto &elm : list) {
        if (std::find(nameQuery.begin(), nameQuery.end(), elm->invoker) == nameQuery.end())
            nameQuery.push_back(elm->invoker);
        if (std::find(nameQuery.begin(), nameQuery.end(), elm->target) == nameQuery.end())
            nameQuery.push_back(elm->target);
    }

    auto dbInfo = serverInstance->databaseHelper()->queryDatabaseInfo(this->server, nameQuery);

    Command result(this->getExternalType() == CLIENT_TEAMSPEAK ? "notifycomplainlist" : "");
    int index = 0;
    for (const auto &elm : list) {
        result[index]["tcldbid"] = elm->target;
        result[index]["tname"] = "unknown";

        result[index]["fcldbid"] = elm->invoker;
        result[index]["fname"] = "unknown";

        result[index]["message"] = elm->reason;
        result[index]["timestamp"] = chrono::duration_cast<chrono::seconds>(elm->created.time_since_epoch()).count();

        for (const auto &e : dbInfo) {
            if (e->client_database_id == elm->target)
                result[index]["tname"] = e->client_nickname;
            if (e->client_database_id == elm->invoker)
                result[index]["fname"] = e->client_nickname;
        }
        index++;
    }

    this->sendCommand(result);
    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandComplainDel(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);

    ClientDbId tid = cmd["tcldbid"];
    ClientDbId fid = cmd["fcldbid"];

    shared_ptr<ComplainEntry> entry;
    for (const auto &elm : this->server->complains->findComplainsFromTarget(tid))
        if (elm->invoker == fid) {
            entry = elm;
            break;
        }
    if (!entry) return command_result{error::database_empty_result};

    if (entry->invoker == this->getClientDatabaseId())
        ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_client_complain_delete_own, 1);
    else
        ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_client_complain_delete, 1);

    this->server->complains->deleteComplain(entry);

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandComplainDelAll(Command &cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(25);
    ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_client_complain_delete, 1);

    ClientDbId tid = cmd["tcldbid"];
    if (!this->server->complains->deleteComplainsFromTarget(tid)) return command_result{error::database_empty_result};
    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandHelp(Command& cmd) {
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(5);
    ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_serverinstance_help_view, 1);

    string command = cmd[0].has("command") ? cmd["command"].as<string>() : "";
    if(command.empty())
        for(const auto& key : cmd[0].keys()) {
            command = key;
            break;
        }
    if(command.empty())
        command = "help";
    std::transform(command.begin(), command.end(), command.begin(), ::tolower);

    auto file = fs::u8path("commanddocs/" + command + ".txt");
    if(!fs::exists(file)) return command_result{error::file_not_found};

    string line;
    ifstream stream(file);
    if(!stream) return command_result{error::file_io_error};
    while(getline(stream, line))
        this->sendCommand(Command{line});

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandPermReset(ts::Command& cmd) {
    CMD_REQ_SERVER;
    CMD_RESET_IDLE;
    CMD_CHK_AND_INC_FLOOD_POINTS(50);
    ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_virtualserver_permission_reset, 1);

    string token;
    if(!this->server->resetPermissions(token))
        return command_result{error::vs_critical};

    Command result("");
    result["token"] = token;
    this->sendCommand(result);

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandLogView(ts::Command& cmd) {
    CMD_CHK_AND_INC_FLOOD_POINTS(50);

    ServerId target_server = cmd[0].has("instance") && cmd["instance"].as<bool>() ? (ServerId) 0 : this->getServerId();
    if(target_server == 0)
        ACTION_REQUIRES_INSTANCE_PERMISSION(permission::b_serverinstance_log_view, 1);
    else
        ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_virtualserver_log_view, 1);

    auto lagacy = this->getType() == CLIENT_TEAMSPEAK || cmd.hasParm("lagacy") || cmd.hasParm("legacy");
#if 0
    string log_path;
    string server_identifier;
    if(target_server > 0)
        server_identifier = to_string(target_server);
    else
        server_identifier = "[A-Z]{0,7}";

    for(const auto& sink : logger::logger(target_server)->sinks()) {
        if(dynamic_pointer_cast<spdlog::sinks::rotating_file_sink_mt>(sink)) {
            log_path = dynamic_pointer_cast<spdlog::sinks::rotating_file_sink_mt>(sink)->filename();
            break;
        } else if(dynamic_pointer_cast<spdlog::sinks::rotating_file_sink_st>(sink)) {
            log_path = dynamic_pointer_cast<spdlog::sinks::rotating_file_sink_st>(sink)->filename();
            break;
        }
    }
    if(log_path.empty())
        return command_result{error::file_not_found, "Cant find log file (May log disabled?)"};

    { //Replace " within the log path
        size_t index = 0;
        while((index = log_path.find('"', index)) != string::npos) {
            log_path.replace(index, 1, "\\\"");
            index += 2;
        }
    }
    string command = "cat \"" + log_path + "\"";
    command += " | grep -E ";
    command += R"("\] \[.*\]( ){0,6}?)" + server_identifier + " \\|\"";

    size_t beginpos = cmd[0].has("begin_pos") ? cmd["begin_pos"].as<size_t>() : 0ULL; //TODO test it?
    size_t file_index = 0;
    size_t max_lines = cmd[0].has("lines") ? cmd["lines"].as<size_t>() : 100ULL; //TODO bounds?
    deque<pair<uintptr_t, string>> lines;
    {
        debugMessage(target_server, "Logview command: \"{}\"", command);

        array<char, 1024> buffer{};
        string line_buffer;

        std::shared_ptr<FILE> pipe(popen(command.c_str(), "r"), pclose);
        if (!pipe) return command_result{error::file_io_error, "Could not execute command"};
        while (!feof(pipe.get())) {
            auto read = fread(buffer.data(), 1, buffer.size(), pipe.get());
            if(read > 0) {
                if(beginpos == 0 || file_index < beginpos) {
                    if(beginpos != 0 && file_index + read > beginpos) { //We're done we just want to get the size later
                        line_buffer += string(buffer.data(), beginpos - file_index);

                        lines.emplace_back(file_index, line_buffer);
                        if(lines.size() > max_lines) lines.pop_front();
                        //debugMessage(LOG_GENERAL, "Final line {}", line_buffer);
                        line_buffer = "";
                    } else {
                        line_buffer += string(buffer.data(), read);

                        size_t index;
                        size_t length;
                        size_t cut_offset = 0;
                        while((index = line_buffer.find("\n")) != string::npos || (index = line_buffer.find("\r")) != string::npos) {
                            length = 0;
                            if(index > 0) {
                                if(line_buffer[index - 1] == '\r' || line_buffer[index - 1] == '\n') {
                                    length = 2;
                                    index--;
                                }
                            }
                            if(length == 0) {
                                if(index + 1 < line_buffer.length()) {
                                    if(line_buffer[index + 1] == '\r' || line_buffer[index + 1] == '\n') {
                                        length = 2;
                                    }
                                }
                            }
                            if(length == 0) length = 1;

                            //debugMessage(LOG_GENERAL, "Got line {}",  line_buffer.substr(0, index));
                            lines.emplace_back(file_index + cut_offset, line_buffer.substr(0, index));
                            if(lines.size() > max_lines) lines.pop_front();

                            cut_offset += index + length;
                            line_buffer = line_buffer.substr(index + length);
                        }
                    }
                }
                file_index += read;
            } else if(read < 0) return command_result{error::file_io_error, "fread(...) returned " + to_string(read) + " (" + to_string(errno) + ")"};
        }

        if(!line_buffer.empty()) {
            lines.emplace_back(file_index - line_buffer.length(), line_buffer);
            if(lines.size() > max_lines) lines.pop_front();
        }
    }
    //last_pos=1558 file_size=1764 l
    if(lines.empty()) return command_result{error::database_empty_result};
    Command result(this->getExternalType() == ClientType::CLIENT_TEAMSPEAK ? "notifyserverlog" : "");
    result["last_pos"] = lines.front().first;
    result["file_size"] = file_index;

    if(!(cmd.hasParm("reverse") && cmd["revers"].as<bool>()))
        std::reverse(lines.begin(), lines.end());

    int index = 0;
    for(const auto& index_line : lines) {
        auto line = index_line.second;
        //2018-07-15 21:01:46.488639
        //TeamSpeak format:
        //YYYY-MM-DD hh:mm:ss.millis|{:<8}|{:<14}|{:<3}|....
        //2018-07-15 21:01:47.066367|INFO    |VirtualServer |1  |listening on 0.0.0.0:9989, [::]:9989

        //TeaSpeak:
        //[2018-07-15 23:21:47] [ERROR] Timer sql_test tick needs more than 9437 microseconds. Max allowed was 5000 microseconds.
        if(lagacy) {
            string ts = line.substr(1, 19) + ".000000|";

            {
                string type = "unknown";

                auto idx = line.find_first_of('[', 2);
                if(idx != string::npos) {
                    type = line.substr(idx + 1, line.find(']', idx + 1) - idx - 1);
                }

                ts += type + " |    | |" + line.substr(line.find('|') + 1);
            }

            if(ts.length() > 1024)
                ts = ts.substr(0, 1024) + "...";
            result[index++]["l"] = ts;
        } else {
            if(line.length() > 1024)
                line = line.substr(0, 1024) + "...";
            result[index++]["l"] = line;
        }
    }
    this->sendCommand(result);
#else
    constexpr static std::array<std::string_view, 5> log_output{
        "located at your TeaSpeak installation folder. All logs could be found there.",
        "If you need to lookup the TeaSpeak - Server logs, please visit the 'logs/' folder,",
        "",
        "In order to lookup the server actions use 'logquery'.",
        "The command 'logview' is not supported anymore."
    };

    command_builder result{this->getExternalType() == ClientType::CLIENT_TEAMSPEAK ? "notifyserverlog" : ""};
    result.put_unchecked(0, "last_pos", 0);
    result.put_unchecked(0, "file_size", 0);

    size_t index{0};
    if(lagacy) {
        for(const auto& message : log_output) {
           std::string line{"2020-06-27 00:00.000" + std::to_string(index) + "|CRITICAL|Server Instance | |"};
           line += message;
           result.put_unchecked(index++, "l", line);
        }
    } else {
        for(const auto& message : log_output) {
            std::string line{"[2020-06-27 00:00:0" + std::to_string(index) + "][ERROR] "};
            line += message;
            result.put_unchecked(index++, "l", line);
        }
    }
    this->sendCommand(result);
#endif

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandLogQuery(ts::Command &cmd) {
    CMD_CHK_AND_INC_FLOOD_POINTS(50);

    uint64_t target_server = (cmd[0].has("instance") && cmd["instance"].as<bool>()) || cmd.hasParm("instance") ? (ServerId) 0 : this->getServerId();
    if(target_server == 0) {
        ACTION_REQUIRES_INSTANCE_PERMISSION(permission::b_serverinstance_log_view, 1);
    } else {
        ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_virtualserver_log_view, 1);
    }

    std::chrono::system_clock::time_point timestamp_begin{}, timestamp_end{};

    if(cmd[0].has("begin"))
        timestamp_begin += std::chrono::milliseconds{cmd["begin"].as<uint64_t>()};

    if(cmd[0].has("end"))
        timestamp_end += std::chrono::milliseconds{cmd["end"].as<uint64_t>()};

    if(timestamp_begin <= timestamp_end && timestamp_begin.time_since_epoch().count() != 0)
        return command_result{error::parameter_constraint_violation, "begin > end"};

    size_t limit{100};
    if(cmd[0].has("limit"))
        limit = std::min((size_t) 2000, cmd["limit"].as<size_t>());

    std::vector<log::LoggerGroup> groups{};
    if(cmd[0].has("groups")) {
        auto groups_string = cmd["groups"].string();
        size_t offset{0}, findex;
        do {
            findex = groups_string.find(',', offset);

            auto group_name = groups_string.substr(offset, findex - offset);
            offset = findex + 1;


            size_t index{0};
            for(; index < (size_t) log::LoggerGroup::MAX; index++) {
                auto group = static_cast<log::LoggerGroup>(index);
                if(log::kLoggerGroupName[(int) group] == group_name) {
                    if(std::find(groups.begin(), groups.end(), group) != groups.end())
                        return command_result{error::parameter_invalid, "groups"};

                    groups.push_back(group);
                }
            }

            if(index == (size_t) log::LoggerGroup::MAX)
                return command_result{error::parameter_invalid, "groups"};
        } while(offset != 0);
    }

    auto result = serverInstance->action_logger()->query(groups, target_server, timestamp_begin, timestamp_end, limit);
    if(result.empty())
        return command_result{error::database_empty_result};

    command_builder notify{this->notify_response_command("notifylogquery")};
    size_t index{0};
    size_t threshold = this->getType() == ClientType::CLIENT_QUERY ? (size_t) -1 : 4096; /* limit each command to 4096 bytes */
    for(log::LogEntryInfo& entry : result) {
        notify.set_bulk(index, std::move(entry.info));
        if(index == 0)
            notify.put_unchecked(0, "sid", this->getServerId());

        if(notify.current_size() > threshold) {
            this->sendCommand(notify);
            notify.reset();
            index = 0;
        }
        index++;
    }
    if(index> 0)
        this->sendCommand(notify);

    if(this->getType() != ClientType::CLIENT_QUERY)
        this->sendCommand(command_builder{"notifylogqueryfinished"});

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandLogAdd(ts::Command& cmd) {
    CMD_CHK_AND_INC_FLOOD_POINTS(50);

    uint64_t target_server = cmd[0].has("instance") && cmd["instance"].as<bool>() ? (ServerId) 0 : this->getServerId();
    if(target_server == 0) {
        ACTION_REQUIRES_INSTANCE_PERMISSION(permission::b_serverinstance_log_add, 1);
    } else {
        ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_virtualserver_log_add, 1);
    }

    serverInstance->action_logger()->custom_logger.add_log_message(target_server, this->ref(), cmd["msg"]);
    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandUpdateMyTsId(ts::Command &) {
    if(config::voice::suppress_myts_warnings) return command_result{error::ok};
    return command_result{error::not_implemented};
}

command_result ConnectedClient::handleCommandUpdateMyTsData(ts::Command &) {
    if(config::voice::suppress_myts_warnings) return command_result{error::ok};
    return command_result{error::not_implemented};
}


command_result ConnectedClient::handleCommandQueryList(ts::Command &cmd) {
    OptionalServerId server_id = EmptyServerId;
    if(this->getExternalType() == ClientType::CLIENT_TEAMSPEAK)
        server_id = this->getServerId();

    if(cmd[0].has("server_id"))
        server_id = cmd["server_id"];
    if(cmd[0].has("sid"))
        server_id = cmd["sid"];

    auto server = server_id == EmptyServerId ? nullptr : serverInstance->getVoiceServerManager()->findServerById(server_id);
    if(!server && server_id != EmptyServerId && server_id != 0)
        return command_result{error::server_invalid_id};

    ClientPermissionCalculator client_permissions{server, this->getClientDatabaseId(), this->getType(), 0};
    auto global_list = permission::v2::permission_granted(1, client_permissions.calculate_permission(permission::b_client_query_list));
    auto own_list = global_list || permission::v2::permission_granted(1, client_permissions.calculate_permission(permission::b_client_query_list_own));

    if(!own_list && !global_list)
        return command_result{permission::b_client_query_list};

    auto accounts = serverInstance->getQueryServer()->list_query_accounts(server_id);
    if(!global_list) {
        accounts.erase(remove_if(accounts.begin(), accounts.end(), [&](const std::shared_ptr<QueryAccount>& account) {
            return account->unique_id != this->getUid();
        }), accounts.end());
    }

    if(accounts.empty())
        return command_result{error::database_empty_result};

    Command result(this->getExternalType() == ClientType::CLIENT_TEAMSPEAK ? "notifyquerylist" : "");
    result["server_id"] = server_id;
    result["flag_own"] = own_list;
    result["flag_all"] = global_list;

    size_t index = 0;
    for(const auto& account : accounts) {
        result[index]["client_unique_identifier"] = account->unique_id;
        result[index]["client_login_name"] = account->username;
        result[index]["client_bound_server"] = account->bound_server;
        index++;
    }

    this->sendCommand(result);

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandQueryCreate(ts::Command &cmd) {
    OptionalServerId server_id = this->getServerId();
    if(cmd[0].has("server_id"))
        server_id = cmd["server_id"];

    if(cmd[0].has("sid"))
        server_id = cmd["sid"];

    auto server = server_id == EmptyServerId ? nullptr : serverInstance->getVoiceServerManager()->findServerById(server_id);
    if(!server && server_id != EmptyServerId && server_id != 0)
        return command_result{error::server_invalid_id};

    auto username = cmd["client_login_name"].as<string>();
    auto password = cmd[0].has("client_login_password") ? cmd["client_login_password"].as<string>() : "";

    auto account = serverInstance->getQueryServer()->find_query_account_by_name(username);
    if(account) return command_result{error::query_already_exists};

    ClientPermissionCalculator client_permissions{server, this->getClientDatabaseId(), this->getType(), 0};
    auto uid{this->getUid()};
    if(cmd[0].has("cldbid")){
        if(!serverInstance->databaseHelper()->validClientDatabaseId(server, cmd["cldbid"].as<ClientDbId>()))
            return command_result{error::database_empty_result};


        if(!permission::v2::permission_granted(1, client_permissions.calculate_permission(permission::b_client_query_create))) {
            return command_result{permission::b_client_query_create};
        }

        auto info = serverInstance->databaseHelper()->queryDatabaseInfo(server, {cmd["cldbid"].as<ClientDbId>()});
        if(info.empty())
            return command_result{error::database_empty_result};
        uid = info[0]->client_unique_id;
    } else {
        if(!permission::v2::permission_granted(1, client_permissions.calculate_permission(permission::b_client_query_create_own))) {
            return command_result{permission::b_client_query_create_own};
        }
    }

    if(password.empty())
        password = rnd_string(QUERY_PASSWORD_LENGTH);

    account = serverInstance->getQueryServer()->create_query_account(username, server_id, uid, password);
    if(!account)
        return command_result{error::vs_critical};

    Command result(this->getExternalType() == ClientType::CLIENT_TEAMSPEAK ? "notifyquerycreated" : "");
    result["client_unique_identifier"] = account->unique_id;
    result["client_login_name"] = account->username;
    result["client_login_password"] = password;
    result["client_bound_server"] = account->bound_server;
    this->sendCommand(result);

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandQueryDelete(ts::Command &cmd) {
    auto username = cmd["client_login_name"].as<string>();
    auto account = serverInstance->getQueryServer()->find_query_account_by_name(username);
    if(!account)
        return command_result{error::query_not_exists};

    auto server = serverInstance->getVoiceServerManager()->findServerById(account->bound_server);
    /* If the server is not existing anymore, we're asking for global permissions
    if(!server && account->bounded_server != 0)
        return command_result{error::server_invalid_id};
    */

    ClientPermissionCalculator client_permissions{server, this->getClientDatabaseId(), this->getType(), 0};
    auto delete_all = permission::v2::permission_granted(1, client_permissions.calculate_permission(permission::b_client_query_delete));
    auto delete_own = delete_all || permission::v2::permission_granted(1, client_permissions.calculate_permission(permission::b_client_query_delete_own));

    if(account->unique_id == this->getUid()) {
        if(!delete_own) {
            return command_result{permission::b_client_query_delete_own};
        }
    } else {
        if(!delete_all) {
            return command_result{permission::b_client_query_delete};
        }
    }

    if(account->unique_id == "serveradmin" && account->username == "serveradmin") {
        return command_result{error::vs_critical};
    }

    serverInstance->getQueryServer()->delete_query_account(account);

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandQueryRename(ts::Command &cmd) {
    auto username = cmd["client_login_name"].as<string>();
    auto new_username = cmd["client_new_login_name"].as<string>();

    auto account = serverInstance->getQueryServer()->find_query_account_by_name(username);
    if(!account)
        return command_result{error::query_not_exists};

    auto server = serverInstance->getVoiceServerManager()->findServerById(account->bound_server);
    if(!server && account->bound_server != 0)
        return command_result{error::server_invalid_id};


    ClientPermissionCalculator client_permissions{server, this->getClientDatabaseId(), this->getType(), 0};
    auto rename_all = permission::v2::permission_granted(1, client_permissions.calculate_permission(permission::b_client_query_rename));
    auto rename_own = rename_all || permission::v2::permission_granted(1, client_permissions.calculate_permission(permission::b_client_query_rename_own));

    if(account->unique_id == this->getUid()) {
        if(!rename_own) {
            return command_result{permission::b_client_query_rename_own};
        }
    } else {
        if(!rename_all) {
            return command_result{permission::b_client_query_rename};
        }
    }

    auto target_account = serverInstance->getQueryServer()->find_query_account_by_name(new_username);
    if(target_account) return command_result{error::query_already_exists};

    if(account->unique_id == "serveradmin" && account->username == "serveradmin")
        return command_result{error::parameter_invalid};

    if(!serverInstance->getQueryServer()->rename_query_account(account, new_username))
        return command_result{error::vs_critical};

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandQueryChangePassword(ts::Command &cmd) {
    auto username = cmd["client_login_name"].as<string>();
    auto account = serverInstance->getQueryServer()->find_query_account_by_name(username);
    if(!account)
        return command_result{error::query_not_exists};

    auto server = serverInstance->getVoiceServerManager()->findServerById(account->bound_server);
    if(!server && account->bound_server != 0)
        return command_result{error::server_invalid_id};

    ClientPermissionCalculator client_permissions{server, this->getClientDatabaseId(), this->getType(), 0};
    auto change_all = permission::v2::permission_granted(1, client_permissions.calculate_permission(permission::b_client_query_change_password));
    auto change_own = change_all || permission::v2::permission_granted(1, client_permissions.calculate_permission(permission::b_client_query_change_own_password));

    auto password = cmd[0].has("client_login_password") ? cmd["client_login_password"].as<string>() : "";

    if(password.empty())
        password = rnd_string(QUERY_PASSWORD_LENGTH);

    if(account->unique_id == this->getUid()) {
        if(!change_own)
            return command_result{permission::b_client_query_change_own_password};
    } else {
        if(!change_all)
            return command_result{server ? permission::b_client_query_change_password : permission::b_client_query_change_password_global};
    }

    if(!serverInstance->getQueryServer()->change_query_password(account, password))
        return command_result{error::vs_critical};

    Command result(this->getExternalType() == ClientType::CLIENT_TEAMSPEAK ? "notifyquerypasswordchanges" : "");
    result["client_login_name"] = account->username;
    result["client_login_password"] = password;
    this->sendCommand(result);

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandDummy_IpChange(ts::Command &cmd) {
    CMD_REF_SERVER(server);
    logMessage(this->getServerId(), "[{}] Address changed from {} to {}", CLIENT_STR_LOG_PREFIX, cmd["old_ip"].string(), cmd["new_ip"].string());

    if(geoloc::provider_vpn && !permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_ignore_vpn, 0))) {
        auto provider = this->isAddressV4() ? geoloc::provider_vpn->resolveInfoV4(this->getPeerIp(), true) : geoloc::provider_vpn->resolveInfoV6(this->getPeerIp(), true);
        if(provider) {
            this->disconnect(strvar::transform(ts::config::messages::kick_vpn, strvar::StringValue{"provider.name", provider->name}, strvar::StringValue{"provider.website", provider->side}));
            return command_result{error::ok};
        }
    }

    string new_country = config::geo::countryFlag;
    if(geoloc::provider) {
        auto loc = this->isAddressV4() ? geoloc::provider->resolveInfoV4(this->getPeerIp(), false) : geoloc::provider->resolveInfoV6(this->getPeerIp(), false);
        if(loc) {
            logMessage(this->getServerId(), "[{}] Received new ip location. IP {} traced to {} ({}).", CLIENT_STR_LOG_PREFIX, this->getLoggingPeerIp(), loc->name, loc->identifier);
            this->properties()[property::CLIENT_COUNTRY] = loc->identifier;
            server->notifyClientPropertyUpdates(this->ref(),  deque<property::ClientProperties>{property::CLIENT_COUNTRY});
            new_country = loc->identifier;
        } else {
            logError(this->getServerId(), "[{}] Failed to resolve ip location for IP {}.", CLIENT_STR_LOG_PREFIX, this->getLoggingPeerIp());
        }
    }

    serverInstance->databaseHelper()->updateClientIpAddress(this->getServerId(), this->getClientDatabaseId(), this->getLoggingPeerIp());
    return command_result{error::ok};
}

//conversationhistory cid=1 [cpw=xxx] [timestamp_begin] [timestamp_end (0 := no end)] [message_count (default 25| max 100)] [-merge]
command_result ConnectedClient::handleCommandConversationHistory(ts::Command &command) {
    CMD_REF_SERVER(ref_server);
    CMD_CHK_AND_INC_FLOOD_POINTS(25);

    if(!command[0].has("cid") || !command[0]["cid"].castable<ChannelId>())
        return command_result{error::conversation_invalid_id};

    auto conversation_id = command[0]["cid"].as<ChannelId>();
    /* test if we have access to the conversation */
    if(conversation_id > 0) {
        /* test if we're able to see the channel */
        {
            shared_lock channel_view_lock(this->channel_tree_mutex);
            auto channel = this->channel_view()->find_channel(conversation_id);
            if(!channel)
                return command_result{error::conversation_invalid_id};

            auto conversation_mode = channel->channel()->properties()[property::CHANNEL_CONVERSATION_MODE].as_unchecked<ChannelConversationMode>();
            switch (conversation_mode) {
                case ChannelConversationMode::CHANNELCONVERSATIONMODE_PRIVATE:
                    return command_result{error::conversation_is_private};

                case ChannelConversationMode::CHANNELCONVERSATIONMODE_NONE:
                    return command_result{error::conversation_not_exists};

                case ChannelConversationMode::CHANNELCONVERSATIONMODE_PUBLIC:
                    break;
            }
        }

        /* test if there is a channel password or join power which denies that we see the conversation */
        {
            shared_lock channel_view_lock(ref_server->channel_tree_mutex);
            auto channel = ref_server->getChannelTree()->findChannel(conversation_id);
            if(!channel) /* should never happen! */
                return command_result{error::conversation_invalid_id};

            if (!channel->verify_password(command["cpw"].optional_string(), this->getType() != ClientType::CLIENT_QUERY)) {
                ACTION_REQUIRES_PERMISSION(permission::b_channel_join_ignore_password, 1, channel->channelId());
            }

            auto error = this->calculate_and_get_join_state(channel);
            if(error) return command_result{error};
        }
    }

    auto conversation_manager = ref_server->conversation_manager();
    auto conversation = conversation_manager->get(conversation_id);
    if(!conversation)
        return command_result{error::database_empty_result};

    system_clock::time_point timestamp_begin = system_clock::now();
    system_clock::time_point timestamp_end;
    size_t message_count = 25;

    if(command[0].has("timestamp_begin"))
        timestamp_begin = system_clock::time_point{} + milliseconds(command[0]["timestamp_begin"].as<uint64_t>());

    if(command[0].has("timestamp_end"))
        timestamp_end = system_clock::time_point{} + milliseconds(command[0]["timestamp_end"].as<uint64_t>());

    if(command[0].has("message_count"))
        message_count = command[0]["message_count"].as<uint64_t>();

    if(timestamp_begin < timestamp_end)
        return command_result{error::parameter_invalid};
    if(message_count > 100)
        message_count = 100;

    auto messages = conversation->message_history(timestamp_begin, message_count + 1, timestamp_end); /* query one more to test for more data */
    if(messages.empty())
        return command_result{error::database_empty_result};
    bool more_data = messages.size() > message_count;
    if(more_data)
        messages.pop_back();

    Command notify(this->notify_response_command("notifyconversationhistory"));
    size_t index = 0;
    size_t length = 0;
    bool merge = command.hasParm("merge");

    for(auto it = messages.rbegin(); it != messages.rend(); it++) {
        if(index == 0) {
            notify[index]["cid"] = conversation_id;
            notify[index]["flag_volatile"] = conversation->volatile_only();
        }

        auto& message = *it;
        notify[index]["timestamp"] = duration_cast<milliseconds>(message->message_timestamp.time_since_epoch()).count();
        notify[index]["sender_database_id"] = message->sender_database_id;
        notify[index]["sender_unique_id"] = message->sender_unique_id;
        notify[index]["sender_name"] = message->sender_name;

        notify[index]["msg"] = message->message;
        length += message->message.size();
        length += message->sender_name.size();
        length += message->sender_unique_id.size();
        if(length > 1024 * 8 || !merge) {
            index = 0;
            this->sendCommand(notify);
            notify = Command{this->notify_response_command("notifyconversationhistory")};
        } else
            index++;
    }
    if(index > 0)
        this->sendCommand(notify);

    if(more_data)
        return command_result{error::conversation_more_data};

    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandConversationFetch(ts::Command &cmd) {
    CMD_REF_SERVER(ref_server);
    CMD_CHK_AND_INC_FLOOD_POINTS(25);


    Command result(this->notify_response_command("notifyconversationindex"));
    size_t result_index = 0;

    auto conversation_manager = ref_server->conversation_manager();
    for(size_t index = 0; index < cmd.bulkCount(); index++) {
        auto& bulk = cmd[index];

        if(!bulk.has("cid") || !bulk["cid"].castable<ChannelId>())
            continue;
        auto conversation_id = bulk["cid"].as<ChannelId>();

        auto& result_bulk = result[result_index++];
        result_bulk["cid"] = conversation_id;

        /* test if we have access to the conversation */
        if(conversation_id > 0) {
            /* test if we're able to see the channel */
            {
                shared_lock channel_view_lock(this->channel_tree_mutex);
                auto channel = this->channel_view()->find_channel(conversation_id);
                if(!channel) {
                    auto error = findError("conversation_invalid_id");
                    result_bulk["error_id"] = error.errorId;
                    result_bulk["error_msg"] = error.message;
                    continue;
                }

                auto conversation_mode = channel->channel()->properties()[property::CHANNEL_CONVERSATION_MODE].as_unchecked<ChannelConversationMode>();
                switch (conversation_mode) {
                    case ChannelConversationMode::CHANNELCONVERSATIONMODE_PRIVATE: {
                        auto error = findError("conversation_is_private");
                        result_bulk["error_id"] = error.errorId;
                        result_bulk["error_msg"] = error.message;
                        continue;
                    }

                    case ChannelConversationMode::CHANNELCONVERSATIONMODE_NONE: {
                        auto error = findError("conversation_not_exists");
                        result_bulk["error_id"] = error.errorId;
                        result_bulk["error_msg"] = error.message;
                        continue;
                    }

                    case ChannelConversationMode::CHANNELCONVERSATIONMODE_PUBLIC:
                        break;
                }
            }

            /* test if there is a channel password or join power which denies that we see the conversation */
            {
                shared_lock channel_view_lock(ref_server->channel_tree_mutex);
                auto channel = ref_server->getChannelTree()->findChannel(conversation_id);
                if(!channel) { /* should never happen! */
                    auto error = findError("conversation_invalid_id");
                    result_bulk["error_id"] = error.errorId;
                    result_bulk["error_msg"] = error.message;
                    continue;
                }

                if (!channel->verify_password( bulk.has("cpw") ? std::make_optional(bulk["cpw"].string()) : std::nullopt, this->getType() != ClientType::CLIENT_QUERY)) {
                    if(!permission::v2::permission_granted(1, this->calculate_permission(permission::b_channel_join_ignore_password, 1, channel->channelId()))) {
                        auto error = findError("channel_invalid_password");
                        result_bulk["error_id"] = error.errorId;
                        result_bulk["error_msg"] = error.message;
                        continue;
                    }
                }

                if(auto error_perm = this->calculate_and_get_join_state(channel); error_perm) {
                    auto error = findError("server_insufficeient_permissions");
                    result_bulk["error_id"] = error.errorId;
                    result_bulk["error_msg"] = error.message;
                    result_bulk["failed_permid"] = (int) error_perm;
                    continue;
                }
            }
        }

        auto conversation = conversation_manager->get(conversation_id);
        if(conversation) {
            result_bulk["timestamp"] = duration_cast<milliseconds>(conversation->last_message().time_since_epoch()).count();
            result_bulk["flag_volatile"] = conversation->volatile_only();
        } else {
            result_bulk["timestamp"] = 0;
            result_bulk["flag_volatile"] = false;
        }
    }
    if(result_index == 0)
        return command_result{error::database_empty_result};
    this->sendCommand(result);


    return command_result{error::ok};
}

command_result ConnectedClient::handleCommandConversationMessageDelete(ts::Command &cmd) {
    CMD_REF_SERVER(ref_server);
    CMD_CHK_AND_INC_FLOOD_POINTS(25);

    auto conversation_manager = ref_server->conversation_manager();
    std::shared_ptr<conversation::Conversation> current_conversation;
    ChannelId current_conversation_id = 0;

    for(size_t index = 0; index < cmd.bulkCount(); index++) {
        auto &bulk = cmd[index];

        if(!bulk.has("cid") || !bulk["cid"].castable<ChannelId>())
            continue;

        /* test if we have access to the conversation */
        if(current_conversation_id != bulk["cid"].as<ChannelId>()) {
            current_conversation_id = bulk["cid"].as<ChannelId>();

            /* test if we're able to see the channel */
            {
                shared_lock channel_view_lock(this->channel_tree_mutex);
                auto channel = this->channel_view()->find_channel(current_conversation_id);
                if(!channel)
                    return command_result{error::conversation_invalid_id};
            }

            /* test if there is a channel password or join power which denies that we see the conversation */
            {
                shared_lock channel_view_lock(ref_server->channel_tree_mutex);
                auto channel = ref_server->getChannelTree()->findChannel(current_conversation_id);
                if(!channel)
                    return command_result{error::conversation_invalid_id};

                if (!channel->verify_password( bulk.has("cpw") ? std::make_optional(bulk["cpw"].string()) : std::nullopt, this->getType() != ClientType::CLIENT_QUERY)) {
                    ACTION_REQUIRES_PERMISSION(permission::b_channel_join_ignore_password, 1, channel->channelId());
                }

                if (!permission::v2::permission_granted(1, this->calculate_permission(permission::b_channel_conversation_message_delete, channel->channelId())))
                    return command_result{permission::b_channel_conversation_message_delete};

                if(auto error_perm = this->calculate_and_get_join_state(channel); error_perm != permission::ok && error_perm != permission::b_client_is_sticky)
                    return command_result{error_perm};
            }
        }

        current_conversation = conversation_manager->get(current_conversation_id);
        if(!current_conversation) continue;

        auto timestamp_begin = system_clock::time_point{} + milliseconds{bulk["timestamp_begin"]};
        auto timestamp_end = system_clock::time_point{} + milliseconds{bulk.has("timestamp_end") ? bulk["timestamp_end"].as<uint64_t>() : 0};
        auto limit = bulk.has("limit") ? bulk["limit"].as<uint64_t>() : 1;
        if(limit > 100)
            limit = 100;

        auto delete_count = current_conversation->delete_messages(timestamp_end, limit, timestamp_begin, bulk["cldbid"]);
        if(delete_count > 0) {
            for(const auto& client : ref_server->getClients()) {
                if(client->connectionState() != ConnectionState::CONNECTED)
                    continue;

                auto type = client->getType();
                if(type == ClientType::CLIENT_INTERNAL || type == ClientType::CLIENT_MUSIC)
                    continue;

                client->notifyConversationMessageDelete(current_conversation_id, timestamp_begin, timestamp_end, bulk["cldbid"], delete_count);
            }
        }
    }

    return command_result{error::ok};
}

enum struct FeatureSupportMode {
    NONE,
    FULL,
    EXPERIMENTAL,
    DEPRECATED
};

#define REGISTER_FEATURE(name, support, version)                \
    notify.put_unchecked(index, "name", name);                  \
    notify.put_unchecked(index, "support", (int) support);      \
    notify.put_unchecked(index, "version", version);            \
    index++

command_result ConnectedClient::handleCommandListFeatureSupport(ts::Command &cmd) {
    ts::command_builder notify{this->notify_response_command("notifyfeaturesupport")};
    int index{0};

    REGISTER_FEATURE("error-bulks", FeatureSupportMode::FULL, 1);
    REGISTER_FEATURE("advanced-channel-chat", FeatureSupportMode::FULL, 1);
    REGISTER_FEATURE("log-query", FeatureSupportMode::FULL, 1);
    REGISTER_FEATURE("whisper-echo", FeatureSupportMode::FULL, 1);
    REGISTER_FEATURE("video", FeatureSupportMode::EXPERIMENTAL, 1);
    REGISTER_FEATURE("sidebar-mode", FeatureSupportMode::FULL, 1);
    REGISTER_FEATURE("token", FeatureSupportMode::FULL, 1);

    this->sendCommand(notify);
    return command_result{error::ok};
}