#include "blade.h"
#include "tap.h"

#define CONSOLE_INPUT_MAX 512

ks_bool_t g_shutdown = KS_FALSE;

void loop(blade_handle_t *bh);
void process_console_input(blade_handle_t *bh, char *line);

typedef void (*command_callback)(blade_handle_t *bh, char *args);

struct command_def_s {
	const char *cmd;
	command_callback callback;
};

void command_quit(blade_handle_t *bh, char *args);

static const struct command_def_s command_defs[] = {
	{ "quit", command_quit },

	{ NULL, NULL }
};



ks_status_t blade_module_chat_create(blade_module_t **bmP, blade_handle_t *bh);
ks_status_t blade_module_chat_on_startup(blade_module_t *bm, config_setting_t *config);
ks_status_t blade_module_chat_on_shutdown(blade_module_t *bm);

typedef struct blade_module_chat_s blade_module_chat_t;
struct blade_module_chat_s {
	blade_handle_t *handle;
	ks_pool_t *pool;
	ks_thread_pool_t *tpool;
	blade_module_t *module;
	//blade_module_callbacks_t *module_callbacks;

	blade_space_t *blade_chat_space;
	const char *session_state_callback_id;
	ks_list_t *participants;
};

void blade_module_chat_on_session_state(blade_session_t *bs, blade_session_state_condition_t condition, void *data);

ks_bool_t blade_chat_join_request_handler(blade_module_t *bm, blade_request_t *breq);
ks_bool_t blade_chat_leave_request_handler(blade_module_t *bm, blade_request_t *breq);
ks_bool_t blade_chat_send_request_handler(blade_module_t *bm, blade_request_t *breq);

static blade_module_callbacks_t g_module_chat_callbacks =
{
	blade_module_chat_on_startup,
	blade_module_chat_on_shutdown,
};


int main(int argc, char **argv)
{
	blade_handle_t *bh = NULL;
	config_t config;
	config_setting_t *config_blade = NULL;
	blade_module_t *mod_chat = NULL;
	//blade_identity_t *id = NULL;
	const char *cfgpath = "blades.cfg";

	ks_global_set_default_logger(KS_LOG_LEVEL_DEBUG);

	blade_init();

	blade_handle_create(&bh);

	//if (argc > 1) cfgpath = argv[1];

	config_init(&config);
	if (!config_read_file(&config, cfgpath)) {
		ks_log(KS_LOG_ERROR, "%s:%d - %s\n", config_error_file(&config), config_error_line(&config), config_error_text(&config));
		config_destroy(&config);
		return EXIT_FAILURE;
	}
	config_blade = config_lookup(&config, "blade");
	if (!config_blade) {
		ks_log(KS_LOG_ERROR, "Missing 'blade' config group\n");
		config_destroy(&config);
		return EXIT_FAILURE;
	}
	if (config_setting_type(config_blade) != CONFIG_TYPE_GROUP) {
		ks_log(KS_LOG_ERROR, "The 'blade' config setting is not a group\n");
		return EXIT_FAILURE;
	}

	// must occur before startup
	blade_module_chat_create(&mod_chat, bh);
	blade_handle_module_register(mod_chat);

	if (blade_handle_startup(bh, config_blade) != KS_STATUS_SUCCESS) {
		ks_log(KS_LOG_ERROR, "Blade startup failed\n");
		return EXIT_FAILURE;
	}

	loop(bh);

	blade_handle_destroy(&bh);

	config_destroy(&config);

	blade_shutdown();

	return 0;
}

void loop(blade_handle_t *bh)
{
	char buf[CONSOLE_INPUT_MAX];
	while (!g_shutdown) {
		if (!fgets(buf, CONSOLE_INPUT_MAX, stdin)) break;

		for (int index = 0; buf[index]; ++index) {
			if (buf[index] == '\r' || buf[index] == '\n') {
				buf[index] = '\0';
				break;
			}
		}
		process_console_input(bh, buf);
	}
}

void parse_argument(char **input, char **arg, char terminator)
{
	char *tmp;

	ks_assert(input);
	ks_assert(*input);
	ks_assert(arg);

	tmp = *input;
	*arg = tmp;

	while (*tmp && *tmp != terminator) ++tmp;
	if (*tmp == terminator) {
		*tmp = '\0';
		++tmp;
	}
	*input = tmp;
}

