#include "lua_objs.h"
#include "lua_irc.h"
#include "log.h"

#include <stdlib.h>
#include <string.h>

void lua_obj_create_type (lua_State *L, const char *name, const struct luaL_Reg methods[])
{
    luaL_newmetatable(L, name);

    // set the metatable __index to itself
    lua_pushvalue(L, -1);
    lua_setfield(L, -1, "__index");

    // register the methods to the metatable
    luaL_register(L, NULL, methods);
}

void* lua_obj_create_obj (lua_State *L, const char *name, size_t size)
{
    // create the new userdata on the stack
    void *ud = lua_newuserdata(L, size);

    // get the type and set it
    luaL_getmetatable(L, name);
    lua_setmetatable(L, -2);
    
    // ok
    return ud;
}

void* lua_obj_create_global_type (lua_State *L, const char *type_name, const struct luaL_Reg methods[], const char *global_name, size_t size)
{
    // allocate the global object
    void *obj = lua_newuserdata(L, size);
    
    // create the type metatable
    lua_obj_create_type(L, type_name, methods);

    // set the userdata's metatable
    lua_setmetatable(L, -2);

    // store it as a global
    lua_setglobal(L, global_name);
    
    // ok
    return obj;
}

void* lua_obj_get_obj (lua_State *L, const char *func, const char *name)
{
    void *ud;

    // validate the userdata arg
    if ((ud = luaL_checkudata(L, 1, name)) == NULL) {
        luaL_error(L, "bad type argument to %s: `%s` expected", func, name);
        
        // XXX: needs a __noreturn__ attribute
        return NULL;

    } else {
        // ok
        return ud;

    }
}

/**
 * Wrapper for module
 */
struct lua_module {
    struct module *module;
};

/**
 * Create a lua_module userdata from the given module and push it onto the stack, returning 1.
 *
 * The given module should be a reference of its own right.
 */
static int lua_module_create (lua_State *L, struct module *module)
{
    // create the new obj
    struct lua_module *lua_module = lua_obj_create_obj(L, "spbot.module", sizeof(*lua_module));

    // initialize
    lua_module->module = module;

    // ok
    return 1;
}

/**
 * module_put() our module reference
 */
static int lua_module__gc (lua_State *L)
{
    struct lua_module *lua_module = lua_obj_get_obj(L, __func__, "spbot.module");
    
    // put it
    module_put(lua_module->module);

    return 0;
}

/**
 * Parse and apply the given config option value as a raw value to the given module's option
 */
static int _lua_module_conf_raw_str (lua_State *L, struct lua_module *lua_module, struct nexus *nexus, 
        const struct config_option *option, const char *conf_value)
{
    struct config_value value;
    struct error_info err;

    // mutable version of the conf_value
    char conf_value_buf[strlen(conf_value) + 1];
    strcpy(conf_value_buf, conf_value);

    // parse it as a raw value
    if (config_parse(option, nexus, &value, conf_value_buf, &err))
        return luaL_error(L, "config_parse: %s/%s: %s", option->name, conf_value_buf, error_msg(&err));
    
    // apply it while conf_value_buf is still in scope
    if (module_conf(lua_module->module, option, &value, &err))
        return luaL_error(L, "module_conf: %s/%s: %s", module_name(lua_module->module), option->name, error_msg(&err));
    
    // ok
    return 0;
}

