#ifdef WITH_RIVE_SCRIPTING
#include "lualib.h"

#include <cstring>
#include <cstdint>

#if defined(__aarch64__) || defined(__ARM_NEON__) || defined(__ARM_NEON)
#include <arm_neon.h>
#if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
#define RIVE_BUF_NEON_F16 1
#endif
#endif

#if defined(__F16C__)
#include <immintrin.h>
#define RIVE_BUF_F16C 1
#elif defined(__SSE2__)
#include <emmintrin.h>
#endif

#define isoutofbounds(offset, len, accessize)                                  \
  (uint64_t(unsigned(offset)) + (accessize) > uint64_t(len))

// --------------------------------------------------------------------------
// Half-float (IEEE 754 half-precision) — scalar fallback
// --------------------------------------------------------------------------

static float halfToFloat(uint16_t h)
{
  uint32_t sign = (uint32_t)(h >> 15) << 31;
  uint32_t exp = (h >> 10) & 0x1F;
  uint32_t mant = h & 0x3FF;

  if (exp == 0)
  {
    if (mant == 0)
    {
      uint32_t bits = sign;
      float f;
      memcpy(&f, &bits, 4);
      return f;
    }
    exp = 1;
    while ((mant & 0x400) == 0)
    {
      mant <<= 1;
      exp--;
    }
    mant &= 0x3FF;
    uint32_t bits = sign | ((exp + 127 - 15) << 23) | (mant << 13);
    float f;
    memcpy(&f, &bits, 4);
    return f;
  }
  if (exp == 31)
  {
    uint32_t bits = sign | 0x7F800000 | (mant << 13);
    float f;
    memcpy(&f, &bits, 4);
    return f;
  }
  uint32_t bits = sign | ((exp + 127 - 15) << 23) | (mant << 13);
  float f;
  memcpy(&f, &bits, 4);
  return f;
}

static uint16_t floatToHalf(float value)
{
  uint32_t bits;
  memcpy(&bits, &value, 4);

  uint32_t sign = (bits >> 16) & 0x8000;
  int32_t exp = ((bits >> 23) & 0xFF) - 127 + 15;
  uint32_t mant = bits & 0x7FFFFF;

  if (exp <= 0)
  {
    if (exp < -10)
      return (uint16_t)sign;
    mant |= 0x800000;
    uint32_t shift = (uint32_t)(1 - exp);
    uint32_t round = mant & ((1u << (shift + 13)) - 1);
    mant >>= (shift + 13);
    if (round > (1u << (shift + 12)) ||
        (round == (1u << (shift + 12)) && (mant & 1)))
      mant++;
    return (uint16_t)(sign | mant);
  }
  if (exp == 0xFF - 127 + 15)
  {
    if (mant == 0)
      return (uint16_t)(sign | 0x7C00);
    return (uint16_t)(sign | 0x7C00 | (mant >> 13));
  }
  uint32_t round = mant & 0x1FFF;
  mant >>= 13;
  if (round > 0x1000 || (round == 0x1000 && (mant & 1)))
  {
    mant++;
    if (mant >= 0x400)
    {
      mant = 0;
      exp++;
    }
  }
  if (exp >= 31)
    return (uint16_t)(sign | 0x7C00);
  return (uint16_t)(sign | ((uint32_t)exp << 10) | mant);
}

// --------------------------------------------------------------------------
// SIMD bulk f32↔f16 conversion
// --------------------------------------------------------------------------

static void convertF32ToF16Bulk(const float* src, uint16_t* dst, int count)
{
  int i = 0;
#if RIVE_BUF_NEON_F16
  for (; i + 3 < count; i += 4)
  {
    float32x4_t v = vld1q_f32(src + i);
    float16x4_t h = vcvt_f16_f32(v);
    vst1_u16(dst + i, vreinterpret_u16_f16(h));
  }
#elif RIVE_BUF_F16C
  for (; i + 3 < count; i += 4)
  {
    __m128 v = _mm_loadu_ps(src + i);
    __m128i h = _mm_cvtps_ph(v, _MM_FROUND_TO_NEAREST_INT);
    _mm_storel_epi64((__m128i*)(dst + i), h);
  }
#endif
  for (; i < count; i++)
    dst[i] = floatToHalf(src[i]);
}