void process_console_input(blade_handle_t *bh, char *line)
{
	char *args = line;
	char *cmd = NULL;
	ks_bool_t found = KS_FALSE;

	ks_log(KS_LOG_DEBUG, "Output: %s\n", line);

	parse_argument(&args, &cmd, ' ');

	ks_log(KS_LOG_DEBUG, "Command: %s, Args: %s\n", cmd, args);

	for (int32_t index = 0; command_defs[index].cmd; ++index) {
		if (!strcmp(command_defs[index].cmd, cmd)) {
			found = KS_TRUE;
			command_defs[index].callback(bh, args);
		}
	}
	if (!found) ks_log(KS_LOG_INFO, "Command '%s' unknown.\n", cmd);
}

void command_quit(blade_handle_t *bh, char *args)
{
	ks_assert(bh);
	ks_assert(args);

	ks_log(KS_LOG_DEBUG, "Shutting down\n");
	g_shutdown = KS_TRUE;
}




static void blade_module_chat_cleanup(ks_pool_t *pool, void *ptr, void *arg, ks_pool_cleanup_action_t action, ks_pool_cleanup_type_t type)
{
	blade_module_chat_t *bm_chat = (blade_module_chat_t *)ptr;

	ks_assert(bm_chat);

	switch (action) {
	case KS_MPCL_ANNOUNCE:
		break;
	case KS_MPCL_TEARDOWN:
		break;
	case KS_MPCL_DESTROY:
		break;
	}
}


ks_status_t blade_module_chat_create(blade_module_t **bmP, blade_handle_t *bh)
{
	blade_module_chat_t *bm_chat = NULL;
	ks_pool_t *pool = NULL;

	ks_assert(bmP);
	ks_assert(bh);

	ks_pool_open(&pool);
	ks_assert(pool);

	bm_chat = ks_pool_alloc(pool, sizeof(blade_module_chat_t));
	bm_chat->handle = bh;
	bm_chat->pool = pool;
	bm_chat->tpool = blade_handle_tpool_get(bh);
	bm_chat->session_state_callback_id = NULL;

	ks_list_create(&bm_chat->participants, pool);
	ks_assert(bm_chat->participants);

	blade_module_create(&bm_chat->module, bh, pool, bm_chat, &g_module_chat_callbacks);
	ks_assert(bm_chat->module);

	ks_pool_set_cleanup(pool, bm_chat, NULL, blade_module_chat_cleanup);

	ks_log(KS_LOG_DEBUG, "Created\n");

	*bmP = bm_chat->module;

	return KS_STATUS_SUCCESS;
}


ks_status_t blade_module_chat_config(blade_module_chat_t *bm_chat, config_setting_t *config)
{
	config_setting_t *chat = NULL;

	ks_assert(bm_chat);
	ks_assert(config);

	if (!config_setting_is_group(config)) {
		ks_log(KS_LOG_DEBUG, "!config_setting_is_group(config)\n");
		return KS_STATUS_FAIL;
	}

	chat = config_setting_get_member(config, "chat");
	if (chat) {
	}


	// Configuration is valid, now assign it to the variables that are used
	// If the configuration was invalid, then this does not get changed

	ks_log(KS_LOG_DEBUG, "Configured\n");

	return KS_STATUS_SUCCESS;
}

ks_status_t blade_module_chat_on_startup(blade_module_t *bm, config_setting_t *config)
{
	blade_module_chat_t *bm_chat = NULL;
	blade_space_t *space = NULL;
	blade_method_t *method = NULL;

	ks_assert(bm);
	ks_assert(config);

	bm_chat = (blade_module_chat_t *)blade_module_data_get(bm);

	if (blade_module_chat_config(bm_chat, config) != KS_STATUS_SUCCESS) {
		ks_log(KS_LOG_DEBUG, "blade_module_chat_config failed\n");
		return KS_STATUS_FAIL;
	}

	blade_space_create(&space, bm_chat->handle, bm, "blade.chat");
	ks_assert(space);

	bm_chat->blade_chat_space = space;

	blade_method_create(&method, space, "join", blade_chat_join_request_handler);
	ks_assert(method);
	blade_space_methods_add(space, method);

	blade_method_create(&method, space, "leave", blade_chat_leave_request_handler);
	ks_assert(method);
	blade_space_methods_add(space, method);

	blade_method_create(&method, space, "send", blade_chat_send_request_handler);
	ks_assert(method);
	blade_space_methods_add(space, method);

	blade_handle_space_register(space);

	blade_handle_session_state_callback_register(blade_module_handle_get(bm), bm, blade_module_chat_on_session_state, &bm_chat->session_state_callback_id);

	ks_log(KS_LOG_DEBUG, "Started\n");

	return KS_STATUS_SUCCESS;
}

