/* Copyright (C) 2019 Mr Goldberg
   This file is part of the Goldberg Emulator

   The Goldberg Emulator is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 3 of the License, or (at your option) any later version.

   The Goldberg Emulator is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the Goldberg Emulator; if not, see
   <http://www.gnu.org/licenses/>.  */

#include "dll/dll.h"


static void network_callback(void *object, Common_Message *msg)
{
    PRINT_DEBUG("steam_matchmaking_servers_callback\n");

    Steam_Matchmaking_Servers *obj = (Steam_Matchmaking_Servers *)object;
    obj->Callback(msg);
}

Steam_Matchmaking_Servers::Steam_Matchmaking_Servers(class Settings *settings, class Networking *network)
{
    this->settings = settings;
    this->network = network;
    this->network->setCallback(CALLBACK_ID_GAMESERVER, (uint64) 0, &network_callback, this);
}

static int server_list_request = 0;

HServerListRequest Steam_Matchmaking_Servers::RequestServerList(AppId_t iApp, ISteamMatchmakingServerListResponse *pRequestServersResponse, EMatchMakingType type)
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::RequestServerList %u %p, %i\n", iApp, pRequestServersResponse, (int)type);
    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    ++server_list_request;
    HServerListRequest id = (char *)0 + server_list_request; // (char *)0 silences the compiler warning

    if (settings->matchmaking_server_list_always_lan_type) {
        PRINT_DEBUG("Steam_Matchmaking_Servers::RequestServerList forcing request type to LAN\n");
        type = EMatchMakingType::eLANServer;
    }

    struct Steam_Matchmaking_Request request{};
    request.appid = iApp;
    request.callbacks = pRequestServersResponse;
    request.old_callbacks = NULL;
    request.cancelled = false;
    request.completed = false;
    request.type = type;
    request.id = id;
    requests.push_back(request);
    PRINT_DEBUG("Steam_Matchmaking_Servers::request id: %p\n", id);

    if (type == eLANServer) return id;

    if (type == eFriendsServer) {
        for (auto &g : gameservers_friends) {
            if (g.source_id != settings->get_local_steam_id().ConvertToUint64()) {
                Gameserver server;
                server.set_ip(g.ip);
                server.set_port(g.port);
                server.set_query_port(g.port);
                server.set_appid(iApp);

                struct Steam_Matchmaking_Servers_Gameserver g2;
                g2.last_recv = std::chrono::high_resolution_clock::now();
                g2.server = server;
                g2.type = type;
                gameservers.push_back(g2);
                PRINT_DEBUG("  eFriendsServer SERVER ADDED\n");
            }
        }
        return id;
    }

    std::string file_path;
    unsigned long long file_size;
    if (type == eInternetServer || type == eSpectatorServer) {
        file_path = Local_Storage::get_user_appdata_path() + "/7/" + Local_Storage::remote_storage_folder + "/serverbrowser.txt";
        file_size = file_size_(file_path);
    } else if (type == eFavoritesServer) {
        file_path = Local_Storage::get_user_appdata_path() + "/7/" + Local_Storage::remote_storage_folder + "/serverbrowser_favorites.txt";
        file_size = file_size_(file_path);
    } else if (type == eHistoryServer) {
        file_path = Local_Storage::get_user_appdata_path() + "/7/" + Local_Storage::remote_storage_folder + "/serverbrowser_history.txt";
        file_size = file_size_(file_path);
    }

    PRINT_DEBUG("Steam_Matchmaking_Servers::Server list file '%s' [%llu bytes]\n", file_path.c_str(), file_size);
    std::string list;
    if (file_size) {
        list.resize(file_size);
        Local_Storage::get_file_data(file_path, (char *)list.data(), file_size, 0);
    } else {
        return id;
    }

    std::istringstream list_ss (list);
    std::string list_ip;
    while (std::getline(list_ss, list_ip)) {
        if (list_ip.length() < 0) continue;

        unsigned int byte4, byte3, byte2, byte1, byte0;
        uint32 ip_int;
        uint16 port_int;
        char newip[24];
        if (sscanf(list_ip.c_str(), "%u.%u.%u.%u:%u", &byte3, &byte2, &byte1, &byte0, &byte4) == 5) {
            ip_int = (byte3 << 24) + (byte2 << 16) + (byte1 << 8) + byte0;
            port_int = byte4;

            unsigned char ip_tmp[4];
            ip_tmp[0] = ip_int & 0xFF;
            ip_tmp[1] = (ip_int >> 8) & 0xFF;
            ip_tmp[2] = (ip_int >> 16) & 0xFF;
            ip_tmp[3] = (ip_int >> 24) & 0xFF;
            snprintf(newip, sizeof(newip), "%d.%d.%d.%d", ip_tmp[3], ip_tmp[2], ip_tmp[1], ip_tmp[0]);
        } else {
            continue;
        }

        Gameserver server;
        server.set_ip(ip_int);
        server.set_port(port_int);
        server.set_query_port(port_int);
        server.set_appid(iApp);

        struct Steam_Matchmaking_Servers_Gameserver g;
        g.last_recv = std::chrono::high_resolution_clock::now();
        g.server = server;
        g.type = type;
        gameservers.push_back(g);
        PRINT_DEBUG("  SERVER ADDED\n");

        list_ip = "";
    }

    return id;
}

