// The reference application: the whole library running as a real program, fed by
// a 1 MS/s producer thread through the GLFW adapter.
//
// What it demonstrates, and what the other three adapters copy:
//
//  - a `StreamSeries` at the retention limit (1 << 20 samples, 1.048576 s at this
//    rate) pushed from a background thread and acquired exactly once per frame on
//    the render thread;
//  - a signal whose decimation correctness is visible: a 437 Hz sine plus a small
//    noise term plus a narrow spike every 100 ms. A bucket that kept only its
//    first sample would drop the spike; a bucket that keeps its extrema cannot;
//  - a plot the user can drive: grid, both axes titled and labelled (the time
//    axis with `format_time` clock labels, the value axis with SI ones), one
//    trace, two cursors and the measurement readout the plot layer draws itself
//    (shaded band plus a `dx/dy/rms/mean` line) -- no drawing code here;
//  - the headless smoke mode the adapter implements once
//    (PLOT_DEMO_EXIT_AFTER_MS / PLOT_DEMO_SCREENSHOT), so CI can run this under
//    `xvfb-run` and check the frame it wrote;
//  - `PLOT_DEMO_FOLLOW=1`: the same run with the time axis armed for live following
//    (`XFollow::Live`), driving three wheel notches and a pan through the host's own
//    controller and printing, at each step, the range's width, its distance behind
//    the newest sample and the follow state -- the interaction spec §12 is about,
//    measured on a real stream rather than in a unit test.
//
// The producer is joined before the stream it writes into is destroyed, and
// before the host closes the GL context (main's destruction order does that).

#include <glfw/glfw_host.hpp>

#include <plot/data/stream_series.hpp>
#include <plot/plot/ticks.hpp>

#include <atomic>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <numbers>
#include <thread>
#include <utility>
#include <vector>

namespace {

using plot::f32;
using plot::f64;
using plot::u32;
using plot::u64;

/// One sample per microsecond: 1 MS/s.
constexpr f64 kSampleRate = 1.0e6;
constexpr f64 kDx = 1.0 / kSampleRate;
/// The retained window: 1 << 20 samples = 1.048576 s. A power of two, so the
/// ring never has to round it up.
constexpr u64 kCapacity = 1u << 20;
/// Producer wakeup: about a millisecond of samples per push batch.
constexpr u64 kBatch = 1u << 10;
/// Cap on one push batch, so a process that was stopped and resumed catches up
/// over several iterations instead of allocating a batch for the whole gap.
constexpr u64 kMaxBatch = 1u << 16;

/// The signal: a few hundred Hz sine, a small noise term, a narrow spike.
constexpr f64 kSineHz = 437.0;
constexpr f64 kNoiseAmp = 0.02;
constexpr f64 kSpikePeriodS = 0.1;
constexpr f64 kSpikeWidthS = 2.0e-6;
constexpr f64 kSpikeAmp = 3.0;

// The trace colour the render smoke test's blue-dominance predicate expects, so
// the same predicate reads this demo's screenshot.
constexpr plot::Color kTraceColor = plot::Color::hex(0x40C0FF);
constexpr plot::Color kCursorAColor = plot::Color::hex(0xFFB020);
constexpr plot::Color kCursorBColor = plot::Color::hex(0x35D0A8);

/// y(t) for sample index `i`: sine + deterministic noise + a two-sample spike.
///
/// The noise hash takes the low 32 bits of the index, so its pattern repeats
/// every ~4295 s at 1 MS/s -- far beyond any run of this demo, and it keeps the
/// sample path allocation-free and branch-light, unlike a PRNG.
f32 sample_at(u64 i) noexcept {
  const f64 t = static_cast<f64>(i) * kDx;
  f64 y = std::sin(2.0 * std::numbers::pi * kSineHz * t);

  u32 h = static_cast<u32>(i) * 2654435761u;
  h ^= h >> 15;
  h *= 2246822519u;
  h ^= h >> 13;
  h *= 3266489917u;
  h ^= h >> 16;
  y += kNoiseAmp * (static_cast<f64>(h & 0xFFFFFFu) / 8388608.0 - 1.0);

  const f64 phase = std::fmod(t, kSpikePeriodS);
  if (phase < kSpikeWidthS) {
    y += kSpikeAmp * (1.0 - phase / kSpikeWidthS);
  }
  return static_cast<f32>(y);
}

/// Feeds a `StreamSeries` from its own thread at 1 MS/s on average, paced by
/// absolute deadlines off a steady clock: every wakeup produces every sample
/// whose time has already come, so a late wakeup is caught up instead of pushing
/// the phase back, and the achieved rate cannot drift the way a fixed
/// `sleep_for()` per batch does.
class Producer {
 public:
  explicit Producer(plot::data::StreamSeries& series)
      : series_(&series), thread_([this] { run(); }) {}
  ~Producer() { stop(); }

