#include "lua_lsup.h"

#define check_graph(L) \
    *(LSUP_Graph **)luaL_checkudata(L, 1, "LSUP.Graph")


static LSUP_Graph **allocate_graph (lua_State *L)
{
    LSUP_Graph **gp = lua_newuserdatauv (L, sizeof (*gp), 1);
    luaL_getmetatable (L, "LSUP.Graph");
    lua_setmetatable (L, -2);

    return gp;
}


static int l_graph_new (lua_State *L)
{
    LSUP_Store *store;

    if (!lua_isnoneornil (L, 1))
        store = *(LSUP_Store **)luaL_checkudata (L, 1, "LSUP.Store");
    else store = NULL;
    const char *uri_str = lua_tostring (L, 2);

    LSUP_Graph **gp = allocate_graph (L);

    // TODO Make store ID, nsm and initial size accessible.
    *gp = LSUP_graph_new (store, uri_str, NULL);
    LUA_NLCHECK (*gp, "Error creating graph.");

    return 1;
}


static int l_graph_list (lua_State *L)
{
    const LSUP_Store *store = *(LSUP_Store **)luaL_checkudata (
            L, 1, "LSUP.Store");

    LSUP_TermSet **ts_p = lua_newuserdata (L, sizeof *ts_p);
    luaL_getmetatable (L, "LSUP.TermSet");
    lua_setmetatable (L, -2);

    *ts_p = LSUP_graph_list (store);
    LUA_NLCHECK (ts_p, "Error retrieving context list.");

    return 1;
}


/*
 * Class methods.
 */

static int l_graph_gc (lua_State *L)
{
    LSUP_Graph **gp = luaL_checkudata(L, 1, "LSUP.Graph");
    LOG_DEBUG ("Garbage collecting graph @%p", *gp);

    LSUP_graph_free (*gp);
    *gp = NULL;

    return 0;
}


static int l_graph_to_string (lua_State *L)
{
    const LSUP_Graph *gr = check_graph (L);
    lua_pushfstring (
            L, "LSUP.Graph @%p <%s>: %d triples",
            gr, LSUP_graph_uri (gr)->data, LSUP_graph_size (gr));

    return 1;
}


static int l_graph_len (lua_State *L)
{
    const LSUP_Graph *gr = check_graph (L);
    lua_pushinteger (L, LSUP_graph_size (gr));

    return 1;
}


static int l_graph_copy (lua_State *L)
{
    const LSUP_Graph *src = check_graph (L);
    LSUP_Graph *dest = *(LSUP_Graph **)luaL_checkudata(L, 2, "LSUP.Graph");

    LUA_PCHECK (LSUP_graph_copy (src, dest), "Error copying graph");

    return 1;
}


static int l_graph_copy_contents (lua_State *L)
{
    const LSUP_Graph *src = check_graph (L);
    LSUP_Graph *dest = *(LSUP_Graph **)luaL_checkudata (L, 2, "LSUP.Graph");
    const LSUP_Term *s, *p, *o;

    if lua_isnoneornil (L, 3) s = NULL;
    else s = *(LSUP_Term **)luaL_checkudata (L, 3, "LSUP.Term");
    if lua_isnoneornil (L, 4) p = NULL;
    else p = *(LSUP_Term **)luaL_checkudata (L, 4, "LSUP.Term");
    if lua_isnoneornil (L, 5) o = NULL;
    else o = *(LSUP_Term **)luaL_checkudata (L, 5, "LSUP.Term");

    LUA_PCHECK (LSUP_graph_copy_contents (
                src, dest, s, p, o), "Error copying graph.");

    return 1;
}


static int l_graph_equals (lua_State *L)
{
    const LSUP_Graph *gr1 = check_graph (L);
    const LSUP_Graph *gr2 =
        *(LSUP_Graph **)luaL_checkudata (L, 2, "LSUP.Graph");

    LOG_DEBUG ("Comparing graphs %p %p", gr1, gr2);
    int eq_rc = LSUP_graph_equals (gr1, gr2);
    lua_pushboolean (L, eq_rc);

    return 1;
}


static int l_graph_contains (lua_State *L)
{
    const LSUP_Graph *gr = check_graph (L);
    const LSUP_Triple *spo =
        *(LSUP_Triple **)luaL_checkudata (L, 2, "LSUP.Triple");

    lua_pushboolean (L, LSUP_graph_contains (gr, spo));

    return 1;
}