static void convertF16ToF32Bulk(const uint16_t* src, float* dst, int count)
{
  int i = 0;
#if RIVE_BUF_NEON_F16
  for (; i + 3 < count; i += 4)
  {
    uint16x4_t h = vld1_u16(src + i);
    float32x4_t v = vcvt_f32_f16(vreinterpret_f16_u16(h));
    vst1q_f32(dst + i, v);
  }
#elif RIVE_BUF_F16C
  for (; i + 3 < count; i += 4)
  {
    __m128i h = _mm_loadl_epi64((const __m128i*)(src + i));
    __m128 v = _mm_cvtph_ps(h);
    _mm_storeu_ps(dst + i, v);
  }
#endif
  for (; i < count; i++)
    dst[i] = halfToFloat(src[i]);
}

// --------------------------------------------------------------------------
// buffer.readf16 / buffer.writef16
// --------------------------------------------------------------------------

static int buffer_readf16(lua_State* L)
{
  size_t len = 0;
  void* buf = luaL_checkbuffer(L, 1, &len);
  int offset = luaL_checkinteger(L, 2);

  if (isoutofbounds(offset, len, 2))
    luaL_error(L, "buffer access out of bounds");

  uint16_t half;
  memcpy(&half, (char*)buf + offset, 2);
  lua_pushnumber(L, (double)halfToFloat(half));
  return 1;
}

static int buffer_writef16(lua_State* L)
{
  size_t len = 0;
  void* buf = luaL_checkbuffer(L, 1, &len);
  int offset = luaL_checkinteger(L, 2);
  double value = luaL_checknumber(L, 3);

  if (isoutofbounds(offset, len, 2))
    luaL_error(L, "buffer access out of bounds");

  uint16_t half = floatToHalf((float)value);
  memcpy((char*)buf + offset, &half, 2);
  return 0;
}

// --------------------------------------------------------------------------
// buffer.stridedcopy
// --------------------------------------------------------------------------

static int buffer_stridedcopy(lua_State* L)
{
  size_t dstLen = 0, srcLen = 0;
  void* dst = luaL_checkbuffer(L, 1, &dstLen);
  int dstOffset = luaL_checkinteger(L, 2);
  int dstStride = luaL_checkinteger(L, 3);
  void* src = luaL_checkbuffer(L, 4, &srcLen);
  int srcOffset = luaL_checkinteger(L, 5);
  int srcStride = luaL_checkinteger(L, 6);
  int elementSize = luaL_checkinteger(L, 7);
  int count = luaL_checkinteger(L, 8);

  if (elementSize < 0)
    luaL_error(L, "elementSize must be non-negative");
  if (count < 0)
    luaL_error(L, "count must be non-negative");
  if (count == 0)
    return 0;
  if (srcStride < elementSize || dstStride < elementSize)
    luaL_error(L, "stride must be >= elementSize");

  int64_t srcEnd = (int64_t)srcOffset + (int64_t)(count - 1) * srcStride +
                   elementSize;
  if (srcOffset < 0 || srcEnd > (int64_t)srcLen)
    luaL_error(L, "buffer access out of bounds");

  int64_t dstEnd = (int64_t)dstOffset + (int64_t)(count - 1) * dstStride +
                   elementSize;
  if (dstOffset < 0 || dstEnd > (int64_t)dstLen)
    luaL_error(L, "buffer access out of bounds");

  char* d = (char*)dst + dstOffset;
  const char* s = (const char*)src + srcOffset;

  for (int i = 0; i < count; i++)
  {
    memcpy(
        d + (int64_t)i * dstStride,
        s + (int64_t)i * srcStride,
        (size_t)elementSize);
  }

  return 0;
}

// --------------------------------------------------------------------------
// buffer.convert — bulk format conversion with optional stride + SIMD
// --------------------------------------------------------------------------

enum BufFormat
{
  BufFormat_f16,
  BufFormat_f32,
  BufFormat_u8,
  BufFormat_u8norm,
  BufFormat_i8norm,
  BufFormat_u16,
  BufFormat_u16norm,
  BufFormat_i16norm,
  BufFormat_u32,
};

