#pragma once

#include "../base/Types.h"
#include "../event/Event.h"

#include <renderive/renderable/base/Renderable_Base.hpp>

#include <atomic>
#include <functional>
#include <mutex>
#include <string>

namespace renderive {

class Plot_Core;
namespace detail {
class Painter;
class Renderable_State_Observer;
}

class Event_Handler {
public:
    virtual ~Event_Handler() = default;
    virtual void handle_event(const Event& event) = 0;
};

class LIB_DECL Renderable : public ::Renderable_Base {
public:
    explicit Renderable(Plot_Core& plot, bool cache_enabled = true);
    ~Renderable() override;

    [[nodiscard]] Plot_Core& plot() const noexcept { return plot_; }
    [[nodiscard]] Renderable_Cache_Mode get_cache_mode() const noexcept;
    void set_cache_mode(Renderable_Cache_Mode mode);

    [[nodiscard]] std::string object_name() const;
    void set_object_name(std::string name);
    [[nodiscard]] bool is_visible() const noexcept;
    void set_visible(bool visible);

    void render(const ::Scene_Render_Context& context) final;

protected:
    using Paint_Task_Function =
        std::function<void(detail::Painter&, const Render_State_View&)>;

    virtual void paint(detail::Painter& painter, const Render_State_View& state) = 0;
    virtual void build_paint_task_graph(Renderable_Task_Graph& graph);
    Renderable_Task_Graph::Task add_paint_task(Renderable_Task_Graph& graph,
                                               std::string name,
                                               Paint_Task_Function function);
    void changed() noexcept;
    void task_graph_changed() noexcept;
    [[nodiscard]] Size viewport_size() const noexcept;

private:
    void build_task_graph(Renderable_Task_Graph& graph) final;
    friend class detail::Renderable_State_Observer;
    Plot_Core& plot_;
    mutable std::mutex metadata_mutex_;
    std::string object_name_;
    std::atomic<bool> visible_{true};
};

namespace detail {

class Renderable_State_Observer {
public:
    static constexpr bool enabled = true;

    explicit Renderable_State_Observer(Renderable* renderable) noexcept : renderable_(renderable) {}

    template <class Observation>
    void observe(const Observation& observation) noexcept {
        if (observation.event == decltype(observation.event)::cache_updated)
            renderable_->changed();
    }

private:
    Renderable* renderable_;
};

} // namespace detail

} // namespace renderive