#include "rive/animation/listener_invocation.hpp"
#include "rive/animation/state_machine_instance.hpp"
#include "rive/core/binary_reader.hpp"
#include "rive/input/focus_manager.hpp"
#include "rive/input/gamepad_batch.hpp"
#include "rive/input/gamepad_snapshot.hpp"
#include "rive/input/standard_gamepad.hpp"
#include "rive/scripted/scripted_drawable.hpp"
#include "rive/span.hpp"
// Defines StateMachineInstance's SMIInputExtras cluster, which owns the
// embedder gamepad snapshots and the gamepad-aware scripted drawables.
#include "rive/animation/state_machine_instance_clusters.hpp"

namespace rive
{

static void recomputeButtonMaskFromValues(GamepadSnapshot& s)
{
  s.buttonMask = 0;
  for (size_t i = 0; i < s.buttonValues.size(); i++)
  {
    if (s.buttonValues[i] >= 0.5f)
    {
      s.buttonMask |= (uint64_t(1) << i);
    }
  }
}

static void fillStandardIntent(
    const GamepadSnapshot& snap,
    GamepadEventInvocation& ev)
{
  ev.hasStandardButtonIntent = false;
  ev.hasStandardAxisIntent = false;
  if (snap.mapping != GamepadMappingKind::standard)
  {
    return;
  }
  if (ev.change.kind == GamepadInputChangeKind::button)
  {
    if (ev.change.index <= static_cast<uint8_t>(StandardGamepadButton::start))
    {
      ev.hasStandardButtonIntent = true;
      ev.standardButton = static_cast<StandardGamepadButton>(ev.change.index);
    }
  }
  else
  {
    if (ev.change.index <=
        static_cast<uint8_t>(StandardGamepadAxis::rightTrigger))
    {
      ev.hasStandardAxisIntent = true;
      ev.standardAxis = static_cast<StandardGamepadAxis>(ev.change.index);
    }
  }
}

static bool readConnectedPayload(
    BinaryReader& reader,
    GamepadSnapshot& outSnapshot)
{
  outSnapshot = GamepadSnapshot{};
  outSnapshot.deviceId = static_cast<int32_t>(reader.readUint32());
  const uint8_t mappingByte = reader.readByte();
  const uint8_t nButtons = reader.readByte();
  const uint8_t nAxes = reader.readByte();
  reader.readByte(); // 1-byte padding to align the float arrays.
  if (reader.hasError() || nButtons > kGamepadBatchMaxButtons ||
      nAxes > kGamepadBatchMaxAxes)
  {
    return false;
  }
  outSnapshot.mapping = mappingByte == 0 ? GamepadMappingKind::standard
                                         : GamepadMappingKind::unknown;
  outSnapshot.buttonValues.resize(nButtons);
  outSnapshot.axes.resize(nAxes);
  for (uint8_t b = 0; b < nButtons; b++)
  {
    outSnapshot.buttonValues[b] = reader.readFloat32();
  }
  for (uint8_t a = 0; a < nAxes; a++)
  {
    outSnapshot.axes[a] = reader.readFloat32();
  }
  if (reader.hasError())
  {
    return false;
  }
  // buttonMask is not on the wire — derive it from the per-button values.
  recomputeButtonMaskFromValues(outSnapshot);
  return true;
}

static bool applyUpdateChange(
    GamepadSnapshot& snap,
    const GamepadInputChange& ch)
{
  if (ch.kind == GamepadInputChangeKind::button)
  {
    if (ch.index >= kGamepadBatchMaxButtons)
    {
      return false;
    }
    if (snap.buttonValues.size() <= ch.index)
    {
      snap.buttonValues.resize(ch.index + 1, 0.f);
    }
    snap.buttonValues[ch.index] = ch.value;
    recomputeButtonMaskFromValues(snap);
  }
  else
  {
    if (ch.index >= kGamepadBatchMaxAxes)
    {
      return false;
    }
    if (snap.axes.size() <= ch.index)
    {
      snap.axes.resize(ch.index + 1, 0.f);
    }
    snap.axes[ch.index] = ch.value;
  }
  return true;
}

static GamepadEventInvocation makeEventInvocation(
    const GamepadSnapshot& afterApply,
    const GamepadInputChange& ch)
{
  GamepadEventInvocation ev;
  ev.fullState = afterApply;
  ev.change = ch;
  fillStandardIntent(afterApply, ev);
  return ev;
}

// Decode a little-endian binary batch of gamepad events produced by the
// embedder (e.g. the JS runtime — see registerGamepadInteractions.ts) and
// dispatch them through the focus manager.
//
// Wire format (all multi-byte values little-endian, fixed-width — no LEB128):
//   uint32  version  -- must equal kGamepadBatchWireVersion
//   then a stream of records, each starting with a 1-byte GamepadRecordType:
//
//     connected (0):
//       int32   deviceId
//       uint8   mapping           (0 = standard, else unknown)
//       uint8   nButtons          (<= kGamepadBatchMaxButtons)
//       uint8   nAxes             (<= kGamepadBatchMaxAxes)
//       uint8   padding           (alignment filler)
//       float32 buttonValues[nButtons]
//       float32 axes[nAxes]
//
//     update (1):
//       int32   deviceId
//       uint8   nChanges
//       repeated nChanges times:
//         uint8   kind            (0 = button, 1 = axis)
//         uint8   index
//         float32 value
//
//     disconnected (2):
//       int32   deviceId
//
// Returns false (and stops dispatching) on any malformed record: short read,
// wrong version, unknown device on update, out-of-range button/axis index,
// or unknown record type. A truncated batch leaves any records dispatched so
// far in place.
bool StateMachineInstance::submitGamepadsFromBuffer(
    const uint8_t* data,
    size_t n)
{
  if (data == nullptr)
  {
    return false;
  }
  BinaryReader reader(Span<const uint8_t>(data, n));
  const uint32_t version = reader.readUint32();
  if (reader.hasError() || version != kGamepadBatchWireVersion)
  {
    return false;
  }
  FocusManager* fm = focusManager();
  if (fm == nullptr)
  {
    return false;
  }
  // An embedder submitting a batch is exactly the moment gamepad state
  // starts existing on this instance, so allocate the cluster up front and
  // keep the pointer for the whole drain.
  SMIInputExtras& extras = ensureInputExtras();
  // reachedEnd() returns true once the cursor hits end-of-buffer OR the
  // reader has flagged an overflow, so any partial-record read inside the
  // loop will both `return false` and naturally terminate iteration.
  while (!reader.reachedEnd())
  {
    const uint8_t typeByte = reader.readByte();
    if (reader.hasError())
    {
      return false;
    }
    const auto rec = static_cast<GamepadRecordType>(typeByte);
    switch (rec)
    {
      case GamepadRecordType::connected:
      {
        GamepadSnapshot snap;
        if (!readConnectedPayload(reader, snap))
        {
          return false;
        }
        extras.embedderGamepads[snap.deviceId] = snap;
        {
          auto invocation = ListenerInvocation::gamepadConnected(snap);
          ScriptedDrawable* dispatched = nullptr;
          (void)fm->gamepadDispatch(invocation, &dispatched);
          broadcastGamepadToScriptedDrawables(invocation, dispatched);
        }
        break;
      }
      case GamepadRecordType::update:
      {
        const int32_t deviceId = static_cast<int32_t>(reader.readUint32());
        const uint8_t nChanges = reader.readByte();
        if (reader.hasError())
        {
          return false;
        }
        // Updates must target a gamepad we've previously seen
        // connected; otherwise we have no snapshot to mutate.
        auto it = extras.embedderGamepads.find(deviceId);
        if (it == extras.embedderGamepads.end())
        {
          return false;
        }
        std::vector<GamepadInputChange> changes;
        changes.reserve(nChanges);
        for (uint8_t i = 0; i < nChanges; i++)
        {
          const uint8_t chKindB = reader.readByte();
          const uint8_t chIndex = reader.readByte();
          const float fval = reader.readFloat32();
          if (reader.hasError())
          {
            return false;
          }
          GamepadInputChange ch;
          ch.kind = chKindB == 0 ? GamepadInputChangeKind::button
                                 : GamepadInputChangeKind::axis;
          ch.index = chIndex;
          ch.value = fval;
          changes.push_back(ch);
        }
        // Apply all changes to the stored snapshot first so that every
        // dispatched event sees the same fully-updated `fullState`...
        GamepadSnapshot& snap = it->second;
        for (const auto& ch : changes)
        {
          if (!applyUpdateChange(snap, ch))
          {
            return false;
          }
        }
        // ...then dispatch one event per change carrying that final
        // state plus the specific change that occurred.
        const GamepadSnapshot finalSnap = snap;
        for (const auto& ch : changes)
        {
          GamepadEventInvocation evi = makeEventInvocation(finalSnap, ch);
          auto invocation = ListenerInvocation::gamepadEvent(std::move(evi));
          ScriptedDrawable* dispatched = nullptr;
          (void)fm->gamepadDispatch(invocation, &dispatched);
          broadcastGamepadToScriptedDrawables(invocation, dispatched);
        }
        break;
      }
      case GamepadRecordType::disconnected:
      {
        const int32_t deviceId = static_cast<int32_t>(reader.readUint32());
        if (reader.hasError())
        {
          return false;
        }
        extras.embedderGamepads.erase(deviceId);
        {
          auto invocation = ListenerInvocation::gamepadDisconnected(deviceId);
          ScriptedDrawable* dispatched = nullptr;
          (void)fm->gamepadDispatch(invocation, &dispatched);
          broadcastGamepadToScriptedDrawables(invocation, dispatched);
        }
        break;
      }
      default:
        // Unknown record type — wire format mismatch, bail out.
        return false;
    }
  }
  return true;
}

HitResult StateMachineInstance::broadcastGamepadToScriptedDrawables(
    const ListenerInvocation& invocation,
    ScriptedDrawable* alreadyDispatched)
{
  bool hitSomething = false;
  bool hitOpaque = false;
  // Walk m_hitComponents purely for the nested-propagation overrides
  // (HitNestedArtboard / HitArtboardComponentList recurse into their
  // child SMIs). HitScriptedDrawable's gamepad path is intentionally a
  // no-op — direct dispatch happens via gamepadScriptedDrawables below
  // so scripts without pointer handlers are still reached.
  for (const auto& hitShape : m_hitComponents)
  {
    HitResult hitResult = hitShape->processGamepadInvocation(
        invocation,
        alreadyDispatched);
    if (hitResult != HitResult::none)
    {
      hitSomething = true;
      if (hitResult == HitResult::hitOpaque)
      {
        hitOpaque = true;
      }
    }
  }

#ifdef WITH_RIVE_SCRIPTING
  // Null whenever no script in this artboard declared a gamepad handler,
  // which is the common case — nothing to broadcast to.
  if (auto* extras = inputExtras())
  {
    for (ScriptedDrawable* drawable : extras->gamepadScriptedDrawables)
    {
      if (drawable == nullptr || drawable == alreadyDispatched)
      {
        continue;
      }
      switch (invocation.kind())
      {
        case ListenerInvocationKind::gamepadConnected:
          if (!drawable->wantsGamePadConnect())
          {
            continue;
          }
          break;
        case ListenerInvocationKind::gamepadEvent:
          if (!drawable->wantsGamePadEvent())
          {
            continue;
          }
          break;
        case ListenerInvocationKind::gamepadDisconnected:
          if (!drawable->wantsGamePadDisconnect())
          {
            continue;
          }
          break;
        default:
          continue;
      }
      if (drawable->gamepadDispatch(invocation))
      {
        hitSomething = true;
      }
    }
  }
#endif

  return hitSomething ? hitOpaque ? HitResult::hitOpaque : HitResult::hit
                      : HitResult::none;
}
} // namespace rive