#include "stdafx.h"

#include "WindowsLeaderboardManager.h"

#include <algorithm>
#include <vector>

#include "../Network/json.hpp"
using json = nlohmann::json;

#include "../../Minecraft.h"
#include "../../StatsCounter.h"
#include "../Windows64_Launcher.h"
#include "../Windows64_Minecraft.h"
#include "../Network/WinsockNetLayer.h"

#include "../../../Minecraft.World/Stats.h"
#include "../../../Minecraft.World/StringHelpers.h"
#include "../../../Minecraft.World/net.minecraft.world.item.h"
#include "../../../Minecraft.World/net.minecraft.world.level.tile.h"

wchar_t g_Win64LeaderboardURL[256] = L"leaderboard.mclegacyedition.xyz";

namespace
{
    static int ClampDifficulty(int d)
    {
        if (d < 0) return 0;
        if (d > 3) return 3;
        return d;
    }

    static unsigned long ClampToULong(unsigned long long v)
    {
        if (v > static_cast<unsigned long long>(ULONG_MAX)) return ULONG_MAX;
        return static_cast<unsigned long>(v);
    }

    static unsigned int CombinePigmanKills(StatsCounter* stats, unsigned int difficulty)
    {
        if (!stats) return 0;
        return stats->getValue(Stats::killsZombiePigman, difficulty) + stats->getValue(Stats::killsNetherZombiePigman, difficulty);
    }

    static PlayerUID HexToUid(const std::string& hex)
    {
        if (hex.empty()) return INVALID_XUID;
        unsigned long long raw = 0;
        sscanf_s(hex.c_str(), "%llX", &raw);
        return static_cast<PlayerUID>(raw);
    }

    static void ParseServerEntries(const std::string& jsonText,
                                   std::vector<LeaderboardManager::ReadScore>& outScores)
    {
        if (jsonText.empty()) return;
        try
        {
            json arr = json::parse(jsonText);
            if (!arr.is_array()) return;
            for (auto& entry : arr)
            {
                LeaderboardManager::ReadScore score = {};
                score.m_rank            = 1;
                score.m_idsErrorMessage = 0;

                if (entry.contains("uuid") && entry["uuid"].is_string())
                    score.m_uid = HexToUid(entry["uuid"].get<std::string>());

                if (entry.contains("username") && entry["username"].is_string())
                    score.m_name = convStringToWstring(entry["username"].get<std::string>());

                if (entry.contains("totalScore") && entry["totalScore"].is_number())
                    score.m_totalScore = ClampToULong(
                        static_cast<unsigned long long>(entry["totalScore"].get<double>()));

                if (entry.contains("stats") && entry["stats"].is_array())
                {
                    auto& sa = entry["stats"];
                    unsigned int count = static_cast<unsigned int>(
                        (std::min<size_t>)(sa.size(), LeaderboardManager::ReadScore::STATSDATA_MAX));
                    score.m_statsSize = static_cast<unsigned short>(count);
                    for (unsigned int i = 0; i < count; ++i)
                        if (sa[i].is_number())
                            score.m_statsData[i] = static_cast<unsigned long>(sa[i].get<double>());
                }

                outScores.push_back(score);
            }
        }
        catch (...) {}
    }

    static void AssignRanks(std::vector<LeaderboardManager::ReadScore>& scores)
    {
        for (size_t i = 0; i < scores.size(); ++i)
            scores[i].m_rank = static_cast<unsigned long>(i + 1);
    }

