/*
 * This file is part of LEM, a Lua Event Machine.
 * Copyright 2013 Asbjørn Sloth Tønnesen
-- Copyright 2013 Emil Renner Berthing
 *
 * LEM is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of
 * the License, or (at your option) any later version.
 *
 * LEM 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with LEM.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <lem.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <assert.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

struct signal_mapping {
	const char *name;
	uint8_t	no;
};

/* Several signal numbers are architecture-dependent,
 * therefore we need a lookup table on the C-side */
#define ARRAYLEN(a) (sizeof(a)/sizeof((a)[0]))
#define _(sig) { #sig, SIG ## sig }
static struct signal_mapping sigmap[] = {
	_(HUP), _(INT), _(USR1), _(USR2),
	_(QUIT), _(ILL), _(TRAP), _(ABRT),
	_(BUS), _(FPE), _(SEGV), _(PIPE),
	_(ALRM), _(TERM), _(CONT), _(CHLD),
	_(TSTP), _(TTIN), _(TTOU), _(PWR),
	_(PROF), _(SYS), _(URG), _(VTALRM),
	_(XCPU), _(XFSZ), _(WINCH)
};
#undef _

#if EV_SIGNAL_ENABLE
struct sigwatcher {
	struct sigwatcher *next;
	struct ev_signal w;
};

static sigset_t signal_sigset;
static struct sigwatcher *signal_watchers;

static void
signal_os_handler(EV_P_ struct ev_signal *w, int revents)
{
	lua_State *S;

	(void)revents;

	S = lem_newthread();
	lua_pushlightuserdata(S, &sigmap);
	lua_rawget(S, LUA_REGISTRYINDEX);
	if (lua_type(S, 1) != LUA_TFUNCTION) {
		lem_forgetthread(S);
		return;
	}

	lua_pushinteger(S, w->signum);
	lem_queue(S, 1);
}

static int
signal_os_watch(lua_State *T, int sig)
{
	struct sigwatcher *s;

	if (sigismember(&signal_sigset, sig))
		goto out; /* already watched */

	s = lem_xmalloc(sizeof(struct sigwatcher));

	ev_signal_init(&s->w, signal_os_handler, sig);
	ev_set_priority(&s->w, EV_MAXPRI);
	ev_signal_start(LEM_ &s->w);
	ev_unref(LEM); /* watcher shouldn't keep loop alive */

	sigaddset(&signal_sigset, sig);
	pthread_sigmask(SIG_UNBLOCK, &signal_sigset, NULL);

	s->next = signal_watchers;
	signal_watchers = s;
out:
	lua_pushboolean(T, 1);
	return 1;
}

static int
signal_os_unwatch(lua_State *T, int sig)
{
	struct sigwatcher **prevp;
	struct sigwatcher *s;

	for (prevp = &signal_watchers, s = signal_watchers;
			s != NULL;
			prevp = &s->next, s = s->next) {
		if (s->w.signum == sig)
			break;
	}
	if (s != NULL) {
		ev_ref(LEM);
		ev_signal_stop(LEM_ &s->w);

		sigdelset(&signal_sigset, sig);

		*prevp = s->next;
		free(s);
	}
	lua_pushboolean(T, 1);
	return 1;
}
#else /* EV_SIGNAL_ENABLE */
static int
signal_os_unsupported(lua_State *T)
{
	lua_pushnil(T);
	lua_pushliteral(T, "Your libev is compiled without signal support.");
	return 2
}

static inline int
signal_os_watch(lua_State *T)
{
	return signal_os_unsupported(T);
}

static inline int
signal_os_unwatch(lua_State *T)
{
	return signal_os_unsupported(T);
}
#endif

#if EV_CHILD_ENABLE
static struct ev_child signal_child_watcher;

static void
signal_child_handler(EV_P_ struct ev_child *w, int revents)
{
	lua_State *S;
	int status;

	(void)revents;


	S = lem_newthread();

	lua_pushlightuserdata(S, &sigmap);
	lua_rawget(S, LUA_REGISTRYINDEX);
	if (lua_type(S, 1) != LUA_TFUNCTION) {
		lem_forgetthread(S);
		return;
	}
	lua_pushinteger(S, SIGCHLD);

	status = w->rstatus;
	lua_createtable(S, 0, 3);

	if (WIFEXITED(status)) {
		lua_pushinteger(S, WEXITSTATUS(status));
		lua_setfield(S, -2, "status");
		lua_pushstring(S, "exited");
	} else if (WIFSIGNALED(status)) {
		lua_pushinteger(S, WTERMSIG(status));
		lua_setfield(S, -2, "signal");
#ifdef WCOREDUMP
		lua_pushboolean(S, WCOREDUMP(status));
		lua_setfield(S, -2, "coredumped");
#endif
		lua_pushstring(S, "signaled");
	} else if (WIFSTOPPED(status)) {
		lua_pushinteger(S, WSTOPSIG(status));
		lua_setfield(S, -2, "signal");
		lua_pushstring(S, "stopped");
	} else if (WIFCONTINUED(status)) {
		lua_pushstring(S, "continued");
	} else {
		assert(0); /* XXX do something more graceful */
	}
	lua_setfield(S, -2, "type");

	lem_queue(S, 2);
}

