/**
 * \file
 */

#if defined(HAVE_KQUEUE)

#include <sys/types.h>
#include <sys/event.h>
#include <sys/time.h>

#if defined(HOST_WIN32)
/* We assume that kqueue is not available on windows */
#error
#endif

#define KQUEUE_NEVENTS 128

static gint kqueue_fd;
static struct kevent *kqueue_events;

static gint
KQUEUE_INIT_FD (gint fd, gint events, gint flags)
{
	struct kevent event;
	EV_SET (&event, fd, events, flags, 0, 0, 0);
	return kevent (kqueue_fd, &event, 1, NULL, 0, NULL);
}

static gboolean
kqueue_init (gint wakeup_pipe_fd)
{
	kqueue_fd = kqueue ();
	if (kqueue_fd == -1) {
		g_error ("kqueue_init: kqueue () failed, error (%d) %s", errno, g_strerror (errno));
		return FALSE;
	}

	if (KQUEUE_INIT_FD (wakeup_pipe_fd, EVFILT_READ, EV_ADD | EV_ENABLE) == -1) {
		g_error ("kqueue_init: kevent () failed, error (%d) %s", errno, g_strerror (errno));
		close (kqueue_fd);
		return FALSE;
	}

	kqueue_events = g_new0 (struct kevent, KQUEUE_NEVENTS);

	return TRUE;
}

static void
kqueue_register_fd (gint fd, gint events, gboolean is_new)
{
	if (events & EVENT_IN) {
		if (KQUEUE_INIT_FD (fd, EVFILT_READ, EV_ADD | EV_ENABLE) == -1)
			g_error ("kqueue_register_fd: kevent(read,enable) failed, error (%d) %s", errno, g_strerror (errno));
	} else {
		if (KQUEUE_INIT_FD (fd, EVFILT_READ, EV_ADD | EV_DISABLE) == -1)
			g_error ("kqueue_register_fd: kevent(read,disable) failed, error (%d) %s", errno, g_strerror (errno));
	}
	if (events & EVENT_OUT) {
		if (KQUEUE_INIT_FD (fd, EVFILT_WRITE, EV_ADD | EV_ENABLE) == -1)
			g_error ("kqueue_register_fd: kevent(write,enable) failed, error (%d) %s", errno, g_strerror (errno));
	} else {
		if (KQUEUE_INIT_FD (fd, EVFILT_WRITE, EV_ADD | EV_DISABLE) == -1)
			g_error ("kqueue_register_fd: kevent(write,disable) failed, error (%d) %s", errno, g_strerror (errno));
	}
}

static void
kqueue_remove_fd (gint fd)
{
	/* FIXME: a race between closing and adding operation in the Socket managed code trigger a ENOENT error */
	if (KQUEUE_INIT_FD (fd, EVFILT_READ, EV_DELETE) == -1)
		g_error ("kqueue_register_fd: kevent(read,delete) failed, error (%d) %s", errno, g_strerror (errno));
	if (KQUEUE_INIT_FD (fd, EVFILT_WRITE, EV_DELETE) == -1)
		g_error ("kqueue_register_fd: kevent(write,delete) failed, error (%d) %s", errno, g_strerror (errno));
}

static gint
kqueue_event_wait (void (*callback) (gint fd, gint events, gpointer user_data), gpointer user_data)
{
	gint i, ready;

	memset (kqueue_events, 0, sizeof (struct kevent) * KQUEUE_NEVENTS);

	mono_gc_set_skip_thread (TRUE);

	MONO_ENTER_GC_SAFE;
	ready = kevent (kqueue_fd, NULL, 0, kqueue_events, KQUEUE_NEVENTS, NULL);
	MONO_EXIT_GC_SAFE;

	mono_gc_set_skip_thread (FALSE);

	if (ready == -1) {
		switch (errno) {
		case EINTR:
			ready = 0;
			break;
		default:
			g_error ("kqueue_event_wait: kevent () failed, error (%d) %s", errno, g_strerror (errno));
			break;
		}
	}

	if (ready == -1)
		return -1;

	for (i = 0; i < ready; ++i) {
		gint fd, events = 0;

		fd = kqueue_events [i].ident;
		if (kqueue_events [i].filter == EVFILT_READ || (kqueue_events [i].flags & EV_ERROR) != 0)
			events |= EVENT_IN;
		if (kqueue_events [i].filter == EVFILT_WRITE || (kqueue_events [i].flags & EV_ERROR) != 0)
			events |= EVENT_OUT;

		callback (fd, events, user_data);
	}

	return 0;
}

static ThreadPoolIOBackend backend_kqueue = {
	.init = kqueue_init,
	.register_fd = kqueue_register_fd,
	.remove_fd = kqueue_remove_fd,
	.event_wait = kqueue_event_wait,
};

#endif