    static bool BuildLocalScore(LeaderboardManager::ReadScore& out,
                                StatsCounter* stats,
                                LeaderboardManager::EStatsType type,
                                unsigned int diff)
    {
        ZeroMemory(&out, sizeof(out));
        out.m_rank            = 1;
        out.m_idsErrorMessage = 0;

        unsigned long long total = 0;
        auto col = [&](unsigned int idx, unsigned int val)
        {
            if (idx >= LeaderboardManager::ReadScore::STATSDATA_MAX) return;
            out.m_statsData[idx] = val;
            total += val;
        };

        switch (type)
        {
        case LeaderboardManager::eStatsType_Travelling:
            out.m_statsSize = 4;
            col(0, stats->getValue(Stats::walkOneM,     diff));
            col(1, stats->getValue(Stats::fallOneM,     diff));
            col(2, stats->getValue(Stats::minecartOneM, diff));
            col(3, stats->getValue(Stats::boatOneM,     diff));
            break;
        case LeaderboardManager::eStatsType_Mining:
            out.m_statsSize = 7;
            col(0, stats->getValue(Stats::blocksMined[Tile::dirt_Id],        diff));
            col(1, stats->getValue(Stats::blocksMined[Tile::cobblestone_Id], diff));
            col(2, stats->getValue(Stats::blocksMined[Tile::sand_Id],        diff));
            col(3, stats->getValue(Stats::blocksMined[Tile::stone_Id],       diff));
            col(4, stats->getValue(Stats::blocksMined[Tile::gravel_Id],      diff));
            col(5, stats->getValue(Stats::blocksMined[Tile::clay_Id],        diff));
            col(6, stats->getValue(Stats::blocksMined[Tile::obsidian_Id],    diff));
            break;
        case LeaderboardManager::eStatsType_Farming:
            out.m_statsSize = 6;
            col(0, stats->getValue(Stats::itemsCollected[Item::egg_Id],        diff));
            col(1, stats->getValue(Stats::blocksMined[Tile::wheat_Id],          diff));
            col(2, stats->getValue(Stats::blocksMined[Tile::mushroom_brown_Id], diff));
            col(3, stats->getValue(Stats::blocksMined[Tile::reeds_Id],          diff));
            col(4, stats->getValue(Stats::cowsMilked,                           diff));
            col(5, stats->getValue(Stats::itemsCollected[Tile::pumpkin_Id],     diff));
            break;
        case LeaderboardManager::eStatsType_Kills:
            out.m_statsSize = 7;
            col(0, stats->getValue(Stats::killsZombie,       diff));
            col(1, stats->getValue(Stats::killsSkeleton,     diff));
            col(2, stats->getValue(Stats::killsCreeper,      diff));
            col(3, stats->getValue(Stats::killsSpider,       diff));
            col(4, stats->getValue(Stats::killsSpiderJockey, diff));
            col(5, CombinePigmanKills(stats,                 diff));
            col(6, stats->getValue(Stats::killsSlime,        diff));
            break;
        default:
            return false;
        }

        out.m_totalScore = ClampToULong(total);
        return true;
    }
}

LeaderboardManager* LeaderboardManager::m_instance = new WindowsLeaderboardManager();

bool WindowsLeaderboardManager::WriteStats(unsigned int viewCount, ViewIn views)
{
    return false; // Since WriteStats is useless we just do this, exact same thing is done in DurangoLeaderboardManager
}

bool WindowsLeaderboardManager::SendStats(EStatsType type, int diff)
{
    if (!Windows64Launcher::IsInOfflineMode || Windows64Minecraft::IsOfflineMode)
    {
        Minecraft* mc = Minecraft::GetInstance();
        const int pad = ProfileManager.GetPrimaryPad();
        if (mc && pad >= 0 && pad < XUSER_MAX_COUNT)
        {
            StatsCounter* stats = mc->stats[pad];
            if (stats)
            {
                LeaderboardManager::ReadScore localScore = {};
                if (BuildLocalScore(localScore, stats, type, diff))
                {
                    json statsArr = json::array();
                    for (unsigned int i = 0; i < localScore.m_statsSize; ++i)
                        statsArr.push_back(localScore.m_statsData[i]);

                    json submitBody;
                    submitBody["type"]       = static_cast<int>(type);
                    submitBody["difficulty"] = static_cast<int>(diff);
                    submitBody["stats"]      = statsArr;
                    submitBody["totalScore"] = static_cast<unsigned long long>(localScore.m_totalScore);

                    sendScores(submitBody.dump());
                }
            }
        }
    }
}

bool WindowsLeaderboardManager::ReadStats_Friends(LeaderboardReadListener* callback,
    int difficulty, EStatsType type, PlayerUID myUID,
    unsigned int startIndex, unsigned int readCount)
{
    if (!LeaderboardManager::ReadStats_Friends(callback, difficulty, type, startIndex, myUID, readCount))
        return false;
    return ReadNetworkStats(callback, difficulty, type, eFM_Friends, startIndex, readCount);
}