ks_status_t blade_module_chat_on_shutdown(blade_module_t *bm)
{
	blade_module_chat_t *bm_chat = NULL;

	ks_assert(bm);

	bm_chat = (blade_module_chat_t *)blade_module_data_get(bm);
	ks_assert(bm_chat);

	if (bm_chat->session_state_callback_id)	blade_handle_session_state_callback_unregister(blade_module_handle_get(bm), bm_chat->session_state_callback_id);
	bm_chat->session_state_callback_id = NULL;

	if (bm_chat->blade_chat_space) blade_handle_space_unregister(bm_chat->blade_chat_space);

	ks_log(KS_LOG_DEBUG, "Stopped\n");

	return KS_STATUS_SUCCESS;
}

void blade_module_chat_on_session_state(blade_session_t *bs, blade_session_state_condition_t condition, void *data)
{
	blade_module_t *bm = NULL;
	blade_module_chat_t *bm_chat = NULL;

	ks_assert(bs);
	ks_assert(data);

	bm = (blade_module_t *)data;
	bm_chat = (blade_module_chat_t *)blade_module_data_get(bm);
	ks_assert(bm_chat);

	if (blade_session_state_get(bs) == BLADE_SESSION_STATE_HANGUP && condition == BLADE_SESSION_STATE_CONDITION_PRE) {
		cJSON *props = NULL;

		ks_log(KS_LOG_DEBUG, "Removing session from chat participants if present\n");

		props = blade_session_properties_get(bs);
		ks_assert(props);

		cJSON_DeleteItemFromObject(props, "blade.chat.participant");

		ks_list_delete(bm_chat->participants, blade_session_id_get(bs)); // @todo make copy of session id instead and search manually, also free the id
	}
}

ks_bool_t blade_chat_join_request_handler(blade_module_t *bm, blade_request_t *breq)
{
	blade_module_chat_t *bm_chat = NULL;
	blade_session_t *bs = NULL;
	cJSON *res = NULL;
	cJSON *props = NULL;
	cJSON *props_participant = NULL;

	ks_assert(bm);
	ks_assert(breq);

	ks_log(KS_LOG_DEBUG, "Request Received!\n");

	bm_chat = (blade_module_chat_t *)blade_module_data_get(bm);
	ks_assert(bm_chat);

	bs = blade_handle_sessions_get(breq->handle, breq->session_id);
	ks_assert(bs);

	// @todo properties only used to demonstrate a flexible container for session data, should just rely on the participants list/hash
	blade_session_properties_write_lock(bs, KS_TRUE);

	props = blade_session_properties_get(bs);
	ks_assert(props);

	props_participant = cJSON_GetObjectItem(props, "blade.chat.participant");
	if (props_participant && props_participant->type == cJSON_True) {
		ks_log(KS_LOG_DEBUG, "Session (%s) attempted to join chat but is already a participant\n", blade_session_id_get(bs));
		blade_rpc_error_create(&res, NULL, breq->message_id, -10000, "Already a participant of chat");
	}
	else {
		ks_log(KS_LOG_DEBUG, "Session (%s) joined chat\n", blade_session_id_get(bs));

		if (props_participant) props_participant->type = cJSON_True;
		else cJSON_AddTrueToObject(props, "blade.chat.participant");

		ks_list_append(bm_chat->participants, blade_session_id_get(bs)); // @todo make copy of session id instead and cleanup when removed

		blade_rpc_response_create(&res, NULL, breq->message_id);

		// @todo create an event to send to participants when a session joins and leaves, send after main response though
	}

	blade_session_properties_write_unlock(bs);

	blade_session_send(bs, res, NULL);

	blade_session_read_unlock(bs);

	cJSON_Delete(res);

	return KS_FALSE;
}