static int l_graph_add (lua_State *L)
{
    LSUP_Graph *gr = check_graph (L);
    int rc;
    LSUP_rc lsup_rc= LSUP_NOACTION;
    size_t i = 0, ct = 0;
    LSUP_GraphIterator *it = LSUP_graph_add_init (gr);

    while ((rc = lua_rawgeti (L, 2, ++i)) != LUA_TNIL) {
        //LOG_DEBUG ("Triple type: %s", lua_typename (L, rc));
        const LSUP_Triple *spo =
            *(LSUP_Triple **)luaL_checkudata (L, -1, "LSUP.Triple");
        LOG_DEBUG (
                "Got triple %d: {%s %s %s}\n",
                i, spo->s->data, spo->p->data, spo->o->data);
        lsup_rc = LSUP_graph_add_iter (it, spo);

        if (lsup_rc < LSUP_OK) break;
        if (lsup_rc == LSUP_OK) ct++;
    };
    LSUP_graph_add_done (it);
    lua_pushinteger (L, ct);

    if (UNLIKELY (lsup_rc < LSUP_OK)) return luaL_error (
            L, "Error adding triple at position %d: %s",
            i, LSUP_strerror (lsup_rc));
    else return 1;
}


static int l_graph_remove (lua_State *L)
{
    LSUP_Graph *gr = check_graph (L);
    const LSUP_Term *s, *p, *o;
    if lua_isnoneornil (L, 2) s = NULL;
    else s = *(LSUP_Term **)luaL_checkudata (L, 2, "LSUP.Term");
    if lua_isnoneornil (L, 3) p = NULL;
    else p = *(LSUP_Term **)luaL_checkudata (L, 3, "LSUP.Term");
    if lua_isnoneornil (L, 4) o = NULL;
    else o = *(LSUP_Term **)luaL_checkudata (L, 4, "LSUP.Term");

    size_t ct;
    LSUP_rc rc = LSUP_graph_remove (gr, s, p, o, &ct);

    LUA_PCHECK (rc, "Error removing triples from graph.");
    lua_pushinteger (L, ct);

    return 1;
}


static int graph_iter_next (lua_State *L)
{
    LSUP_GraphIterator **it_p = lua_touserdata (L, lua_upvalueindex (1));

    LSUP_Triple **spo_p = lua_newuserdatauv (L, sizeof (*spo_p), 1);
    luaL_getmetatable (L, "LSUP.Triple");
    lua_setmetatable (L, -2);
    *spo_p = NULL;

    LSUP_rc rc = LSUP_graph_iter_next (*it_p, spo_p);

    if (rc != LSUP_OK) {
        LSUP_graph_iter_free (*it_p);
        *it_p = NULL;

        if (rc == LSUP_END) {
            lua_pushnil (L);
            lua_pushstring (L, "End of lookup results.");
            return 2;
        }

        LUA_PCHECK (rc, "Error retrieving a lookup result.");
    }

    return 1;
}


static int l_graph_lookup (lua_State *L)
{
    const LSUP_Graph *gr = check_graph (L);
    const LSUP_Term *s, *p, *o;
    if lua_isnoneornil (L, 2) s = NULL;
    else s = *(LSUP_Term **)luaL_checkudata (L, 2, "LSUP.Term");
    if lua_isnoneornil (L, 3) p = NULL;
    else p = *(LSUP_Term **)luaL_checkudata (L, 3, "LSUP.Term");
    if lua_isnoneornil (L, 4) o = NULL;
    else o = *(LSUP_Term **)luaL_checkudata (L, 4, "LSUP.Term");

    LSUP_GraphIterator **it_p =
        (LSUP_GraphIterator **)lua_newuserdata (L, sizeof *it_p);
    *it_p = NULL;
    luaL_getmetatable (L, "LSUP.GraphIterator");
    lua_setmetatable (L, -2);

    size_t ct;
    *it_p = LSUP_graph_lookup (gr, s, p, o, &ct);
    LUA_NLCHECK (*it_p, "Error creating graph iterator.");
    LOG_DEBUG ("Found triples: %d", ct);

    lua_pushcclosure (L, graph_iter_next, 1);

    return 1;
}


/** @brief Free an iterator handle.
 *
 * This is only called if the iterator is abandoned before the
 * iteration cycle is over (either by end of loop or error).
 *
 * @note A new iterator should not be started without first garbage-collecting
 * an incomplete one. That would cause a MDB_BAD_RSLOT error on an LMDB-backed
 * graph, because it attempts to open a new read transaction while the old
 * iterator is keeping the old one open.
 */
static int graph_iter_gc (lua_State *L)
{
    LSUP_GraphIterator **it_p = lua_touserdata (L, 1);

    if (UNLIKELY (!it_p || !*it_p)) return 0;
    LOG_DEBUG ("Garbage collecting iterator @%p", it_p);

    LSUP_graph_iter_free (*it_p);
    *it_p = NULL;

    return 0;
}


