/**
 *******************************************
 * @file    libcpu/threadPool/include/thread_pool.hpp
 * @version 1.0
 * @date    8-December-2024
 * @brief   thread pool
 * @note    https://git.leshe4ka.ru/leshe4ka/oop24/src/branch/lab3/3
 *******************************************
 */

#ifndef THREAD_POOL_HPP_INC_
#define THREAD_POOL_HPP_INC_

#include "vector/vector.hpp" // IWYU pragma: export

#include <any>
#include <atomic>
#include <condition_variable> // IWYU pragma: export
#include <cstdint>            // IWYU pragma: export
#include <functional>         // IWYU pragma: export
#include <future>             // IWYU pragma: export
#include <list>
#include <memory>             // IWYU pragma: export
#include <mutex>              // IWYU pragma: export
#include <queue>              // IWYU pragma: export
#include <thread>             // IWYU pragma: export
#include <vector>             // IWYU pragma: export

namespace cpu_n {
// template <typename F, typename... Args> class MyBind {
//   public:
//     explicit MyBind(F &&f, Args &&...args)
//         : f_(std::forward<F>(f)),
//           args_(std::make_tuple(std::forward<Args>(args)...)) {}

//     auto operator()() { return std::apply(f_, args_); }

//   private:

//     std::function<std::invoke_result_t<F, Args...>()> f_;
//     std::tuple<Args...> args_;
// };

class ThreadPool {
  public:
    // NOLINTNEXTLINE
    ThreadPool(uint64_t threads = std::thread::hardware_concurrency());
    ~ThreadPool();

    void start();

    template <typename F, typename... Args>
    auto enqueue(F &&f, Args &&...args) -> std::future<decltype(f(args...))> {
        if (worker_count->load() != workers.size()) {
            start();
        }

        auto func = [f = std::forward<F>(f),
                     ... args = std::forward<Args>(args)]() mutable {
            return f(args...);
        };

        auto encapsulated_ptr =
            std::make_shared<std::packaged_task<decltype(f(args...))()>>(func);
        // auto task = std::packaged_task<decltype(f(args...))()>(func);

        std::future<decltype(f(args...))> future_object = encapsulated_ptr->get_future();
        // std::future<decltype(f(args...))> future_object = task.get_future();

        {
            std::lock_guard<std::mutex> lock(*mutexPtr);
            queue.emplace([encapsulated_ptr](){ (*encapsulated_ptr)();});
            // queue.emplace([t = std::move(task)]() mutable { t(); });
        }
        cvPtr->notify_one();
        return future_object;
    }

    ThreadPool(const ThreadPool &) = delete;
    ThreadPool(ThreadPool &&o) noexcept = default;
    ThreadPool &operator=(const ThreadPool &) = delete;
    ThreadPool &operator=(ThreadPool &&o) = default;

    [[nodiscard]] auto threadsNum() const { return threads; }
    [[nodiscard]] auto started() const { return started_state; }

  private:
    vec::vector<std::thread> workers;
    std::vector<bool> worker_up;
    std::unique_ptr<std::atomic<uint64_t>> worker_count;
    std::unique_ptr<std::mutex> mutexPtr;
    std::unique_ptr<std::condition_variable> cvPtr;
    std::queue<std::function<void()>,std::list<std::function<void()>>> queue;
    void worker(uint64_t thread_id);
    bool stop;

    uint64_t threads;
    bool started_state = false;
};

} // namespace cpu_n
#endif