// Request a new list of servers of a particular type.  These calls each correspond to one of the EMatchMakingType values.
// Each call allocates a new asynchronous request object.
// Request object must be released by calling ReleaseRequest( hServerListRequest )
HServerListRequest Steam_Matchmaking_Servers::RequestInternetServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::RequestInternetServerList\n");
    return RequestServerList(iApp, pRequestServersResponse, eInternetServer);
}

HServerListRequest Steam_Matchmaking_Servers::RequestLANServerList( AppId_t iApp, ISteamMatchmakingServerListResponse *pRequestServersResponse )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::RequestLANServerList\n");
    return RequestServerList(iApp, pRequestServersResponse, eLANServer);
}

HServerListRequest Steam_Matchmaking_Servers::RequestFriendsServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::RequestFriendsServerList\n");
    return RequestServerList(iApp, pRequestServersResponse, eFriendsServer);
}

HServerListRequest Steam_Matchmaking_Servers::RequestFavoritesServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::RequestFavoritesServerList\n");
    return RequestServerList(iApp, pRequestServersResponse, eFavoritesServer);
}

HServerListRequest Steam_Matchmaking_Servers::RequestHistoryServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::RequestHistoryServerList\n");
    return RequestServerList(iApp, pRequestServersResponse, eHistoryServer);
}

HServerListRequest Steam_Matchmaking_Servers::RequestSpectatorServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::RequestSpectatorServerList\n");
    return RequestServerList(iApp, pRequestServersResponse, eSpectatorServer);
}

// old server list request

void Steam_Matchmaking_Servers::RequestOldServerList(AppId_t iApp, ISteamMatchmakingServerListResponse001 *pRequestServersResponse, EMatchMakingType type)
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::RequestOldServerList %u\n", iApp);
    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    auto g = std::begin(requests);
    while (g != std::end(requests)) {
        if (g->id == (void *)type) {
            return;
        }

        ++g;
    }

    struct Steam_Matchmaking_Request request{};
    request.appid = iApp;
    request.callbacks = NULL;
    request.old_callbacks = pRequestServersResponse;
    request.cancelled = false;
    request.completed = false;
    request.type = type;
    request.id = (void *)type;
    requests.push_back(request);
}

void Steam_Matchmaking_Servers::RequestInternetServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse001 *pRequestServersResponse )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::%s old\n", __FUNCTION__);
    //TODO
    RequestOldServerList(iApp, pRequestServersResponse, eInternetServer);
}

void Steam_Matchmaking_Servers::RequestLANServerList( AppId_t iApp, ISteamMatchmakingServerListResponse001 *pRequestServersResponse )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::%s old\n", __FUNCTION__);
    //TODO
    RequestOldServerList(iApp, pRequestServersResponse, eLANServer);
}

void Steam_Matchmaking_Servers::RequestFriendsServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse001 *pRequestServersResponse )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::%s old\n", __FUNCTION__);
    //TODO
    RequestOldServerList(iApp, pRequestServersResponse, eFriendsServer);
}

void Steam_Matchmaking_Servers::RequestFavoritesServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse001 *pRequestServersResponse )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::%s old\n", __FUNCTION__);
    //TODO
    RequestOldServerList(iApp, pRequestServersResponse, eFavoritesServer);
}

void Steam_Matchmaking_Servers::RequestHistoryServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse001 *pRequestServersResponse )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::%s old\n", __FUNCTION__);
    //TODO
    RequestOldServerList(iApp, pRequestServersResponse, eHistoryServer);
}

void Steam_Matchmaking_Servers::RequestSpectatorServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse001 *pRequestServersResponse )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::%s old\n", __FUNCTION__);
    //TODO
    RequestOldServerList(iApp, pRequestServersResponse, eSpectatorServer);
}


