#include <renderive/error/Error_Policy.hpp>
#include "Renderable_Base_p.hpp"
#include "renderive/renderable/Renderable_Build.hpp"
#include <algorithm>
#include <limits>
#include <stdexcept>
#include <utility>
#include "renderive/real_time_data/base/Real_Time_Data_Base.hpp"
#include "renderive/renderable/Renderive_Id_Allocator.hpp"
#include "renderive/scene/base/Scene_Base.hpp"
#include "renderive/scene/base/Scene_Base.inl"
namespace {
void advance_revision(std::atomic<std::uint64_t>& revision) noexcept {
    std::uint64_t value = revision.load(std::memory_order_relaxed);
    while (value != std::numeric_limits<std::uint64_t>::max() &&
        !revision.compare_exchange_weak(value, value + 1,
                                        std::memory_order_release,
                                        std::memory_order_relaxed)) {}
}
} // namespace
Renderable_Base::Impl::Impl() : renderable_id(allocate_renderive_renderable_id()),
                                composite_node_id(allocate_renderive_node_id()) {}
Renderable_Base::Impl::~Impl() {
    real_time_data_state->attached.store(false, std::memory_order_release);
    real_time_data_state->renderable_alive.store(false,
                                                 std::memory_order_release);
}
void Renderable_Base::bind_observation_source(
    std::unique_ptr<renderive::inheritance::Observation_Source> source) {
    d_func().bind_observation_source(std::move(source));
}
void Renderable_Base::unbind_observation_source() noexcept {
    d_func().unbind_observation_source();
}
bool Renderable_Base::observation_snapshot(
    std::type_index type, void* destination) const {
    std::shared_ptr<renderive::inheritance::Observation_Source> source;
    {
        std::lock_guard lock(d_func().observation_mutex);
        source = d_func().observation_source;
    }
    return source && source->snapshot(type, destination);
}
void Renderable_Base::Impl::bind_observation_source(
    std::unique_ptr<renderive::inheritance::Observation_Source> source) {
    std::lock_guard lock(observation_mutex);
    observation_source = std::move(source);
}
void Renderable_Base::Impl::unbind_observation_source() noexcept {
    std::shared_ptr<renderive::inheritance::Observation_Source> source;
    {
        std::lock_guard lock(observation_mutex);
        source = std::exchange(observation_source, {});
    }
    if (source) source->stop();
}
void Renderable_Base::Impl::publish_observation() {
    std::shared_ptr<renderive::inheritance::Observation_Source> source;
    {
        std::lock_guard lock(observation_mutex);
        source = observation_source;
    }
    if (source) source->publish();
}
Renderable_Base& Renderable_Base::Impl::owner() noexcept {
    return *owner_;
}
const Renderable_Base& Renderable_Base::Impl::owner() const noexcept {
    return *owner_;
}
void Renderable_Base::Impl::invalidate_prepare() noexcept {
    advance_revision(prepare_revision);
}
void Renderable_Base::Impl::invalidate_paint() noexcept {
    advance_revision(paint_revision);
}
void Renderable_Base::Impl::bind_scene(
    std::shared_ptr<Scene_Lifetime> lifetime) {
    auto& current = real_time_data_state->scene_lifetime;
    if (!current) current = std::move(lifetime);
    else if (current != lifetime) ::renderive::error::unexpected<std::invalid_argument>("renderable belongs to another scene");
}
void Renderable_Base::Impl::rebuild_render_graph() {
    if (!attached()) {
        reset_render_graph();
        return;
    }
    scene().d_func().request_render_graph_rebuild(owner());
}
void Renderable_Base::Impl::reset_render_graph() {
    std::lock_guard lock(render_graph_mutex);
    render_graph.reset();
    invalidate_prepare();
}
std::shared_ptr<const Renderable_Graph> Renderable_Base::Impl::render_graph_snapshot() {
    std::lock_guard lock(render_graph_mutex);
    if (!render_graph) {
        std::pmr::unordered_map<std::string, Render_Node_Id> next_identities{
            &memory_resource()
        };
        Renderable_Graph_Builder builder(
            renderable_id,
            [this, &next_identities](std::string_view key) {
                const std::string logical_key(key);
                if (next_identities.contains(logical_key))
                    ::renderive::error::unexpected<std::invalid_argument>(
                        "duplicate render node logical key");
                const auto current = node_identities.find(logical_key);
                const Render_Node_Id node_id =
                current == node_identities.end()
                    ? allocate_renderive_node_id()
                    : current->second;
                next_identities.emplace(logical_key, node_id);
                return node_id;
            });
        build_prepare_graph(builder);
        build_paint_graph(builder);
        render_graph = std::make_shared<Renderable_Graph>(
            std::move(builder).finish());
        node_identities.clear();
        node_identities.insert(next_identities.begin(), next_identities.end());
    }
    return render_graph;
}
std::pmr::memory_resource& Renderable_Base::Impl::memory_resource() const noexcept {
    return *memory_resource_pointer;
}
Scene_Base& Renderable_Base::Impl::scene() const {
    const auto lifetime = real_time_data_state->scene_lifetime;
    if (!lifetime) ::renderive::error::unexpected<std::logic_error>("renderable is not bound to a scene");
    auto lease = lifetime->acquire();
    if (!lease) ::renderive::error::unexpected<std::logic_error>("renderable scene is no longer alive");
    return lease.scene();
}
bool Renderable_Base::Impl::attached() const noexcept {
    return real_time_data_state->attached.load(std::memory_order_acquire);
}
void Renderable_Base::Impl::set_configuration(
    Renderable_Configuration value) {
    const Renderable_Configuration previous =
    configuration.load(std::memory_order_acquire);
    if (previous == value) return;
    configuration.store(value, std::memory_order_release);
    invalidate_prepare();
}
void Renderable_Base::Impl::set_visible(bool value) {
    if (visible.exchange(value, std::memory_order_acq_rel) == value) return;
    invalidate_prepare();
}
void Renderable_Base::Impl::discard_stale_frame_on_latest_data_update(
    bool enabled) noexcept {
    real_time_data_state->discard_stale_frame_on_latest_data_update.store(
        enabled, std::memory_order_release);
}
void Renderable_Base::Impl::build_prepare_graph(
    Renderable_Graph_Builder& builder) {
    builder.emplace("prepare", "Prepare",
                    [this](const Prepare_Render_Context& context) {
                        execute_prepare(context);
                    });
}
void Renderable_Base::Impl::build_paint_graph(
    Renderable_Graph_Builder&) {}
