#include "apiUrl.hpp"
#include "hearthstoneApi.hpp"
#include "hearthstoneTokenBuilder.hpp"
#include <catch2/benchmark/catch_benchmark.hpp>
#include <catch2/benchmark/catch_chronometer.hpp>
#include <catch2/benchmark/detail/catch_analyse.hpp>
#include <catch2/benchmark/detail/catch_benchmark_function.hpp>
#include <catch2/benchmark/detail/catch_estimate_clock.hpp>
#include <catch2/catch_approx.hpp>
#include <catch2/catch_config.hpp>
#include <catch2/catch_test_macros.hpp>
#include <cstdint>
#include <fstream>
#include <nlohmann/json.hpp>
#include <string>
#include <tokenBuilder.hpp>

TEST_CASE("Retrieve number of cards", "[countCards]") {
    const std::string aContentType{"cards"};
    const std::string aRegion{"eu"};
    bnet::ApiUrl aApiUrl(aContentType, aRegion);
    aApiUrl.setLocale("fr_FR");
    aApiUrl.setGameMode("constructed");
    aApiUrl.setPageSize(1);
    bnet::HearthstoneTokenBuilder aHearthstoneTokenBuilder("resources/credentials.json");
    const nlohmann::json aResponse = bnet::HearthstoneApi::makeApiRequest(
        aApiUrl, aHearthstoneTokenBuilder.allowBattleNetApiCall()
                     .allowUpdateSourceFile()
                     .buildToken()
                     .getToken()
                     ->text()
                     .value());
    REQUIRE(aResponse.size() > 0);
    REQUIRE(aResponse.contains("pageCount"));
    std::uint64_t aNumberOfCards{aResponse["pageCount"]};
    std::uint64_t aExpectedNumberOfCards{6000};
    REQUIRE(aNumberOfCards >= aExpectedNumberOfCards);
}

TEST_CASE("Retrieve page once", "[retrievePageOnce]") {
    const std::string aContentType{"cards"};
    const std::string aRegion{"eu"};
    bnet::ApiUrl aApiUrl(aContentType, aRegion);
    aApiUrl.setLocale("fr_FR");
    aApiUrl.setGameMode("constructed");
    aApiUrl.setPageSize(16);
    bnet::HearthstoneTokenBuilder aHearthstoneTokenBuilder("resources/credentials.json");
    const std::string aTokenText{aHearthstoneTokenBuilder.allowBattleNetApiCall()
                                     .allowUpdateSourceFile()
                                     .buildToken()
                                     .getToken()
                                     ->text()
                                     .value()};
    const nlohmann::json aApiResponse = bnet::HearthstoneApi::makeApiRequest(aApiUrl, aTokenText);
    REQUIRE(aApiResponse["cards"].size() == 16);
}

TEST_CASE("Retrieve pages 10 times without parallelization", "[retrievePagesNoParallel]") {
    const std::string aContentType{"cards"};
    const std::string aRegion{"eu"};
    bnet::ApiUrl aApiUrl(aContentType, aRegion);
    aApiUrl.setLocale("fr_FR");
    aApiUrl.setGameMode("constructed");
    aApiUrl.setPageSize(16);
    aApiUrl.setPage("1");
    bnet::HearthstoneTokenBuilder aHearthstoneTokenBuilder("resources/credentials.json");
    const std::string aTokenText{aHearthstoneTokenBuilder.allowBattleNetApiCall()
                                     .allowUpdateSourceFile()
                                     .buildToken()
                                     .getToken()
                                     ->text()
                                     .value()};
    bnet::json aApiResponse = bnet::HearthstoneApi::makeApiRequest(aApiUrl, aTokenText);

    // Retrieve number of pages
    const int aNumberOfRetrievals{10};
    const int aNumberOfPages{aApiResponse["pageCount"]};
    REQUIRE(aNumberOfPages >= aNumberOfRetrievals);
    for (int i{1}; i < aNumberOfRetrievals; ++i) {
        REQUIRE(aApiResponse["cards"].size() == 16);
        aApiUrl.setPage(std::to_string(i + 1));
        aApiResponse = bnet::HearthstoneApi::makeApiRequest(aApiUrl, aTokenText);
    }
    REQUIRE(aApiResponse["cards"].size() >= 1);
    REQUIRE(aApiResponse["cards"].size() <= 16);
}