  Producer(const Producer&) = delete;
  Producer& operator=(const Producer&) = delete;

  /// Sets the stop flag and joins the thread. Idempotent; the destructor calls
  /// it, so the thread is never detached and never outlives the stream.
  void stop() noexcept {
    stop_.store(true, std::memory_order_relaxed);
    if (thread_.joinable()) thread_.join();
  }

  /// Samples pushed so far. Written by the producer, read by the render thread.
  u64 produced() const noexcept { return produced_.load(std::memory_order_relaxed); }

 private:
  void run() {
    using clock = std::chrono::steady_clock;
    const auto start = clock::now();
    u64 next = 0;
    while (!stop_.load(std::memory_order_relaxed)) {
      const f64 elapsed = std::chrono::duration<f64>(clock::now() - start).count();
      const u64 due = static_cast<u64>(elapsed / kDx) + 1;  // samples whose time has come
      if (due > next) {
        u64 n = due - next;
        if (n > kMaxBatch) n = kMaxBatch;
        batch_.resize(static_cast<plot::usize>(n));
        for (u64 k = 0; k < n; ++k) {
          batch_[static_cast<plot::usize>(k)] = sample_at(next + k);
        }
        series_->push(batch_.data(), n);
        next += n;
        produced_.store(next, std::memory_order_relaxed);
      }
      // Sleep until one batch past the last produced sample: an absolute
      // deadline, so the phase is fixed at `start` and never accumulates.
      const f64 wake_s = static_cast<f64>(next + kBatch) * kDx;
      std::this_thread::sleep_until(
          start + std::chrono::duration_cast<clock::duration>(std::chrono::duration<f64>(wake_s)));
    }
  }

  plot::data::StreamSeries* series_;
  std::vector<f32> batch_;
  std::atomic<u64> produced_{0};
  std::atomic<bool> stop_{false};
  std::thread thread_;  ///< declared last: the lambda runs once everything is up
};

/// The live readout: the achieved push rate, the frame time and the frame count.
struct Meter {
  f64 rate = 0.0;        ///< samples/s, refreshed a few times a second
  f64 frame_ms = 0.0;    ///< exponential moving average of the frame time
  f64 elapsed = 0.0;     ///< seconds of frame callback time
  f64 last_report = 0.0;
  u64 last_produced = 0;
  u64 frames = 0;
};

/// The scripted live-follow sequence `PLOT_DEMO_FOLLOW=1` runs.
///
/// The follow arithmetic is pinned by the library's tests; "the plot keeps showing
/// the newest sample while the user zooms and pans it" is an *interaction*, and this
/// is the program that has one -- a real 1 MS/s producer, the real host, the real
/// controller. So the sequence arms `XFollow::Live` once the stream holds data and
/// then takes four measurements, one per frame:
///
///  (a) steady state, with the retained window framed;
///  (b) after three wheel notches, rolled over the x label strip -- outside `axes`,
///      where the wheel's anchor is the live edge, so the zoom changes the width and
///      nothing else;
///  (c) after a 100 px left-drag, the real pan gesture, which moves the window back
///      from the live edge;
///  (d) after a further 50 ms of data has arrived.
///
/// Each measurement prints the range's width, how far its right edge sits behind the
/// newest sample, and whether following is still armed. Only the zoom may change the
/// width, only the pan may change the distance behind, and following must be armed
/// throughout; the last line of the run says whether that held, so the run is a check
/// rather than a printout to be read.
struct FollowScript {
  bool enabled = false;
  plot::u32 step = 0;
  plot::f64 width[4]{};
  plot::f64 behind[4]{};
  bool live[4]{};
  plot::f64 wait_from = 0.0;

  static FollowScript from_env() {
    FollowScript s;
    const char* v = std::getenv("PLOT_DEMO_FOLLOW");
    s.enabled = v != nullptr && v[0] != '0' && v[0] != '\0';
    return s;
  }