ks_bool_t blade_chat_leave_request_handler(blade_module_t *bm, blade_request_t *breq)
{
	blade_module_chat_t *bm_chat = NULL;
	blade_session_t *bs = NULL;
	cJSON *res = NULL;
	cJSON *props = NULL;
	cJSON *props_participant = NULL;

	ks_assert(bm);
	ks_assert(breq);

	ks_log(KS_LOG_DEBUG, "Request Received!\n");

	bm_chat = (blade_module_chat_t *)blade_module_data_get(bm);
	ks_assert(bm_chat);

	bs = blade_handle_sessions_get(breq->handle, breq->session_id);
	ks_assert(bs);

	blade_session_properties_write_lock(bs, KS_TRUE);

	props = blade_session_properties_get(bs);
	ks_assert(props);

	props_participant = cJSON_GetObjectItem(props, "blade.chat.participant");
	if (!props_participant || props_participant->type == cJSON_False) {
		ks_log(KS_LOG_DEBUG, "Session (%s) attempted to leave chat but is not a participant\n", blade_session_id_get(bs));
		blade_rpc_error_create(&res, NULL, breq->message_id, -10000, "Not a participant of chat");
	}
	else {
		ks_log(KS_LOG_DEBUG, "Session (%s) left chat\n", blade_session_id_get(bs));

		cJSON_DeleteItemFromObject(props, "blade.chat.participant");

		ks_list_delete(bm_chat->participants, blade_session_id_get(bs)); // @todo make copy of session id instead and search manually, also free the id

		blade_rpc_response_create(&res, NULL, breq->message_id);

		// @todo create an event to send to participants when a session joins and leaves, send after main response though
	}

	blade_session_properties_write_unlock(bs);

	blade_session_send(bs, res, NULL);

	blade_session_read_unlock(bs);

	cJSON_Delete(res);

	return KS_FALSE;
}

ks_bool_t blade_chat_send_request_handler(blade_module_t *bm, blade_request_t *breq)
{
	blade_module_chat_t *bm_chat = NULL;
	blade_session_t *bs = NULL;
	cJSON *params = NULL;
	cJSON *res = NULL;
	cJSON *event = NULL;
	const char *message = NULL;
	ks_bool_t sendevent = KS_FALSE;

	ks_assert(bm);
	ks_assert(breq);

	ks_log(KS_LOG_DEBUG, "Request Received!\n");

	bm_chat = (blade_module_chat_t *)blade_module_data_get(bm);
	ks_assert(bm_chat);

	params = cJSON_GetObjectItem(breq->message, "params"); // @todo cache this in blade_request_t for quicker/easier access
	if (!params) {
		ks_log(KS_LOG_DEBUG, "Session (%s) attempted to send chat message with no 'params' object\n", blade_session_id_get(bs));
		blade_rpc_error_create(&res, NULL, breq->message_id, -32602, "Missing params object");
	}
	else if (!(message = cJSON_GetObjectCstr(params, "message"))) {
		ks_log(KS_LOG_DEBUG, "Session (%s) attempted to send chat message with no 'message'\n", blade_session_id_get(bs));
		blade_rpc_error_create(&res, NULL, breq->message_id, -32602, "Missing params message string");
	}

	bs = blade_handle_sessions_get(breq->handle, breq->session_id);
	ks_assert(bs);

	if (!res) {
		blade_rpc_response_create(&res, NULL, breq->message_id);
		sendevent = KS_TRUE;
	}
	blade_session_send(bs, res, NULL);

	blade_session_read_unlock(bs);

	cJSON_Delete(res);

	if (sendevent) {
		blade_rpc_event_create(&event, &res, "blade.chat.message");
		ks_assert(event);
		cJSON_AddStringToObject(res, "from", breq->session_id); // @todo should really be the identity, but we don't have that in place yet
		cJSON_AddStringToObject(res, "message", message);

		blade_handle_sessions_send(breq->handle, bm_chat->participants, NULL, event);

		cJSON_Delete(event);
	}

	return KS_FALSE;
}


/* For Emacs:
* Local Variables:
* mode:c
* indent-tabs-mode:t
* tab-width:4
* c-basic-offset:4
* End:
* For VIM:
* vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet:
*/