bool WindowsLeaderboardManager::ReadStats_MyScore(LeaderboardReadListener* callback,
    int difficulty, EStatsType type, PlayerUID myUID, unsigned int readCount)
{
    if (!LeaderboardManager::ReadStats_MyScore(callback, difficulty, type, myUID, readCount))
        return false;
    return ReadNetworkStats(callback, difficulty, type, eFM_MyScore, 1, readCount);
}

bool WindowsLeaderboardManager::ReadStats_TopRank(LeaderboardReadListener* callback,
    int difficulty, EStatsType type,
    unsigned int startIndex, unsigned int readCount)
{
    if (!LeaderboardManager::ReadStats_TopRank(callback, difficulty, type, startIndex, readCount))
        return false;
    return ReadNetworkStats(callback, difficulty, type, eFM_TopRank, startIndex, readCount);
}

bool WindowsLeaderboardManager::ReadNetworkStats(LeaderboardReadListener* callback,
    int difficulty, EStatsType type,
    EFilterMode filterMode,
    unsigned int startIndex, unsigned int readCount)
{
    if (!callback) return false;

    unsigned int diff = static_cast<unsigned int>(ClampDifficulty(difficulty));
    if (type == eStatsType_Kills && diff == 0) diff = 1;

    // Submit live score only when authenticated.
    if (!Windows64Launcher::IsInOfflineMode || Windows64Minecraft::IsOfflineMode)
    {
        WindowsLeaderboardManager::SendStats(type, diff);
    }

    std::vector<LeaderboardManager::ReadScore> allRows;

    if (filterMode == eFM_Friends)
    {
        unsigned int limit  = (readCount > 0) ? (std::min)(readCount, 100u) : 64u;
        unsigned int offset = (startIndex > 1) ? (startIndex - 1) : 0;
        ParseServerEntries(fetchFriends(type, diff, offset, limit), allRows);
    }
    else if (filterMode == eFM_MyScore)
    {
        unsigned int limit  = (readCount > 0) ? (std::min)(readCount, 100u) : 64u;
        unsigned int offset = (startIndex > 1) ? (startIndex - 1) : 0;
        ParseServerEntries(fetchMyscore(type, diff, offset, limit), allRows);
    }
    else
    {
        unsigned int limit  = (readCount > 0) ? (std::min)(readCount, 100u) : 64u;
        unsigned int offset = (startIndex > 1) ? (startIndex - 1) : 0;
        ParseServerEntries(fetchOverall(type, diff, offset, limit), allRows);
    }

    std::sort(allRows.begin(), allRows.end(),
        [](const LeaderboardManager::ReadScore& a, const LeaderboardManager::ReadScore& b)
        {
            if (a.m_totalScore != b.m_totalScore) return a.m_totalScore > b.m_totalScore;
            const wchar_t* na = a.m_name.empty() ? L"" : a.m_name.c_str();
            const wchar_t* nb = b.m_name.empty() ? L"" : b.m_name.c_str();
            int cmp = _wcsicmp(na, nb);
            if (cmp != 0) return cmp < 0;
            return _wcsicmp(na, nb) < 0;
        });

    AssignRanks(allRows);

    if (allRows.empty())
    {
        ReadView empty = {};
        callback->OnStatsReadComplete(eStatsReturn_NoResults, 0, empty);
        return true;
    }

    size_t pageStart = 0;
    size_t pageCount = allRows.size();

    if (filterMode == eFM_TopRank)
    {
        if (startIndex > 1)
            pageStart = (std::min<size_t>)(static_cast<size_t>(startIndex - 1), allRows.size());
        pageCount = allRows.size() - pageStart;
        if (readCount > 0)
            pageCount = (std::min<size_t>)(pageCount, static_cast<size_t>(readCount));
    }

    if (pageStart >= allRows.size())
    {
        ReadView empty = {};
        callback->OnStatsReadComplete(eStatsReturn_NoResults, 0, empty);
        return true;
    }

    pageCount = (std::min)(pageCount, allRows.size() - pageStart);

    std::vector<LeaderboardManager::ReadScore> page(
        allRows.begin() + static_cast<std::ptrdiff_t>(pageStart),
        allRows.begin() + static_cast<std::ptrdiff_t>(pageStart + pageCount));

    if (page.empty())
    {
        ReadView empty = {};
        callback->OnStatsReadComplete(eStatsReturn_NoResults, 0, empty);
        return true;
    }

    ReadView view = {};
    view.m_numQueries = static_cast<unsigned int>(page.size());
    view.m_queries    = page.data();

    int totalResults = (filterMode == eFM_MyScore)
        ? static_cast<int>(page.size())
        : static_cast<int>(allRows.size());

    callback->OnStatsReadComplete(eStatsReturn_Success, totalResults, view);
    return true;
}

