#include <catch.hpp>
#include <pls/internal/base/thread.h>
#include <pls/internal/base/spin_lock.h>

#include <vector>
#include <mutex>

using namespace pls::internal::base;
using namespace std;

static bool base_tests_visited;
static int base_tests_local_value_one;
static vector<int> base_tests_local_value_two;

TEST_CASE( "thread creation and joining", "[internal/base/thread.h]") {
    base_tests_visited = false;
    auto t1 = start_thread([]() { base_tests_visited = true; });
    t1.join();

    REQUIRE(base_tests_visited);
}

TEST_CASE( "thread state", "[internal/base/thread.h]") {
    int state_one = 1;
    vector<int> state_two{1, 2};

    auto t1 = start_thread([]() { base_tests_local_value_one = *this_thread::state<int>(); }, &state_one);
    auto t2 = start_thread([]() { base_tests_local_value_two = *this_thread::state<vector<int>>(); }, &state_two);
    t1.join();
    t2.join();

    REQUIRE(base_tests_local_value_one == 1);
    REQUIRE(base_tests_local_value_two == vector<int>{1, 2});
}

TEST_CASE( "spinlock protects concurrent counter", "[internal/base/spinlock.h]") {
    constexpr int num_iterations = 100000;
    int shared_counter = 0;
    spin_lock lock{};

    SECTION( "lock can be used by itself" ) {
        auto t1 = start_thread([&]() {
            for (int i = 0; i < num_iterations; i++) {
                lock.lock();
                shared_counter++;
                lock.unlock();
            }
        });
        auto t2 = start_thread([&]() {
            for (int i = 0; i < num_iterations; i++) {
                lock.lock();
                shared_counter--;
                lock.unlock();
            }
        });

        t1.join();
        t2.join();

        REQUIRE(shared_counter == 0);
    }

    SECTION( "lock can be used with std::lock_guard" ) {
        auto t1 = start_thread([&]() {
            for (int i = 0; i < num_iterations; i++) {
                std::lock_guard<spin_lock> my_lock{lock};
                shared_counter++;
            }
        });
        auto t2 = start_thread([&]() {
            for (int i = 0; i < num_iterations; i++) {
                std::lock_guard<spin_lock> my_lock{lock};
                shared_counter--;
            }
        });

        t1.join();
        t2.join();

        REQUIRE(shared_counter == 0);
    }
}