#include <gtest/gtest.h>
#include <future>
#include <thread>
// #include <ranges>
#include "queue.hh"

struct Env {
  size_t num_to_repeat{1000};
  size_t time{0};
};

template <typename T, size_t size>
void producer(lfq::LockFreeQueue<T, size>& queue, T el, Env env) {
  for (int i = 0; i < env.num_to_repeat; ++i) {
    queue.push_back({el});
    sleep(env.time);
  }
}

template <typename T, size_t size>
void consumer(lfq::LockFreeQueue<T, size>& queue, Env env) {
  T element;
  for (int i = 0; i < env.num_to_repeat; ++i) {
    queue.pull_front(element);
    sleep(env.time);
  }
}

TEST(LFQ, spsc) {
  std::cout << "Single producer single consumer\n";
  lfq::LockFreeQueue<size_t> queue;
  size_t element = 10;
  Env env{.num_to_repeat = 10, .time = 0};
  EXPECT_NO_THROW(producer(queue, element, env));
  EXPECT_NO_THROW(consumer(queue, env));
  ASSERT_EQ(queue.apprx_available(), 0);
}

TEST(LFQ, spmc) {
  std::cout << "Single producer multi consumer\n";
  lfq::LockFreeQueue<size_t, 4096> queue;
  size_t element = 10;
  Env env_consumer{.num_to_repeat = 1000, .time = 0};
  Env env_producer{.num_to_repeat = 10000, .time = 0};

  std::future<void> pobj =
      std::async(std::launch::async, [env_producer, &queue] {
        EXPECT_NO_THROW(producer(queue, size_t(10), env_producer));
      });

  std::vector<std::future<void>> consumers;
  for (int i = 0; i < 10; ++i) {
    consumers.emplace_back(
        std::async(std::launch::async, [env_consumer, &queue] {
          EXPECT_NO_THROW(consumer(queue, env_consumer));
        }));
  }

  for (auto& cobj : consumers) {
    EXPECT_NO_THROW(cobj.wait());
  }
  ASSERT_EQ(queue.apprx_available(), 0);
}

TEST(LFQ, mpsc) {}

TEST(LFQ, mpmc) {}

int main(int argc, char** argv) {
  testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}