#ifdef WITH_RIVE_SCRIPTING
#include "rive/lua/rive_lua_libs.hpp"
#include "rive/data_bind/data_values/data_value_number.hpp"

#include <math.h>
#include <stdio.h>

using namespace rive;

ScriptedDataValue::~ScriptedDataValue()
{
    if (m_dataValue)
    {
        delete m_dataValue;
    }
}

static int property_namecall_atom(lua_State* L,
                                  ScriptedDataValue* scriptedDataValue,
                                  uint8_t tag,
                                  int atom,
                                  bool& error)
{
    switch (atom)
    {
        case (int)LuaAtoms::value:
        {
            assert(scriptedDataValue->state() == L);
            switch (tag)
            {
                case ScriptedDataValueNumber::luaTag:
                {
                    auto dataValue =
                        scriptedDataValue->dataValue()->as<DataValueNumber>();
                    lua_pushnumber(L, dataValue->value());
                    return 1;
                }
                case ScriptedDataValueString::luaTag:
                {
                    auto dataValue =
                        scriptedDataValue->dataValue()->as<DataValueString>();
                    lua_pushstring(L, dataValue->value().c_str());
                    return 1;
                }
                case ScriptedDataValueBoolean::luaTag:
                {
                    auto dataValue =
                        scriptedDataValue->dataValue()->as<DataValueBoolean>();
                    lua_pushboolean(L, dataValue->value() ? 1 : 0);
                    return 1;
                }
                case ScriptedDataValueColor::luaTag:
                {
                    auto dataValue =
                        scriptedDataValue->dataValue()->as<DataValueColor>();
                    lua_pushinteger(L, dataValue->value());
                    return 1;
                }
            }
        }
        case (int)LuaAtoms::red:
        {
            assert(scriptedDataValue->state() == L);
            switch (tag)
            {
                case ScriptedDataValueColor::luaTag:
                {
                    auto dataValue =
                        scriptedDataValue->dataValue()->as<DataValueColor>();
                    lua_pushinteger(L, dataValue->red());
                    return 1;
                }
            }
        }
        case (int)LuaAtoms::green:
        {
            assert(scriptedDataValue->state() == L);
            switch (tag)
            {
                case ScriptedDataValueColor::luaTag:
                {
                    auto dataValue =
                        scriptedDataValue->dataValue()->as<DataValueColor>();
                    lua_pushinteger(L, dataValue->green());
                    return 1;
                }
            }
        }
        case (int)LuaAtoms::blue:
        {
            assert(scriptedDataValue->state() == L);
            switch (tag)
            {
                case ScriptedDataValueColor::luaTag:
                {
                    auto dataValue =
                        scriptedDataValue->dataValue()->as<DataValueColor>();
                    lua_pushinteger(L, dataValue->blue());
                    return 1;
                }
            }
        }
        case (int)LuaAtoms::alpha:
        {
            assert(scriptedDataValue->state() == L);
            switch (tag)
            {
                case ScriptedDataValueColor::luaTag:
                {
                    auto dataValue =
                        scriptedDataValue->dataValue()->as<DataValueColor>();
                    lua_pushinteger(L, dataValue->alpha());
                    return 1;
                }
            }
        }
    }
    error = true;
    return 0;
}

// Direct field getters dispatched per-tag. Each ScriptedDataValue subtype has
// its own luaTag, so we can register without needing the inner tag switch the
// slow path uses.

static void data_value_number_direct_value(void* udata, void* result)
{
    auto* self = (ScriptedDataValue*)udata;
    lua_userdatadirectfield_setnumber(
        result,
        self->dataValue()->as<DataValueNumber>()->value());
}

static void data_value_boolean_direct_value(void* udata, void* result)
{
    auto* self = (ScriptedDataValue*)udata;
    lua_userdatadirectfield_setboolean(
        result,
        self->dataValue()->as<DataValueBoolean>()->value() ? 1 : 0);
}

static void data_value_color_direct_value(void* udata, void* result)
{
    auto* self = (ScriptedDataValue*)udata;
    lua_userdatadirectfield_setnumber(
        result,
        (double)self->dataValue()->as<DataValueColor>()->value());
}

static void data_value_color_direct_red(void* udata, void* result)
{
    auto* self = (ScriptedDataValue*)udata;
    lua_userdatadirectfield_setnumber(
        result,
        (double)self->dataValue()->as<DataValueColor>()->red());
}

static void data_value_color_direct_green(void* udata, void* result)
{
    auto* self = (ScriptedDataValue*)udata;
    lua_userdatadirectfield_setnumber(
        result,
        (double)self->dataValue()->as<DataValueColor>()->green());
}

