/*
 * pointer_log_replay.hpp
 *
 * Loads a pointer-interaction log recorded by the Rive viewer (see
 * packages/viewer InteractionRecorder) and replays it against a
 * SerializingFactory to drive a "silver" test at runtime -- an alternative to
 * generating C++ ahead of time with tools/pointer_log_to_silver.js.
 *
 * The replay follows the SAME cadence + quantization rules as that generator,
 * so a JSON-driven test and a generated-code test produce the identical .sriv
 * stream (and therefore the same golden).
 *
 * Usage:
 *   SerializingFactory silver;
 *   auto file = ReadRiveFile("assets/foo.riv", &silver);
 *   auto artboard = file->artboardDefault();
 *   silver.frameSize(artboard->width(), artboard->height());
 *   auto sm = artboard->stateMachineAt(0);
 *   // ... bind view model, prime, initial draw (mirror the generator preamble)
 *   auto renderer = silver.makeRenderer();
 *   artboard->draw(renderer.get());
 *   replayPointerLog("assets/foo.json", silver, artboard.get(), sm.get(),
 *                    renderer.get(), {.stride = 1});
 *   CHECK(silver.matches("foo"));
 */

#ifndef _RIVE_POINTER_LOG_REPLAY_HPP_
#define _RIVE_POINTER_LOG_REPLAY_HPP_

#include "rive/animation/state_machine_instance.hpp"
#include "rive/artboard.hpp"
#include "rive/math/vec2d.hpp"
#include "rive/renderer.hpp"
#include "utils/serializing_factory.hpp"

#include "rive_testing.hpp"

#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <fstream>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

namespace rive
{
namespace pointer_log
{

// ---------------------------------------------------------------------------
// Minimal JSON value + parser (sufficient for the recorder's schema: an object
// with a "meta" object and an "entries" array of flat objects whose values are
// strings, numbers, and booleans). Not a general-purpose JSON library.
//
// Entry ops:
//   {op:"pointer", type:"down|move|up|exit", x, y, id}
//   {op:"advance", dt}                    -- one frame
//   {op:"multiAdvance", count, dt}        -- `count` frames of `dt` each
// ---------------------------------------------------------------------------
struct Json
{
  enum class Type
  {
    null,
    boolean,
    number,
    string,
    array,
    object
  };

  Type type = Type::null;
  bool boolean = false;
  double number = 0;
  std::string str;
  std::vector<Json> array;
  std::vector<std::pair<std::string, Json>> object;

  const Json* find(const char* key) const
  {
    for (const auto& kv : object)
    {
      if (kv.first == key)
      {
        return &kv.second;
      }
    }
    return nullptr;
  }

  double numberOr(double fallback) const
  {
    return type == Type::number ? number : fallback;
  }
  bool boolOr(bool fallback) const
  {
    return type == Type::boolean ? boolean : fallback;
  }
  std::string stringOr(const char* fallback) const
  {
    return type == Type::string ? str : std::string(fallback);
  }
};

class Parser
{
public:
  Parser(const char* begin, const char* end) : m_p(begin), m_end(end) {}

  bool parse(Json& out)
  {
    skipWs();
    if (!parseValue(out))
    {
      return false;
    }
    skipWs();
    return m_ok;
  }

private:
  const char* m_p;
  const char* m_end;
  bool m_ok = true;

  bool atEnd() const { return m_p >= m_end; }
  char peek() const { return atEnd() ? '\0' : *m_p; }

  void skipWs()
  {
    while (!atEnd())
    {
      char c = *m_p;
      if (c == ' ' || c == '\t' || c == '\n' || c == '\r')
      {
        m_p++;
      }
      else
      {
        break;
      }
    }
  }

  bool expect(char c)
  {
    if (peek() != c)
    {
      m_ok = false;
      return false;
    }
    m_p++;
    return true;
  }

  bool parseValue(Json& out)
  {
    skipWs();
    char c = peek();
    switch (c)
    {
      case '{':
        return parseObject(out);
      case '[':
        return parseArray(out);
      case '"':
        return parseString(out);
      case 't':
      case 'f':
        return parseBool(out);
      case 'n':
        return parseNull(out);
      default:
        return parseNumber(out);
    }
  }

  bool parseObject(Json& out)
  {
    out.type = Json::Type::object;
    if (!expect('{'))
    {
      return false;
    }
    skipWs();
    if (peek() == '}')
    {
      m_p++;
      return true;
    }
    while (true)
    {
      skipWs();
      Json key;
      if (!parseString(key))
      {
        return false;
      }
      skipWs();
      if (!expect(':'))
      {
        return false;
      }
      Json value;
      if (!parseValue(value))
      {
        return false;
      }
      out.object.emplace_back(key.str, std::move(value));
      skipWs();
      if (peek() == ',')
      {
        m_p++;
        continue;
      }
      return expect('}');
    }
  }

