#include <glib.h>

#include <gmodule.h>

#include <lua.h>

#include <lauxlib.h>

#include <lualib.h>

#include <stdio.h>       // popen, pclose, fileno

#include "logprint.h"    // scr_LogPrint

#include "screen.h"      // scr_Beep, scr_WriteIncomingMessage

#include "hbuf.h"        // HBB_PREFIX_INFO

#include "commands.h"    // process_command

#include "xmpp.h"        // xmpp_getstatus, xmpp_getstatusmsg, lconnection

#include "roster.h"      // imstatus2char, foreach_buddy, buddy_*, current_buddy, BUDDATA, ROSTER_TYPE_*

#include "utils.h"       // from_utf8

#include "lua_util.h"    // mcabber_config_file, string2enum

#include "hooks.h"

#include "settings.h"

lua_State *lua = NULL;    // global lua state object

char *mcabber_config_filename (const char *file)

{

  char *home = getenv("HOME");

  if (!home)

    return NULL;

  return g_strconcat (home, "/.mcabber/", file ? file : "", NULL);

}

/// print

/// Prints it's arguments to log with default priority.

/// A: message, message...

static int lua_global_print (lua_State *L)

{

  const char *message;

  lua_concat (L, lua_gettop (L));

  message = lua_tostring (L, -1);

  scr_LogPrint (LPRINT_LOGNORM, message);

  lua_pop (L, 1);

  return 0;

}

/// dopath

/// Loads lua file from default location.

/// A: string (filename, without ".lua")

static int lua_global_dopath (lua_State *L)

{

 // const char *name = luaL_checkstring (L, 1);

  // FIXME

  return 0;

}

/// main.config_file

/// Adds mcabber default config location path to config file name.

/// Note: not sure, that this function will stay alive long.

/// A: string (filename)

/// R: string (full path)

static int lua_main_config_file (lua_State *L)

{

  char *home = mcabber_config_filename (lua_isstring (L, 1) ?

                                        lua_tostring (L, 1) : NULL);

  lua_pop (L, 1);

  if (!home) {

    lua_pushstring (L, "Cannot find home dir!");

    lua_error (L);

  }

  lua_pushstring (L, home);

  g_free (home); // XXX

  return 1;

}

/// log print type

/// V: normal, log, debug, notutf8, lognorm

static const string2enum_t lua_lprint[] = {

  { "normal",  LPRINT_NORMAL  },

  { "log",     LPRINT_LOG     },

  { "debug",   LPRINT_DEBUG   },

  { "notutf0", LPRINT_NOTUTF8 },

  { NULL,      0              },

};

static const string2enum_t lua_roster_type[] = {

  { "user",    ROSTER_TYPE_USER    },

  { "group",   ROSTER_TYPE_GROUP   },

  { "agent",   ROSTER_TYPE_AGENT   },

  { "room",    ROSTER_TYPE_ROOM    },

  { "special", ROSTER_TYPE_SPECIAL },

  { NULL,      0                   },

};

/// main.log

/// Prints message to log.

/// A: log print type, message, message...

static int lua_main_log (lua_State *L)

{

  const char *message;

  int type = luaL_checkenum_multi (L, 1, lua_lprint);

  lua_concat (L, lua_gettop (L) - 1);

  message = lua_tostring (L, -1);

  scr_LogPrint (type, message);

  return 0;

}

/// main.option

/// Sets or gets value of mcabber option.

/// You can specify nil as a value to delete option.

/// XXX: Should we do types here?

/// A: string (option name), string (value, optional)

/// R: string (value, optional)

static int lua_main_option (lua_State *L)

{

  const char *name = luaL_checkstring (L, 1);

  if (lua_gettop (L) > 1) { // Set

    if (lua_type (L, 2) == LUA_TNIL)

      settings_del (SETTINGS_TYPE_OPTION, name);

    else {

      const char *value = luaL_checkstring (L, 2);

      settings_set (SETTINGS_TYPE_OPTION, name, value);

    }

    return 0;

  } else {

    const char *value = settings_get (SETTINGS_TYPE_OPTION, name);

    if (value)

      lua_pushstring (L, value);

    else

      lua_pushnil (L);

    return 1;

  }

}

/// main.connection

/// Returns lightuserdata of mcabber's loudmouth connection.

/// This can be very useful with lua-loudmouth, and not much otherwise.

/// R: lightuserdata

static int lua_main_connection (lua_State *L)

{

  lua_pushlightuserdata (L, lconnection);

  return 1;

}

// Well, for now

// I cannot get how

// To use caps.

/// main.add_feature

