// Headers are available because we added the pls target
#include <iostream>
#include <functional>
#include <array>
#include <atomic>

#include <pls/pls.h>
#include <pls/internal/base/prohibit_new.h>

using namespace pls;

// Example for static memory allocation (no malloc or free required)
static static_scheduler_memory<8, 2 << 12> my_scheduler_memory;

class fib: public fork_join_sub_task {
    static constexpr int CUTOFF = 20;

    int num_;
    int* result_;

public:
    fib(int num, int* result): num_{num}, result_{result} {}

private:
    static int fib_serial(int num) {
        if (num == 0) {
            return 0;
        }
        if (num == 1) {
            return 1;
        }

        return fib_serial(num - 1) + fib_serial(num - 2);
    }

protected:
    void execute_internal() override {
        if (num_ <= CUTOFF) {
            *result_ = fib_serial(num_);
            return;
        }

        int left_result;
        int right_result;

        spawn_child(fib{num_ - 1, &left_result});
        spawn_child(fib{num_ - 2, &right_result});

        wait_for_all();
        *result_ = left_result + right_result;
    }
public:
    void test() override {
        std::cout << "Test Override" << std::endl;
    }
};


int main() {
    scheduler my_scheduler{&my_scheduler_memory, 4};

    auto start = std::chrono::high_resolution_clock::now();
    my_scheduler.perform_work([] (){
        int result;

        fib fib_sub_task{45, &result};
        fork_join_task tbb_task{&fib_sub_task, task_id{1}};
        scheduler::execute_task(tbb_task);

        std::cout << "Result: " << result << std::endl;
    });
    auto end = std::chrono::high_resolution_clock::now();
    long time = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
    std::cout << "Startup time in us: " << time << std::endl;
}