static BufFormat parseFormat(lua_State* L, int arg)
{
  const char* s = luaL_checkstring(L, arg);
  if (strcmp(s, "f16") == 0)
    return BufFormat_f16;
  if (strcmp(s, "f32") == 0)
    return BufFormat_f32;
  if (strcmp(s, "u8") == 0)
    return BufFormat_u8;
  if (strcmp(s, "u8norm") == 0)
    return BufFormat_u8norm;
  if (strcmp(s, "i8norm") == 0)
    return BufFormat_i8norm;
  if (strcmp(s, "u16") == 0)
    return BufFormat_u16;
  if (strcmp(s, "u16norm") == 0)
    return BufFormat_u16norm;
  if (strcmp(s, "i16norm") == 0)
    return BufFormat_i16norm;
  if (strcmp(s, "u32") == 0)
    return BufFormat_u32;
  luaL_error(L, "unknown buffer format '%s'", s);
  return BufFormat_f32;
}

static int formatByteSize(BufFormat fmt)
{
  switch (fmt)
  {
    case BufFormat_f16:
    case BufFormat_u16:
    case BufFormat_u16norm:
    case BufFormat_i16norm:
      return 2;
    case BufFormat_f32:
    case BufFormat_u32:
      return 4;
    case BufFormat_u8:
    case BufFormat_u8norm:
    case BufFormat_i8norm:
      return 1;
  }
  return 0;
}

static double readElement(const char* ptr, BufFormat fmt)
{
  switch (fmt)
  {
    case BufFormat_f16:
    {
      uint16_t h;
      memcpy(&h, ptr, 2);
      return (double)halfToFloat(h);
    }
    case BufFormat_f32:
    {
      float f;
      memcpy(&f, ptr, 4);
      return (double)f;
    }
    case BufFormat_u8:
      return (double)(uint8_t)*ptr;
    case BufFormat_u8norm:
      return (double)(uint8_t)*ptr / 255.0;
    case BufFormat_i8norm:
    {
      int8_t v;
      memcpy(&v, ptr, 1);
      double d = (double)v / 127.0;
      return d < -1.0 ? -1.0 : d;
    }
    case BufFormat_u16:
    {
      uint16_t v;
      memcpy(&v, ptr, 2);
      return (double)v;
    }
    case BufFormat_u16norm:
    {
      uint16_t v;
      memcpy(&v, ptr, 2);
      return (double)v / 65535.0;
    }
    case BufFormat_i16norm:
    {
      int16_t v;
      memcpy(&v, ptr, 2);
      double d = (double)v / 32767.0;
      return d < -1.0 ? -1.0 : d;
    }
    case BufFormat_u32:
    {
      uint32_t v;
      memcpy(&v, ptr, 4);
      return (double)v;
    }
  }
  return 0.0;
}

static void writeElement(char* ptr, BufFormat fmt, double value)
{
  switch (fmt)
  {
    case BufFormat_f16:
    {
      uint16_t h = floatToHalf((float)value);
      memcpy(ptr, &h, 2);
      break;
    }
    case BufFormat_f32:
    {
      float f = (float)value;
      memcpy(ptr, &f, 4);
      break;
    }
    case BufFormat_u8:
    {
      *ptr = (char)(uint8_t)(unsigned int)value;
      break;
    }
    case BufFormat_u8norm:
    {
      double c = value < 0.0 ? 0.0 : (value > 1.0 ? 1.0 : value);
      *ptr = (char)(uint8_t)(c * 255.0 + 0.5);
      break;
    }
    case BufFormat_i8norm:
    {
      double c = value < -1.0 ? -1.0 : (value > 1.0 ? 1.0 : value);
      int8_t v = (int8_t)(c * 127.0 + (c >= 0 ? 0.5 : -0.5));
      memcpy(ptr, &v, 1);
      break;
    }
    case BufFormat_u16:
    {
      uint16_t v = (uint16_t)(unsigned int)value;
      memcpy(ptr, &v, 2);
      break;
    }
    case BufFormat_u16norm:
    {
      double c = value < 0.0 ? 0.0 : (value > 1.0 ? 1.0 : value);
      uint16_t v = (uint16_t)(c * 65535.0 + 0.5);
      memcpy(ptr, &v, 2);
      break;
    }
    case BufFormat_i16norm:
    {
      double c = value < -1.0 ? -1.0 : (value > 1.0 ? 1.0 : value);
      int16_t v = (int16_t)(c * 32767.0 + (c >= 0 ? 0.5 : -0.5));
      memcpy(ptr, &v, 2);
      break;
    }
    case BufFormat_u32:
    {
      uint32_t v = (uint32_t)value;
      memcpy(ptr, &v, 4);
      break;
    }
  }
}

