#include "Plot_Frame_Pipeline.h"
#include "../architecture/Update_Completion.h"
#include <utility>

namespace renderive {

Plot_Frame::Plot_Frame()
    : presented_update_states(memory_resource(Memory_Domain::Update_Completion)),
      metadata(std::make_shared<Frame_Lifecycle_Record>()) {}

Plot_Frame_Lease::Plot_Frame_Lease(Plot_Frame* buffer, Triple_Role_Buffer_Control* control, Triple_Buffer_Lease lease)
    : frame(buffer), control(control), lease(lease) {}

Plot_Frame_Lease::Plot_Frame_Lease(Plot_Frame_Lease&& other) noexcept
    : frame(std::exchange(other.frame, nullptr)),
      control(std::exchange(other.control, nullptr)),
      lease(std::exchange(other.lease, Triple_Buffer_Lease{})) {}

Plot_Frame_Lease& Plot_Frame_Lease::operator=(Plot_Frame_Lease&& other) noexcept {
    if (this == &other)
        return *this;
    reset();
    frame = std::exchange(other.frame, nullptr);
    control = std::exchange(other.control, nullptr);
    lease = std::exchange(other.lease, Triple_Buffer_Lease{});
    return *this;
}

Plot_Frame_Lease::~Plot_Frame_Lease() {
    reset();
}

void Plot_Frame_Lease::reset() {
    if (!control)
        return;
    control->unmark_use(lease);
    frame = nullptr;
    control = nullptr;
    lease = {};
}

Plot_Frame_Pipeline::Plot_Frame_Pipeline() {
    frame_control.reset();
}

Plot_Frame_Pipeline::~Plot_Frame_Pipeline() {
    cancel_all_update_states();
}

void Plot_Frame_Pipeline::advance_edit_version() {
    edit_version.fetch_add(1, std::memory_order_release);
}

bool Plot_Frame_Pipeline::has_unrendered_edit() const {
    return buffer_version_newer(edit_version.load(std::memory_order_acquire), rendered_edit_version);
}

Plot_Frame* Plot_Frame_Pipeline::frame_by_index(std::uint8_t index) {
    return &frames[index];
}

const Plot_Frame* Plot_Frame_Pipeline::frame_by_index(std::uint8_t index) const {
    return &frames[index];
}

Plot_Frame* Plot_Frame_Pipeline::frame_by_role(std::uint8_t role) {
    return frame_by_index(frame_control.read_view()[role]);
}

const Plot_Frame* Plot_Frame_Pipeline::frame_by_role(std::uint8_t role) const {
    return frame_by_index(frame_control.read_view()[role]);
}

Plot_Frame_Lease Plot_Frame_Pipeline::try_acquire_render_frame() {
    auto record = frame_control.try_acquire_role(Frame_Rendering);
    if (record.result != Triple_Buffer_Result::Success) {
        ++attempt_counters.render_role_busy_count;
        return {};
    }
    return {frame_by_index(record.lease.index), &frame_control, record.lease};
}

Plot_Frame_Pipeline::Frame_Publish_Result Plot_Frame_Pipeline::try_publish_rendered_frame(std::uint64_t now_ns) {
    Frame_Publish_Result result;
    Plot_Frame* rendered = frame_by_role(Frame_Rendering);

    auto swap = frame_control.try_swap_role(Frame_Rendering, Frame_Middle, [this](const Triple_Buffer_View& view) {
        const Plot_Frame* rendering = frame_by_index(view[Frame_Rendering]);
        const Plot_Frame* middle = frame_by_index(view[Frame_Middle]);
        return buffer_version_newer(rendering->version.load(std::memory_order_acquire), middle->version.load(std::memory_order_acquire));
    }, [this, &result, now_ns](const Triple_Buffer_View& old_view, const Triple_Buffer_View& new_view) {
        Plot_Frame* rendered = frame_by_index(old_view[Frame_Rendering]);
        Plot_Frame* old_middle = frame_by_index(old_view[Frame_Middle]);
        const Plot_Frame* painting = frame_by_index(old_view[Frame_Painting]);
        bool supersede_middle = buffer_version_newer(old_middle->version.load(std::memory_order_acquire), painting->version.load(std::memory_order_acquire));

        rendered->metadata->transition_12_ns = now_ns;
        rendered->metadata->wait_12_ns = now_ns > rendered->metadata->render_end_ns ? now_ns - rendered->metadata->render_end_ns : 0;

        if (supersede_middle && old_middle->metadata && old_middle->metadata->frame_id) {
            old_middle->metadata->superseded_time_ns = now_ns;
            old_middle->metadata->outcome = Frame_Outcome::Superseded;
            result.superseded_frame_record = old_middle->metadata;
            supersede_update_states(old_middle->presented_update_states);
        }

        Plot_Frame* next_rendering = frame_by_index(new_view[Frame_Rendering]);
        next_rendering->metadata = std::make_shared<Frame_Lifecycle_Record>();
        next_rendering->metadata->render_role_enter_ns = now_ns;
    });
    if (swap.result != Triple_Buffer_Result::Success) {
        rendered->metadata->outcome = Frame_Outcome::Publish_Dropped;
        result.dropped_frame_record = rendered->metadata;
        supersede_update_states(rendered->presented_update_states);
        ++attempt_counters.publish_dropped_count;
        return result;
    }

    Frame_Publish_Result update_result = request_present(now_ns);
    update_result.superseded_frame_record = result.superseded_frame_record;
    update_result.dropped_frame_record = result.dropped_frame_record;
    return update_result;
}

Plot_Frame_Pipeline::Frame_Publish_Result Plot_Frame_Pipeline::request_present(std::uint64_t now_ns) {
    Frame_Publish_Result result;
    if (!middle_frame_ready())
        return result;
    Plot_Frame* middle = frame_by_role(Frame_Middle);
    if (paint_request_pending.load(std::memory_order_acquire)) {
        middle->metadata->update_request_id = pending_present_request_id.load(std::memory_order_acquire);
        middle->metadata->update_request_time_ns = pending_present_request_time_ns.load(std::memory_order_acquire);
        return result;
    }
    result.update_request_id = ++next_present_request_id;
    result.update_request_time = now_ns;
    middle->metadata->update_request_id = result.update_request_id;
    middle->metadata->update_request_time_ns = result.update_request_time;
    pending_present_request_id.store(result.update_request_id, std::memory_order_release);
    pending_present_request_time_ns.store(result.update_request_time, std::memory_order_release);
    paint_request_pending.store(true, std::memory_order_release);
    Size size = middle->image.size();
    result.dirty_rect = Rect{0, 0, size.width, size.height};
    result.request_present = true;
    return result;
}

Plot_Frame_Pipeline::Frame_Consume_Result Plot_Frame_Pipeline::try_acquire_paint_frame(std::uint64_t now_ns) {
    Frame_Consume_Result result;
    bool pending = paint_request_pending.load(std::memory_order_acquire);

    if (middle_frame_ready()) {
        auto swap = frame_control.try_swap_role(Frame_Middle, Frame_Painting, [this](const Triple_Buffer_View& view) {
            const Plot_Frame* middle = frame_by_index(view[Frame_Middle]);
            const Plot_Frame* painting = frame_by_index(view[Frame_Painting]);
            return buffer_version_newer(middle->version.load(std::memory_order_acquire), painting->version.load(std::memory_order_acquire));
        }, [this, &result, now_ns](const Triple_Buffer_View& old_view, const Triple_Buffer_View&) {
            Plot_Frame* old_painting = frame_by_index(old_view[Frame_Painting]);
            Plot_Frame* new_painting = frame_by_index(old_view[Frame_Middle]);
            result.has_new_frame = true;
            if (old_painting->metadata && old_painting->metadata->frame_id && old_painting->metadata->paint_end_ns) {
                old_painting->metadata->transition_32_ns = now_ns;
                old_painting->metadata->wait_32_ns = now_ns > old_painting->metadata->paint_end_ns ? now_ns - old_painting->metadata->paint_end_ns : 0;
                result.returned_frame_record = old_painting->metadata;
            }
            new_painting->metadata->transition_23_ns = now_ns;
            new_painting->metadata->wait_23_ns = now_ns > new_painting->metadata->transition_12_ns ? now_ns - new_painting->metadata->transition_12_ns : 0;
        });
        if (swap.result != Triple_Buffer_Result::Success) {
            result.paint_frame_unavailable = true;
            ++attempt_counters.paint_role_busy_count;
        }
    }

    auto record = frame_control.try_acquire_role(Frame_Painting);
    if (record.result == Triple_Buffer_Result::Success) {
        result.lease = {frame_by_index(record.lease.index), &frame_control, record.lease};
        result.present_request_was_pending = pending && paint_request_pending.exchange(false, std::memory_order_acq_rel);
    }
    else {
        result.paint_frame_unavailable = true;
        ++attempt_counters.paint_role_busy_count;
    }
    return result;
}

bool Plot_Frame_Pipeline::middle_frame_ready() const {
    const Plot_Frame* middle = frame_by_role(Frame_Middle);
    const Plot_Frame* painting = frame_by_role(Frame_Painting);
    return buffer_version_newer(middle->version.load(std::memory_order_acquire), painting->version.load(std::memory_order_acquire));
}

bool Plot_Frame_Pipeline::painting_frame_in_use() const {
    return frame_control.role_busy(Frame_Painting);
}

void Plot_Frame_Pipeline::cancel_all_update_states() {
    for (Plot_Frame& frame : frames)
        cancel_update_states(frame.presented_update_states);
}

} // namespace renderive