/* Copyright 2009 Myhailo Danylenko

This file is part of mcabber-lua.

mcabber-lua is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 2 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program.  If not, see <http://www.gnu.org/licenses/>. */

#include <glib.h>

#include <gmodule.h>   // g_module_*

#include <lua.h>

#include <lauxlib.h>

#include <lualib.h>

#include <stdio.h>

#include <stdlib.h>    // getenv

#include <string.h>    // strcmp

#include <mcabber/logprint.h>    // scr_log_print

#include <mcabber/screen.h>      // scr_Beep, scr_WriteIncomingMessage

#include <mcabber/hbuf.h>        // HBB_PREFIX_INFO

#include <mcabber/commands.h>    // process_command, cmd_add, cmd_del

#include <mcabber/xmpp.h>        // xmpp_getstatus, xmpp_getstatusmsg, lconnection

#include <mcabber/xmpp_helper.h> // xmpp_add_feature, xmpp_del_feature

#include <mcabber/roster.h>      // imstatus2char, foreach_buddy, buddy_*, current_buddy, BUDDATA, ROSTER_TYPE_*

#include <mcabber/utils.h>       // from_utf8, jidtodisp

#include <mcabber/hooks.h>       // hk_add_handler, hk_del_handler

#include <mcabber/settings.h>    // settings_set, settings_del, settings_get

#include <mcabber/compl.h>       // compl_new_category, compl_add_category_word, compl_del_category_word

#include <mcabber/events.h>      // evs_*

#include <mcabber/modules.h>     // module_info_t

#include <mcabber/api.h>         // mcabber_branch, mcabber_api_version

#include <mcabber/main.h>        // mcabber_version

#include "config.h"

#include "util.h"

// module description

static void mlua_init   (void);

static void mlua_uninit (void);

#ifdef LLM_LOG_HANDLER

#define DESCRIPTION ( \

	"Lua scripting interface\n" \

	"Recognizes options lua_init_file, lua_hook_function and lua_lm_debug\n" \

	"Provides command /lua" )

#else

#define DESCRIPTION ( \

	"Lua scripting interface\n" \

	"Recognizes options lua_init_file and lua_hook_function\n" \

	"Provides command /lua" )

#endif

static module_info_t info_lua_experimental = {

	.branch      = "experimental",

	.api         = 27,

	.version     = PROJECT_VERSION,

	.description = DESCRIPTION,

	.requires    = NULL,

	.init        = mlua_init,

	.uninit      = mlua_uninit,

	.next        = NULL,

};

static module_info_t info_lua_dev = {

	.branch      = "dev",

	.api         = 13,

	.version     = PROJECT_VERSION,

	.description = DESCRIPTION,

	.requires    = NULL,

	.init        = mlua_init,

	.uninit      = mlua_uninit,

	.next        = &info_lua_experimental,

};

module_info_t info_lua = {

	.branch      = "0.10.0",

	.api         = 1,

	.version     = PROJECT_VERSION,

	.description = DESCRIPTION,

	.requires    = NULL,

	.init        = mlua_init,

	.uninit      = mlua_uninit,

	.next        = &info_lua_dev,

};

// global lua state object, necessary for uninitialization function

static lua_State *lua = NULL;

// caller sould g_free result

static char *mcabber_config_filename (const char *file)

{

	const char *home = getenv ("HOME");

	if (!home)

		return NULL;

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

}

/// print

/// Prints its arguments to log with default priority.

/// A: something, ...

static int lua_global_print (lua_State *L)

