#include <lua.h>
#include <lauxlib.h>
#include <loudmouth/loudmouth.h>

#include "config.h"
#include "util.h"
#include "lm_types.h"
#include "lm_message_node.h"

/// lm.message
/// Module, representing individual message.
/// Message have a type and optionally a sub type.
/// Message have a set common methods with message node,
/// these are next, prev, children, parent, value, child,
/// find_child, attribute, raw, xml and path. They just save
/// you typing :node() each time and save memory for
/// one node object.

/// message type
/// Message type (root tag type).
/// G:
const string2enum_t type_lm_message[] = {
	{ "message",         LM_MESSAGE_TYPE_MESSAGE         },
	{ "presence",        LM_MESSAGE_TYPE_PRESENCE        },
	{ "iq",              LM_MESSAGE_TYPE_IQ              },
	{ "stream",          LM_MESSAGE_TYPE_STREAM          },
	{ "stream error",    LM_MESSAGE_TYPE_STREAM_ERROR    },
	{ "stream features", LM_MESSAGE_TYPE_STREAM_FEATURES },
	{ "auth",            LM_MESSAGE_TYPE_AUTH            },
	{ "challenge",       LM_MESSAGE_TYPE_CHALLENGE       },
	{ "response",        LM_MESSAGE_TYPE_RESPONSE        },
	{ "success",         LM_MESSAGE_TYPE_SUCCESS         },
	{ "failure",         LM_MESSAGE_TYPE_FAILURE         },
	{ "proceed",         LM_MESSAGE_TYPE_PROCEED         },
	{ "starttls",        LM_MESSAGE_TYPE_STARTTLS        },
	{ "unknown",         LM_MESSAGE_TYPE_UNKNOWN         },
	{ "stream:stream",   LM_MESSAGE_TYPE_STREAM          },
	{ "stream:error",    LM_MESSAGE_TYPE_STREAM_ERROR    },
	{ "stream:features", LM_MESSAGE_TYPE_STREAM_FEATURES },
	{ "stream_error",    LM_MESSAGE_TYPE_STREAM_ERROR    },
	{ "stream_features", LM_MESSAGE_TYPE_STREAM_FEATURES },
	{ NULL,              0                               },
};

/// message sub type
/// Message subtype, not all combinations of type and subtype are possible.
/// G:
const string2enum_t sub_type_lm_message[] = {
	{ "not set",       LM_MESSAGE_SUB_TYPE_NOT_SET      },
	{ "available",     LM_MESSAGE_SUB_TYPE_AVAILABLE    },
	{ "normal",        LM_MESSAGE_SUB_TYPE_NORMAL       },
	{ "chat",          LM_MESSAGE_SUB_TYPE_CHAT         },
	{ "groupchat",     LM_MESSAGE_SUB_TYPE_GROUPCHAT    },
	{ "headline",      LM_MESSAGE_SUB_TYPE_HEADLINE     },
	{ "unavailable",   LM_MESSAGE_SUB_TYPE_UNAVAILABLE  },
	{ "probe",         LM_MESSAGE_SUB_TYPE_PROBE        },
	{ "subscribe",     LM_MESSAGE_SUB_TYPE_SUBSCRIBE    },
	{ "unsubscribe",   LM_MESSAGE_SUB_TYPE_UNSUBSCRIBE  },
	{ "subscribed",    LM_MESSAGE_SUB_TYPE_SUBSCRIBED   },
	{ "unsubscribed",  LM_MESSAGE_SUB_TYPE_UNSUBSCRIBED },
	{ "get",           LM_MESSAGE_SUB_TYPE_GET          },
	{ "set",           LM_MESSAGE_SUB_TYPE_SET          },
	{ "result",        LM_MESSAGE_SUB_TYPE_RESULT       },
	{ "error",         LM_MESSAGE_SUB_TYPE_ERROR        },
	{ "not_set",       LM_MESSAGE_SUB_TYPE_NOT_SET      },
	{ NULL,            0                                },
};

