// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2026 Martino Ferrari

// The GLFW host's event routing in figure mode: which row's controller a pointer pixel
// reaches.
//
// This is the adapter's own logic and not GLFW's -- a figure is several plots stacked in
// one framebuffer, and the host has to decide which of them a gesture was aimed at -- so it
// is tested here rather than through a window. Nothing below calls `run()`: the case needs
// no GL context, no display and no window, only the rects `Figure::layout()` computes and
// the controllers the host builds from them.
#include "harness.hpp"

#include <glfw/glfw_host.hpp>
#include <plot/plot/figure.hpp>

namespace {

/// A figure of `rows` rows over a known rect, with an x and a y axis in every row (so
/// each row lays out as a plot rather than as an empty rect), handed to a host.
struct Routed {
  explicit Routed(plot::u32 rows, plot::f32 gap = 0.0f) : figure(rows) {
    figure.set_viewport({0.0f, 0.0f, 300.0f, 600.0f});
    figure.set_row_gap(gap);
    for (plot::u32 row = 0; row < rows; ++row) {
      plot::Plot& p = figure.plot(row);
      p.add_x_axis({"t", {0.0, 1.0}, false, plot::AxisPlace::Bottom, false});
      p.add_y_axis({"v", {-1.0, 1.0}, false, plot::AxisPlace::Left, false});
    }
    host.set_figure(&figure);
    figure.layout();
  }

  plot::Figure figure;
  plot::glfw::Host host;
};

}  // namespace

PLOT_TEST(the_host_routes_a_pixel_to_the_row_it_is_in) {
  Routed r(3u);
  const std::vector<plot::Rect> rows = r.figure.layout().rows;
  PLOT_CHECK(rows.size() == 3u);
  for (plot::u32 row = 0; row < 3u; ++row) {
    PLOT_CHECK(r.host.row_controller(row) != nullptr);
    const plot::f32 x = rows[row].x + 0.5f * rows[row].w;
    const plot::f32 y = rows[row].y + 0.5f * rows[row].h;
    PLOT_CHECK(&r.host.controller_at(x, y) == r.host.row_controller(row));
  }
  // Above the first row and below the last one (the figure's own margins) are still the
  // nearest row rather than a dropped event: a drag that leaves the data area must end
  // where it should.
  PLOT_CHECK(&r.host.controller_at(150.0f, 0.0f) == r.host.row_controller(0u));
  PLOT_CHECK(&r.host.controller_at(150.0f, 599.0f) == r.host.row_controller(2u));
}

PLOT_TEST(the_host_routes_a_pixel_in_a_row_gap_to_the_nearest_row) {
  // A gap is what `set_row_gap()` asks for. Rows tile the figure at the default of 0, so
  // this is the only way a pixel can land in none of them -- and the routing must then
  // answer with the row it is *near*, not with row 0, which is what a "first row that
  // matches, else whatever `row` started at" loop would do.
  Routed r(3u, 40.0f);
  const std::vector<plot::Rect> rows = r.figure.layout().rows;
  PLOT_CHECK(rows.size() == 3u);
  for (plot::u32 row = 0; row + 1u < 3u; ++row) {
    const plot::f32 gap = rows[row + 1u].y - rows[row].bottom();
    PLOT_CHECK(gap > 0.0f);
    const plot::f32 middle = rows[row].bottom() + 0.5f * gap;
    // Just past a row's bottom edge the gap pixel is that row's...
    PLOT_CHECK(&r.host.controller_at(150.0f, rows[row].bottom() + 1.0f) ==
               r.host.row_controller(row));
    // ... and just above the next row's top edge it is the next row's.
    PLOT_CHECK(&r.host.controller_at(150.0f, rows[row + 1u].y - 1.0f) ==
               r.host.row_controller(row + 1u));
    // The middle of the gap goes to the nearer of the two rows -- and, whatever it picks,
    // to a row of *this* figure rather than to a default: this is the assertion the
    // "first match, else whatever `row` started at" loop failed, since it answered row 0
    // for every gap pixel.
    plot::input::Controller& in_gap = r.host.controller_at(150.0f, middle);
    PLOT_CHECK(&in_gap == r.host.row_controller(row) || &in_gap == r.host.row_controller(row + 1u));
    PLOT_CHECK(&in_gap != r.host.row_controller(2u) || row + 1u == 2u);
  }
}

// --- a drag that crosses rows is still one drag ------------------------------

namespace {

/// A two-row figure with a wide region on row 0, handed to a host: the fixture for the
/// drag capture. The region is what a drag edits, so where it ends up -- and whether the
/// owning controller still thinks it is dragging -- says whether the gesture that began on
/// it was the gesture the release ended.
struct DragRouted {
  DragRouted() : figure(2u) {
    figure.set_viewport({0.0f, 0.0f, 300.0f, 600.0f});
    for (plot::u32 row = 0; row < 2u; ++row) {
      plot::Plot& p = figure.plot(row);
      p.add_x_axis({"t", {0.0, 1.0}, false, plot::AxisPlace::Bottom, false});
      p.add_y_axis({"v", {-1.0, 1.0}, false, plot::AxisPlace::Left, false});
    }
    plot::Region region;
    region.x0 = 0.25;
    region.x1 = 0.75;
    region.snap = plot::RegionSnap::Free;  // the bounds are the test's, not a sample's
    region_id = figure.plot(0u).add_region(region);
    host.set_figure(&figure);
    figure.layout();
  }