// Releases the asynchronous request object and cancels any pending query on it if there's a pending query in progress.
// RefreshComplete callback is not posted when request is released.
void Steam_Matchmaking_Servers::ReleaseRequest( HServerListRequest hServerListRequest )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::ReleaseRequest %p\n", hServerListRequest);
    auto g = std::begin(requests);
    while (g != std::end(requests)) {
        if (g->id == hServerListRequest) {
            //NOTE: some garbage games release the request before getting server details from it.
            //     g = requests.erase(g);
            // } else {
            //TODO: eventually delete the released request.
            g->cancelled = true;
            g->released = true;
        }

        ++g;
    }
}


/* the filter operation codes that go in the key part of MatchMakingKeyValuePair_t should be one of these:

    "map"
        - Server passes the filter if the server is playing the specified map.
    "gamedataand"
        - Server passes the filter if the server's game data (ISteamGameServer::SetGameData) contains all of the
        specified strings.  The value field is a comma-delimited list of strings to match.
    "gamedataor"
        - Server passes the filter if the server's game data (ISteamGameServer::SetGameData) contains at least one of the
        specified strings.  The value field is a comma-delimited list of strings to match.
    "gamedatanor"
        - Server passes the filter if the server's game data (ISteamGameServer::SetGameData) does not contain any
        of the specified strings.  The value field is a comma-delimited list of strings to check.
    "gametagsand"
        - Server passes the filter if the server's game tags (ISteamGameServer::SetGameTags) contains all
        of the specified strings.  The value field is a comma-delimited list of strings to check.
    "gametagsnor"
        - Server passes the filter if the server's game tags (ISteamGameServer::SetGameTags) does not contain any
        of the specified strings.  The value field is a comma-delimited list of strings to check.
    "and" (x1 && x2 && ... && xn)
    "or" (x1 || x2 || ... || xn)
    "nand" !(x1 && x2 && ... && xn)
    "nor" !(x1 || x2 || ... || xn)
        - Performs Boolean operation on the following filters.  The operand to this filter specifies
        the "size" of the Boolean inputs to the operation, in Key/value pairs.  (The keyvalue
        pairs must immediately follow, i.e. this is a prefix logical operator notation.)
        In the simplest case where Boolean expressions are not nested, this is simply
        the number of operands.

        For example, to match servers on a particular map or with a particular tag, would would
        use these filters.

            ( server.map == "cp_dustbowl" || server.gametags.contains("payload") )
            "or", "2"
            "map", "cp_dustbowl"
            "gametagsand", "payload"

        If logical inputs are nested, then the operand specifies the size of the entire
        "length" of its operands, not the number of immediate children.

            ( server.map == "cp_dustbowl" || ( server.gametags.contains("payload") && !server.gametags.contains("payloadrace") ) )
            "or", "4"
            "map", "cp_dustbowl"
            "and", "2"
            "gametagsand", "payload"
            "gametagsnor", "payloadrace"

        Unary NOT can be achieved using either "nand" or "nor" with a single operand.

    "addr"
        - Server passes the filter if the server's query address matches the specified IP or IP:port.
    "gameaddr"
        - Server passes the filter if the server's game address matches the specified IP or IP:port.

    The following filter operations ignore the "value" part of MatchMakingKeyValuePair_t

    "dedicated"
        - Server passes the filter if it passed true to SetDedicatedServer.
    "secure"
        - Server passes the filter if the server is VAC-enabled.
    "notfull"
        - Server passes the filter if the player count is less than the reported max player count.
    "hasplayers"
        - Server passes the filter if the player count is greater than zero.
    "noplayers"
        - Server passes the filter if it doesn't have any players.
    "linux"
        - Server passes the filter if it's a linux server
*/