static void data_value_color_direct_blue(void* udata, void* result)
{
    auto* self = (ScriptedDataValue*)udata;
    lua_userdatadirectfield_setnumber(
        result,
        (double)self->dataValue()->as<DataValueColor>()->blue());
}

static void data_value_color_direct_alpha(void* udata, void* result)
{
    auto* self = (ScriptedDataValue*)udata;
    lua_userdatadirectfield_setnumber(
        result,
        (double)self->dataValue()->as<DataValueColor>()->alpha());
}

static int data_value_index(lua_State* L)
{
    int atom;
    lua_tostringatom(L, 2, &atom);

    size_t namelen = 0;
    const char* name = luaL_checklstring(L, 2, &namelen);

    auto tag = lua_userdatatag(L, 1);
    auto scriptedDataValue = (ScriptedDataValue*)lua_touserdata(L, 1);

    bool error = false;
    int stackChange =
        property_namecall_atom(L, scriptedDataValue, tag, atom, error);
    if (!error)
    {
        return stackChange;
    }

    luaL_error(L, "'%s' is not a valid index of DataValue", name);
    return 0;
}

static int data_value_newindex(lua_State* L)
{
    int atom;
    const char* key = lua_tostringatom(L, 2, &atom);
    if (!key)
    {
        luaL_typeerrorL(L, 2, lua_typename(L, LUA_TSTRING));
        return 0;
    }

    auto tag = lua_userdatatag(L, 1);
    auto scriptedDataValue = (ScriptedDataValue*)lua_touserdata(L, 1);
    switch (atom)
    {
        case (int)LuaAtoms::value:
        {
            switch (tag)
            {
                case ScriptedDataValueNumber::luaTag:
                {
                    auto val = float(luaL_checknumber(L, 3));
                    scriptedDataValue->dataValue()
                        ->as<DataValueNumber>()
                        ->value(val);
                    return 1;
                }
                case ScriptedDataValueString::luaTag:
                {
                    auto val = luaL_checkstring(L, 3);
                    scriptedDataValue->dataValue()
                        ->as<DataValueString>()
                        ->value(val);
                    return 1;
                }
                case ScriptedDataValueBoolean::luaTag:
                {
                    auto val = luaL_checkboolean(L, 3);
                    scriptedDataValue->dataValue()
                        ->as<DataValueBoolean>()
                        ->value(val != 0);
                    return 1;
                }
                case ScriptedDataValueColor::luaTag:
                {
                    auto val = luaL_checkunsigned(L, 3);
                    scriptedDataValue->dataValue()->as<DataValueColor>()->value(
                        val);
                    return 1;
                }
            }
        }
        case (int)LuaAtoms::red:
        {
            switch (tag)
            {
                case ScriptedDataValueColor::luaTag:
                {
                    auto val = luaL_checkinteger(L, 3);
                    scriptedDataValue->dataValue()->as<DataValueColor>()->red(
                        val);
                    return 1;
                }
                default:
                    return 1;
            }
        }
        case (int)LuaAtoms::green:
        {
            switch (tag)
            {
                case ScriptedDataValueColor::luaTag:
                {
                    auto val = luaL_checkinteger(L, 3);
                    scriptedDataValue->dataValue()->as<DataValueColor>()->green(
                        val);
                    return 1;
                }
                default:
                    return 1;
            }
        }
        case (int)LuaAtoms::blue:
        {
            switch (tag)
            {
                case ScriptedDataValueColor::luaTag:
                {
                    auto val = luaL_checkinteger(L, 3);
                    scriptedDataValue->dataValue()->as<DataValueColor>()->blue(
                        val);
                    return 1;
                }
                default:
                    return 1;
            }
        }
        case (int)LuaAtoms::alpha:
        {
            switch (tag)
            {
                case ScriptedDataValueColor::luaTag:
                {
                    auto val = luaL_checkinteger(L, 3);
                    scriptedDataValue->dataValue()->as<DataValueColor>()->alpha(
                        val);
                    return 1;
                }
                default:
                    return 1;
            }
        }
        default:
            return 0;
    }

    return 0;
}

static int dataValue_number(lua_State* L)
{
    lua_newrive<ScriptedDataValueNumber>(L, L, 0);

    return 1;
}

static int dataValue_string(lua_State* L)
{
    lua_newrive<ScriptedDataValueString>(L, L, "");

    return 1;
}

static int dataValue_boolean(lua_State* L)
{
    lua_newrive<ScriptedDataValueBoolean>(L, L, false);

    return 1;
}

static int dataValue_color(lua_State* L)
{
    lua_newrive<ScriptedDataValueColor>(L, L, 0);

    return 1;
}