  /// One frame per step: the gesture, then the measurement of what it did. The last
  /// step waits for data to actually arrive, because the last measurement is about
  /// what more samples do to a window the user has moved.
  void advance(plot::glfw::Host& host, plot::data::StreamSeries& stream, plot::Plot& p,
               plot::u32 axis) {
    switch (step) {
      case 0:
        // Enough retained data for the numbers to be worth printing; the producer
        // starts before the window opens, so this usually fires on the first frame.
        if (stream.size() < 262144u) return;
        p.set_x_follow(axis, plot::XFollow::Live);
        p.auto_fit_x();  // the retained window, ending at the live edge
        record(0, p, stream, axis);
        break;
      case 1:
        notches(host, p);
        record(1, p, stream, axis);
        break;
      case 2:
        pan(host, p);
        record(2, p, stream, axis);
        wait_from = stream.x_bounds().max;
        break;
      case 3:
        // 50 ms at this demo's 1 MS/s, i.e. ~50000 samples of new data before the
        // fourth measurement.
        if (stream.x_bounds().max - wait_from < 0.05) return;
        record(3, p, stream, axis);
        report();
        break;
      default:
        return;
    }
    ++step;
  }

 private:
  /// Three notches of the wheel over the x label strip centre.
  static void notches(plot::glfw::Host& host, plot::Plot& p) {
    const plot::Rect strip = p.layout().x_label_area;
    const plot::input::WheelEvent w{strip.x + 0.5f * strip.w, strip.y + 0.5f * strip.h,
                                    0.0f, 1.0f, 0};
    for (int i = 0; i < 3; ++i) host.controller().on_wheel(w);
  }

  /// A 100 px drag to the right across the axes, as press/move/release.
  static void pan(plot::glfw::Host& host, plot::Plot& p) {
    const plot::Rect axes = p.layout().axes;
    const f32 x = axes.x + 0.5f * axes.w;
    const f32 y = axes.y + 0.5f * axes.h;
    host.controller().on_pointer({x, y, 0.0f, 0.0f, plot::input::Button::Left, 0, true, true, false});
    host.controller().on_pointer(
        {x + 100.0f, y, 100.0f, 0.0f, plot::input::Button::Left, 0, true, false, false});
    host.controller().on_pointer(
        {x + 100.0f, y, 0.0f, 0.0f, plot::input::Button::Left, 0, false, false, true});
  }

  void record(int i, plot::Plot& p, plot::data::StreamSeries& stream, plot::u32 axis) {
    p.layout();
    const plot::Range r = p.x_range(axis);
    width[i] = r.span();
    behind[i] = stream.x_bounds().max - r.max;
    live[i] = p.x_follow(axis) == plot::XFollow::Live;
    std::printf("[glfw_demo] follow %c: width %9.6f s  behind %9.6f s  follow %s  newest %.6f s\n",
                "abcd"[i], width[i], behind[i], live[i] ? "armed" : "OFF",
                stream.x_bounds().max);
    std::fflush(stdout);
  }

  void report() {
    // Tolerances rather than `==`: the window is recomputed from a newest x that has
    // moved between the frames the two numbers were taken on, so the last bits of
    // the width and the distance behind may differ.
    const auto same = [](plot::f64 a, plot::f64 b) {
      return std::fabs(a - b) <= 1e-9 * std::fabs(a) + 1e-12;
    };
    const auto at_edge = [](plot::f64 distance) { return std::fabs(distance) < 1e-6; };
    const bool zoom_only_width =
        width[0] > width[1] * 1.01 && same(width[1], width[2]) && same(width[2], width[3]);
    const bool pan_only_behind =
        at_edge(behind[0]) && at_edge(behind[1]) && behind[2] > 1e-6 && same(behind[2], behind[3]);
    const bool following = live[0] && live[1] && live[2] && live[3];
    std::printf(
        "[glfw_demo] follow checks: width changed only by the zoom: %s; distance behind only"
        " by the pan: %s; following armed throughout: %s\n",
        zoom_only_width ? "yes" : "NO", pan_only_behind ? "yes" : "NO",
        following ? "yes" : "NO");
    std::fflush(stdout);
  }
};

}  // namespace