void Steam_Matchmaking_Servers::server_details(Gameserver *g, gameserveritem_t *server)
{
    int latency = 10;

    if (settings->matchmaking_server_details_via_source_query && !(g->ip() < 0) && !(g->query_port() < 0)) {
        unsigned char ip[4]{};
        char newip[24];
        ip[0] = g->ip() & 0xFF;
        ip[1] = (g->ip() >> 8) & 0xFF;
        ip[2] = (g->ip() >> 16) & 0xFF;
        ip[3] = (g->ip() >> 24) & 0xFF;
        snprintf(newip, sizeof(newip), "%d.%d.%d.%d", ip[3], ip[2], ip[1], ip[0]);

        PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details connecting to ssq server on  %s:%u\n", newip, g->query_port());
        SSQ_SERVER *ssq = ssq_server_new(newip, g->query_port());
        if (ssq != NULL && ssq_server_eok(ssq)) {
            PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details ssq server connection ok\n");
            ssq_server_timeout(ssq, (SSQ_TIMEOUT_SELECTOR)(SSQ_TIMEOUT_RECV | SSQ_TIMEOUT_SEND), 1200);

            std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
            A2S_INFO *ssq_a2s_info = ssq_info(ssq);
            std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
            latency = (int)std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count();
            if (latency < 10) latency = 10; // TODO I don't know if low latency is problematic or not

            if (ssq_server_eok(ssq)) {
                PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details ssq server info ok\n");
                if (ssq_info_has_steamid(ssq_a2s_info)) g->set_id(ssq_a2s_info->steamid);
                g->set_game_description(ssq_a2s_info->game);
                g->set_mod_dir(ssq_a2s_info->folder);
                if (ssq_a2s_info->server_type == A2S_SERVER_TYPE_DEDICATED) g->set_dedicated_server(true);
                else if (ssq_a2s_info->server_type == A2S_SERVER_TYPE_STV_RELAY) g->set_dedicated_server(true);
                else g->set_dedicated_server(false);
                g->set_max_player_count(ssq_a2s_info->max_players);
                g->set_bot_player_count(ssq_a2s_info->bots);
                g->set_server_name(ssq_a2s_info->name);
                g->set_map_name(ssq_a2s_info->map);
                if (ssq_a2s_info->visibility) g->set_password_protected(true);
                else g->set_password_protected(false);
                if (ssq_info_has_stv(ssq_a2s_info)) {
                    g->set_spectator_port(ssq_a2s_info->stv_port);
                    g->set_spectator_server_name(ssq_a2s_info->stv_name);
                }
                //g->set_tags(ssq_a2s_info->keywords);
                //g->set_gamedata();
                //g->set_region();
                g->set_product(ssq_a2s_info->game);
                if (ssq_a2s_info->vac) g->set_secure(true);
                else g->set_secure(false);
                g->set_num_players(ssq_a2s_info->players);
                g->set_version(std::stoull(ssq_a2s_info->version, NULL, 0));
                if (ssq_info_has_port(ssq_a2s_info)) g->set_port(ssq_a2s_info->port);
                if (ssq_info_has_gameid(ssq_a2s_info)) g->set_appid(ssq_a2s_info->gameid);
                else g->set_appid(ssq_a2s_info->id);
                g->set_offline(false);
            } else {
                PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details ssq server info failed: %s\n", ssq_server_emsg(ssq));
            }

            if (ssq_a2s_info != NULL) ssq_info_free(ssq_a2s_info);
        } else {
            PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details ssq server connection failed: %s\n", (ssq ? ssq_server_emsg(ssq) : "NULL instance"));
        }

        if (ssq != NULL) ssq_server_free(ssq);
    }

    uint16 query_port = g->query_port();
    if (g->query_port() == 0xFFFF) {
        query_port = g->port();
    }

    server->m_NetAdr.Init(g->ip(), query_port, g->port());
    server->m_nPing = latency;
    server->m_bHadSuccessfulResponse = true;
    server->m_bDoNotRefresh = false;

    server->m_nAppID = g->appid();
    server->m_nPlayers = g->num_players();
    server->m_nMaxPlayers = g->max_player_count();
    server->m_nBotPlayers = g->bot_player_count();
    server->m_bPassword = g->password_protected();
    server->m_bSecure = g->secure();
    server->m_ulTimeLastPlayed = 0;
    server->m_nServerVersion = g->version();
    server->SetName(g->server_name().c_str());
    server->m_steamID = CSteamID((uint64)g->id());
    
    memset(server->m_szGameDir, 0, sizeof(server->m_szGameDir));
    g->mod_dir().copy(server->m_szGameDir, sizeof(server->m_szGameDir) - 1);

    memset(server->m_szMap, 0, sizeof(server->m_szMap));
    g->map_name().copy(server->m_szMap, sizeof(server->m_szMap) - 1);

    memset(server->m_szGameDescription, 0, sizeof(server->m_szGameDescription));
    g->game_description().copy(server->m_szGameDescription, sizeof(server->m_szGameDescription) - 1);

    memset(server->m_szGameTags, 0, sizeof(server->m_szGameTags));
    g->tags().copy(server->m_szGameTags, sizeof(server->m_szGameTags) - 1);

    PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details " "%" PRIu64 "\n", g->id());
}