/** Returns a LinkMap that can be iterated over with iter().
 */
static int l_graph_connections (lua_State *L)
{
    const LSUP_Graph *gr = check_graph (L);
    LSUP_Term *t = *(LSUP_Term **)luaL_checkudata (L, 2, "LSUP.Term");
    const LSUP_LinkType type = luaL_checkinteger (L, 3);
    LOG_DEBUG ("Adding term for connections: @%p", *t);

    LSUP_LinkMap **lm_p = lua_newuserdata (L, sizeof *lm_p);
    *lm_p = LSUP_graph_connections (gr, t, type);
    LUA_NLCHECK (*lm_p, "Error creating Link map.");
    luaL_getmetatable (L, "LSUP.LinkMap");
    lua_setmetatable (L, -2);

    return 1;
}


static int l_graph_term_set (lua_State *L)
{
    const LSUP_Graph *gr = check_graph (L);
    const LSUP_Term *t1 = *(LSUP_Term **)luaL_checkudata (L, 2, "LSUP.Term");
    const LSUP_TriplePos t1_pos = luaL_checkinteger (L, 3);
    const LSUP_Term *t2 = *(LSUP_Term **)luaL_checkudata (L, 4, "LSUP.Term");
    const LSUP_TriplePos t2_pos = luaL_checkinteger (L, 5);

    LSUP_TermSet **ts_p = lua_newuserdata (L, sizeof *ts_p);
    luaL_getmetatable (L, "LSUP.TermSet");
    lua_setmetatable (L, -2);

    *ts_p = LSUP_graph_term_set (gr, t1, t1_pos, t2, t2_pos);
    LUA_NLCHECK (*ts_p, "Error creating term set.");

    return 1;
}


static int l_graph_unique_terms (lua_State *L)
{
    const LSUP_Graph *gr = check_graph (L);
    const LSUP_TriplePos pos = luaL_checkinteger (L, 2);

    LSUP_TermSet **ts_p = lua_newuserdata (L, sizeof *ts_p);
    luaL_getmetatable (L, "LSUP.TermSet");
    lua_setmetatable (L, -2);

    *ts_p = LSUP_graph_unique_terms (gr, pos);
    LUA_NLCHECK (*ts_p, "Error creating term set.");

    return 1;
}


/*
 * Library setup.
 */

static const luaL_Reg graph_lib_fn [] = {
    {"new", l_graph_new},
    {"list", l_graph_list},

    {NULL}
};


/*
static const luaL_Reg graph_getters [] = {
    {"uri", l_graph_get_uri},
    {"namespace", l_graph_get_nsm},

    {NULL}
};
*/


/*
static const luaL_Reg graph_setters [] = {
    {"uri", l_graph_set_uri},

    {NULL}
};
*/

static const luaL_Reg graph_lib_meth [] = {
    {"__eq", l_graph_equals},
    {"__gc", l_graph_gc},
    //{"__index", get_attr},
    //{"__newindex", set_attr},
    {"__tostring", l_graph_to_string},
    {"__len", l_graph_len},

    {"copy", l_graph_copy},
    {"copy_contents", l_graph_copy_contents},

    {"add", l_graph_add},
    {"remove", l_graph_remove},

    {"lookup", l_graph_lookup},
    {"contains", l_graph_contains},
    {"connections", l_graph_connections},
    {"term_set", l_graph_term_set},
    {"unique_terms", l_graph_unique_terms},

    //{"to_n3", l_graph_to_n3},
    {NULL}
};


static const LEnumConst graph_enums[] = {
    {NULL, 0}
};


int luaopen_lsup_graph (lua_State *L)
{
    LSUP_init();  // This is idempotent: no problem calling it multiple times.
    luaL_newmetatable (L, "LSUP.Graph");
    lua_pushvalue (L, -1);
    lua_setfield (L, -2, "__index");
    luaL_setfuncs (L, graph_lib_meth, 0);

    // Metatables for ancillary types.
    luaL_newmetatable (L, "LSUP.GraphIterator");
    lua_pushcfunction (L, graph_iter_gc);
    lua_setfield (L, -2, "__gc");

    /*
    // Getters table.
    lua_newtable (L);
    for (int i = 0; graph_getters[i].name != NULL; i++) {
        lua_pushcfunction (L, graph_getters[i].func);
        lua_setfield (L, -2, graph_getters[i].name);
    }
    // Set getters table as a value for the Graph metatable.
    lua_setfield (L, -2, "getters");
    */
    luaL_newlib (L, graph_lib_fn);

    // Module-level constants.
    push_int_const (L, graph_enums);

    return 1;
}