#include <gtest/gtest.h>
#include <memory>
#include <vector>
#include "renderive/renderable/Renderable.hpp"
#include "renderive/scene/Scene.hpp"
struct Renderable_Task_Graph_Test_Renderable : Renderable_Base {
    Renderable_Task_Graph_Test_Renderable(Scene_Base& scene, std::vector<int>& order, int base)
        : Renderable_Base(scene, {.cache_enabled = false}), order(&order), base(base) {}
    void build_task_graph(Renderable_Task_Graph& graph) override {
        auto first = graph.emplace([this](const Scene_Render_Context&) {
            order->push_back(base + 1);
        }, "first");
        auto second = graph.emplace([this](const Scene_Render_Context&) {
            order->push_back(base + 2);
        }, "second");
        graph.precede(first, second);
    }
    std::vector<int>* order;
    int base;
};
TEST(renderable_task_graph_test, combines_internal_and_external_dependencies) {
    Scene2D_Context<> scene;
    std::vector<int> order;
    auto dependency = std::make_shared<Renderable_Task_Graph_Test_Renderable>(scene, order, 0);
    auto dependent = std::make_shared<Renderable_Task_Graph_Test_Renderable>(scene, order, 10);
    scene.attach_renderable(dependency);
    scene.attach_renderable(dependent);
    dependency->dependency_node.append_child(dependent->dependency_node);
    scene.render();
    scene.wait_for_render();
    EXPECT_EQ(order, (std::vector<int>{1, 2, 11, 12}));
}

#include <algorithm>
#include <atomic>
#include <chrono>
#include <thread>
struct Renderable_Task_Graph_Concurrency_Test_Renderable : Renderable_Base {
    Renderable_Task_Graph_Concurrency_Test_Renderable(Scene_Base& scene, std::atomic<int>& active, std::atomic<int>& maximum)
        : Renderable_Base(scene, {.cache_enabled = false}), active(&active), maximum(&maximum) {}
    void build_task_graph(Renderable_Task_Graph& graph) override {
        auto work = [this](const Scene_Render_Context&) {
            const int value = active->fetch_add(1, std::memory_order_acq_rel) + 1;
            int observed = maximum->load(std::memory_order_acquire);
            while (observed < value && !maximum->compare_exchange_weak(observed, value, std::memory_order_acq_rel)) {}
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
            active->fetch_sub(1, std::memory_order_acq_rel);
        };
        graph.emplace(work, "parallel_a");
        graph.emplace(work, "parallel_b");
    }
    std::atomic<int>* active;
    std::atomic<int>* maximum;
};
TEST(renderable_task_graph_concurrency_test, DISABLED_runs_independent_internal_tasks_concurrently) {
    Scene2D_Context<> scene;
    std::atomic<int> active{};
    std::atomic<int> maximum{};
    auto renderable = std::make_shared<Renderable_Task_Graph_Concurrency_Test_Renderable>(scene, active, maximum);
    scene.attach_renderable(renderable);
    scene.render();
    scene.wait_for_render();
    EXPECT_GE(maximum.load(std::memory_order_acquire), 2);
}