  bool parseArray(Json& out)
  {
    out.type = Json::Type::array;
    if (!expect('['))
    {
      return false;
    }
    skipWs();
    if (peek() == ']')
    {
      m_p++;
      return true;
    }
    while (true)
    {
      Json value;
      if (!parseValue(value))
      {
        return false;
      }
      out.array.push_back(std::move(value));
      skipWs();
      if (peek() == ',')
      {
        m_p++;
        continue;
      }
      return expect(']');
    }
  }

  bool parseString(Json& out)
  {
    out.type = Json::Type::string;
    if (!expect('"'))
    {
      return false;
    }
    std::string s;
    while (!atEnd())
    {
      char c = *m_p++;
      if (c == '"')
      {
        out.str = std::move(s);
        return true;
      }
      if (c == '\\')
      {
        if (atEnd())
        {
          break;
        }
        char e = *m_p++;
        switch (e)
        {
          case '"':
            s.push_back('"');
            break;
          case '\\':
            s.push_back('\\');
            break;
          case '/':
            s.push_back('/');
            break;
          case 'n':
            s.push_back('\n');
            break;
          case 't':
            s.push_back('\t');
            break;
          case 'r':
            s.push_back('\r');
            break;
          case 'b':
            s.push_back('\b');
            break;
          case 'f':
            s.push_back('\f');
            break;
          case 'u':
            // Skip the 4 hex digits; the recorder never emits
            // these.
            for (int i = 0; i < 4 && !atEnd(); i++)
            {
              m_p++;
            }
            s.push_back('?');
            break;
          default:
            s.push_back(e);
            break;
        }
      }
      else
      {
        s.push_back(c);
      }
    }
    m_ok = false;
    return false;
  }

  bool parseNumber(Json& out)
  {
    const char* start = m_p;
    if (peek() == '-')
    {
      m_p++;
    }
    bool any = false;
    while (!atEnd())
    {
      char c = *m_p;
      if ((c >= '0' && c <= '9') || c == '.' || c == 'e' || c == 'E' ||
          c == '+' || c == '-')
      {
        any = true;
        m_p++;
      }
      else
      {
        break;
      }
    }
    if (!any)
    {
      m_ok = false;
      return false;
    }
    out.type = Json::Type::number;
    out.number = std::strtod(std::string(start, m_p).c_str(), nullptr);
    return true;
  }

  bool parseBool(Json& out)
  {
    if (matchLiteral("true"))
    {
      out.type = Json::Type::boolean;
      out.boolean = true;
      return true;
    }
    if (matchLiteral("false"))
    {
      out.type = Json::Type::boolean;
      out.boolean = false;
      return true;
    }
    m_ok = false;
    return false;
  }

  bool parseNull(Json& out)
  {
    if (matchLiteral("null"))
    {
      out.type = Json::Type::null;
      return true;
    }
    m_ok = false;
    return false;
  }