void Steam_Matchmaking_Servers::server_details_players(Gameserver *g, Steam_Matchmaking_Servers_Direct_IP_Request *r)
{
    if (settings->matchmaking_server_details_via_source_query && !(g->ip() < 0) && !(g->query_port() < 0)) {
        unsigned char ip[4]{};
        char newip[24];
        ip[0] = g->ip() & 0xFF;
        ip[1] = (g->ip() >> 8) & 0xFF;
        ip[2] = (g->ip() >> 16) & 0xFF;
        ip[3] = (g->ip() >> 24) & 0xFF;
        snprintf(newip, sizeof(newip), "%d.%d.%d.%d", ip[3], ip[2], ip[1], ip[0]);

        PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details_players connecting to ssq server on  %s:%u\n", newip, g->query_port());
        SSQ_SERVER *ssq = ssq_server_new(newip, g->query_port());
        if (ssq != NULL && ssq_server_eok(ssq)) {
            PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details_players ssq server connection ok\n");
            ssq_server_timeout(ssq, (SSQ_TIMEOUT_SELECTOR)(SSQ_TIMEOUT_RECV | SSQ_TIMEOUT_SEND), 1200);

            uint8_t ssq_a2s_player_count = 0;
            A2S_PLAYER *ssq_a2s_player = ssq_player(ssq, &ssq_a2s_player_count);

            if (ssq_server_eok(ssq)) {
                PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details_players ssq server players ok\n");
                for (int i = 0; i < ssq_a2s_player_count; i++) {
                    r->players_response->AddPlayerToList(ssq_a2s_player[i].name, ssq_a2s_player[i].score, ssq_a2s_player[i].duration);
                }
            } else {
                PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details_players ssq server players failed: %s\n", ssq_server_emsg(ssq));
            }

            if (ssq_a2s_player != NULL) ssq_player_free(ssq_a2s_player, ssq_a2s_player_count);
        } else {
            PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details_players ssq server connection failed: %s\n", (ssq ? ssq_server_emsg(ssq) : "NULL instance"));
        }

        if (ssq != NULL) ssq_server_free(ssq);
    } else if (!settings->matchmaking_server_details_via_source_query) { // original behavior
        uint32_t number_players = g->num_players();
        PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details_players players: %u\n", number_players);
        const auto &players = get_steam_client()->steam_gameserver->get_players();
        auto player = players->cbegin();
        for (int i = 0; i < number_players && player != players->end(); ++i, ++player) {
            float playtime = static_cast<float>(std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - player->second.join_time).count());
            PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details_players PLAYER [%u] '%s' %u %f\n", i, player->second.name.c_str(), player->second.score, playtime);
            r->players_response->AddPlayerToList(player->second.name.c_str(), player->second.score, playtime);
        }
    }

    PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details_players " "%" PRIu64 "\n", g->id());
}

void Steam_Matchmaking_Servers::server_details_rules(Gameserver *g, Steam_Matchmaking_Servers_Direct_IP_Request *r)
{
    if (settings->matchmaking_server_details_via_source_query && !(g->ip() < 0) && !(g->query_port() < 0)) {
        unsigned char ip[4]{};
        char newip[24];
        ip[0] = g->ip() & 0xFF;
        ip[1] = (g->ip() >> 8) & 0xFF;
        ip[2] = (g->ip() >> 16) & 0xFF;
        ip[3] = (g->ip() >> 24) & 0xFF;
        snprintf(newip, sizeof(newip), "%d.%d.%d.%d", ip[3], ip[2], ip[1], ip[0]);

        PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details_rules connecting to ssq server on %s:%u\n", newip, g->query_port());
        SSQ_SERVER *ssq = ssq_server_new(newip, g->query_port());
        if (ssq != NULL && ssq_server_eok(ssq)) {
            ssq_server_timeout(ssq, (SSQ_TIMEOUT_SELECTOR)(SSQ_TIMEOUT_RECV | SSQ_TIMEOUT_SEND), 1200);

            uint16_t ssq_a2s_rules_count = 0;
            A2S_RULES *ssq_a2s_rules = ssq_rules(ssq, &ssq_a2s_rules_count);

            if (ssq_server_eok(ssq)) {
                PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details_rules ssq server rules ok\n");
                for (int i = 0; i < ssq_a2s_rules_count; i++) {
                    r->rules_response->RulesResponded(ssq_a2s_rules[i].name, ssq_a2s_rules[i].value);
                }
            } else {
                PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details_rules ssq server rules failed: %s\n", ssq_server_emsg(ssq));
            }

            if (ssq_a2s_rules != NULL) ssq_rules_free(ssq_a2s_rules, ssq_a2s_rules_count);
        } else {
            PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details_rules ssq server connection failed: %s\n", (ssq ? ssq_server_emsg(ssq) : "NULL instance"));
        }

        if (ssq != NULL) ssq_server_free(ssq);
    } else if (!settings->matchmaking_server_details_via_source_query) { // original behavior
        int number_rules = (int)g->values().size();
        PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details_rules rules: %i\n", number_rules);
        auto rule = g->values().begin();
        for (int i = 0; i < number_rules; ++i) {
            PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details_rules RULE '%s' '%s'\n", rule->first.c_str(), rule->second.c_str());
            r->rules_response->RulesResponded(rule->first.c_str(), rule->second.c_str());
            ++rule;
        }
    }

    PRINT_DEBUG("  Steam_Matchmaking_Servers::server_details_rules " "%" PRIu64 "\n", g->id());
}