// buffer.convert(dst, dstOff, dstFmt, src, srcOff, srcFmt, count,
//                components?, dstStride?, srcStride?)
static int buffer_convert(lua_State* L)
{
  size_t dstLen = 0, srcLen = 0;
  void* dst = luaL_checkbuffer(L, 1, &dstLen);
  int dstOffset = luaL_checkinteger(L, 2);
  BufFormat dstFmt = parseFormat(L, 3);
  void* src = luaL_checkbuffer(L, 4, &srcLen);
  int srcOffset = luaL_checkinteger(L, 5);
  BufFormat srcFmt = parseFormat(L, 6);
  int count = luaL_checkinteger(L, 7);
  int components = luaL_optinteger(L, 8, 1);

  int srcElemSize = formatByteSize(srcFmt);
  int dstElemSize = formatByteSize(dstFmt);

  int dstStride = luaL_optinteger(L, 9, components * dstElemSize);
  int srcStride = luaL_optinteger(L, 10, components * srcElemSize);

  if (count < 0)
    luaL_error(L, "count must be non-negative");
  if (components < 1)
    luaL_error(L, "components must be at least 1");
  if (count == 0)
    return 0;
  if (srcStride < 0 || dstStride < 0)
    luaL_error(L, "stride must be non-negative");

  int64_t srcSpan = (int64_t)components * srcElemSize;
  int64_t dstSpan = (int64_t)components * dstElemSize;

  if (srcStride > 0 && srcStride < srcSpan)
    luaL_error(L, "srcStride must be >= components * element size");
  if (dstStride > 0 && dstStride < dstSpan)
    luaL_error(L, "dstStride must be >= components * element size");

  // Bounds check: last element at offset + (count-1)*stride + span
  {
    int64_t srcEnd = (int64_t)srcOffset + (int64_t)(count - 1) * srcStride +
                     srcSpan;
    if (srcOffset < 0 || srcEnd > (int64_t)srcLen)
      luaL_error(L, "buffer access out of bounds");

    int64_t dstEnd = (int64_t)dstOffset + (int64_t)(count - 1) * dstStride +
                     dstSpan;
    if (dstOffset < 0 || dstEnd > (int64_t)dstLen)
      luaL_error(L, "buffer access out of bounds");
  }

  const char* s = (const char*)src + srcOffset;
  char* d = (char*)dst + dstOffset;

  bool packed = (srcStride == (int)srcSpan && dstStride == (int)dstSpan);
  int totalScalars = count * components;

  // Fast path: same format, packed → memcpy
  if (srcFmt == dstFmt && packed)
  {
    memcpy(d, s, (size_t)totalScalars * srcElemSize);
    return 0;
  }

  // SIMD fast path: packed f32 → f16
  if (srcFmt == BufFormat_f32 && dstFmt == BufFormat_f16 && packed)
  {
    convertF32ToF16Bulk((const float*)s, (uint16_t*)d, totalScalars);
    return 0;
  }

  // SIMD fast path: packed f16 → f32
  if (srcFmt == BufFormat_f16 && dstFmt == BufFormat_f32 && packed)
  {
    convertF16ToF32Bulk((const uint16_t*)s, (float*)d, totalScalars);
    return 0;
  }

  // General path: per-element with stride support
  for (int i = 0; i < count; i++)
  {
    const char* sp = s + (int64_t)i * srcStride;
    char* dp = d + (int64_t)i * dstStride;
    for (int c = 0; c < components; c++)
    {
      double val = readElement(sp + c * srcElemSize, srcFmt);
      writeElement(dp + c * dstElemSize, dstFmt, val);
    }
  }
  return 0;
}

// --------------------------------------------------------------------------
// Registration
// --------------------------------------------------------------------------

extern "C" int luaopen_rive_buffer_ext(lua_State* L)
{
  lua_getglobal(L, "buffer");

  lua_pushcfunction(L, buffer_readf16, "buffer.readf16");
  lua_setfield(L, -2, "readf16");

  lua_pushcfunction(L, buffer_writef16, "buffer.writef16");
  lua_setfield(L, -2, "writef16");

  lua_pushcfunction(L, buffer_stridedcopy, "buffer.stridedcopy");
  lua_setfield(L, -2, "stridedcopy");

  lua_pushcfunction(L, buffer_convert, "buffer.convert");
  lua_setfield(L, -2, "convert");

  lua_pop(L, 1);
  return 0;
}

#endif // WITH_RIVE_SCRIPTING