  bool matchLiteral(const char* literal)
  {
    const char* q = m_p;
    while (*literal)
    {
      if (q >= m_end || *q != *literal)
      {
        return false;
      }
      q++;
      literal++;
    }
    m_p = q;
    return true;
  }
};

} // namespace pointer_log

/// Cadence options; mirror the tools/pointer_log_to_silver.js flags. Every
/// advance is always applied at its (quantized) recorded dt so animation state
/// stays faithful; these only control how often a frame is recorded.
struct PointerLogReplayOptions
{
  /// Seconds between snapshots. When > 0 this takes precedence over `stride`.
  float interval = 0.0f;
  /// Convenience: when > 0, interval = 1 / fps.
  float fps = 0.0f;
  /// Count-based cadence: snapshot every Nth advance (used when interval <=
  /// 0).
  int stride = 1;
  /// dt bucket size for grouping near-equal advances. <= 0 disables grouping
  /// (each distinct exact dt is emitted as-is; only identical dts group).
  float quantize = 0.001f;
};

/// Replays the entries of a recorded pointer log against `silver`, driving
/// `sm` / `artboard` and recording frames into `renderer`.
static inline void replayPointerLog(
    const char* jsonPath,
    SerializingFactory& silver,
    Artboard* artboard,
    StateMachineInstance* sm,
    Renderer* renderer,
    const PointerLogReplayOptions& opts = {})
{
  // Read the whole file.
  std::ifstream stream(jsonPath, std::ios::binary);
  REQUIRE(stream.good());
  std::stringstream buffer;
  buffer << stream.rdbuf();
  std::string text = buffer.str();

  pointer_log::Json root;
  pointer_log::Parser parser(text.data(), text.data() + text.size());
  REQUIRE(parser.parse(root));

  const pointer_log::Json* entries = root.find("entries");
  REQUIRE(entries != nullptr);
  REQUIRE(entries->type == pointer_log::Json::Type::array);

  // Resolve cadence.
  float interval = opts.interval;
  if (opts.fps > 0.0f)
  {
    interval = 1.0f / opts.fps;
  }
  const bool useInterval = interval > 0.0f;
  const int stride = opts.stride < 1 ? 1 : opts.stride;
  const float quantize = opts.quantize;

  // Bucket a dt (> 0) into a grouping key and the float we emit for it.
  // `q` is guaranteed > 0 so `interval / q` can never divide by zero:
  //   - quantize > 0: round to the nearest bucket, clamped to >= 1 bucket so
  //     a tiny dt still yields q == quantize rather than 0.
  //   - quantize <= 0: grouping disabled -- use the exact dt (always > 0
  //     here); only advances with identical dt group together.
  auto bucketFor = [&](double dt) -> std::pair<double, float> {
    if (quantize > 0.0f)
    {
      long bucket = std::lround(dt / quantize);
      if (bucket < 1)
      {
        bucket = 1;
      }
      return {(double)bucket, (float)bucket * quantize};
    }
    return {dt, (float)dt};
  };

  // Open advance group state: a run of consecutive advances sharing
  // `groupKey` (and thus the emitted `groupQ`).
  double groupKey = 0;
  float groupQ = 0.0f;
  bool haveGroup = false;
  int groupCount = 0;

  auto flushGroup = [&]() {
    if (!haveGroup || groupCount == 0)
    {
      haveGroup = false;
      groupCount = 0;
      return;
    }
    const float q = groupQ; // always > 0
    const int step = useInterval ? std::max(1, (int)std::lround(interval / q))
                                 : stride;
    const int periods = groupCount / step;
    const int remainder = groupCount - periods * step;

    for (int p = 0; p < periods; p++)
    {
      silver.addFrame();
      for (int s = 0; s < step; s++)
      {
        sm->advanceAndApply(q);
      }
      artboard->draw(renderer);
    }
    // Trailing advances that don't complete a snapshot period: apply time
    // without recording a frame.
    for (int r = 0; r < remainder; r++)
    {
      sm->advanceAndApply(q);
    }

    haveGroup = false;
    groupCount = 0;
  };

  // Feed one advance of `dt` into the grouping state (a `multiAdvance` entry
  // calls this `count` times).
  auto handleAdvance = [&](double dt) {
    if (dt <= 0)
    {
      // Zero-length advance (drain): apply without a frame.
      flushGroup();
      sm->advanceAndApply(0.0f);
      return;
    }
    const auto bq = bucketFor(dt);
    const double key = bq.first;
    const float q = bq.second;
    if (!haveGroup)
    {
      haveGroup = true;
      groupKey = key;
      groupQ = q;
      groupCount = 1;
    }
    else if (key == groupKey)
    {
      groupCount++;
    }
    else
    {
      flushGroup();
      haveGroup = true;
      groupKey = key;
      groupQ = q;
      groupCount = 1;
    }
  };

  for (const auto& e : entries->array)
  {
    const pointer_log::Json* opJson = e.find("op");
    if (opJson == nullptr)
    {
      continue;
    }
    const std::string op = opJson->stringOr("");

    if (op == "pointer")
    {
      flushGroup();
      const pointer_log::Json* typeJson = e.find("type");
      const std::string type = typeJson ? typeJson->stringOr("")
                                        : std::string();
      const float x = (float)(e.find("x") ? e.find("x")->numberOr(0) : 0);
      const float y = (float)(e.find("y") ? e.find("y")->numberOr(0) : 0);
      const int id = (int)(e.find("id") ? e.find("id")->numberOr(0) : 0);
      const Vec2D pos(x, y);
      if (type == "down")
      {
        sm->pointerDown(pos, id);
      }
      else if (type == "up")
      {
        sm->pointerUp(pos, id);
      }
      else if (type == "move")
      {
        sm->pointerMove(pos, 0, id);
      }
      else if (type == "exit")
      {
        sm->pointerExit(pos, id);
      }
    }
    else if (op == "advance")
    {
      handleAdvance(e.find("dt") ? e.find("dt")->numberOr(0) : 0);
    }
    else if (op == "multiAdvance")
    {
      // A run of identical-delta advances: {count, dt}.
      const double dt = e.find("dt") ? e.find("dt")->numberOr(0) : 0;
      const long count = (long)(e.find("count") ? e.find("count")->numberOr(0)
                                                : 0);
      for (long i = 0; i < count; i++)
      {
        handleAdvance(dt);
      }
    }
  }
  flushGroup();
}

} // namespace rive

#endif