#include "Core/architecture/Frame_Scheduler.h"
#include "Core/architecture/Triple_Buffer.h"
#include "Core/plot/Latency_Eager_Refresh_Strategy.h"
#include "Core/plot/Plot_Frame_Pipeline.h"
#include "Core/plot/Plot_Core.h"
#include "Core/execution/Render_Executor.h"
#include "Core/plottable/Performance_Shower_p.h"
#include "Core/plottable/export.h"
#include "Core/render/Image.h"
#include <array>
#include <chrono>
#include <functional>
#include <gtest/gtest.h>
#include <rigtorp/MPMCQueue.h>
#include <thread>

namespace renderive {
namespace {

bool unique_roles(const Triple_Buffer_View& view) {
    std::array<bool, 3> seen{};
    for (std::uint8_t index : view.index) {
        if (index >= seen.size() || seen[index])
            return false;
        seen[index] = true;
    }
    return true;
}

Frame_Lifecycle_Record render_frame(std::uint64_t begin_ns, std::uint64_t end_ns) {
    Frame_Lifecycle_Record frame;
    frame.render_role_enter_ns = begin_ns;
    frame.render_begin_ns = begin_ns;
    frame.render_end_ns = end_ns;
    return frame;
}

bool wait_until(std::function<bool()> predicate) {
    auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(2);
    while (std::chrono::steady_clock::now() < deadline) {
        if (predicate())
            return true;
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
    return predicate();
}

std::shared_ptr<Frame_Lifecycle_Record> performance_frame(std::uint64_t frame_id, int width = 240, int height = 80) {
    auto frame = std::make_shared<Frame_Lifecycle_Record>();
    frame->frame_id = frame_id;
    frame->input_version = frame_id + 1;
    frame->render_begin_ns = 10;
    frame->prepare_begin_ns = 11;
    frame->prepare_end_ns = 12;
    frame->draw_begin_ns = 13;
    frame->draw_end_ns = 14;
    frame->render_end_ns = 20;
    frame->transition_12_ns = 25;
    frame->paint_begin_ns = 30;
    frame->paint_end_ns = 40;
    frame->transition_32_ns = 45;
    frame->pixel_width = static_cast<std::uint64_t>(width);
    frame->pixel_height = static_cast<std::uint64_t>(height);
    frame->viewport_version = 1;
    frame->outcome = Frame_Outcome::Presented;
    frame->worker.executor_at_finish.worker_count = 4;
    frame->worker.executor_at_finish.active_workers = 1;
    frame->worker.executor_at_finish.completed_tasks = frame_id;
    return frame;
}

bool valid_utf8(const std::string& text) {
    for (std::size_t i = 0; i < text.size();) {
        unsigned char c = static_cast<unsigned char>(text[i]);
        std::size_t n = 0;
        if ((c & 0x80u) == 0)
            n = 1;
        else if ((c & 0xE0u) == 0xC0u)
            n = 2;
        else if ((c & 0xF0u) == 0xE0u)
            n = 3;
        else if ((c & 0xF8u) == 0xF0u)
            n = 4;
        else
            return false;
        if (i + n > text.size())
            return false;
        for (std::size_t j = 1; j < n; ++j) {
            if ((static_cast<unsigned char>(text[i + j]) & 0xC0u) != 0x80u)
                return false;
        }
        i += n;
    }
    return true;
}

} // namespace

TEST(Renderive_Canvas, TextUsesPenAndFillUsesBrush) {
    auto diagnostics = Canvas::default_font_diagnostics();
    ASSERT_TRUE(diagnostics.face_valid);
    ASSERT_TRUE(diagnostics.font_valid);
    ASSERT_GT(diagnostics.test_width, 0.0);
    ASSERT_GT(diagnostics.test_height, 0.0);

    Image image(400, 100);
    image.fill(Color::transparent());
    {
        Canvas canvas(image);
        canvas.set_brush(Brush{Color::white(), Brush_Style::Solid});
        canvas.set_pen(Pen{Color::black()});
        canvas.fill_rect(RectF{0.0, 0.0, 400.0, 100.0});
        canvas.draw_text(PointF{10.0, 10.0}, "0123456789 ABC \xE4\xB8\xAD\xE6\x96\x87");
        canvas.draw_text(RectF{10.0, 50.0, 300.0, 30.0}, Text_Align::Left | Text_Align::Top, "0123");
    }

    EXPECT_EQ(premultiplied_to_color(image.row(2)[2]), Color::white());
    int dark_pixels = 0;
    for (int y = 8; y < 82; ++y) {
        const Pixel* row = image.row(y);
        ASSERT_NE(row, nullptr);
        for (int x = 8; x < 320; ++x) {
            Color color = premultiplied_to_color(row[x]);
            if (color.alpha && color.red < 120 && color.green < 120 && color.blue < 120)
                ++dark_pixels;
        }
    }
    EXPECT_GT(dark_pixels, 20);
}

TEST(Renderive_Triple_Buffer, RoleSwapsAreTryOnlyAndDeterministic) {
    Triple_Role_Buffer_Control control;
    control.reset();
    EXPECT_TRUE(unique_roles(control.read_view()));

    auto first = control.try_swap_role(Frame_Rendering, Frame_Middle, [](const Triple_Buffer_View&) {
        return true;
    });
    EXPECT_EQ(first.result, Triple_Buffer_Result::Success);
    EXPECT_TRUE(unique_roles(control.read_view()));

    auto painting = control.try_acquire_role(Frame_Painting);
    ASSERT_EQ(painting.result, Triple_Buffer_Result::Success);
    auto blocked = control.try_swap_role(Frame_Middle, Frame_Painting, [](const Triple_Buffer_View&) {
        return true;
    });
    EXPECT_EQ(blocked.result, Triple_Buffer_Result::Busy);
    control.unmark_use(painting.lease);

    for (int i = 0; i < 1000000; ++i) {
        auto a = control.try_swap_role(Frame_Rendering, Frame_Middle, [](const Triple_Buffer_View&) {
            return true;
        });
        ASSERT_EQ(a.result, Triple_Buffer_Result::Success);
        auto b = control.try_swap_role(Frame_Middle, Frame_Painting, [](const Triple_Buffer_View&) {
            return true;
        });
        ASSERT_EQ(b.result, Triple_Buffer_Result::Success);
        ASSERT_TRUE(unique_roles(control.read_view()));
    }
}

TEST(Renderive_Frame_Pipeline, PublishAndPaintUseMiddleVersionOnly) {
    Plot_Frame_Pipeline pipeline;
    auto lease = pipeline.try_begin_render();
    ASSERT_TRUE(static_cast<bool>(lease));
    ASSERT_TRUE(lease.frame->metadata);
    lease.frame->metadata->frame_id = 1;
    lease.frame->metadata->render_begin_ns = 10;
    lease.frame->metadata->render_end_ns = 20;
    lease.frame->version.store(1, std::memory_order_release);
    lease.reset();

    auto published = pipeline.try_publish_rendered(25);
    EXPECT_TRUE(pipeline.middle_has_new_frame());
    EXPECT_TRUE(published.request_present);
    EXPECT_EQ(published.dropped_frame, nullptr);

    auto painting = pipeline.try_begin_paint(30);
    EXPECT_TRUE(painting.new_frame);
    EXPECT_TRUE(static_cast<bool>(painting.lease));
    EXPECT_FALSE(pipeline.middle_has_new_frame());
}

TEST(Renderive_Frame_Pipeline, PaintAcquireFailureKeepsPendingRequest) {
    Plot_Frame_Pipeline pipeline;
    auto lease = pipeline.try_begin_render();
    ASSERT_TRUE(static_cast<bool>(lease));
    ASSERT_TRUE(lease.frame->metadata);
    lease.frame->metadata->frame_id = 1;
    lease.frame->metadata->render_begin_ns = 10;
    lease.frame->metadata->render_end_ns = 20;
    lease.frame->version.store(1, std::memory_order_release);
    lease.reset();

    auto published = pipeline.try_publish_rendered(25);
    ASSERT_TRUE(published.request_present);
    EXPECT_TRUE(pipeline.paint_request_pending.load(std::memory_order_acquire));

    auto busy = pipeline.frame_control.try_acquire_role(Frame_Painting);
    ASSERT_EQ(busy.result, Triple_Buffer_Result::Success);
    auto failed = pipeline.try_begin_paint(30);
    EXPECT_TRUE(failed.paint_acquire_dropped);
    EXPECT_FALSE(failed.update_was_pending);
    EXPECT_TRUE(pipeline.paint_request_pending.load(std::memory_order_acquire));
    pipeline.frame_control.unmark_use(busy.lease);

    auto consumed = pipeline.try_begin_paint(35);
    EXPECT_TRUE(consumed.update_was_pending);
    EXPECT_TRUE(static_cast<bool>(consumed.lease));
}

TEST(Renderive_MPMCQueue, UsesTryOnlyBoundedCapacity) {
    rigtorp::MPMCQueue<int> queue(2);
    EXPECT_TRUE(queue.try_push(1));
    EXPECT_TRUE(queue.try_push(2));
    EXPECT_FALSE(queue.try_push(3));

    int value = 0;
    EXPECT_TRUE(queue.try_pop(value));
    EXPECT_EQ(value, 1);
    EXPECT_TRUE(queue.try_pop(value));
    EXPECT_EQ(value, 2);
    EXPECT_FALSE(queue.try_pop(value));
}

TEST(Renderive_Frame_Feedback, SelectsRenderPaintAndUserSources) {
    Frame_Feedback_Controller controller;
    controller.set_max_render_fps(200.0);
    for (int i = 0; i < 4; ++i) {
        auto render_limited = render_frame(0, 20000000);
        controller.on_render_completed(render_limited);
    }
    EXPECT_EQ(controller.state().source, Refresh_Limit_Source::Render);

    controller.reset();
    controller.set_max_render_fps(200.0);
    for (int i = 0; i < 4; ++i) {
        auto frame = render_frame(0, 5000000);
        controller.on_render_completed(frame);
        frame.transition_12_ns = 0;
        frame.paint_begin_ns = 0;
        frame.paint_end_ns = 25000000;
        controller.on_frame_presented(frame);
    }
    EXPECT_EQ(controller.state().source, Refresh_Limit_Source::Paint);

    controller.reset();
    controller.set_max_render_fps(30.0);
    for (int i = 0; i < 4; ++i) {
        auto frame = render_frame(0, 5000000);
        controller.on_render_completed(frame);
        frame.paint_begin_ns = 0;
        frame.paint_end_ns = 8000000;
        controller.on_frame_presented(frame);
    }
    EXPECT_EQ(controller.state().source, Refresh_Limit_Source::User);
}

TEST(Renderive_Render_Executor, FrameAdmissionIsBounded) {
    Render_Executor executor(Render_Runtime_Config{1});
    std::atomic_bool entered{false};
    std::atomic_bool release{false};
    std::atomic_bool completed{false};
    auto first_stat = std::make_shared<Frame_Worker_Stat>();
    ASSERT_TRUE(executor.try_submit(Render_Executor_Task{
        1,
        1,
        Render_Task_Kind::Frame,
        Task([&]() {
            entered.store(true, std::memory_order_release);
            while (!release.load(std::memory_order_acquire))
                std::this_thread::sleep_for(std::chrono::milliseconds(1));
        }),
        Task([&]() {
            completed.store(true, std::memory_order_release);
        }),
        first_stat,
        true
    }));
    ASSERT_TRUE(wait_until([&]() {
        return entered.load(std::memory_order_acquire);
    }));
    auto second_stat = std::make_shared<Frame_Worker_Stat>();
    EXPECT_FALSE(executor.try_submit(Render_Executor_Task{
        2,
        1,
        Render_Task_Kind::Frame,
        Task([]() {}),
        Task([]() {}),
        second_stat,
        true
    }));
    release.store(true, std::memory_order_release);
    ASSERT_TRUE(wait_until([&]() {
        return completed.load(std::memory_order_acquire);
    }));
    executor.shutdown();
}

TEST(Renderive_Performance_Shower, ToggleDoesNotReenterRenderableTreeUnsafely) {
    Plot_Core plot(std::make_unique<Latency_Eager_Refresh_Strategy>());
    plot.init();
    auto root = plot.root_renderable();
    ASSERT_TRUE(root);
    EXPECT_TRUE(root->children_snapshot().empty());
    set_performance_shower_enabled(plot, true);
    EXPECT_TRUE(performance_shower_enabled(plot));
    EXPECT_TRUE(root->children_snapshot().empty());
    set_performance_shower_enabled(plot, false);
    EXPECT_FALSE(performance_shower_enabled(plot));
    EXPECT_TRUE(root->children_snapshot().empty());
}

TEST(Renderive_Performance_Shower, WorkerConsumesSharedFrameRecord) {
    auto state = std::make_shared<Performance_Metrics_Worker_State>();
    auto frame = std::make_shared<Frame_Lifecycle_Record>();
    frame->frame_id = 7;
    frame->input_version = 3;
    frame->render_begin_ns = 10;
    frame->render_end_ns = 20;
    frame->transition_12_ns = 25;
    frame->paint_begin_ns = 30;
    frame->paint_end_ns = 40;
    frame->transition_32_ns = 45;
    frame->pixel_width = 320;
    frame->pixel_height = 240;
    frame->outcome = Frame_Outcome::Presented;
    Performance_Frame_Record record = frame;
    ASSERT_TRUE(state->metric_queue.try_push(record));

    schedule_performance_metrics_worker(state);
    auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(2);
    std::shared_ptr<const Performance_Display_Snapshot> snapshot;
    while (std::chrono::steady_clock::now() < deadline) {
        snapshot = state->display_snapshot_slot.load(std::memory_order_acquire);
        if (snapshot && !state->worker_active.load(std::memory_order_acquire))
            break;
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
    state->cancelled.store(true, std::memory_order_release);

    ASSERT_TRUE(snapshot);
    EXPECT_FALSE(snapshot->lines.empty());
    EXPECT_TRUE(state->aggregate.has_frame);
    EXPECT_EQ(state->aggregate.latest.frame_id, 7);
}

TEST(Renderive_Performance_Shower, NumericFieldWidthIsMonotonicAcrossResetAndResize) {
    auto state = std::make_shared<Performance_Metrics_Worker_State>();
    auto frame_width = [&]() {
        return state->field_layout_states[static_cast<std::size_t>(Performance_Field_Id::Frame_Id)].max_value_width;
    };
    double previous = 0.0;
    double wide = 0.0;
    for (std::uint64_t frame_id : {1ull, 99ull, 123456ull, 2ull, 8ull}) {
        Performance_Frame_Record record = performance_frame(frame_id, 320, 120);
        ASSERT_TRUE(state->metric_queue.try_push(record));
        schedule_performance_metrics_worker(state);
        ASSERT_TRUE(wait_until([&]() {
            auto snapshot = state->display_snapshot_slot.load(std::memory_order_acquire);
            return snapshot && state->aggregate.latest.frame_id == frame_id && !state->worker_active.load(std::memory_order_acquire);
        }));
        double current = frame_width();
        EXPECT_GE(current, previous);
        previous = current;
        if (frame_id == 123456)
            wide = current;
        if (frame_id == 2 || frame_id == 8)
            EXPECT_EQ(current, wide);
    }

    state->reset_requested.store(true, std::memory_order_release);
    schedule_performance_metrics_worker(state);
    ASSERT_TRUE(wait_until([&]() {
        return !state->worker_active.load(std::memory_order_acquire);
    }));
    EXPECT_EQ(frame_width(), wide);

    state->viewport_width.store(180, std::memory_order_release);
    state->viewport_height.store(90, std::memory_order_release);
    state->viewport_version.store(2, std::memory_order_release);
    state->snapshot_rebuild_requested.store(true, std::memory_order_release);
    schedule_performance_metrics_worker(state);
    ASSERT_TRUE(wait_until([&]() {
        auto snapshot = state->display_snapshot_slot.load(std::memory_order_acquire);
        return snapshot && snapshot->viewport_version == 2 && !state->worker_active.load(std::memory_order_acquire);
    }));
    EXPECT_EQ(frame_width(), wide);
    state->cancelled.store(true, std::memory_order_release);
}

TEST(Renderive_Performance_Shower, ScrollCommandsUpdateOffsetAndClamp) {
    Performance_Shower shower;
    shower.setEnabled(true);
    shower.set_viewport(Size{220, 70}, 1);
    auto frame = performance_frame(1, 220, 70);
    shower.collect_frame(frame);
    ASSERT_TRUE(wait_until([&]() {
        auto snapshot = shower.display_snapshot();
        return snapshot && snapshot->max_scroll_offset > 0.0;
    }));

    auto snapshot = shower.display_snapshot();
    ASSERT_TRUE(snapshot);
    EXPECT_TRUE(shower.handle_wheel(PointF{5.0, 5.0}, -120.0, 0.0));
    ASSERT_TRUE(wait_until([&]() {
        auto next = shower.display_snapshot();
        return next && next->scroll_offset > snapshot->scroll_offset;
    }));

    snapshot = shower.display_snapshot();
    ASSERT_TRUE(snapshot);
    PointF page_down{snapshot->scroll_track_rect.x + 1.0, snapshot->scroll_thumb_rect.bottom() + 1.0};
    EXPECT_TRUE(shower.handle_pointer_press(page_down));
    ASSERT_TRUE(wait_until([&]() {
        auto next = shower.display_snapshot();
        return next && next->scroll_offset > snapshot->scroll_offset;
    }));

    snapshot = shower.display_snapshot();
    ASSERT_TRUE(snapshot);
    PointF thumb_center{snapshot->scroll_thumb_rect.x + 1.0, snapshot->scroll_thumb_rect.y + snapshot->scroll_thumb_rect.height * 0.5};
    EXPECT_TRUE(shower.handle_pointer_press(thumb_center));
    EXPECT_TRUE(shower.handle_pointer_move(PointF{thumb_center.x, snapshot->scroll_track_rect.bottom()}));
    EXPECT_TRUE(shower.handle_pointer_release(PointF{thumb_center.x, snapshot->scroll_track_rect.bottom()}));
    ASSERT_TRUE(wait_until([&]() {
        auto next = shower.display_snapshot();
        return next && next->max_scroll_offset > 0.0 && next->scroll_offset > next->max_scroll_offset * 0.8;
    }));
}

TEST(Renderive_Performance_Shower, Utf8WrappingKeepsValidText) {
    Performance_Shower shower;
    shower.setEnabled(true);
    shower.set_viewport(Size{120, 90}, 1);
    auto frame = performance_frame(1, 120, 90);
    Renderable_Frame_Stat stat;
    stat.object_name = "\xE4\xB8\xAD\xE6\x96\x87\xE6\xB5\x8B\xE8\xAF\x95\xE5\xAD\x97\xE6\xAE\xB5\xE5\xBE\x88\xE9\x95\xBF\xE5\xBE\x88\xE9\x95\xBF";
    stat.tree_depth = 0;
    stat.render_count = 1;
    stat.total_render_time_ns = 1000000;
    frame->renderable_stats.push_back(stat);
    shower.collect_frame(frame);
    ASSERT_TRUE(wait_until([&]() {
        auto snapshot = shower.display_snapshot();
        return snapshot && !snapshot->lines.empty();
    }));
    auto snapshot = shower.display_snapshot();
    ASSERT_TRUE(snapshot);
    for (const auto& line : snapshot->lines)
        EXPECT_TRUE(valid_utf8(line)) << line;
}

} // namespace renderive

int main(int argc, char** argv) {
    testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}