/*
 * This file Copyright (C) Mnemosyne LLC
 *
 * It may be used under the GNU GPL versions 2 or 3
 * or any future license endorsed by Mnemosyne LLC.
 *
 */

#include <array>
#include <cstdlib>
#include <set>
#include <string_view>
#include <vector>

#include "transmission.h"

#include "announce-list.h"
#include "error.h"
#include "metainfo.h"
#include "utils.h"
#include "variant.h"

#include "gtest/gtest.h"

using AnnounceListTest = ::testing::Test;
using namespace std::literals;

TEST_F(AnnounceListTest, canAdd)
{
    auto constexpr Tier = tr_tracker_tier_t{ 2 };
    auto constexpr Announce = "https://example.org/announce"sv;

    auto announce_list = tr_announce_list{};
    EXPECT_EQ(1, announce_list.add(Tier, Announce));
    auto const tracker = announce_list.at(0);
    EXPECT_EQ(Announce, tracker.announce.full);
    EXPECT_EQ("https://example.org/scrape"sv, tracker.scrape.full);
    EXPECT_EQ(Tier, tracker.tier);
    EXPECT_EQ("example.org:443"sv, tracker.host.sv());
}

TEST_F(AnnounceListTest, groupsSiblingsIntoSameTier)
{
    auto constexpr Tier1 = tr_tracker_tier_t{ 1 };
    auto constexpr Tier2 = tr_tracker_tier_t{ 2 };
    auto constexpr Tier3 = tr_tracker_tier_t{ 3 };
    auto constexpr Announce1 = "https://example.org/announce"sv;
    auto constexpr Announce2 = "http://example.org/announce"sv;
    auto constexpr Announce3 = "udp://example.org:999/announce"sv;

    auto announce_list = tr_announce_list{};
    EXPECT_TRUE(announce_list.add(Tier1, Announce1));
    EXPECT_TRUE(announce_list.add(Tier2, Announce2));
    EXPECT_TRUE(announce_list.add(Tier3, Announce3));

    EXPECT_EQ(3, std::size(announce_list));
    EXPECT_EQ(Tier1, announce_list.at(0).tier);
    EXPECT_EQ(Tier1, announce_list.at(1).tier);
    EXPECT_EQ(Tier1, announce_list.at(2).tier);
    EXPECT_EQ(Announce1, announce_list.at(1).announce.full);
    EXPECT_EQ(Announce2, announce_list.at(0).announce.full);
    EXPECT_EQ(Announce3, announce_list.at(2).announce.full);
    EXPECT_EQ("example.org:443"sv, announce_list.at(1).host.sv());
    EXPECT_EQ("example.org:80"sv, announce_list.at(0).host.sv());
    EXPECT_EQ("example.org:999"sv, announce_list.at(2).host.sv());
}

TEST_F(AnnounceListTest, canAddWithoutScrape)
{
    auto constexpr Tier = tr_tracker_tier_t{ 2 };
    auto constexpr Announce = "https://example.org/foo"sv;

    auto announce_list = tr_announce_list{};
    EXPECT_TRUE(announce_list.add(Tier, Announce));
    auto const tracker = announce_list.at(0);
    EXPECT_EQ(Announce, tracker.announce.full);
    EXPECT_TRUE(std::empty(tracker.scrape_str));
    EXPECT_EQ(Tier, tracker.tier);
}

TEST_F(AnnounceListTest, canAddUdp)
{
    auto constexpr Tier = tr_tracker_tier_t{ 2 };
    auto constexpr Announce = "udp://example.org/"sv;

    auto announce_list = tr_announce_list{};
    EXPECT_TRUE(announce_list.add(Tier, Announce));
    auto const tracker = announce_list.at(0);
    EXPECT_EQ(Announce, tracker.announce.full);
    EXPECT_EQ("udp://example.org/"sv, tracker.scrape.full);
    EXPECT_EQ(Tier, tracker.tier);
}

TEST_F(AnnounceListTest, canNotAddDuplicateAnnounce)
{
    auto constexpr Tier = tr_tracker_tier_t{ 2 };
    auto constexpr Announce = "https://example.org/announce"sv;

    auto announce_list = tr_announce_list{};
    EXPECT_TRUE(announce_list.add(Tier, Announce));
    EXPECT_EQ(1, announce_list.size());
    EXPECT_FALSE(announce_list.add(Tier, Announce));
    EXPECT_EQ(1, announce_list.size());

    auto constexpr Announce2 = "https://example.org:443/announce"sv;
    EXPECT_FALSE(announce_list.add(Tier, Announce2));
    EXPECT_EQ(1, announce_list.size());
}