{

	int         top = lua_gettop (L);

	int         i;

	luaL_Buffer B;

	luaL_buffinit (L, &B);

	for (i = 1; i <= top; i++) {

		int type = lua_type (L, i);

		if (i > 1)

			luaL_addchar (&B, '\t');

		if (type == LUA_TSTRING) {

			size_t len;

			const char *str = lua_tolstring (L, i, &len);

			luaL_addlstring (&B, str, len);

		} else if (type == LUA_TNUMBER)

			luaL_addstring (&B, lua_tostring (L, i)); // XXX: modifies

		else if (type == LUA_TBOOLEAN) {

			if (lua_toboolean (L, i))

				 luaL_addstring (&B, "true");

			else

				luaL_addstring (&B, "false");

		} else if (type == LUA_TNIL)

			luaL_addstring (&B, "nil");

		else {

			char xbuf[9];

			luaL_addstring (&B, luaL_typename (L, i));

			luaL_addstring (&B, ": 0x");

			snprintf (&xbuf[0], 9, "%08x", (int) lua_topointer (L, i));

			luaL_addlstring (&B, xbuf, 8); // XXX

		}

	}

	luaL_pushresult (&B);

	scr_log_print (LPRINT_LOGNORM | LPRINT_NOTUTF8, lua_tostring (L, -1));

	return 0;

}

/// dopath

/// Loads lua file from default location.

/// XXX: g_filename_from_utf8?

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

/// R: string (error message, optional)

static int lua_global_dopath (lua_State *L)

{

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

	size_t      size = lua_objlen (L, 1);

	char       *path;

	int         ret = 0;

	if (size > 4 && !strncmp (name + size - 4, ".lua", 4))

		path = mcabber_config_filename (name);

	else {

		char *fname = g_strconcat (name, ".lua", NULL);

		path = mcabber_config_filename (fname);

		g_free (fname);

	}

	if ((ret = luaL_loadfile (L, path)))

		scr_log_print (LPRINT_LOGNORM, "lua: Unable to compile file %s: %s", path, lua_tostring (L, -1));

	else if ((ret = lua_pcall (L, 0, LUA_MULTRET, 0)))

		scr_log_print (LPRINT_LOGNORM, "lua: Runtime error in file %s: %s", path, lua_tostring (L, -1));

	g_free (path);

	if (ret)

		return 1;

	else

		return 0;

}

/// yes or no ansvers

/// G:

static const string2enum_t lua_yesno[] = {

	{ "1",       1 },

	{ "0",       0 },

	{ "enable",  1 },

	{ "disable", 0 },

	{ "true",    1 },

	{ "false",   0 },

	{ "on",      1 },

	{ "off",     0 },

	{ "yes",     1 },

	{ "no",      0 },

	{ NULL,     -1 },

};

/// main.yesno

/// According to yes or no ansvers returns true or false.

/// If ansver is not recognized, returns nil.

/// A: anything (string expected)

/// R: boolean or nil

static int lua_main_yesno (lua_State *L)

{

	int type = lua_type (L, 1);

	if (type == LUA_TSTRING) {

		int ret = luaL_checkenum (L, 1, lua_yesno);

		if (ret == -1)

			lua_pushnil (L);

		else

			lua_pushboolean (L, ret);

	} else if (type == LUA_TNUMBER)

		lua_pushboolean (L, lua_tointeger (L, 1));

	else if (type != LUA_TBOOLEAN)

		lua_pushnil (L);

	return 1;

}

/// main.version

/// Returns information about mcabber version

/// R: table

static int lua_main_version (lua_State *L)

{

	lua_createtable (L, 0, 3);

	lua_pushstring (L, mcabber_branch);

	lua_setfield (L, -2, "branch");

	lua_pushinteger (L, mcabber_api_version);

	lua_setfield (L, -2, "api");

	{

		gchar *version = mcabber_version ();

		lua_pushstring (L, version);

		g_free (version);

	}

	lua_setfield (L, -2, "version");

	lua_pushliteral (L, MCABBER_BRANCH);

	lua_setfield (L, -2, "build_branch");

	lua_pushinteger (L, MCABBER_API_VERSION);

	lua_setfield (L, -2, "build_api");

	lua_pushinteger (L, MCABBER_API_MIN);

	lua_setfield (L, -2, "build_api_min");

	return 1;

}

/// log print type

/// G:

static const string2enum_t lua_lprint[] = {

	{ "normal",  LPRINT_NORMAL  },

	{ "log",     LPRINT_LOG     },

	{ "debug",   LPRINT_DEBUG   },

	{ "notutf0", LPRINT_NOTUTF8 },

	{ NULL,      0              },

};