  plot::Figure figure;
  plot::glfw::Host host;
  plot::u32 region_id = 0u;
};

}  // namespace

/// The finding: `controller_at()` routes *every* pointer event by the row the pixel is in,
/// ignoring the row a drag began in. A press on row 0's region, a motion into row 1 and a
/// release in row 1 therefore left row 0's controller with `MoveRegion`, `drag_region_`,
/// `drag_cursor_` and `drag_fixed_x_` set for ever: it kept publishing the grabbed bound,
/// `grabbed_region()` reported a drag that had ended, and a later gesture re-entering row 0
/// resumed the stale edit from the old anchor. The routing now captures the press's row for
/// the button's whole life, so the motion and the release reach the controller that owns them.
PLOT_TEST(a_drag_that_crosses_rows_is_ended_by_the_release_in_the_other_row) {
  DragRouted r;
  const std::vector<plot::Rect> rows = r.figure.layout().rows;
  PLOT_CHECK(rows.size() == 2u);
  plot::input::Controller& row0 = *r.host.row_controller(0u);
  plot::input::Controller& row1 = *r.host.row_controller(1u);

  // The screen x of data 0.5 on row 0's own x axis, and the middle of each row.
  const plot::f32 x = static_cast<plot::f32>(r.figure.plot(0u).x_transform(0u).to_screen_x(0.5));
  const plot::f32 y_a = rows[0].y + 0.5f * rows[0].h;
  const plot::f32 y_b = rows[1].y + 0.5f * rows[1].h;

  // Press on the region's body in row A.
  r.host.feed_pointer_event({x, y_a, 0.0f, 0.0f, plot::input::Button::Left, 0u, true, true, false});
  PLOT_CHECK(row0.drag_mode() == plot::input::DragMode::MoveRegion);
  PLOT_CHECK(row0.grabbed_region() == r.region_id);

  // Move into row B with the button still down, then release there.
  r.host.feed_pointer_event(
      {x + 4.0f, y_b, 4.0f, y_b - y_a, plot::input::Button::Left, 0u, true, false, false});
  r.host.feed_pointer_event(
      {x + 4.0f, y_b, 0.0f, 0.0f, plot::input::Button::Left, 0u, false, false, true});

  // (a) No controller is left holding a drag mode -- the release ended the gesture on the
  // controller that began it.
  PLOT_CHECK(row0.drag_mode() == plot::input::DragMode::None);
  PLOT_CHECK(row1.drag_mode() == plot::input::DragMode::None);
  // (b) And nothing reports a grabbed handle any more.
  PLOT_CHECK(row0.grabbed_region() == plot::kInvalid);
  PLOT_CHECK(row0.grabbed_cursor() == plot::kInvalid);
  PLOT_CHECK(row1.grabbed_region() == plot::kInvalid);

  // (d) The region is where the release left it: the press below is in row B, so a motion
  // re-entering row A must not edit it again from the old anchor. (Before the fix row A's
  // stale `MoveRegion` resumed on exactly this motion and moved the region further.)
  const plot::Region after = r.figure.plot(0u).region(r.region_id);
  r.host.feed_pointer_event({x, y_b, 0.0f, 0.0f, plot::input::Button::Left, 0u, true, true, false});
  r.host.feed_pointer_event({x + 20.0f, y_a, 20.0f, y_a - y_b, plot::input::Button::Left, 0u, true,
                             false, false});
  r.host.feed_pointer_event(
      {x + 20.0f, y_a, 0.0f, 0.0f, plot::input::Button::Left, 0u, false, false, true});
  const plot::Region now = r.figure.plot(0u).region(r.region_id);
  PLOT_CHECK(now.x0 == after.x0);
  PLOT_CHECK(now.x1 == after.x1);
  PLOT_CHECK(row0.drag_mode() == plot::input::DragMode::None);
}

PLOT_TEST(the_host_keeps_its_own_controller_while_no_figure_is_set) {
  plot::glfw::Host host;
  PLOT_CHECK(host.figure() == nullptr);
  PLOT_CHECK(host.row_controller(0u) == nullptr);
  // With no figure the routing is the single-plot loop's: one controller for every pixel.
  PLOT_CHECK(&host.controller_at(10.0f, 10.0f) == &host.controller());
  PLOT_CHECK(&host.controller_at(1000.0f, 1000.0f) == &host.controller());

  plot::Figure figure(2u);
  figure.set_viewport({0.0f, 0.0f, 300.0f, 600.0f});
  host.set_figure(&figure);
  PLOT_CHECK(host.figure() == &figure);
  PLOT_CHECK(host.row_controller(0u) != nullptr);
  PLOT_CHECK(host.row_controller(2u) == nullptr);  // a row that does not exist
  // And clearing it goes back to the single-plot answer.
  host.set_figure(nullptr);
  PLOT_CHECK(host.figure() == nullptr);
  PLOT_CHECK(host.row_controller(0u) == nullptr);
  PLOT_CHECK(&host.controller_at(10.0f, 10.0f) == &host.controller());
}