void Renderable_Base::Impl::prepare(const Prepare_Render_Context&) {}
void Renderable_Base::Impl::capture_frame_data(Frame_Render_Snapshot&) const {}
void Renderable_Base::Impl::add_prepare_action(Prepare_Action action) {
    if (!action) ::renderive::error::unexpected<std::invalid_argument>("renderable prepare action is empty");
    prepare_actions.push_back(std::move(action));
}
void Renderable_Base::Impl::execute_prepare(
    const Prepare_Render_Context& context) {
    for (const auto& action : prepare_actions) action();
    prepare(context);
}
Render_State_View Renderable_Base::Impl::render_state_view() noexcept {
    return {};
}
Real_Time_Data_Binding Renderable_Base::Impl::bind_real_time_data(
    Real_Time_Data_Base& data) {
    return data.bind_renderable(owner());
}
void Renderable_Base::Impl::mark_prepared(std::uint64_t revision) noexcept {
    prepared_revision.store(revision, std::memory_order_release);
}
void Renderable_Base::Impl::mark_painted(
    std::uint64_t current_paint_revision,
    std::uint64_t current_prepare_revision) noexcept {
    painted_prepare_revision.store(current_prepare_revision,
                                   std::memory_order_release);
    painted_revision.store(current_paint_revision, std::memory_order_release);
}
void Renderable_Base::Impl::register_real_time_data(
    Real_Time_Data_Base& data) {
    std::lock_guard lock(real_time_data_mutex);
    if (std::find(real_time_data.begin(), real_time_data.end(), &data) ==
        real_time_data.end())
        real_time_data.push_back(&data);
}
void Renderable_Base::Impl::unregister_real_time_data(
    Real_Time_Data_Base& data) {
    std::lock_guard lock(real_time_data_mutex);
    std::erase(real_time_data, &data);
}
void Renderable_Base::Impl::publish_real_time_data() {
    std::lock_guard lock(real_time_data_mutex);
    for (Real_Time_Data_Base* data : real_time_data) data->publish_render_state();
}
Renderable_Base::Renderable_Base(Renderable_Configuration configuration,
                                 std::pmr::memory_resource& memory_resource) : Renderable_Base(std::make_unique<Impl>(), configuration,
                                                                                               memory_resource) {}