TEST_F(AnnounceListTest, canNotAddInvalidUrl)
{
    auto constexpr Tier = tr_tracker_tier_t{ 2 };
    auto constexpr Announce = "telnet://example.org/announce"sv;

    auto announce_list = tr_announce_list{};
    EXPECT_FALSE(announce_list.add(Tier, Announce));
    EXPECT_EQ(0, announce_list.size());
}

TEST_F(AnnounceListTest, canSet)
{
    auto constexpr Urls = std::array<char const*, 3>{
        "https://www.example.com/a/announce",
        "https://www.example.com/b/announce",
        "https://www.example.com/c/announce",
    };
    auto constexpr Tiers = std::array<tr_tracker_tier_t, 3>{ 1, 2, 3 };

    auto announce_list = tr_announce_list{};
    EXPECT_EQ(3, announce_list.set(std::data(Urls), std::data(Tiers), 3));
    EXPECT_EQ(3, announce_list.size());
    EXPECT_EQ(Tiers[0], announce_list.at(0).tier);
    EXPECT_EQ(Tiers[1], announce_list.at(1).tier);
    EXPECT_EQ(Tiers[2], announce_list.at(2).tier);
    EXPECT_EQ(Urls[0], announce_list.at(0).announce.full);
    EXPECT_EQ(Urls[1], announce_list.at(1).announce.full);
    EXPECT_EQ(Urls[2], announce_list.at(2).announce.full);
    auto const expected_tiers = std::set<tr_tracker_tier_t>(std::begin(Tiers), std::end(Tiers));
    auto const tiers = announce_list.tiers();
    EXPECT_EQ(expected_tiers, tiers);
}

TEST_F(AnnounceListTest, canSetUnsortedWithBackupsInTiers)
{
    auto constexpr Urls = std::array<char const*, 6>{
        "https://www.backup-a.com/announce",  "https://www.backup-b.com/announce",  "https://www.backup-c.com/announce",
        "https://www.primary-a.com/announce", "https://www.primary-b.com/announce", "https://www.primary-c.com/announce",
    };
    auto constexpr Tiers = std::array<tr_tracker_tier_t, 6>{ 0, 1, 2, 0, 1, 2 };

    auto announce_list = tr_announce_list{};
    EXPECT_EQ(6, announce_list.set(std::data(Urls), std::data(Tiers), 6));
    EXPECT_EQ(6, announce_list.size());
    EXPECT_EQ(0, announce_list.at(0).tier);
    EXPECT_EQ(0, announce_list.at(1).tier);
    EXPECT_EQ(1, announce_list.at(2).tier);
    EXPECT_EQ(1, announce_list.at(3).tier);
    EXPECT_EQ(2, announce_list.at(4).tier);
    EXPECT_EQ(2, announce_list.at(5).tier);
    EXPECT_EQ(Urls[0], announce_list.at(0).announce.full);
    EXPECT_EQ(Urls[3], announce_list.at(1).announce.full);
    EXPECT_EQ(Urls[1], announce_list.at(2).announce.full);
    EXPECT_EQ(Urls[4], announce_list.at(3).announce.full);
    EXPECT_EQ(Urls[2], announce_list.at(4).announce.full);
    EXPECT_EQ(Urls[5], announce_list.at(5).announce.full);

    // confirm that each has a unique id
    auto ids = std::set<tr_tracker_id_t>{};
    for (size_t i = 0, n = std::size(announce_list); i < n; ++i)
    {
        ids.insert(announce_list.at(i).id);
    }
    EXPECT_EQ(std::size(announce_list), std::size(ids));
}

TEST_F(AnnounceListTest, canSetExceptDuplicate)
{
    auto constexpr Urls = std::array<char const*, 3>{
        "https://www.example.com/a/announce",
        "https://www.example.com/b/announce",
        "https://www.example.com/b/announce",
    };
    auto constexpr Tiers = std::array<tr_tracker_tier_t, 3>{ 3, 2, 1 };

    auto announce_list = tr_announce_list{};
    EXPECT_EQ(2, announce_list.set(std::data(Urls), std::data(Tiers), 3));
    EXPECT_EQ(2, announce_list.size());
    EXPECT_EQ(Tiers[0], announce_list.at(1).tier);
    EXPECT_EQ(Tiers[1], announce_list.at(0).tier);
    EXPECT_EQ(Urls[0], announce_list.at(1).announce.full);
    EXPECT_EQ(Urls[1], announce_list.at(0).announce.full);
}