int main() {
  plot::glfw::Host host;
  plot::data::StreamSeries stream(kCapacity, 0.0, kDx);
  Producer producer(stream);

  plot::Plot& p = host.plot();
  // Time axis: clock labels, which `TickFormat::Time` routes through
  // `format_time`. The value axis keeps SI labels, which is `format_si`.
  const u32 axis_x = p.add_x_axis(
      {"time", {-0.5, 0.5}, true, plot::AxisPlace::Bottom, false, plot::TickFormat::Time});
  const u32 axis_y = p.add_y_axis(
      {"signal", {-4.0, 4.0}, true, plot::AxisPlace::Left, false, plot::TickFormat::Si});
  const u32 trace = p.add_trace({&stream, kTraceColor, 1.5f, axis_x, axis_y});

  // Snapped cursors sit exactly on a sample, so the readout measures samples
  // rather than a rounded position between two of them.
  const u32 cursor_a = p.add_cursor(0.0, kCursorAColor);
  const u32 cursor_b = p.add_cursor(0.0, kCursorBColor);
  p.set_cursor_snap(cursor_a, plot::SnapMode::NearestSample);
  p.set_cursor_snap(cursor_b, plot::SnapMode::NearestSample);
  const u32 measure = p.add_measure(cursor_a, cursor_b, trace);

  Meter meter;
  /// The scripted live-follow verification, off unless `PLOT_DEMO_FOLLOW` asks for
  /// it. It is the same shape as the headless smoke mode above: a driven run whose
  /// result is a few numbers on stdout.
  FollowScript script = FollowScript::from_env();
  // The cursors ride the live window until the user takes over: the first
  // ctrl+drag on a cursor, or a pan/zoom that clears the x axis' auto scale,
  // stops them where the user put them. Under `Live` the follow path owns the x
  // range whatever auto scale says, so a zoom is not the user taking the x view
  // over -- only a cursor drag, or following being switched off, is.
  bool cursors_follow = true;

  const plot::glfw::FrameFn frame = [&](plot::Plot& graph, plot::f64 dt) {
    stream.acquire();  // once per frame, on the render thread

    if (script.enabled) script.advance(host, stream, graph, axis_x);

    // Re-frame the live stream while the user has not overridden the ranges, and
    // while the axis is not following. `auto_fit_*` re-arms auto scale, so it may
    // only run while auto scale is still on: calling it after a pan would undo the
    // pan every frame -- and under `Live` a fit means "back to the live edge", so a
    // per-frame one would undo the offset the user just panned to as well.
    if (graph.x_follow(axis_x) == plot::XFollow::Off && graph.x_axis(axis_x).auto_scale) {
      graph.auto_fit_x();
    }
    if (graph.y_axis(axis_y).auto_scale) graph.auto_fit_y(axis_y);

    if (cursors_follow) {
      const bool x_taken_over = graph.x_follow(axis_x) == plot::XFollow::Live
                                    ? false
                                    : !graph.x_axis(axis_x).auto_scale;
      if (host.controller().drag_mode() == plot::input::DragMode::MoveCursor || x_taken_over) {
        cursors_follow = false;
      } else {
        const plot::Range xr = graph.x_range(axis_x);
        graph.set_cursor_x(cursor_a, xr.min + 0.35 * xr.span());
        graph.set_cursor_x(cursor_b, xr.min + 0.65 * xr.span());
      }
    }

    meter.elapsed += dt;
    meter.frames += 1;
    meter.frame_ms += 0.1 * (dt * 1.0e3 - meter.frame_ms);  // EMA
    if (meter.elapsed - meter.last_report >= 0.25) {
      const u64 produced = producer.produced();
      meter.rate = static_cast<f64>(produced - meter.last_produced) /
                   (meter.elapsed - meter.last_report);
      meter.last_produced = produced;
      meter.last_report = meter.elapsed;

      // The title carries the live readout: samples/second, frame time, and the
      // samples per pixel that say which rasterisation path the trace took. The
      // stats are the previous frame's, since this runs before draw().
      const plot::Renderer* r = host.renderer();
      const plot::FrameStats prev = r != nullptr ? r->stats() : plot::FrameStats{};
      const plot::Rect axes = std::as_const(graph).layout().axes;
      const f64 spp = axes.w > 0.0f ? static_cast<f64>(prev.visible_samples) /
                                          static_cast<f64>(axes.w)
                                    : 0.0;
      char title[192];
      std::snprintf(title, sizeof title,
                    "plot glfw demo | %.3f MS/s | %.2f ms/frame | %.0f samples/px | %s | %llu frames",
                    meter.rate * 1.0e-6, meter.frame_ms, spp,
                    prev.lod_traces > 0 ? "LOD" : (prev.raw_traces > 0 ? "raw" : "-"),
                    static_cast<unsigned long long>(meter.frames));
      host.set_title(title);

      std::printf("[glfw_demo] t=%.1fs  %.3f MS/s  %.2f ms/frame  %.0f samples/px  %s\n",
                  meter.elapsed, meter.rate * 1.0e-6, meter.frame_ms, spp,
                  prev.lod_traces > 0 ? "LOD" : (prev.raw_traces > 0 ? "raw" : "-"));
      std::fflush(stdout);
    }
  };

  // vsync on: this is a real application, and the headless mode below is what
  // makes it verifiable without a display.
  plot::glfw::RunConfig cfg;
  cfg.title = "plot glfw demo";
  cfg.vsync = true;

  plot::Status st;
  const bool ok = host.run(cfg, frame, &st);
  producer.stop();  // no thread pushes into the stream after this point

  if (!ok) {
    std::fprintf(stderr, "plot_glfw_demo: %s: %s\n", plot::to_string(st.code), st.message);
    return 1;
  }

  const plot::Renderer* r = host.renderer();
  const plot::FrameStats stats = r != nullptr ? r->stats() : plot::FrameStats{};
  const plot::Rect axes = std::as_const(p).layout().axes;
  const f64 spp =
      axes.w > 0.0f ? static_cast<f64>(stats.visible_samples) / static_cast<f64>(axes.w) : 0.0;
  const f64 dense = r != nullptr ? static_cast<f64>(r->style().dense_threshold_spp) : 0.0;
  const plot::Measurement m = p.measurement(measure);
  const f64 mean_ms =
      meter.frames > 0 ? meter.elapsed / static_cast<f64>(meter.frames) * 1.0e3 : 0.0;
  const plot::Range yr = stream.y_bounds();

  std::printf("\n[glfw_demo] ---- run summary ----\n");
  // The rate is the last metered interval, not produced/elapsed: this thread's
  // clock starts when the first frame runs, and the producer starts ~0.4 s
  // earlier, still building the window, so a cumulative division would report a
  // rate the producer never sustained.
  std::printf("[glfw_demo] producer      %llu samples pushed, last metered %.3f MS/s\n",
              static_cast<unsigned long long>(producer.produced()), meter.rate * 1.0e-6);
  std::printf("[glfw_demo] frames        %llu in %.3f s, mean %.2f ms/frame (%.1f fps),"
              " last metered %.2f ms/frame\n",
              static_cast<unsigned long long>(meter.frames), meter.elapsed, mean_ms,
              mean_ms > 0.0 ? 1.0e3 / mean_ms : 0.0, meter.frame_ms);
  std::printf("[glfw_demo] retained      %llu samples, x [%.6f, %.6f] s, y [%.3f, %.3f]\n",
              static_cast<unsigned long long>(stream.size()), stream.x_bounds().min,
              stream.x_bounds().max, yr.min, yr.max);
  std::printf("[glfw_demo] pixel spaces  viewport (framebuffer px) %.0fx%.0f, window->framebuffer"
              " scale %.2fx%.2f, content scale %.2fx%.2f\n",
              static_cast<double>(p.viewport().w), static_cast<double>(p.viewport().h),
              static_cast<double>(host.framebuffer_scale_x()),
              static_cast<double>(host.framebuffer_scale_y()),
              static_cast<double>(host.content_scale_x()),
              static_cast<double>(host.content_scale_y()));
  std::printf("[glfw_demo] last frame    %.1f samples/px (dense threshold %.1f) -> %s\n", spp,
              dense, stats.lod_traces > 0 ? "LOD pyramid" : "raw samples");
  std::printf("[glfw_demo] last frame    visible_samples %llu, axes %.0fx%.0f, staged_segments %u"
              ", draw_calls %u, lod %u raw %u\n",
              static_cast<unsigned long long>(stats.visible_samples),
              static_cast<double>(axes.w), static_cast<double>(axes.h), stats.staged_segments,
              stats.draw_calls, stats.lod_traces, stats.raw_traces);
  std::printf("[glfw_demo] measurement   %s dx %g s dy %g rms %g mean %g\n",
              m.valid ? "valid:" : "INVALID", m.dx, m.dy, m.rms, m.mean);
  std::printf("[glfw_demo] upload path   %s, gl error on the last frame %d\n",
              r != nullptr && r->using_persistent_upload() ? "persistent-mapped ring" : "orphan",
              r != nullptr && r->last_frame_had_gl_error() ? 1 : 0);

  return 0;  // ~producer (no-op after stop), ~stream, then ~host closes GL
}