// Get details on a given server in the list, you can get the valid range of index
// values by calling GetServerCount().  You will also receive index values in 
// ISteamMatchmakingServerListResponse::ServerResponded() callbacks
gameserveritem_t *Steam_Matchmaking_Servers::GetServerDetails( HServerListRequest hRequest, int iServer )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::GetServerDetails %p %i\n", hRequest, iServer);
    std::lock_guard<std::recursive_mutex> lock(global_mutex);

    std::vector <struct Steam_Matchmaking_Servers_Gameserver> gameservers_filtered;
    auto g = std::begin(requests);
    while (g != std::end(requests)) {
        PRINT_DEBUG("  equal? %p %p\n", hRequest, g->id);
        if (g->id == hRequest) {
            gameservers_filtered = g->gameservers_filtered;
            PRINT_DEBUG("  found %zu\n", gameservers_filtered.size());
            break;
        }

        ++g;
    }

    if (iServer >= gameservers_filtered.size() || iServer < 0) {
        return NULL;
    }

    Gameserver *gs = &gameservers_filtered[iServer].server;
    gameserveritem_t *server = new gameserveritem_t(); //TODO: is the new here ok?
    server_details(gs, server);
    PRINT_DEBUG("  Returned server details\n");
    return server;
}


// Cancel an request which is operation on the given list type.  You should call this to cancel
// any in-progress requests before destructing a callback object that may have been passed 
// to one of the above list request calls.  Not doing so may result in a crash when a callback
// occurs on the destructed object.
// Canceling a query does not release the allocated request handle.
// The request handle must be released using ReleaseRequest( hRequest )
void Steam_Matchmaking_Servers::CancelQuery( HServerListRequest hRequest )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::CancelQuery %p\n", hRequest);
    auto g = std::begin(requests);
    while (g != std::end(requests)) {
        if (g->id == hRequest) {
            g->cancelled = true;
        }

        ++g;
    }
}
 

// Ping every server in your list again but don't update the list of servers
// Query callback installed when the server list was requested will be used
// again to post notifications and RefreshComplete, so the callback must remain
// valid until another RefreshComplete is called on it or the request
// is released with ReleaseRequest( hRequest )
void Steam_Matchmaking_Servers::RefreshQuery( HServerListRequest hRequest )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::RefreshQuery %p\n", hRequest);
}
 

// Returns true if the list is currently refreshing its server list
bool Steam_Matchmaking_Servers::IsRefreshing( HServerListRequest hRequest )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::IsRefreshing %p\n", hRequest);
    return false;
}
 

// How many servers in the given list, GetServerDetails above takes 0... GetServerCount() - 1
int Steam_Matchmaking_Servers::GetServerCount( HServerListRequest hRequest )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::GetServerCount %p\n", hRequest);
    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    int size = 0;
    auto g = std::begin(requests);
    while (g != std::end(requests)) {
        if (g->id == hRequest) {
            size = g->gameservers_filtered.size();
            break;
        }

        ++g;
    }

    return size;
}


// Refresh a single server inside of a query (rather than all the servers )
void Steam_Matchmaking_Servers::RefreshServer( HServerListRequest hRequest, int iServer )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::RefreshServer %p\n", hRequest);
    //TODO
}
 
static HServerQuery new_server_query()
{
    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    static int a = 0;
    ++a;
    if (!a) ++a;
    return a;
}

//-----------------------------------------------------------------------------
// Queries to individual servers directly via IP/Port
//-----------------------------------------------------------------------------

// Request updated ping time and other details from a single server
HServerQuery Steam_Matchmaking_Servers::PingServer( uint32 unIP, uint16 usPort, ISteamMatchmakingPingResponse *pRequestServersResponse )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::PingServer %hhu.%hhu.%hhu.%hhu:%hu\n", ((unsigned char *)&unIP)[3], ((unsigned char *)&unIP)[2], ((unsigned char *)&unIP)[1], ((unsigned char *)&unIP)[0], usPort);
    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    Steam_Matchmaking_Servers_Direct_IP_Request r;
    r.id = new_server_query();
    r.ip = unIP;
    r.port = usPort;
    r.ping_response = pRequestServersResponse;
    r.created = std::chrono::high_resolution_clock::now();
    direct_ip_requests.push_back(r);
    return r.id;
}