Renderable_Base::Renderable_Base(std::unique_ptr<Impl> implementation,
                                 Renderable_Configuration configuration,
                                 std::pmr::memory_resource& memory_resource) : d_ptr(std::move(implementation)) {
    if (!d_ptr) ::renderive::error::unexpected<std::invalid_argument>("renderable implementation is null");
    d_ptr->owner_ = this;
    d_ptr->memory_resource_pointer = &memory_resource;
    d_ptr->configuration.store(configuration, std::memory_order_release);
}
Renderable_Base::~Renderable_Base() = default;
Renderable_Id Renderable_Base::renderable_id() const noexcept {
    return d_func().renderable_id;
}
bool Renderable_Base::is_visible() const noexcept {
    return d_func().visible.load(std::memory_order_acquire);
}
std::string Renderable_Base::object_name() const {
    return d_func().object_name;
}
void renderive::detail::Renderable_Build_Access::set_object_name(
    Renderable_Base& renderable, std::string name) {
    auto& implementation = renderable.d_func();
    if (implementation.real_time_data_state->scene_lifetime)
        ::renderive::error::unexpected<std::logic_error>(
            "object_name is immutable after scene construction");
    implementation.object_name = std::move(name);
}
void Renderable_Base::add_build_dependency_parent(
    const renderive_Owner<Renderable_Base>& parent) {
    auto& implementation = d_func();
    if (implementation.real_time_data_state->scene_lifetime)
        ::renderive::error::unexpected<std::logic_error>(
            "renderable build topology is immutable after scene construction");
    implementation.build_topology.dependency_parents.emplace_back(
        parent.share());
}
void Renderable_Base::add_build_display_parent(
    const renderive_Owner<Renderable_Base>& parent) {
    auto& implementation = d_func();
    if (implementation.real_time_data_state->scene_lifetime)
        ::renderive::error::unexpected<std::logic_error>(
            "renderable build topology is immutable after scene construction");
    implementation.build_topology.display_parents.emplace_back(parent.share());
}
void Renderable_Base::add_build_display_child(
    const renderive_Owner<Renderable_Base>& child) {
    auto& implementation = d_func();
    if (implementation.real_time_data_state->scene_lifetime)
        ::renderive::error::unexpected<std::logic_error>(
            "renderable build topology is immutable after scene construction");
    implementation.build_topology.display_children.emplace_back(child.share());
}
void renderive::detail::Renderable_Build_Access::add_dependency_parent(
    Renderable_Base& renderable,
    const renderive_Owner<Renderable_Base>& parent) {
    renderable.add_build_dependency_parent(parent);
}
void renderive::detail::Renderable_Build_Access::add_display_parent(
    Renderable_Base& renderable,
    const renderive_Owner<Renderable_Base>& parent) {
    renderable.add_build_display_parent(parent);
}
void renderive::detail::Renderable_Build_Access::add_display_child(
    Renderable_Base& renderable,
    const renderive_Owner<Renderable_Base>& child) {
    renderable.add_build_display_child(child);
}
const renderive::Renderable_Build_Topology&
renderive::detail::Renderable_Build_Access::topology(
    const Renderable_Base& renderable) noexcept {
    return renderable.d_func().build_topology;
}
void renderive::detail::Renderable_Build_Access::complete(
    Renderable_Base& renderable) noexcept {
    renderable.d_func().build_topology = {};
}
void Renderable_Base::set_visible(bool visible) {
    d_func().set_visible(visible);
}
void Renderable_Base::discard_stale_frame_on_latest_data_update(
    bool enabled) noexcept {
    d_func().discard_stale_frame_on_latest_data_update(enabled);
}
void Renderable_Base::Impl::changed() {
    invalidate_prepare();
}
void Renderable_Base::Impl::paint_changed() {
    invalidate_paint();
}
void Renderable_Base::Impl::render_graph_changed() {
    rebuild_render_graph();
}