/// lm.message.new
/// Creates new message object.
/// Note: you can specify nil as to argument to send message to server.
/// A: string (to), message type, message sub type (optional)
/// R: lm message object
static int new_lm_message (lua_State *L)
{
	const char *to   = NULL;
	int         type = luaL_checkenum (L, 2, type_lm_message);
	LmMessage *message;

	if (lua_type (L, 1) != LUA_TNIL)
		to = luaL_checkstring (L, 1);
	if (lua_gettop (L) > 2)
		message = lm_message_new_with_sub_type (to, type,
						luaL_checkenum (L, 3, sub_type_lm_message));
	else
		message = lm_message_new (to, type);
	bless_lm_message (L, message);
	lm_message_unref (message);
	D ("Message %X created", (int) message);
	return 1;
}

/// lm.message.bless
/// Blesses given pointer to lm message object.
/// A: lightuserdata (C lm message object)
/// R: lm message object
static int bless_lua_lm_message (lua_State *L)
{
	luaL_argcheck (L, lua_islightuserdata (L, 1), 1, "lm message lightuserdata expected");
	bless_lm_message (L, lua_touserdata (L, 1));
	return 1;
}

/// message:node
/// Returns root node object of message.
/// R: lm message node object
static int node_lm_message (lua_State *L)
{
	llm_message_t *object = luaL_checklm_message (L, 1);
	LmMessageNode *node = lm_message_get_node (object->message);
	bless_lm_node (L, node);
	// XXX lm_message_node_unref (node);
	return 1;
}

/// message:type
/// Returns two strings: message type and message sub type.
/// R: message type, message sub type
static int kind_lm_message (lua_State *L)
{
	llm_message_t *object = luaL_checklm_message (L, 1);
	luaL_pushenum (L, lm_message_get_type (object->message), type_lm_message);
	luaL_pushenum (L, lm_message_get_sub_type (object->message), sub_type_lm_message);
	return 2;
}

/// message:pointer
/// Returns pointer to underlying C loudmouth structure.
/// R: lightuserdata
static int pointer_lm_message (lua_State *L)
{
	llm_message_t *object = luaL_checklm_message (L, 1);
	lua_pushlightuserdata (L, object->message);
	return 1;
}

static int gc_lm_message (lua_State *L)
{
	llm_message_t *message = luaL_checklm_message (L, 1);
	D ("Message %X gc called", (int) message);
	lm_message_unref (message->message);
	return 0;
}

static const luaL_Reg reg_f_lm_message[] = {
	{ "new",   new_lm_message       },
	{ "bless", bless_lua_lm_message },
	{ NULL,    NULL                 },
};

static const luaL_Reg reg_m_lm_message[] = {
	{ "node",       node_lm_message    },
	{ "type",       kind_lm_message    },
	// These methods are common for message and message node
	{ "next",       next_lm_node       },
	{ "prev",       prev_lm_node       },
	{ "children",   children_lm_node   },
	{ "parent",     parent_lm_node     },
	{ "value",      value_lm_node      },
	{ "child",      child_lm_node      },
	{ "find_child", find_child_lm_node },
	{ "attribute",  attribute_lm_node  },
	{ "raw",        raw_lm_node        },
	{ "xml",        xml_lm_node        },
	{ "path",       path_lm_node       },
	// End common methods
	{ "pointer",    pointer_lm_message },
	{ "__gc",       gc_lm_message      },
	{ NULL,         NULL               },
};

int luaopen_lm_message (lua_State *L)
{
	luaL_newmetatable (L, "loudmouth.message");
	lua_pushstring (L, "__index");
	lua_pushvalue (L, -2);
	lua_settable (L, -3);
	luaL_register (L, NULL, reg_m_lm_message);
	lua_pop (L, 1);
	luaL_register (L, "lm.message", reg_f_lm_message);
	return 1;
}