/// roster type

/// G:

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.

/// Note: most likely you need notutf8 flag enabled.

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

static int lua_main_log (lua_State *L)

{

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

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

	scr_log_print (type, lua_tostring (L, -1));

	return 0;

}

// expects table on top

static void lua_options_callback (char *key, char *value, lua_State *L)

{

	char *loc = from_utf8 (key);

	lua_pushstring (L, loc);

	g_free (loc);

	loc = from_utf8 (value);

	lua_pushstring (L, loc);

	g_free (loc);

	lua_settable (L, -3);

}

/// main.option

/// Sets or gets value of mcabber option.

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

/// If you omit option name, it returns hash table of all options.

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

/// R: string (value, optional)

static int lua_main_option (lua_State *L)

{

	int top = lua_gettop (L);

	if (top > 0) {

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

		if (top > 1) { // Set

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

				settings_del (SETTINGS_TYPE_OPTION, name);

			else { // Set

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

				settings_set (SETTINGS_TYPE_OPTION, name, value);

				g_free (value);

			}

			g_free (name);

			return 0;

		} else { // Get

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

			if (value) {

				lua_pushstring (L, value);

				g_free (value);

			} else

				lua_pushnil (L);

			g_free (name);

			return 1;

		}

	} else { // List

		lua_newtable (L);

		settings_foreach (SETTINGS_TYPE_OPTION, (void (*)(char *key, char *val, void *ud)) lua_options_callback, L);

		return 1;

	}

}

/// main.alias

/// Sets or gets alias.

/// You can specify nil as a command to delete alias.

/// If you omit alias name, it will return hash table of all aliases.

/// A: string (alias name, optional), string (command, optional)

/// R: string (command, optional)

static int lua_main_alias (lua_State *L)

{

	int top = lua_gettop (L);

	if (top > 0) {

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

		if (top > 1) { // Set

			if (lua_type (L, 2) == LUA_TNIL) { // Unset

				settings_del (SETTINGS_TYPE_ALIAS, name);

				compl_del_category_word (COMPL_CMD, name);

			} else { // Set

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

				if (!settings_get (SETTINGS_TYPE_ALIAS, name))

					compl_add_category_word (COMPL_CMD, name);

				settings_set (SETTINGS_TYPE_ALIAS, name, value);

				g_free (value);

			}

			g_free (name);

			return 0;

		} else { // Get

			char *value = from_utf8 (settings_get (SETTINGS_TYPE_ALIAS, name));

			if (value) {

				lua_pushstring (L, value);

				g_free (value);

			} else

				lua_pushnil (L);

			g_free (name);

			return 1;

		}

	} else { // List

		lua_newtable (L);

		settings_foreach (SETTINGS_TYPE_ALIAS, (void (*)(char *key, char *val, void *ud)) lua_options_callback, L);

		return 1;

	}

}

/// main.bind

/// Sets or gets binding.

/// You can specify nil as a command to unbind key.

/// If you omit keycode, it will return hash table of all bindings.

/// A: string (keycode, optional), string (command, optional)

/// R: string (command, optional)

static int lua_main_binding (lua_State *L)

{

	int top = lua_gettop (L);

	if (top > 0) {

		// just to be sure...

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

		if (top > 1) { // Set

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

				settings_del (SETTINGS_TYPE_BINDING, name);

			else { // Set

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

				settings_set (SETTINGS_TYPE_BINDING, name, value);

				g_free (value);

			}

			g_free (name);

			return 0;

		} else { // Get

			char *value = from_utf8 (settings_get (SETTINGS_TYPE_BINDING, name));

			if (value) {

				lua_pushstring (L, value);

				g_free (value);

			} else

				lua_pushnil (L);

			g_free (name);

			return 1;

		}

	} else { // List

		lua_newtable (L);

		settings_foreach (SETTINGS_TYPE_BINDING, (void (*)(char *key, char *val, void *ud)) lua_options_callback, L);

		return 1;

	}

}

/// main.fileoption

/// Gets option, expanding it as filename.

/// A: string (option name)

/// R: string (expanded option value) or nil