#include <lua.h>
//#include <lualib.h>
#include <lauxlib.h>
#include <term.h>

#define check_term(L) \
    *(LSUP_Term **)luaL_checkudata(L, 1, "LSUP.Term")


lua_State *L;


static LSUP_Term **allocate_term (lua_State *L)
{
    LSUP_Term **tp = lua_newuserdatauv (L, sizeof (*tp), 1);
    luaL_getmetatable (L, "LSUP.Term");
    lua_setmetatable (L, -2);

    return tp;
}


/*
 * Factory methods.
 */

static int l_iriref_new (lua_State *L)
{
    const char *data = luaL_checkstring (L, 1);
    // TODO handle nsm.
    LSUP_NSMap *nsm = lua_touserdata (L, 2);

    LSUP_Term **tp = allocate_term (L);

    *tp = LSUP_iriref_new (data, nsm);
    if (!*tp) luaL_error (L, "Error while creating a term!");

    return 1;
}


static int l_iriref_new_abs (lua_State *L)
{
    LSUP_Term
        *root = check_term (L),
        *iri = *(LSUP_Term **)luaL_checkudata (L, 2, "LSUP.Term");

    LSUP_Term **tp = allocate_term (L);

    *tp = LSUP_iriref_absolute (root, iri);
    if (!*tp) luaL_error (L, "Error while creating a term!");

    return 1;
}


static int l_iriref_new_rel (lua_State *L)
{
    LSUP_Term
        *root = check_term (L),
        *iri = *(LSUP_Term **)luaL_checkudata (L, 2, "LSUP.Term");

    LSUP_Term **tp = allocate_term (L);

    *tp = LSUP_iriref_relative (root, iri);
    if (!*tp) luaL_error (L, "Error while creating a term!");

    return 1;
}


static int l_lit_new (lua_State *L)
{
    const char
        *data = luaL_checkstring (L, 1),
        *dtype_str = luaL_checkstring (L, 2);
    const char *lang = luaL_checkstring (L, 3);

    LSUP_Term **tp = allocate_term (L);

    if (lang) *tp = LSUP_lt_literal_new (data, (char *)lang);
    else {
        LSUP_Term *dtype = (dtype) ? LSUP_iriref_new (dtype_str, NULL) : NULL;
        *tp = LSUP_literal_new (data, dtype);
    }

    if (!*tp) luaL_error (L, "Error while creating a term!");

    return 1;
}


static int l_bnode_new (lua_State *L)
{
    const char *data = luaL_checkstring (L, 1);

    LSUP_Term **tp = allocate_term (L);

    *tp = LSUP_bnode_new (data);
    if (!*tp) luaL_error (L, "Error while creating a term!");

    return 1;
}


static int l_term_new_copy (lua_State *L)
{
    LSUP_Term *src = check_term (L);

    LSUP_Term **tp = allocate_term (L);

    *tp = LSUP_term_copy (src);
    if (!*tp) luaL_error (L, "Error while creating a term!");

    return 1;
}


static int l_term_new_from_buffer (lua_State *L)
{
    const LSUP_Buffer *sterm = *(LSUP_Buffer **)luaL_checkudata (
            L, 1, "LSUP.Buffer");

    LSUP_Term **tp = allocate_term (L);

    *tp = LSUP_term_new_from_buffer (sterm);
    if (!*tp) luaL_error (L, "Error while creating a term!");

    return 1;
}


/*
 * Class methods.
 */

static int l_term_equals (lua_State *L)
{
    LSUP_Term
        *t1 = check_term (L),
        *t2 = *(LSUP_Term **)luaL_checkudata (L, 2, "LSUP.Term");

    lua_pushboolean (L, LSUP_term_equals (t1, t2));

    return 1;
}


static int l_term_gc (lua_State *L)
{
    LSUP_Term *t = check_term (L);
    if (t) LSUP_term_free (t);

    return 0;
}


static int l_term_get_hash (lua_State *L)
{
    LSUP_Term *t = check_term (L);

    lua_pushinteger (L, LSUP_term_hash (t));

    return 1;
}


static int l_term_serialize (lua_State *L)
{
    LSUP_Term *t = check_term (L);

    LSUP_Buffer *buf = LSUP_term_serialize (t);
    if (!buf) luaL_error (L, "Error while serializing a term!");

    lua_pushfstring (L, buf->addr, buf->size);
    LSUP_buffer_free (buf);

    return 1;
}


/*
 * Getters.
 */


static int l_term_get_attr (lua_State *L)
{
    const char *attr = luaL_checkstring (L, 1);
    // TODO generic getter.

    return 0;
}

static int l_term_get_data (lua_State *L)
{
    LSUP_Term *t = check_term (L);
    lua_pushstring (L, t->data);

    return 1;
}


static int l_term_get_iriref_nsm (lua_State *L)
{
    LSUP_Term *t = check_term (L);
    // TODO
    lua_pushlightuserdata (L, LSUP_iriref_nsm (t));

    return 1;
}


static int l_term_get_iriref_prefix (lua_State *L)
{
    LSUP_Term *t = check_term (L);
    lua_pushstring (L, LSUP_iriref_prefix (t));

    return 1;
}


static int l_term_get_iriref_path (lua_State *L)
{
    LSUP_Term *t = check_term (L);
    lua_pushstring (L, LSUP_iriref_path (t));

    return 1;
}


static int l_term_get_iriref_frag (lua_State *L)
{
    LSUP_Term *t = check_term (L);
    lua_pushstring (L, LSUP_iriref_frag (t));

    return 1;
}


static int l_term_get_lit_datatype (lua_State *L)
{
    LSUP_Term *t = check_term (L);
    if (!LSUP_IS_LITERAL (t)) luaL_error (L, "Term is not a literal.");

    lua_pushstring (L, t->datatype->data);

    return 1;
}


static int l_term_get_lit_lang (lua_State *L)
{
    LSUP_Term *t = check_term (L);
    if (!LSUP_IS_LITERAL (t)) luaL_error (L, "Term is not a literal.");

    lua_pushstring (L, t->lang);

    return 1;
}


/*
 * Library setup.
 */

static const struct luaL_Reg term_lib_fn [] = {
    {"iriref_new", l_iriref_new},
    {"iriref_new_abs", l_iriref_new_abs},
    {"iriref_new_rel", l_iriref_new_rel},
    {"lit_new", l_lit_new},
    {"bnode_new", l_bnode_new},
    {"term_new_copy", l_term_new_copy},
    {NULL}
};


static const struct luaL_Reg term_lib_meth [] = {
    {"__eq", l_term_equals},
    {"__gc", l_term_gc},

    {"hash", l_term_get_hash},
    {"serialize", l_term_serialize},

    {"get_data", l_term_get_data},
    {"get_type", l_term_get_data},
    {"get_iriref_nsm", l_term_get_iriref_nsm},
    {"get_iriref_prefix", l_term_get_iriref_prefix},
    {"get_iriref_path", l_term_get_iriref_path},
    {"get_iriref_frag", l_term_get_iriref_frag},
    {"get_lit_datatype", l_term_get_lit_datatype},
    {"get_lit_lang", l_term_get_lit_lang},
    {NULL}
};


int luaopen_term (lua_State *L)
{
    luaL_newmetatable (L, "LSUP.Term");
    lua_pushvalue (L, -1);
    lua_setfield (L, -2, "__index");
    luaL_setfuncs (L, term_lib_meth, 0);
    luaL_newlib (L, term_lib_fn);

    return 1;
}