#ifdef WITH_RIVE_SCRIPTING
#include "lua.h"
#include "lualib.h"
#include "rive/lua/rive_lua_libs.hpp"
#ifdef WITH_RIVE_TEXT
#include "rive/lua/scripted_text.hpp"
#include "rive/text/font_hb.hpp"
#endif

#include <vector>

using namespace rive;

// OpenType tags cross as their four letter names.
static uint32_t tagFromString(lua_State* L, int idx)
{
    size_t length;
    const char* name = luaL_checklstring(L, idx, &length);
    if (length != 4)
    {
        luaL_error(L, "'%s' is not a four letter tag", name);
    }
    return ((uint32_t)(uint8_t)name[0] << 24) |
           ((uint32_t)(uint8_t)name[1] << 16) |
           ((uint32_t)(uint8_t)name[2] << 8) | (uint32_t)(uint8_t)name[3];
}

static void pushTag(lua_State* L, uint32_t tag)
{
    char name[4] = {(char)(tag >> 24),
                    (char)(tag >> 16),
                    (char)(tag >> 8),
                    (char)tag};
    lua_pushlstring(L, name, 4);
}

static Font* checkFont(lua_State* L, int idx)
{
    Font* font = lua_torive<ScriptedFont>(L, idx)->font.get();
    if (font == nullptr)
    {
        luaL_error(L, "Font is empty.");
    }
    return font;
}

static void font_direct_ascent(void* udata, void* result)
{
    Font* font = ((ScriptedFont*)udata)->font.get();
    lua_userdatadirectfield_setnumber(result,
                                      font ? font->lineMetrics().ascent : 0.0);
}

static void font_direct_descent(void* udata, void* result)
{
    Font* font = ((ScriptedFont*)udata)->font.get();
    lua_userdatadirectfield_setnumber(result,
                                      font ? font->lineMetrics().descent : 0.0);
}

static int font_index(lua_State* L)
{
    int atom;
    const char* key = lua_tostringatom(L, 2, &atom);
    if (!key)
    {
        luaL_typeerrorL(L, 2, lua_typename(L, LUA_TSTRING));
    }
    Font* font = checkFont(L, 1);
    switch (atom)
    {
        case (int)LuaAtoms::ascent:
            lua_pushnumber(L, font->lineMetrics().ascent);
            return 1;
        case (int)LuaAtoms::descent:
            lua_pushnumber(L, font->lineMetrics().descent);
            return 1;
        case (int)LuaAtoms::capHeight:
            lua_pushnumber(L, font->lineMetrics().capHeight);
            return 1;
        case (int)LuaAtoms::xHeight:
            lua_pushnumber(L, font->lineMetrics().xHeight);
            return 1;
        case (int)LuaAtoms::weight:
            lua_pushnumber(L, font->getWeight());
            return 1;
        case (int)LuaAtoms::isItalic:
            lua_pushboolean(L, font->isItalic());
            return 1;
        case (int)LuaAtoms::axes:
        {
            uint16_t count = font->getAxisCount();
            lua_createtable(L, count, 0);
            for (uint16_t i = 0; i < count; i++)
            {
                Font::Axis axis = font->getAxis(i);
                lua_createtable(L, 0, 4);
                pushTag(L, axis.tag);
                lua_setfield(L, -2, "tag");
                lua_pushnumber(L, axis.min);
                lua_setfield(L, -2, "min");
                lua_pushnumber(L, axis.def);
                lua_setfield(L, -2, "default");
                lua_pushnumber(L, axis.max);
                lua_setfield(L, -2, "max");
                lua_rawseti(L, -2, i + 1);
            }
            return 1;
        }
        case (int)LuaAtoms::features:
        {
            SimpleArray<uint32_t> features = font->features();
            lua_createtable(L, (int)features.size(), 0);
            for (size_t i = 0; i < features.size(); i++)
            {
                pushTag(L, features[i]);
                lua_rawseti(L, -2, (int)i + 1);
            }
            return 1;
        }
    }
    luaL_error(L,
               "'%s' is not a valid index of %s",
               key,
               ScriptedFont::luaName);
    return 0;
}

// Reads { tag = value } pairs into coords or features.
template <typename T, typename Value>
static void readTagTable(lua_State* L, int idx, std::vector<T>& out)
{
    if (lua_isnoneornil(L, idx))
    {
        return;
    }
    luaL_checktype(L, idx, LUA_TTABLE);
    lua_pushnil(L);
    while (lua_next(L, idx))
    {
        // Converting a numeric key in place would break the traversal.
        if (lua_type(L, -2) != LUA_TSTRING)
        {
            luaL_error(L, "font tags are four letter strings");
        }
        out.push_back({tagFromString(L, -2), (Value)luaL_checknumber(L, -1)});
        lua_pop(L, 1);
    }
}

static int font_namecall(lua_State* L)
{
    int atom;
    const char* str = lua_namecallatom(L, &atom);
    Font* font = checkFont(L, 1);
    switch (atom)
    {
        case (int)LuaAtoms::lineHeight:
        {
            float size = (float)luaL_checknumber(L, 2);
            lua_pushnumber(L, font->descent(size) - font->ascent(size));
            return 1;
        }
        case (int)LuaAtoms::hasGlyph:
            lua_pushboolean(L,
                            font->hasGlyph((Unichar)luaL_checkunsigned(L, 2)));
            return 1;
        case (int)LuaAtoms::axisValue:
            lua_pushnumber(L, font->getAxisValue(tagFromString(L, 2)));
            return 1;
        case (int)LuaAtoms::withOptions:
        {
            std::vector<Font::Coord> coords;
            std::vector<Font::Feature> features;
            readTagTable<Font::Coord, float>(L, 2, coords);
            readTagTable<Font::Feature, uint32_t>(L, 3, features);
            lua_pushfont(L, font->withOptions(coords, features));
            return 1;
        }
#ifdef WITH_RIVE_TEXT
        case (int)LuaAtoms::glyphPath:
        {
            RawPath path =
                RawText::glyphPath(*font, (GlyphID)luaL_checkunsigned(L, 2));
            lua_newrive<ScriptedPath>(L, &path);
            return 1;
        }
#endif
    }
    luaL_error(L, "%s is not a valid method of %s", str, ScriptedFont::luaName);
    return 0;
}

#ifdef WITH_RIVE_TEXT
static int font_decode(lua_State* L)
{
    size_t length;
    void* bytes = luaL_checkbuffer(L, 1, &length);
    rcp<Font> font =
        HBFont::Decode(Span<const uint8_t>((const uint8_t*)bytes, length));
    if (font == nullptr)
    {
        lua_pushnil(L);
        return 1;
    }
    lua_pushfont(L, std::move(font));
    return 1;
}
#endif

static const luaL_Reg fontStaticMethods[] = {
#ifdef WITH_RIVE_TEXT
    {"decode", font_decode},
#endif
    {NULL, NULL},
};

int luaopen_rive_font(lua_State* L)
{
    luaL_register(L, ScriptedFont::luaName, fontStaticMethods);
    lua_register_rive_type<ScriptedFont>(L, font_index, font_namecall);

    lua_registeruserdatadirectfieldget(L,
                                       ScriptedFont::luaTag,
                                       "ascent",
                                       font_direct_ascent);
    lua_registeruserdatadirectfieldget(L,
                                       ScriptedFont::luaTag,
                                       "descent",
                                       font_direct_descent);
    return 1;
}
#endif