TEST_F(AnnounceListTest, canSetExceptInvalid)
{
    auto constexpr Urls = std::array<char const*, 3>{
        "https://www.example.com/a/announce",
        "telnet://www.example.com/b/announce",
        "https://www.example.com/c/announce",
    };
    auto constexpr Tiers = std::array<tr_tracker_tier_t, 3>{ 1, 2, 3 };

    auto announce_list = tr_announce_list{};
    EXPECT_EQ(2, announce_list.set(std::data(Urls), std::data(Tiers), 3));
    EXPECT_EQ(2, announce_list.size());
    EXPECT_EQ(Tiers[0], announce_list.at(0).tier);
    EXPECT_EQ(Tiers[2], announce_list.at(1).tier);
    EXPECT_EQ(Urls[0], announce_list.at(0).announce.full);
    EXPECT_EQ(Urls[2], announce_list.at(1).announce.full);
}

TEST_F(AnnounceListTest, canRemoveById)
{
    auto constexpr Announce = "https://www.example.com/announce"sv;
    auto constexpr Tier = tr_tracker_tier_t{ 1 };

    auto announce_list = tr_announce_list{};
    announce_list.add(Tier, Announce);
    EXPECT_EQ(1, std::size(announce_list));
    auto const id = announce_list.at(0).id;

    EXPECT_TRUE(announce_list.remove(id));
    EXPECT_EQ(0, std::size(announce_list));
}

TEST_F(AnnounceListTest, canNotRemoveByInvalidId)
{
    auto constexpr Announce = "https://www.example.com/announce"sv;
    auto constexpr Tier = tr_tracker_tier_t{ 1 };

    auto announce_list = tr_announce_list{};
    announce_list.add(Tier, Announce);
    EXPECT_EQ(1, std::size(announce_list));
    auto const id = announce_list.at(0).id;

    EXPECT_FALSE(announce_list.remove(id + 1));
    EXPECT_EQ(1, std::size(announce_list));
    EXPECT_EQ(Announce, announce_list.at(0).announce.full);
}

TEST_F(AnnounceListTest, canRemoveByAnnounce)
{
    auto constexpr Announce = "https://www.example.com/announce"sv;
    auto constexpr Tier = tr_tracker_tier_t{ 1 };

    auto announce_list = tr_announce_list{};
    announce_list.add(Tier, Announce);
    EXPECT_EQ(1, std::size(announce_list));

    EXPECT_TRUE(announce_list.remove(Announce));
    EXPECT_EQ(0, std::size(announce_list));
}

TEST_F(AnnounceListTest, canNotRemoveByInvalidAnnounce)
{
    auto constexpr Announce = "https://www.example.com/announce"sv;
    auto constexpr Tier = tr_tracker_tier_t{ 1 };

    auto announce_list = tr_announce_list{};
    announce_list.add(Tier, Announce);
    EXPECT_EQ(1, std::size(announce_list));

    EXPECT_FALSE(announce_list.remove("https://www.not-example.com/announce"sv));
    EXPECT_EQ(1, std::size(announce_list));
}

TEST_F(AnnounceListTest, canReplace)
{
    auto constexpr Tier = tr_tracker_tier_t{ 1 };
    auto constexpr Announce1 = "https://www.example.com/1/announce"sv;
    auto constexpr Announce2 = "https://www.example.com/2/announce"sv;

    auto announce_list = tr_announce_list{};
    EXPECT_TRUE(announce_list.add(Tier, Announce1));
    EXPECT_TRUE(announce_list.replace(announce_list.at(0).id, Announce2));
    EXPECT_EQ(Announce2, announce_list.at(0).announce.full);
}

TEST_F(AnnounceListTest, canNotReplaceInvalidId)
{
    auto constexpr Tier = tr_tracker_tier_t{ 1 };
    auto constexpr Announce1 = "https://www.example.com/1/announce"sv;
    auto constexpr Announce2 = "https://www.example.com/2/announce"sv;

    auto announce_list = tr_announce_list{};
    EXPECT_TRUE(announce_list.add(Tier, Announce1));
    EXPECT_FALSE(announce_list.replace(announce_list.at(0).id + 1, Announce2));
    EXPECT_EQ(Announce1, announce_list.at(0).announce.full);
}

TEST_F(AnnounceListTest, canNotReplaceWithInvalidAnnounce)
{
    auto constexpr Tier = tr_tracker_tier_t{ 1 };
    auto constexpr Announce1 = "https://www.example.com/1/announce"sv;
    auto constexpr Announce2 = "telnet://www.example.com/2/announce"sv;

    auto announce_list = tr_announce_list{};
    EXPECT_TRUE(announce_list.add(Tier, Announce1));
    EXPECT_FALSE(announce_list.replace(announce_list.at(0).id, Announce2));
    EXPECT_EQ(Announce1, announce_list.at(0).announce.full);
}