static int data_value_namecall(lua_State* L)
{
    int atom;
    const char* str = lua_namecallatom(L, &atom);
    if (str != nullptr)
    {
        auto dataValue = (ScriptedDataValue*)lua_touserdata(L, 1);
        switch (atom)
        {
            case (int)LuaAtoms::isNumber:
            {
                assert(dataValue->state() == L);
                lua_pushboolean(L, dataValue->isNumber() ? 1 : 0);
                return 1;
            }
            case (int)LuaAtoms::isString:
            {
                assert(dataValue->state() == L);
                lua_pushboolean(L, dataValue->isString() ? 1 : 0);
                return 1;
            }
            case (int)LuaAtoms::isBoolean:
            {
                assert(dataValue->state() == L);
                lua_pushboolean(L, dataValue->isBoolean() ? 1 : 0);
                return 1;
            }
            case (int)LuaAtoms::isColor:
            {
                assert(dataValue->state() == L);
                lua_pushboolean(L, dataValue->isColor() ? 1 : 0);
                return 1;
            }
            default:
                break;
        }
    }

    luaL_error(L,
               "%s is not a valid method of %s",
               str,
               ScriptedPropertyViewModel::luaName);
    return 0;
}

static const luaL_Reg dataValueStaticMethods[] = {
    {"number", dataValue_number},
    {"string", dataValue_string},
    {"boolean", dataValue_boolean},
    {"color", dataValue_color},
    {nullptr, nullptr}};

int luaopen_rive_data_values(lua_State* L)
{
    {

        luaL_register(L, ScriptedDataValue::luaName, dataValueStaticMethods);
    }
    {
        lua_register_rive<ScriptedDataValueNumber>(L);

        lua_pushcfunction(L, data_value_index, nullptr);
        lua_setfield(L, -2, "__index");

        lua_pushcfunction(L, data_value_newindex, nullptr);
        lua_setfield(L, -2, "__newindex");

        lua_pushcfunction(L, data_value_namecall, nullptr);
        lua_setfield(L, -2, "__namecall");

        lua_setreadonly(L, -1, true);
        lua_pop(L, 1); // pop the metatable

        lua_registeruserdatadirectfieldget(L,
                                           ScriptedDataValueNumber::luaTag,
                                           "value",
                                           data_value_number_direct_value);
    }
    {
        lua_register_rive<ScriptedDataValueString>(L);

        lua_pushcfunction(L, data_value_index, nullptr);
        lua_setfield(L, -2, "__index");

        lua_pushcfunction(L, data_value_newindex, nullptr);
        lua_setfield(L, -2, "__newindex");

        lua_pushcfunction(L, data_value_namecall, nullptr);
        lua_setfield(L, -2, "__namecall");

        lua_setreadonly(L, -1, true);
        lua_pop(L, 1); // pop the metatable
    }
    {
        lua_register_rive<ScriptedDataValueBoolean>(L);

        lua_pushcfunction(L, data_value_index, nullptr);
        lua_setfield(L, -2, "__index");

        lua_pushcfunction(L, data_value_newindex, nullptr);
        lua_setfield(L, -2, "__newindex");

        lua_pushcfunction(L, data_value_namecall, nullptr);
        lua_setfield(L, -2, "__namecall");

        lua_setreadonly(L, -1, true);
        lua_pop(L, 1); // pop the metatable

        lua_registeruserdatadirectfieldget(L,
                                           ScriptedDataValueBoolean::luaTag,
                                           "value",
                                           data_value_boolean_direct_value);
    }
    {
        lua_register_rive<ScriptedDataValueColor>(L);

        lua_pushcfunction(L, data_value_index, nullptr);
        lua_setfield(L, -2, "__index");

        lua_pushcfunction(L, data_value_newindex, nullptr);
        lua_setfield(L, -2, "__newindex");

        lua_pushcfunction(L, data_value_namecall, nullptr);
        lua_setfield(L, -2, "__namecall");

        lua_setreadonly(L, -1, true);
        lua_pop(L, 1); // pop the metatable

        lua_registeruserdatadirectfieldget(L,
                                           ScriptedDataValueColor::luaTag,
                                           "value",
                                           data_value_color_direct_value);
        lua_registeruserdatadirectfieldget(L,
                                           ScriptedDataValueColor::luaTag,
                                           "red",
                                           data_value_color_direct_red);
        lua_registeruserdatadirectfieldget(L,
                                           ScriptedDataValueColor::luaTag,
                                           "green",
                                           data_value_color_direct_green);
        lua_registeruserdatadirectfieldget(L,
                                           ScriptedDataValueColor::luaTag,
                                           "blue",
                                           data_value_color_direct_blue);
        lua_registeruserdatadirectfieldget(L,
                                           ScriptedDataValueColor::luaTag,
                                           "alpha",
                                           data_value_color_direct_alpha);
    }

    return 1;
}
#endif