/// A: string (xmlns)

static int lua_main_add_feature (lua_State *L)

{

//  xmpp_add_feature (luaL_checkstring (L, 1));

  return 0;

}

/// main.del_feature

/// A: stirng (xmlns)

static int lua_main_del_feature (lua_State *L)

{

//  xmpp_del_feature (luaL_checkstring (L, 1));

  return 0;

}

typedef struct {

  int reference;

  lua_State *L;

} lua_command_callback_t;

/// command function

/// A: argument string

void lua_main_command_handler (char *args, lua_command_callback_t *cb)

{

  lua_rawgeti (cb->L, LUA_REGISTRYINDEX, cb->reference);

  lua_pushstring (cb->L, args);

  if (lua_pcall (cb->L, 1, 0, 0)) {

    scr_LogPrint (LPRINT_LOGNORM, "lua: Command execution error: %s",

                  lua_tostring (cb->L, -1));

    lua_pop (cb->L, 1);

  }

}

/// main.add_command

/// A: string (command name), command function

static int lua_main_add_command (lua_State *L)

{

  const char *name = luaL_checkstring (L, 1);

  lua_command_callback_t *cb;

  luaL_argcheck (L, lua_isfunction (L, 2), 2, "function expected");

  cb = luaL_malloc (L, sizeof (lua_command_callback_t));

  cb->reference = luaL_ref (L, LUA_REGISTRYINDEX);

  cb->L = L;

  cmd_add (name, "", 0, 0, (void (*) (char *p)) lua_main_command_handler, cb);

  return 0;

}

/// main.print_info

/// Prints a system message to buddy's window.

/// A: string (jid), string (message)

static int lua_main_print_info (lua_State *L)

{

  char *to = jidtodisp (luaL_checkstring (L, 1));

  const char *message = luaL_checkstring (L, 2);

  scr_WriteIncomingMessage (to, message, 0, HBB_PREFIX_INFO, 0);

  g_free (to);

  return 0;

}

/// main.beep

/// Beeps with system speaker.

static int lua_main_beep (lua_State *L)

{

  scr_Beep ();

  return 0;

}

/// main.run

/// Runs specified mcabber command.

/// A: string

static int lua_main_run (lua_State *L)

{

  const char *command = luaL_checkstring (L, 1);

  process_command (command, TRUE);

  return 0;

}

/// main.status

/// Returns your current status.

/// R: char (status letter), string (status message)

static int lua_main_status (lua_State *L)

{

  char *sm = from_utf8 (xmpp_getstatusmsg ());

  lua_pushlstring (L, &imstatus2char[xmpp_getstatus ()], 1);

  lua_pushstring  (L, sm);

  g_free (sm);

  return 2;

}

// expects table on top!

static void lua_rosterlist_callback (gpointer buddy, lua_State *L)

{

  lua_pushnumber (L, lua_objlen (L, -1) + 1);

  lua_pushstring (L, buddy_getjid (buddy));

  lua_settable (L, -3);

}

/// main.roster

/// Returns array of jids of buddies in roster.

/// R: table

static int lua_main_roster (lua_State *L)

{

  lua_newtable (L);

  foreach_buddy (ROSTER_TYPE_USER|ROSTER_TYPE_AGENT|ROSTER_TYPE_ROOM, (void (*) (gpointer buddy, void *data))lua_rosterlist_callback, L);

  return 1;

}

/// main.current_buddy

/// Returns jid of current selected buddy.

/// R: string

static int lua_main_current_buddy (lua_State *L)

{

  lua_pushstring (L, buddy_getjid (BUDDATA (current_buddy)));

  return 1;

}

typedef struct {

  lua_State *L;

  gpointer buddy;

} lua_state_and_buddy_t; // :)

// expects table on top!

static void lua_buddy_resources_callback (gpointer resource, lua_state_and_buddy_t *d)

{

  lua_pushstring  (d->L, resource);

  lua_createtable (d->L, 0, 3);

  lua_pushstring  (d->L, "priority");

  lua_pushnumber  (d->L, buddy_getresourceprio (d->buddy, resource));

  lua_settable    (d->L, -3);

  lua_pushstring  (d->L, "status");

  lua_pushlstring (d->L, &imstatus2char[buddy_getstatus (d->buddy, resource)], 1);

  lua_settable    (d->L, -3);

  lua_pushstring  (d->L, "message");

  lua_pushstring  (d->L, buddy_getstatusmsg (d->buddy, resource));

  lua_settable    (d->L, -3);

  lua_settable    (d->L, -3);

}

/// main.buddy_info

/// Returns a hash table with information on specified buddy.