// Request the list of players currently playing on a server
HServerQuery Steam_Matchmaking_Servers::PlayerDetails( uint32 unIP, uint16 usPort, ISteamMatchmakingPlayersResponse *pRequestServersResponse )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::PlayerDetails %hhu.%hhu.%hhu.%hhu:%hu\n", ((unsigned char *)&unIP)[3], ((unsigned char *)&unIP)[2], ((unsigned char *)&unIP)[1], ((unsigned char *)&unIP)[0], usPort);
    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    Steam_Matchmaking_Servers_Direct_IP_Request r;
    r.id = new_server_query();
    r.ip = unIP;
    r.port = usPort;
    r.players_response = pRequestServersResponse;
    r.created = std::chrono::high_resolution_clock::now();
    direct_ip_requests.push_back(r);
    return r.id;
}


// Request the list of rules that the server is running (See ISteamGameServer::SetKeyValue() to set the rules server side)
HServerQuery Steam_Matchmaking_Servers::ServerRules( uint32 unIP, uint16 usPort, ISteamMatchmakingRulesResponse *pRequestServersResponse )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::ServerRules %hhu.%hhu.%hhu.%hhu:%hu\n", ((unsigned char *)&unIP)[3], ((unsigned char *)&unIP)[2], ((unsigned char *)&unIP)[1], ((unsigned char *)&unIP)[0], usPort);
    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    Steam_Matchmaking_Servers_Direct_IP_Request r;
    r.id = new_server_query();
    r.ip = unIP;
    r.port = usPort;
    r.rules_response = pRequestServersResponse;
    r.created = std::chrono::high_resolution_clock::now();
    direct_ip_requests.push_back(r);
    return r.id;
}


// Cancel an outstanding Ping/Players/Rules query from above.  You should call this to cancel
// any in-progress requests before destructing a callback object that may have been passed 
// to one of the above calls to avoid crashing when callbacks occur.
void Steam_Matchmaking_Servers::CancelServerQuery( HServerQuery hServerQuery )
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::CancelServerQuery\n");
    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    auto r = std::find_if(direct_ip_requests.begin(), direct_ip_requests.end(), [&hServerQuery](Steam_Matchmaking_Servers_Direct_IP_Request const& item) { return item.id == hServerQuery; });
    if (direct_ip_requests.end() == r) return;
    direct_ip_requests.erase(r);
}