TEST_CASE("Retrieve pages 10 times with parallelization", "[retrievePagesParallel]") {
    const std::string aContentType{"cards"};
    const std::string aRegion{"eu"};
    bnet::ApiUrl aApiUrl(aContentType, aRegion);
    aApiUrl.setLocale("fr_FR");
    aApiUrl.setGameMode("constructed");
    aApiUrl.setPageSize(16);
    aApiUrl.setPage("1");
    std::vector<std::string> aRequests;
    bnet::HearthstoneTokenBuilder aHearthstoneTokenBuilder("resources/credentials.json");
    const std::string aTokenText{aHearthstoneTokenBuilder.allowBattleNetApiCall()
                                     .allowUpdateSourceFile()
                                     .buildToken()
                                     .getToken()
                                     ->text()
                                     .value()};
    bnet::json aFirstPageJson = bnet::HearthstoneApi::makeApiRequest(aApiUrl, aTokenText);

    const int aNumberOfPages{aFirstPageJson["pageCount"]};
    const int aNumberOfRetrievals{10};
    REQUIRE(aNumberOfPages >= aNumberOfRetrievals);
    for (int i{1}; i < aNumberOfRetrievals; ++i) {
        aApiUrl.setPage(std::to_string(i + 1));
        aRequests.emplace_back(aApiUrl.text());
    }
    std::vector<nlohmann::json> aApiResponses =
        bnet::HearthstoneApi::makeApiRequest(aRequests, aTokenText);
    aApiResponses.emplace(aApiResponses.begin(), aFirstPageJson);
    REQUIRE(aApiResponses.size() == aNumberOfRetrievals);
    for (const nlohmann::json &aApiResponse : aApiResponses) {
        REQUIRE(aApiResponse["cards"].size() == 16);
    }
}

TEST_CASE("Merge two card lists from two page requests", "[Merge pages]") {
    std::ifstream aFirstPageFile{"resources/page_merge_00.json"};
    nlohmann::json aFirstPageJson = nlohmann::json::parse(aFirstPageFile);
    std::ifstream aSecondPageFile{"resources/page_merge_01.json"};
    const nlohmann::json aSecondPageJson = nlohmann::json::parse(aSecondPageFile);

    nlohmann::json::reference aMergedCards = aFirstPageJson["cards"];
    for (auto &card : aSecondPageJson["cards"]) {
        aMergedCards.emplace_back(std::move(card));
    }
    REQUIRE(aMergedCards.size() == 32);
    std::ofstream aOutputJson("build/output_pages_merge.json");
    aOutputJson << aMergedCards.dump(4);
}

TEST_CASE("Retrieve a single page with HearthstoneApi::downloadCards",
          "[retrievePageOnceHearthstoneApi]") {
    const std::string aContentType{"cards"};
    const std::string aRegion{"eu"};
    bnet::ApiUrl aApiUrl(aContentType, aRegion);
    aApiUrl.setPage(3);
    bnet::HearthstoneTokenBuilder aHearthstoneTokenBuilder("resources/credentials.json");
    const std::string aTokenText{aHearthstoneTokenBuilder.allowBattleNetApiCall()
                                     .allowUpdateSourceFile()
                                     .buildToken()
                                     .getToken()
                                     ->text()
                                     .value()};
    nlohmann::json aApiResponse = bnet::HearthstoneApi::makeApiRequest(aApiUrl, aTokenText);
    const nlohmann::json::size_type aExpectedNumberOfCards{aApiResponse["cards"].size()};
    aApiResponse =
        bnet::HearthstoneApi::downloadCards(aApiUrl, *aHearthstoneTokenBuilder.getToken());
    const nlohmann::json::size_type aCurrentNumberOfCards{aApiResponse["cards"].size()};
    REQUIRE(aCurrentNumberOfCards == aExpectedNumberOfCards);
}