TEST_F(AnnounceListTest, canNotReplaceWithDuplicate)
{
    auto constexpr Tier = tr_tracker_tier_t{ 1 };
    auto constexpr Announce = "https://www.example.com/announce"sv;

    auto announce_list = tr_announce_list{};
    EXPECT_TRUE(announce_list.add(Tier, Announce));
    EXPECT_FALSE(announce_list.replace(announce_list.at(0).id, Announce));
    EXPECT_EQ(Announce, announce_list.at(0).announce.full);
}

TEST_F(AnnounceListTest, announceToScrape)
{
    struct ScrapeTest
    {
        std::string_view announce;
        std::string_view expected_scrape;
    };

    auto constexpr Tests = std::array<ScrapeTest, 3>{ {
        { "https://www.example.com/announce"sv, "https://www.example.com/scrape"sv },
        { "https://www.example.com/foo"sv, ""sv },
        { "udp://www.example.com:999/"sv, "udp://www.example.com:999/"sv },
    } };

    for (auto const test : Tests)
    {
        auto const scrape = tr_announce_list::announceToScrape(tr_quark_new(test.announce));
        EXPECT_EQ(tr_quark_new(test.expected_scrape), scrape);
    }
}

TEST_F(AnnounceListTest, save)
{
    auto constexpr Urls = std::array<char const*, 3>{
        "https://www.example.com/a/announce",
        "https://www.example.com/b/announce",
        "https://www.example.com/c/announce",
    };
    auto constexpr Tiers = std::array<tr_tracker_tier_t, 3>{ 0, 1, 2 };

    // first, set up a scratch .torrent
    auto constexpr* const OriginalFile = LIBTRANSMISSION_TEST_ASSETS_DIR "/Android-x86 8.1 r6 iso.torrent";
    auto original_content = std::vector<char>{};
    auto const test_file = tr_strvJoin(::testing::TempDir(), "transmission-announce-list-test.torrent"sv);
    tr_error* error = nullptr;
    EXPECT_TRUE(tr_loadFile(original_content, OriginalFile, &error));
    EXPECT_EQ(nullptr, error);
    EXPECT_TRUE(tr_saveFile(test_file.c_str(), { std::data(original_content), std::size(original_content) }, &error));
    EXPECT_EQ(nullptr, error);

    // make an announce_list for it
    auto announce_list = tr_announce_list();
    EXPECT_TRUE(announce_list.add(Tiers[0], Urls[0]));
    EXPECT_TRUE(announce_list.add(Tiers[1], Urls[1]));
    EXPECT_TRUE(announce_list.add(Tiers[2], Urls[2]));

    // try saving to a nonexistent .torrent file
    EXPECT_FALSE(announce_list.save("/this/path/does/not/exist", &error));
    EXPECT_NE(nullptr, error);
    EXPECT_NE(0, error->code);
    tr_error_clear(&error);

    // now save to a real .torrent fi le
    EXPECT_TRUE(announce_list.save(test_file.c_str(), &error));
    EXPECT_EQ(nullptr, error);

    // load the original
    auto metainfo = tr_variant{};
    EXPECT_TRUE(tr_variantFromBuf(
        &metainfo,
        TR_VARIANT_PARSE_BENC | TR_VARIANT_PARSE_INPLACE,
        { std::data(original_content), std::size(original_content) },
        nullptr,
        nullptr));
    auto original = tr_metainfoParse(nullptr, &metainfo, nullptr);
    EXPECT_TRUE(original);
    tr_variantFree(&metainfo);

    // load the scratch that we saved to
    metainfo = tr_variant{};
    EXPECT_TRUE(tr_variantFromFile(&metainfo, TR_VARIANT_PARSE_BENC, test_file.c_str(), nullptr));
    auto saved = tr_metainfoParse(nullptr, &metainfo, nullptr);
    EXPECT_TRUE(saved);
    tr_variantFree(&metainfo);

    // test that non-announce parts of the metainfo are the same
    EXPECT_STREQ(original->info.name, saved->info.name);
    EXPECT_EQ(original->info.fileCount, saved->info.fileCount);
    EXPECT_EQ(original->info.dateCreated, saved->info.dateCreated);
    EXPECT_EQ(original->pieces, saved->pieces);

    // test that the saved version has the updated announce list
    EXPECT_EQ(std::size(announce_list), std::size(*saved->info.announce_list));
    EXPECT_TRUE(std::equal(
        std::begin(announce_list),
        std::end(announce_list),
        std::begin(*saved->info.announce_list),
        std::end(*saved->info.announce_list)));

    // cleanup
    std::remove(test_file.c_str());
}