void Steam_Matchmaking_Servers::RunCallbacks()
{
    PRINT_DEBUG("Steam_Matchmaking_Servers::RunCallbacks\n");

    {
        auto g = std::begin(gameservers);
        while (g != std::end(gameservers)) {
            if (check_timedout(g->last_recv, SERVER_TIMEOUT)) {
                g = gameservers.erase(g);
                PRINT_DEBUG("Steam_Matchmaking_Servers::SERVER TIMEOUT\n");
            } else {
                ++g;
            }
        }
    }

    PRINT_DEBUG("Steam_Matchmaking_Servers::RunCallbacks requests count = %zu, servers count = %zu\n", requests.size(), gameservers.size());

    for (auto &r : requests) {
        if (r.cancelled || r.completed) continue;

        r.gameservers_filtered.clear();
        for (auto &g : gameservers) {
            PRINT_DEBUG("Steam_Matchmaking_Servers::game_server_check %u==%u | %i==%i\n", g.server.appid(), r.appid, (int)g.type, (int)r.type);
            if ((g.server.appid() == r.appid) && (g.type == r.type)) {
                PRINT_DEBUG("Steam_Matchmaking_Servers::REQUESTS server found\n");
                r.gameservers_filtered.push_back(g);
            }
        }
    }

    std::vector <struct Steam_Matchmaking_Request> requests_temp(requests);
    PRINT_DEBUG("Steam_Matchmaking_Servers::REQUESTS_TEMP %zu\n", requests_temp.size());
    for (auto &r : requests) {
        r.completed = true;
    }

    for (auto &r : requests_temp) {
        if (r.cancelled || r.completed) continue;
        int i = 0;

        if (r.callbacks) {
            for (auto &g : r.gameservers_filtered) {
                PRINT_DEBUG("Steam_Matchmaking_Servers::REQUESTS server responded cb %p\n", r.id);
                r.callbacks->ServerResponded(r.id, i);
                ++i;
            }

            if (i) {
                r.callbacks->RefreshComplete(r.id, eServerResponded);
            } else {
                r.callbacks->RefreshComplete(r.id, eNoServersListedOnMasterServer);
            }
        }

        if (r.old_callbacks) {
            for (auto &g : r.gameservers_filtered) {
                PRINT_DEBUG("Steam_Matchmaking_Servers::old REQUESTS server responded cb %p\n", r.id);
                r.old_callbacks->ServerResponded(i);
                ++i;
            }

            if (i) {
                r.old_callbacks->RefreshComplete(eServerResponded);
            } else {
                r.old_callbacks->RefreshComplete(eNoServersListedOnMasterServer);
            }
        }
    }

    std::vector <struct Steam_Matchmaking_Servers_Direct_IP_Request> direct_ip_requests_temp;
    auto dip = std::begin(direct_ip_requests);
    while (dip != std::end(direct_ip_requests)) {
        if (check_timedout(dip->created, DIRECT_IP_DELAY)) {
            direct_ip_requests_temp.push_back(*dip);
            dip = direct_ip_requests.erase(dip);
        } else {
            ++dip;
        }
    }

    for (auto &r : direct_ip_requests_temp) {
        PRINT_DEBUG("Steam_Matchmaking_Servers::dip request: %u:%hu\n", r.ip, r.port);
        for (auto &g : gameservers) {
            PRINT_DEBUG("Steam_Matchmaking_Servers::server: %u:%u\n", g.server.ip(), g.server.query_port());
            uint16 query_port = g.server.query_port();
            if (query_port == 0xFFFF) {
                query_port = g.server.port();
            }

            if (query_port == r.port && g.server.ip() == r.ip) {
                if (r.rules_response) {
                    server_details_rules(&(g.server), &r);
                    r.rules_response->RulesRefreshComplete();
                    r.rules_response = NULL;
                }

                if (r.players_response) {
                    server_details_players(&(g.server), &r);
                    r.players_response->PlayersRefreshComplete();
                    r.players_response = NULL;
                }

                if (r.ping_response) {
                    gameserveritem_t server{};
                    server_details(&(g.server), &server);
                    r.ping_response->ServerResponded(server);
                    r.ping_response = NULL;
                }
            }
        }

        if (r.rules_response) r.rules_response->RulesRefreshComplete();
        if (r.players_response) r.players_response->PlayersRefreshComplete();
        if (r.ping_response) r.ping_response->ServerFailedToRespond();
    }
}

void Steam_Matchmaking_Servers::Callback(Common_Message *msg)
{
    if (msg->has_gameserver() && msg->gameserver().type() != eFriendsServer) {
        PRINT_DEBUG("Steam_Matchmaking_Servers got SERVER " "%" PRIu64 ", offline:%u\n", msg->gameserver().id(), msg->gameserver().offline());
        if (msg->gameserver().offline()) {
            for (auto &g : gameservers) {
                if (g.server.id() == msg->gameserver().id()) {
                    g.last_recv = std::chrono::high_resolution_clock::time_point();
                    g.type = eLANServer;
                }
            }
        } else {
            bool already = false;
            for (auto &g : gameservers) {
                if (g.server.id() == msg->gameserver().id()) {
                    g.last_recv = std::chrono::high_resolution_clock::now();
                    g.server = msg->gameserver();
                    g.server.set_ip(msg->source_ip());
                    g.type = eLANServer;
                    already = true;
                }
            }

            if (!already) {
                struct Steam_Matchmaking_Servers_Gameserver g;
                g.last_recv = std::chrono::high_resolution_clock::now();
                g.server = msg->gameserver();
                g.server.set_ip(msg->source_ip());
                g.type = eLANServer;
                gameservers.push_back(g);
                PRINT_DEBUG("Steam_Matchmaking_Servers::SERVER ADDED\n");
            }
        }
    }

    if (msg->has_gameserver() && msg->gameserver().type() == eFriendsServer) {
        PRINT_DEBUG("Steam_Matchmaking_Servers got eFriendsServer SERVER " "%" PRIu64 "\n", msg->gameserver().id());
        bool addserver = true;
        for (auto &g : gameservers_friends) {
            if (g.source_id == msg->source_id()) {
                g.ip = msg->gameserver().ip();
                g.port = msg->gameserver().port();
                g.last_recv = std::chrono::high_resolution_clock::now();
                addserver = false;
            }
        }

        if (addserver) {
            struct Steam_Matchmaking_Servers_Gameserver_Friends gameserver_friend;
            gameserver_friend.source_id = msg->source_id();
            gameserver_friend.ip = msg->gameserver().ip();
            gameserver_friend.port = msg->gameserver().port();
            gameserver_friend.last_recv = std::chrono::high_resolution_clock::now();
            gameservers_friends.push_back(gameserver_friend);
        }
    }
}