int WindowsLeaderboardManager::sendScores(const std::string& _data) {
    std::vector<std::wstring> headers;
#if defined(MINECRAFT_SERVER_BUILD)
    std::string authToken = ServerAuth::GetAuthenticationToken();
#else
    std::string authToken;
    if (Windows64Minecraft::IsExternalLauncher()) {
        authToken = Windows64Minecraft::GetAuthenticationTicket();
    } else {
        authToken = Windows64Launcher::GetAuthenticationToken();
    }
#endif
    headers.push_back(L"Content-Type: application/json");
    headers.push_back(L"Authorization: " + std::wstring(authToken.begin(), authToken.end()));

    HttpResponse response = WinsockNetLayer::DoWinHttpRequest(g_Win64LeaderboardURL, L"/sendscores", L"POST", _data, headers);
    return response.status;
}

std::string WindowsLeaderboardManager::fetchOverall(int type, int difficulty, int offset, int limit) {
    std::vector<std::wstring> headers;
    std::wstring path = L"/overall?type=" + std::to_wstring(type)
                      + L"&difficulty=" + std::to_wstring(difficulty)
                      + L"&offset=" + std::to_wstring(offset)
                      + L"&limit=" + std::to_wstring(limit);
    HttpResponse response = WinsockNetLayer::DoWinHttpRequest(g_Win64LeaderboardURL, path, L"GET", "", headers);
    return response.body;
}

std::string WindowsLeaderboardManager::fetchFriends(int type, int difficulty, int offset, int limit) {
    std::vector<std::wstring> headers;
#if defined(MINECRAFT_SERVER_BUILD)
    std::string authToken = ServerAuth::GetAuthenticationToken();
#else
    std::string authToken;
    if (Windows64Minecraft::IsExternalLauncher()) {
        authToken = Windows64Minecraft::GetAuthenticationTicket();
    } else {
        authToken = Windows64Launcher::GetAuthenticationToken();
    }
#endif
    headers.push_back(L"Authorization: " + std::wstring(authToken.begin(), authToken.end()));
    std::wstring path = L"/friends?type=" + std::to_wstring(type)
                      + L"&difficulty=" + std::to_wstring(difficulty)
                      + L"&offset=" + std::to_wstring(offset)
                      + L"&limit=" + std::to_wstring(limit);
    HttpResponse response = WinsockNetLayer::DoWinHttpRequest(g_Win64LeaderboardURL, path, L"GET", "", headers);
    return response.body;
}

std::string WindowsLeaderboardManager::fetchMyscore(int type, int difficulty, int offset, int limit) {
    std::vector<std::wstring> headers;
#if defined(MINECRAFT_SERVER_BUILD)
    std::string authToken = ServerAuth::GetAuthenticationToken();
#else
    std::string authToken;
    if (Windows64Minecraft::IsExternalLauncher()) {
        authToken = Windows64Minecraft::GetAuthenticationTicket();
    } else {
        authToken = Windows64Launcher::GetAuthenticationToken();
    }
#endif
    headers.push_back(L"Authorization: " + std::wstring(authToken.begin(), authToken.end()));
    std::wstring path = L"/myscore?type=" + std::to_wstring(type)
                      + L"&difficulty=" + std::to_wstring(difficulty)
                      + L"&offset=" + std::to_wstring(offset)
                      + L"&limit=" + std::to_wstring(limit);
    HttpResponse response = WinsockNetLayer::DoWinHttpRequest(g_Win64LeaderboardURL, path, L"GET", "", headers);
    return response.body;
}