static int
signal_child_watch(lua_State *T)
{
	if (!ev_is_active(&signal_child_watcher)) {
		ev_child_start(LEM_ &signal_child_watcher);
		ev_unref(LEM); /* watcher shouldn't keep loop alive */
	}
	lua_pushboolean(T, 1);
	return 1;
}

static int
signal_child_unwatch(lua_State *T)
{
	if (ev_is_active(&signal_child_watcher)) {
		ev_ref(LEM);
		ev_child_stop(LEM_ &signal_child_watcher);
	}
	lua_pushboolean(T, 1);
	return 1;
}
#else /* EV_CHILD_ENABLE */
static int
signal_child_unsupported(lua_State *T)
{
	lua_pushnil(T);
	lua_pushliteral(T, "Your libev is compiled without child support.");
	return 2
}

static inline int
signal_child_watch(lua_State *T)
{
	return signal_child_unsupported(T);
}

static inline int
signal_child_unwatch(lua_State *T)
{
	return signal_child_unsupported(T);
}
#endif

static int
signal_tonumber(lua_State *T)
{
	const char *needle = luaL_checkstring(T, 1);

	unsigned int i;

	for (i = 0; i < ARRAYLEN(sigmap); i++) {
		struct signal_mapping *sig = &sigmap[i];
		if (strcmp(sig->name, needle) == 0) {
			lua_pushinteger(T, sig->no);
			return 1;
		}
	}
	lua_pushnil(T);
	return 1;
}

static int
signal_tostring(lua_State *T)
{
	int needle = luaL_checkint(T, 1);

	unsigned int i;

	for (i = 0; i < ARRAYLEN(sigmap); i++) {
		struct signal_mapping *sig = &sigmap[i];
		if (sig->no == needle) {
			lua_pushstring(T, sig->name);
			return 1;
		}
	}
	lua_pushnil(T);
	return 1;
}

static int
signal_sethandler(lua_State *T)
{
	int type;

	if (lua_gettop(T) < 1)
		lua_pushnil(T);

	type = lua_type(T, 1);
	if (type != LUA_TNIL && type != LUA_TFUNCTION)
		return luaL_argerror(T, 1, "expected nil or a function");

	lua_settop(T, 1);
	lua_pushlightuserdata(T, &sigmap);
	lua_insert(T, 1);
	lua_rawset(T, LUA_REGISTRYINDEX);
	return 0;
}

static int
signal_watch(lua_State *T)
{
	int sig = luaL_checkint(T, 1);

	lua_settop(T, 1);
	lua_pushlightuserdata(T, &sigmap);
	lua_rawget(T, LUA_REGISTRYINDEX);
	if (lua_isnil(T, 2))
		return luaL_error(T, "You must set a signal handler first");

	if (sig == SIGCHLD)
		return signal_child_watch(T);

	return signal_os_watch(T, sig);
}

static int
signal_unwatch(lua_State *T)
{
	int sig = luaL_checkint(T, 1);

	if (sig == SIGCHLD)
		return signal_child_unwatch(T);

	return signal_os_unwatch(T, sig);
}

int
luaopen_lem_signal_core(lua_State *T)
{
#if EV_CHILD_ENABLE
	ev_child_init(&signal_child_watcher, signal_child_handler, 0, 1);
#endif

#if EV_SIGNAL_ENABLE
	sigemptyset(&signal_sigset);
	/* signal_watchers = NULL; globals are zero initalized */
#endif

	/* create module table */
	lua_newtable(T);

	/* set tonumber function */
	lua_pushcfunction(T, signal_tonumber);
	lua_setfield(T, -2, "tonumber");
	/* set tostring function */
	lua_pushcfunction(T, signal_tostring);
	lua_setfield(T, -2, "tostring");
	/* set sethandler function */
	lua_pushcfunction(T, signal_sethandler);
	lua_setfield(T, -2, "sethandler");
	/* set watch function */
	lua_pushcfunction(T, signal_watch);
	lua_setfield(T, -2, "watch");
	/* set unwatch function */
	lua_pushcfunction(T, signal_unwatch);
	lua_setfield(T, -2, "unwatch");

	return 1;
}