static int lua_module_conf (lua_State *L)
{
    struct lua_module *lua_module = lua_obj_get_obj(L, __func__, "spbot.module");
    const struct config_option *option;
    struct config_value value;
    struct error_info err;

    // XXX: come up with some better way...
    struct nexus *nexus = lua_module->module->modules->nexus;

    // the config name
    const char *conf_name = luaL_checkstring(L, 2);

    // look it up
    if ((option = module_conf_lookup(lua_module->module, conf_name, &err)) == NULL)
        return luaL_error(L, "module_conf_lookup: %s/%s: %s", module_name(lua_module->module), conf_name, error_msg(&err));
 
    // the config value
    switch (lua_type(L, 3)) {
        case LUA_TSTRING:
            // parse+apply it as a raw string
            return _lua_module_conf_raw_str(L, lua_module, nexus, option, lua_tostring(L, 3));

        case LUA_TUSERDATA:
            // some kind of userdata, use its metatable to figure out what type it is
            if (!lua_getmetatable(L, 3))
                return luaL_error(L, "config value is userdata without metatable");

            // get the target metatable
            lua_getfield(L, LUA_REGISTRYINDEX, "evirc.chan");

            // is it a chan?
            if (!lua_rawequal(L, -1, -2))
                return luaL_error(L, "config value is userdata of unknown type");

            // pop the metatables
            lua_pop(L, 2);

            // get the irc_chan
            struct lua_chan *lua_chan = lua_touserdata(L, 3);

            // build the value
            value.type = CONFIG_IRC_CHAN;
            value.irc_chan = lua_chan->chan;
            
            break;
        
        default:
            return luaL_error(L, "config value is of unknown lua type '%s'", lua_typename(L, 3));

    }
    
    // apply it
    if (module_conf(lua_module->module, option, &value, &err))
        return luaL_error(L, "module_conf: %s/%s: %s", module_name(lua_module->module), option->name, error_msg(&err));
   
    // ok
    return 0;
}

static int lua_module_unload (lua_State *L)
{
    struct lua_module *lua_module = lua_obj_get_obj(L, __func__, "spbot.module");
    struct error_info err;

    // just unload it
    if ((ERROR_CODE(&err) = module_unload(lua_module->module)))
        return luaL_error(L, "module_unload: %s: %s", module_name(lua_module->module), error_msg(&err));

    // ok
    return 0;
}

static const struct luaL_Reg lua_module_methods[] = {
    {   "__gc",         &lua_module__gc             },
    {   "conf",         &lua_module_conf            },
    {   "unload",       &lua_module_unload          },
    {   NULL,           NULL                        }
};

/**
 * Initialize the lua_module object type
 */
static void lua_module_init (lua_State *L)
{
    lua_obj_create_type(L, "spbot.module", lua_module_methods);
}

/**
 * Wrapper for modules
 */
struct lua_modules {
    struct modules *modules;
    
    // strdup'd path for module_path
    // XXX: remove when gc'd
    char *path;
};

static int lua_modules__gc (lua_State *L)
{
    struct lua_modules *lua_modules = lua_obj_get_obj(L, __func__, "spbot.modules");
    
    // remove the modules path if it was set by us
    if (lua_modules->path && modules_path(lua_modules->modules, NULL) == lua_modules->path)
        modules_path(lua_modules->modules, "");

    // release any strdup'd path
    free(lua_modules->path);

    // ok
    return 0;
}

static int lua_modules_path (lua_State *L)
{
    struct lua_modules *lua_modules = lua_obj_get_obj(L, __func__, "spbot.modules");
    char *path = NULL;
    const char *old_path;
    
    if (!lua_isnoneornil(L, 2)) {
        // the new path
        if ((path = strdup(luaL_checkstring(L, 2))) == NULL)
            return luaL_error(L, "strdup");
    }

    // set or get
    old_path = modules_path(lua_modules->modules, path);

    // return the old path
    if (old_path)
        lua_pushstring(L, old_path);
    else
        lua_pushnil(L);

    if (path) {
        // replace the old path
        free(lua_modules->path); 
        lua_modules->path = path;
    }

    // ok
    return 1;
}

static int lua_modules_load (lua_State *L)
{
    struct lua_modules *lua_modules = lua_obj_get_obj(L, __func__, "spbot.modules");
    struct module *module;
    struct module_info info;
    struct error_info err;

    // the module name/path
    info.name = luaL_checkstring(L, 2);
    info.path = lua_isnoneornil(L, 3) ? NULL : luaL_checkstring(L, 3);

    // load and get a new reference
    if (module_load(lua_modules->modules, &module, &info, &err))
        return luaL_error(L, "module_load: %s/%s: %s", info.name, info.path, error_msg(&err));

    // wrap
    return lua_module_create(L, module);
}