/// Table contains fields type, name, onserver and resources.

/// Resources is also a hash table, that contains tables with information,

/// specific for each resource. In each resource table there are fields

/// priority, status and message.

/// A: string (jid)

/// R: table

static int lua_main_buddy_info (lua_State *L)

{

  char *jid = jidtodisp (luaL_checkstring (L, 1));

  GSList *buddy = roster_find (jid, jidsearch,

                          ROSTER_TYPE_USER|ROSTER_TYPE_AGENT|ROSTER_TYPE_ROOM);

  lua_state_and_buddy_t snb;

  g_free (jid);

  if (!buddy) {

    lua_pushnil (L);

    return 1;

  }

  lua_createtable (L, 0, 3);

  lua_pushstring  (L, "type");

  lua_pushstring  (L, enum2string (buddy_gettype (BUDDATA (buddy)),

                                   lua_roster_type));

  lua_settable    (L, -3);

  lua_pushstring  (L, "name");

  lua_pushstring  (L, buddy_getname (BUDDATA (buddy)));

  lua_settable    (L, -3);

  lua_pushstring  (L, "onserver");

  lua_pushboolean (L, buddy_getonserverflag (BUDDATA (buddy)));

  lua_settable    (L, -3);

  lua_pushstring  (L, "resources");

  lua_createtable (L, 0, 0);

  snb.L     = L;

  snb.buddy = BUDDATA (buddy);

  g_slist_foreach (buddy_getresources (BUDDATA (buddy)),

                   (GFunc)lua_buddy_resources_callback, &snb);

  lua_settable    (L, -3);

  return 1;

}

// TIMER

#define LUA_TIMER_PRIORITY ( G_PRIORITY_HIGH_IDLE )

typedef struct {

  int reference;

  lua_State *L;

} lua_timer_callback_t;

static void lua_timer_callback_destroy (lua_timer_callback_t *cb)

{

  luaL_unref (cb->L, LUA_REGISTRYINDEX, cb->reference);

  luaL_free (cb->L, cb);

}

/// timer function

/// Function, that will be called periodically until it returns false.

/// R: boolean

static gboolean lua_timer_callback (lua_timer_callback_t *cb)

{

  int ret;

  lua_rawgeti (cb->L, LUA_REGISTRYINDEX, cb->reference);

  if (lua_pcall (cb->L, 0, 1, 0)) {

    scr_LogPrint (LPRINT_LOGNORM, "lua: Timer callback execution error: %s",

                  lua_tostring (cb->L, -1));

    lua_pop (cb->L, 1);

    return FALSE;

  }

  ret = lua_toboolean (cb->L, -1);

  lua_pop (cb->L, 1);

  return ret;

}

/// main.timer

/// Creates new timer function, that will be called periodically.

/// A: integer (interval, seconds), timer function

static int lua_main_timer (lua_State *L)

{

  int interval = luaL_checkint (L, 1);

  lua_timer_callback_t *cb;

  luaL_argcheck (L, lua_isfunction (L, 2), 2, "function expected");

  cb = luaL_malloc (L, sizeof (lua_timer_callback_t));

  cb->reference = luaL_ref (L, LUA_REGISTRYINDEX);

  cb->L         = L;

  g_timeout_add_seconds_full (LUA_TIMER_PRIORITY, interval,

                              (GSourceFunc)lua_timer_callback, cb,

                              (GDestroyNotify)lua_timer_callback_destroy);

  return 0;

}

// BACKGROUND PIPE READING

#define LUA_BGREAD_BUFFER ( 4096 )

typedef struct {

  lua_State *L;

  FILE      *fd;

  int        reference;

} lua_bgread_callback_t;

static gchar lua_bgread_buffer[LUA_BGREAD_BUFFER];

static void lua_bgread_callback_destroy (lua_bgread_callback_t *cb)

{

  luaL_unref (cb->L, LUA_REGISTRYINDEX, cb->reference);

  pclose (cb->fd);

  luaL_free (cb->L, cb);

}

/// background reading function

/// Function, that processes output from pipe in asynchroneous way.

/// A: string (data) or nil (eof)

/// R: boolean (false if reading should be terminated)

static gboolean

lua_bgread_callback (GIOChannel *source, GIOCondition condition,

                     lua_bgread_callback_t *cb)

{

  int ret = TRUE;

  if (condition | G_IO_IN) { // data

    while (TRUE) {

      gsize read = 0;

      g_io_channel_read_chars(source, lua_bgread_buffer, LUA_BGREAD_BUFFER,

                              &read, NULL);

      if (!read) // exausted

        break;