static int lua_modules_module (lua_State *L)
{
    struct lua_modules *lua_modules = lua_obj_get_obj(L, __func__, "spbot.modules");
    struct module *module;
    
    // the module name
    const char *name = luaL_checkstring(L, 2);

    // look it up, as a new reference
    if ((module = module_get(lua_modules->modules, name)) == NULL)
        return luaL_error(L, "module_get: %s: no such module", name);

    // wrap
    return lua_module_create(L, module);
}

static const struct luaL_Reg lua_modules_methods[] = {
    {   "__gc",         &lua_modules__gc            },
    {   "path",         &lua_modules_path           },
    {   "load",         &lua_modules_load           },
    {   "module",       &lua_modules_module         },
    {   NULL,           NULL                        }
};

/**
 * Initialize the spbot.modules type for lua_modules, and registers an instance bound to the given modules list at
 * 'modules'.
 */
static void lua_modules_init (lua_State *L, struct modules *modules)
{
    // allocate the global "modules" object
    struct lua_modules *lua_modules = lua_obj_create_global_type(L, "spbot.modules", lua_modules_methods, "modules", sizeof(*lua_modules));
    
    // initialize it
    lua_modules->modules = modules;
}

/**
 * Wrapper for nexus
 */
struct lua_nexus {
    struct nexus *nexus;
};

static int lua_nexus_shutdown (lua_State *L)
{
    struct lua_nexus *lua_nexus = lua_obj_get_obj(L, __func__, "spbot.nexus");

    // just shut it down
    nexus_shutdown(lua_nexus->nexus);

    return 0;
}

static int lua_nexus_load_config (lua_State *L)
{
    struct lua_nexus *lua_nexus = lua_obj_get_obj(L, __func__, "spbot.nexus");
    struct error_info err;

    const char *path = luaL_checkstring(L, 2);
    
    // just load it
    if (nexus_load_config(lua_nexus->nexus, path, &err))
        return luaL_error(L, "nexus_load_config(%s): %s", path, error_msg(&err));

    return 0;
}

static const struct luaL_Reg lua_nexus_methods[] = {
    {   "shutdown",     &lua_nexus_shutdown         },
    {   "load_config",  &lua_nexus_load_config      },
    {   NULL,           NULL                        }
};

/**
 * Initialize the spbot.nexus type for lua_nexus, and registers an instance bound to the given nexus list at
 * 'nexus'.
 */
static void lua_nexus_init (lua_State *L, struct nexus *nexus)
{
    // allocate the global "nexus" object
    struct lua_nexus *lua_nexus = lua_obj_create_global_type(L, "spbot.nexus", lua_nexus_methods, "nexus", sizeof(*lua_nexus));
    
    // initialize it
    lua_nexus->nexus = nexus;
}

/**
 * Global functions
 */
static int lua_log_level (lua_State *L)
{
    // log level as a string
    enum log_level new_level = luaL_checkoption(L, 1, NULL, log_level_names);

    // set it
    set_log_level(new_level);

    // ok
    return 0;
}

static int lua_log (lua_State *L)
{
    // log level as a string
    enum log_level level = luaL_checkoption(L, 1, NULL, log_level_names);
    
    // log message
    const char *msg = luaL_checkstring(L, 2);

    // log it
    log_msg(level, "lua", "%s", msg);

    // ok
    return 0;
}

static const struct luaL_Reg lua_global_functions[] = {
    {   "log_level",    &lua_log_level              },
    {   "log",          &lua_log                    },
    {   NULL,           NULL                        }
};

static void lua_global_init (lua_State *L)
{
    const struct luaL_Reg *reg;

    for (reg = lua_global_functions; reg->name && reg->func; reg++) {
        // put the function on the stack
        lua_pushcfunction(L, reg->func);

        // set the global
        lua_setglobal(L, reg->name);
    }
}

void lua_objs_init (struct nexus_lua *lua)
{
    // init the various bits
    lua_global_init(lua->st);
    lua_nexus_init(lua->st, lua->nexus);
    lua_modules_init(lua->st, lua->nexus->modules);
    lua_module_init(lua->st);
}