/*
 * Copyright (C) 2022 Jo-Philipp Wich <jo@mein.io>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/**
 * # OpenWrt uloop event loop
 *
 * The `uloop` binding provides functions for integrating with the OpenWrt
 * {@link https://github.com/openwrt/libubox/blob/master/uloop.h uloop library}.
 *
 * Functions can be individually imported and directly accessed using the
 * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#named_import named import}
 * syntax:
 *
 *   ```javascript
 *   import { init, handle, timer, interval, process, signal, task, run } from 'uloop';
 *
 *   init();
 *
 *   handle(…);
 *   timer(…);
 *   interval(…);
 *   process(…);
 *   signal(…);
 *   task(…);
 *
 *   run();
 *   ```
 *
 * Alternatively, the module namespace can be imported using a wildcard import
 * statement:
 *
 *   ```javascript
 *   import * as uloop from 'uloop';
 *
 *   uloop.init();
 *
 *   uloop.handle(…);
 *   uloop.timer(…);
 *   uloop.interval(…);
 *   uloop.process(…);
 *   uloop.signal(…);
 *   uloop.task(…);
 *
 *   uloop.run();
 *   ```
 *
 * Additionally, the uloop binding namespace may also be imported by invoking
 * the `ucode` interpreter with the `-luloop` switch.
 *
 * @module uloop
 */

#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>
#include <fcntl.h>

#include <libubox/uloop.h>

#include "ucode/module.h"
#include "ucode/platform.h"

#define ok_return(expr) do { last_error = 0; return (expr); } while(0)
#define err_return(err) do { last_error = err; return NULL; } while(0)

static uc_resource_type_t *timer_type, *handle_type, *process_type, *task_type, *pipe_type;

#ifdef HAVE_ULOOP_INTERVAL
static uc_resource_type_t *interval_type;
#endif

#ifdef HAVE_ULOOP_SIGNAL
static uc_resource_type_t *signal_type;
#endif

static uc_value_t *object_registry;

static int last_error = 0;

static size_t
uc_uloop_reg_add(uc_value_t *obj, uc_value_t *cb)
{
	size_t i = 0;

	while (ucv_array_get(object_registry, i))
		i += 2;

	ucv_array_set(object_registry, i + 0, ucv_get(obj));
	ucv_array_set(object_registry, i + 1, ucv_get(cb));

	return i;
}

static bool
uc_uloop_reg_remove(size_t i)
{
	if (i + 1 >= ucv_array_length(object_registry))
		return false;

	ucv_array_set(object_registry, i + 0, NULL);
	ucv_array_set(object_registry, i + 1, NULL);

	return true;
}

static bool
uc_uloop_reg_invoke(uc_vm_t *vm, size_t i, uc_value_t *arg)
{
	uc_value_t *obj = ucv_array_get(object_registry, i + 0);
	uc_value_t *cb = ucv_array_get(object_registry, i + 1);

	if (!ucv_is_callable(cb))
		return false;

	uc_vm_stack_push(vm, ucv_get(obj));
	uc_vm_stack_push(vm, ucv_get(cb));
	uc_vm_stack_push(vm, ucv_get(arg));

	if (uc_vm_call(vm, true, 1) != EXCEPTION_NONE) {
		uloop_end();

		return false;
	}

	ucv_put(uc_vm_stack_pop(vm));

	return true;
}

/**
 * Retrieves the last error message.
 *
 * This function retrieves the last error message generated by the uloop event loop.
 * If no error occurred, it returns `null`.
 *
 * @function module:uloop#error
 *
 * @returns {?string}
 * Returns the last error message as a string, or `null` if no error occurred.
 *
 * @example
 * // Retrieve the last error message
 * const errorMessage = uloop.error();
 *
 * if (errorMessage)
 *     printf(`Error message: ${errorMessage}\n`);
 * else
 *     printf("No error occurred\n");
 */
static uc_value_t *
uc_uloop_error(uc_vm_t *vm, size_t nargs)
{
	uc_value_t *errmsg;

	if (last_error == 0)
		return NULL;

	errmsg = ucv_string_new(strerror(last_error));
	last_error = 0;

	return errmsg;
}

/**
 * Initializes the uloop event loop.
 *
 * This function initializes the uloop event loop, allowing subsequent
 * usage of uloop functionalities. It takes no arguments.
 *
 * Returns `true` on success.
 * Returns `null` if an error occurred during initialization.
 *
 * @function module:uloop#init
 *
 * @returns {?boolean}
 * Returns `true` on success, `null` on error.
 *
 * @example
 * // Initialize the uloop event loop
 * const success = uloop.init();
 *
 * if (success)
 *     printf("uloop event loop initialized successfully\n");
 * else
 *     die(`Initialization failure: ${uloop.error()}\n`);
 */
static uc_value_t *
uc_uloop_init(uc_vm_t *vm, size_t nargs)
{
	int rv = uloop_init();

	if (rv == -1)
		err_return(errno);

	ok_return(ucv_boolean_new(true));
}

/**
 * Runs the uloop event loop.
 *
 * This function starts running the uloop event loop, allowing it to handle
 * scheduled events and callbacks. If a timeout value is provided and is
 * non-negative, the event loop will run for that amount of milliseconds
 * before returning. If the timeout is omitted or negative, the event loop
 * runs indefinitely until explicitly stopped.
 *
 * @function module:uloop#run
 *
 * @param {number} [timeout=-1]
 * Optional. The timeout value in milliseconds for running the event loop.
 * Defaults to -1, indicating an indefinite run.
 *
 * @returns {?boolean}
 * Returns `true` on success, `null` on error.
 *
 * @example
 * // Run the uloop event loop indefinitely
 * const success = uloop.run();
 * if (success)
 *     printf("uloop event loop ran successfully\n");
 * else
 *     die(`Error occurred during uloop execution: ${uloop.error()}\n`);
 *
 * // Run the uloop event loop for 1000 milliseconds
 * const success = uloop.run(1000);
 * if (success)
 *     printf("uloop event loop ran successfully\n");
 * else
 *     die(`Error occurred during uloop execution: ${uloop.error()}\n`);
 */
static uc_value_t *
uc_uloop_run(uc_vm_t *vm, size_t nargs)
{
	uc_value_t *timeout = uc_fn_arg(0);
	int t, rv;

	errno = 0;
	t = timeout ? (int)ucv_int64_get(timeout) : -1;

	if (errno)
		err_return(errno);

	rv = uloop_run_timeout(t);

	ok_return(ucv_int64_new(rv));
}

/**
 * Checks if the uloop event loop is currently shutting down.
 *
 * This function checks whether the uloop event loop is currently in the process
 * of shutting down.
 *
 * @function module:uloop#cancelling
 *
 * @returns {boolean}
 * Returns `true` if uloop is currently shutting down, `false` otherwise.
 *
 * @example
 * // Check if the uloop event loop is shutting down
 * const shuttingDown = uloop.cancelling();
 * if (shuttingDown)
 *     printf("uloop event loop is currently shutting down\n");
 * else
 *     printf("uloop event loop is not shutting down\n");
 */
static uc_value_t *
uc_uloop_cancelling(uc_vm_t *vm, size_t nargs)
{
	ok_return(ucv_boolean_new(uloop_cancelling()));
}

/**
 * Checks if the uloop event loop is currently running.
 *
 * This function checks whether the uloop event loop is currently started
 * and running.
 *
 * @function module:uloop#running
 *
 * @returns {boolean}
 * Returns `true` if the event loop is currently running, `false` otherwise.
 *
 * @example
 * // Check if the uloop event loop is running
 * const isRunning = uloop.running();
 * if (isRunning)
 *     printf("uloop event loop is currently running\n");
 * else
 *     printf("uloop event loop is not running\n");
 */
static uc_value_t *
uc_uloop_running(uc_vm_t *vm, size_t nargs)
{
	bool prev = uloop_cancelled;
	bool active;

	uloop_cancelled = true;
	active = uloop_cancelling();
	uloop_cancelled = prev;

	ok_return(ucv_boolean_new(active));
}

/**
 * Halts the uloop event loop.
 *
 * This function halts the uloop event loop, stopping its execution and
 * preventing further processing of scheduled events and callbacks.
 *
 * Expired timeouts and already queued event callbacks are still run to
 * completion.
 *
 * @function module:uloop#end
 *
 * @returns {void}
 * This function does not return any value.
 *
 * @example
 * // Halt the uloop event loop
 * uloop.end();
 */
static uc_value_t *
uc_uloop_end(uc_vm_t *vm, size_t nargs)
{
	uloop_end();

	ok_return(NULL);
}

/**
 * Stops the uloop event loop and cancels pending timeouts and events.
 *
 * This function immediately stops the uloop event loop, cancels all pending
 * timeouts and events, unregisters all handles, and deallocates associated
 * resources.
 *
 * @function module:uloop#done
 *
 * @returns {void}
 * This function does not return any value.
 *
 * @example
 * // Stop the uloop event loop and clean up resources
 * uloop.done();
 */
static uc_value_t *
uc_uloop_done(uc_vm_t *vm, size_t nargs)
{
	uloop_done();

	ok_return(NULL);
}


/**
 * Represents a uloop timer instance as returned by
 * {@link module:uloop#timer|timer()}.
 *
 * @class module:uloop.timer
 * @hideconstructor
 *
 * @see {@link module:uloop#timer|timer()}
 *
 * @example
 *
 * const timeout = uloop.timer(…);
 *
 * timeout.set(…);
 * timeout.remaining();
 * timeout.cancel();
 */
typedef struct {
	struct uloop_timeout timeout;
	size_t registry_index;
	uc_vm_t *vm;
} uc_uloop_timer_t;

static void
uc_uloop_timeout_clear(uc_uloop_timer_t **timer)
{
	/* drop registry entries and clear data to prevent reuse */
	uc_uloop_reg_remove((*timer)->registry_index);
	free(*timer);
	*timer = NULL;
}

/**
 * Rearms the uloop timer with the specified timeout.
 *
 * This method rearms the uloop timer with the specified timeout value,
 * allowing it to trigger after the specified amount of time. If no timeout
 * value is provided or if the provided value is negative, the timer remains
 * disabled until rearmed with a positive timeout value.
 *
 * @function module:uloop.timer#set
 *
 * @param {number} [timeout=-1]
 * Optional. The timeout value in milliseconds until the timer expires.
 * Defaults to -1, which disables the timer until rearmed with a positive timeout.
 *
 * @returns {?boolean}
 * Returns `true` on success, `null` on error, such as an invalid timeout argument.
 *
 * @example
 * const timeout = uloop.timer(…);
 *
 * // Rearm the uloop timer with a timeout of 1000 milliseconds
 * timeout.set(1000);
 *
 * // Disable the uloop timer
 * timeout.set();
 */
static uc_value_t *
uc_uloop_timer_set(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_timer_t **timer = uc_fn_this("uloop.timer");
	uc_value_t *timeout = uc_fn_arg(0);
	int t, rv;

	if (!timer || !*timer)
		err_return(EINVAL);

	errno = 0;
	t = timeout ? (int)ucv_int64_get(timeout) : -1;

	if (errno)
		err_return(errno);

	rv = uloop_timeout_set(&(*timer)->timeout, t);

	ok_return(ucv_boolean_new(rv == 0));
}

/**
 * Returns the number of milliseconds until the uloop timer expires.
 *
 * This method returns the remaining time until the uloop timer expires. If
 * the timer is not armed (i.e., disabled), it returns -1.
 *
 * @function module:uloop.timer#remaining
 *
 * @returns {number}
 * The number of milliseconds until the timer expires, or -1 if the timer is not armed.
 *
 * @example
 * // Get the remaining time until the uloop timer expires (~500ms)
 * const remainingTime = timer.remaining();
 * if (remainingTime !== -1)
 *     printf("Time remaining until timer expires: %d ms\n", remainingTime);
 * else
 *     printf("Timer is not armed\n");
 */
static uc_value_t *
uc_uloop_timer_remaining(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_timer_t **timer = uc_fn_this("uloop.timer");
	int64_t rem;

	if (!timer || !*timer)
		err_return(EINVAL);

#ifdef HAVE_ULOOP_TIMEOUT_REMAINING64
	rem = uloop_timeout_remaining64(&(*timer)->timeout);
#else
	rem = (int64_t)uloop_timeout_remaining(&(*timer)->timeout);
#endif

	ok_return(ucv_int64_new(rem));
}

/**
 * Cancels the uloop timer, disarming it and removing it from the event loop.
 *
 * This method destroys the uloop timer and releases its associated resources.
 *
 * @function module:uloop.timer#cancel
 *
 * @returns {boolean}
 * Returns `true` on success.
 *
 * @example
 * // Cancel the uloop timer
 * timer.cancel();
 */
static uc_value_t *
uc_uloop_timer_cancel(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_timer_t **timer = uc_fn_this("uloop.timer");
	int rv;

	if (!timer || !*timer)
		err_return(EINVAL);

	rv = uloop_timeout_cancel(&(*timer)->timeout);

	uc_uloop_timeout_clear(timer);

	ok_return(ucv_boolean_new(rv == 0));
}

static void
uc_uloop_timer_cb(struct uloop_timeout *timeout)
{
	uc_uloop_timer_t *timer = (uc_uloop_timer_t *)timeout;

	uc_uloop_reg_invoke(timer->vm, timer->registry_index, NULL);
}

/**
 * Creates a timer instance for scheduling callbacks.
 *
 * This function creates a timer instance for scheduling callbacks to be
 * executed after a specified timeout duration. It takes an optional timeout
 * parameter, which defaults to -1, indicating that the timer is initially not
 * armed and can be enabled later by invoking the `.set(timeout)` method on the
 * instance.
 *
 * A callback function must be provided to be executed when the timer expires.
 *
 * @function module:uloop#timer
 *
 * @param {number} [timeout=-1]
 * Optional. The timeout duration in milliseconds. Defaults to -1, indicating
 * the timer is not initially armed.
 *
 * @param {Function} callback
 * The callback function to be executed when the timer expires.
 *
 * @returns {?module:uloop.timer}
 * Returns a timer instance for scheduling callbacks.
 * Returns `null` when the timeout or callback arguments are invalid.
 *
 * @example
 * // Create a timer with a callback to be executed after 1000 milliseconds
 * const myTimer = uloop.timer(1000, () => {
 *     printf("Timer expired!\n");
 * });
 *
 * // Later enable the timer with a timeout of 500 milliseconds
 * myTimer.set(500);
 */
static uc_value_t *
uc_uloop_timer(uc_vm_t *vm, size_t nargs)
{
	uc_value_t *timeout = uc_fn_arg(0);
	uc_value_t *callback = uc_fn_arg(1);
	uc_uloop_timer_t *timer;
	uc_value_t *res;
	int t;

	errno = 0;
	t = timeout ? ucv_int64_get(timeout) : -1;

	if (errno)
		err_return(errno);

	if (!ucv_is_callable(callback))
		err_return(EINVAL);

	timer = xalloc(sizeof(*timer));
	timer->timeout.cb = uc_uloop_timer_cb;
	timer->vm = vm;

	if (t >= 0)
		uloop_timeout_set(&timer->timeout, t);

	res = uc_resource_new(timer_type, timer);

	timer->registry_index = uc_uloop_reg_add(res, callback);

	ok_return(res);
}


/**
 * Represents a uloop handle instance as returned by
 * {@link module:uloop#handle|handle()}.
 *
 * @class module:uloop.handle
 * @hideconstructor
 *
 * @see {@link module:uloop#handle|handle()}
 *
 * @example
 *
 * const handle = uloop.handle(…);
 *
 * handle.fileno();
 * handle.handle();
 *
 * handle.delete();
 */
typedef struct {
	struct uloop_fd fd;
	size_t registry_index;
	uc_value_t *handle;
	uc_vm_t *vm;
} uc_uloop_handle_t;

static void
uc_uloop_handle_clear(uc_uloop_handle_t **handle)
{
	/* drop registry entries and clear data to prevent reuse */
	uc_uloop_reg_remove((*handle)->registry_index);
	ucv_put((*handle)->handle);
	free(*handle);
	*handle = NULL;
}

/**
 * Returns the file descriptor number.
 *
 * This method returns the file descriptor number associated with the underlying
 * handle, which might refer to a socket or file instance.
 *
 * @function module:uloop.handle#fileno
 *
 * @returns {number}
 * The file descriptor number associated with the handle.
 *
 * @example
 * // Get the file descriptor number associated with the uloop handle
 * const fd = handle.fileno();
 * printf("File descriptor number: %d\n", fd);
 */
static uc_value_t *
uc_uloop_handle_fileno(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_handle_t **handle = uc_fn_this("uloop.handle");

	if (!handle || !*handle)
		err_return(EINVAL);

	ok_return(ucv_int64_new((*handle)->fd.fd));
}

/**
 * Returns the underlying file or socket instance.
 *
 * This method returns the underlying file or socket instance associated with
 * the uloop handle.
 *
 * @function module:uloop.handle#handle
 *
 * @returns {module:fs.file|module:fs.proc|module:socket.socket}
 * The underlying file or socket instance associated with the handle.
 *
 * @example
 * // Get the associated file or socket instance
 * const fileOrSocket = handle.handle();
 * printf("Handle: %s\n", fileOrSocket); // e.g. <socket 0x5> or <fs.proc …>
 */
static uc_value_t *
uc_uloop_handle_handle(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_handle_t **handle = uc_fn_this("uloop.handle");

	if (!handle || !*handle)
		err_return(EINVAL);

	ok_return(ucv_get((*handle)->handle));
}

/**
 * Unregisters the uloop handle.
 *
 * This method unregisters the uloop handle from the uloop event loop and frees
 * any associated resources. After calling this method, the handle instance
 * should no longer be used.
 *
 * @function module:uloop.handle#delete
 *
 * @returns {void}
 * This function does not return a value.
 *
 * @example
 * // Unregister the uloop handle and free associated resources
 * handle.delete();
 * printf("Handle deleted successfully\n");
 */
static uc_value_t *
uc_uloop_handle_delete(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_handle_t **handle = uc_fn_this("uloop.handle");
	int rv;

	if (!handle || !*handle)
		err_return(EINVAL);

	rv = uloop_fd_delete(&(*handle)->fd);

	uc_uloop_handle_clear(handle);

	if (rv != 0)
		err_return(errno);

	ok_return(ucv_boolean_new(true));
}

static void
uc_uloop_handle_cb(struct uloop_fd *fd, unsigned int flags)
{
	uc_uloop_handle_t *handle = (uc_uloop_handle_t *)fd;
	uc_value_t *f = ucv_uint64_new(flags);

	uc_uloop_reg_invoke(handle->vm, handle->registry_index, f);
	ucv_put(f);
}

static int
get_fd(uc_vm_t *vm, uc_value_t *val)
{
	uc_value_t *fn;
	int64_t n;
	int fd;

	fn = ucv_property_get(val, "fileno");

	if (ucv_is_callable(fn)) {
		uc_vm_stack_push(vm, ucv_get(val));
		uc_vm_stack_push(vm, ucv_get(fn));

		if (uc_vm_call(vm, true, 0) == EXCEPTION_NONE)  {
			val = uc_vm_stack_pop(vm);
		}
		else {
			errno = EBADF;
			val = NULL;
		}
	}
	else {
		ucv_get(val);
	}

	n = ucv_int64_get(val);

	if (errno) {
		fd = -1;
	}
	else if (n < 0 || n > (int64_t)INT_MAX) {
		errno = EBADF;
		fd = -1;
	}
	else {
		fd = (int)n;
	}

	ucv_put(val);

	return fd;
}

/**
 * Creates a handle instance for monitoring file descriptor events.
 *
 * This function creates a handle instance for monitoring events on a file
 * descriptor, file, or socket. It takes the file or socket handle, a callback
 * function to be invoked when the specified IO events occur, and bitwise OR-ed
 * flags of IO events (`ULOOP_READ`, `ULOOP_WRITE`) that the callback should be
 * invoked for.
 *
 * @function module:uloop#handle
 *
 * @param {number|module:fs.file|module:fs.proc|module:socket.socket} handle
 * The file handle (descriptor number, file or socket instance).
 *
 * @param {Function} callback
 * The callback function to be invoked when the specified IO events occur.
 *
 * @param {number} events
 * Bitwise OR-ed flags of IO events (`ULOOP_READ`, `ULOOP_WRITE`) that the
 * callback should be invoked for.
 *
 * @returns {?module:uloop.handle}
 * Returns a handle instance for monitoring file descriptor events.
 * Returns `null` when the handle, callback or signal arguments are invalid.
 *
 * @example
 * // Create a handle for monitoring read events on file descriptor 3
 * const myHandle = uloop.handle(3, (events) => {
 *     if (events & ULOOP_READ)
 *         printf("Read event occurred!\n");
 * }, uloop.ULOOP_READ);
 *
 * // Check socket for writability
 * const sock = socket.connect("example.org", 80);
 * uloop.handle(sock, (events) => {
 *     sock.send("GET / HTTP/1.0\r\n\r\n");
 * }, uloop.ULOOP_WRITE)
 */
static uc_value_t *
uc_uloop_handle(uc_vm_t *vm, size_t nargs)
{
	uc_value_t *fileno = uc_fn_arg(0);
	uc_value_t *callback = uc_fn_arg(1);
	uc_value_t *flags = uc_fn_arg(2);
	uc_uloop_handle_t *handle;
	uc_value_t *res;
	int fd, ret;
	uint64_t f;

	fd = get_fd(vm, fileno);

	if (fd == -1)
		err_return(errno);

	f = ucv_uint64_get(flags);

	if (errno)
		err_return(errno);

	if (f == 0 || f > (uint64_t)UINT_MAX)
		err_return(EINVAL);

	if (!ucv_is_callable(callback))
		err_return(EINVAL);

	handle = xalloc(sizeof(*handle));
	handle->fd.fd = fd;
	handle->fd.cb = uc_uloop_handle_cb;
	handle->handle = ucv_get(fileno);
	handle->vm = vm;

	ret = uloop_fd_add(&handle->fd, (unsigned int)f);

	if (ret != 0) {
		free(handle);
		err_return(errno);
	}

	res = uc_resource_new(handle_type, handle);

	handle->registry_index = uc_uloop_reg_add(res, callback);

	ok_return(res);
}


/**
 * Represents a uloop process instance as returned by
 * {@link module:uloop#process|process()}.
 *
 * @class module:uloop.process
 * @hideconstructor
 *
 * @see {@link module:uloop#process|process()}
 *
 * @example
 *
 * const proc = uloop.process(…);
 *
 * proc.pid();
 *
 * proc.delete();
 */
typedef struct {
	struct uloop_process process;
	size_t registry_index;
	uc_vm_t *vm;
} uc_uloop_process_t;

static void
uc_uloop_process_clear(uc_uloop_process_t **process)
{
	/* drop registry entries and clear data to prevent reuse */
	uc_uloop_reg_remove((*process)->registry_index);
	*process = NULL;
}

/**
 * Returns the process ID.
 *
 * This method returns the process ID (PID) of the operating system process
 * launched by {@link module:uloop#process|process().
 *
 * @function module:uloop.process#pid
 *
 * @returns {number}
 * The process ID (PID) of the associated launched process.
 *
 * @example
 * const proc = uloop.process(…);
 *
 * printf("Process ID: %d\n", proc.pid());
 */
static uc_value_t *
uc_uloop_process_pid(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_process_t **process = uc_fn_this("uloop.process");

	if (!process || !*process)
		err_return(EINVAL);

	ok_return(ucv_int64_new((*process)->process.pid));
}

/**
 * Unregisters the process from uloop.
 *
 * This method unregisters the process from the uloop event loop and releases
 * any associated resources. However, note that the operating system process
 * itself is not terminated by this method.
 *
 * @function module:uloop.process#delete
 *
 * @returns {boolean}
 * Returns `true` on success.
 *
 * @example
 * const proc = uloop.process(…);
 *
 * proc.delete();
 */
static uc_value_t *
uc_uloop_process_delete(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_process_t **process = uc_fn_this("uloop.process");
	int rv;

	if (!process || !*process)
		err_return(EINVAL);

	rv = uloop_process_delete(&(*process)->process);

	uc_uloop_process_clear(process);

	if (rv != 0)
		err_return(EINVAL);

	ok_return(ucv_boolean_new(true));
}

static void
uc_uloop_process_cb(struct uloop_process *proc, int exitcode)
{
	uc_uloop_process_t *process = (uc_uloop_process_t *)proc;
	uc_value_t *e = ucv_int64_new(exitcode >> 8);

	uc_uloop_reg_invoke(process->vm, process->registry_index, e);
	uc_uloop_process_clear(&process);
	ucv_put(e);
}

/**
 * Creates a process instance for executing external programs.
 *
 * This function creates a process instance for executing external programs.
 * It takes the executable path string, an optional string array as the argument
 * vector, an optional dictionary describing environment variables, and a
 * callback function to be invoked when the invoked process ends.
 *
 * @function module:uloop#process
 *
 * @param {string} executable
 * The path to the executable program.
 *
 * @param {string[]} [args]
 * Optional. An array of strings representing the arguments passed to the
 * executable.
 *
 * @param {Object<string, *>} [env]
 * Optional. A dictionary describing environment variables for the process.
 *
 * @param {Function} callback
 * The callback function to be invoked when the invoked process ends.
 *
 * @returns {?module:uloop.process}
 * Returns a process instance for executing external programs.
 * Returns `null` on error, e.g. due to `exec()` failure or invalid arguments.
 *
 * @example
 * // Create a process instance for executing 'ls' command
 * const myProcess = uloop.process("/bin/ls", ["-l", "/tmp"], null, (code) => {
 *     printf(`Process exited with code ${code}\n`);
 * });
 */
static uc_value_t *
uc_uloop_process(uc_vm_t *vm, size_t nargs)
{
	uc_value_t *executable = uc_fn_arg(0);
	uc_value_t *arguments = uc_fn_arg(1);
	uc_value_t *env_arg = uc_fn_arg(2);
	uc_value_t *callback = uc_fn_arg(3);
	uc_uloop_process_t *process;
	uc_stringbuf_t *buf;
	char **argp, **envp;
	uc_value_t *res;
	pid_t pid;
	size_t i;

	if (ucv_type(executable) != UC_STRING ||
	    (arguments && ucv_type(arguments) != UC_ARRAY) ||
	    (env_arg && ucv_type(env_arg) != UC_OBJECT) ||
	    !ucv_is_callable(callback)) {
		err_return(EINVAL);
	}

	pid = fork();

	if (pid == -1)
		err_return(errno);

	if (pid == 0) {
		argp = calloc(ucv_array_length(arguments) + 2, sizeof(char *));
		envp = calloc(ucv_object_length(env_arg) + 1, sizeof(char *));

		if (!argp || !envp)
			_exit(-1);

		argp[0] = ucv_to_string(vm, executable);

		for (i = 0; i < ucv_array_length(arguments); i++)
			argp[i+1] = ucv_to_string(vm, ucv_array_get(arguments, i));

		i = 0;

		ucv_object_foreach(env_arg, envk, envv) {
			buf = xprintbuf_new();

			ucv_stringbuf_printf(buf, "%s=", envk);
			ucv_to_stringbuf(vm, buf, envv, false);

			envp[i++] = buf->buf;

			free(buf);
		}

		execvpe((const char *)ucv_string_get(executable),
		        (char * const *)argp, (char * const *)envp);

		_exit(-1);
	}

	process = xalloc(sizeof(*process));
	process->process.pid = pid;
	process->process.cb = uc_uloop_process_cb;
	process->vm = vm;

	uloop_process_add(&process->process);

	res = uc_resource_new(process_type, process);

	process->registry_index = uc_uloop_reg_add(res, callback);

	ok_return(res);
}


static bool
readall(int fd, void *buf, size_t len)
{
	ssize_t rlen;

	while (len > 0) {
		rlen = read(fd, buf, len);

		if (rlen == -1) {
			if (errno == EINTR)
				continue;

			return false;
		}

		if (rlen == 0) {
			errno = EINTR;

			return false;
		}

		buf += rlen;
		len -= rlen;
	}

	return true;
}

static bool
writeall(int fd, void *buf, size_t len)
{
	ssize_t wlen;

	while (len > 0) {
		wlen = write(fd, buf, len);

		if (wlen == -1) {
			if (errno == EINTR)
				continue;

			return false;
		}

		buf += wlen;
		len -= wlen;
	}

	return true;
}


/**
 * Represents a uloop task communication pipe instance, passed as sole argument
 * to the task function by {@link module:uloop#task|task()}.
 *
 * @class module:uloop.pipe
 * @hideconstructor
 *
 * @see {@link module:uloop#task|task()}
 *
 * @example *
 * const task = uloop.task((pipe) => {
 *     …
 *     pipe.send();
 *     …
 *     pipe.receive();
 *     …
 * }, …);
 */
typedef struct {
	int input;
	int output;
	bool has_sender;
	bool has_receiver;
} uc_uloop_pipe_t;

static uc_value_t *
uc_uloop_pipe_send_common(uc_vm_t *vm, uc_value_t *msg, int fd)
{
	uc_stringbuf_t *buf;
	size_t len;
	bool rv;

	buf = xprintbuf_new();

	printbuf_memset(buf, 0, 0, sizeof(len));
	ucv_to_stringbuf(vm, buf, msg, true);

	len = printbuf_length(buf);
	memcpy(buf->buf, &len, sizeof(len));

	rv = writeall(fd, buf->buf, len);

	printbuf_free(buf);

	if (!rv)
		err_return(errno);

	ok_return(ucv_boolean_new(true));
}

/**
 * Sends a serialized message to the task handle.
 *
 * This method serializes the provided message and sends it over the task
 * communication pipe. In the main thread, the message is deserialized and
 * passed as an argument to the output callback function registered with the
 * task handle.
 *
 * @function module:uloop.pipe#send
 *
 * @param {*} msg
 * The message to be serialized and sent over the pipe. It can be of arbitrary type.
 *
 * @returns {?boolean}
 * Returns `true` on success, indicating that the message was successfully sent
 * over the pipe. Returns `null` on error, such as when there's no output
 * callback registered with the task handle.
 *
 * @example
 * // Send a message over the uloop pipe
 * const success = pipe.send(message);
 *
 * if (success)
 *     printf("Message sent successfully\n");
 * else
 *     die(`Error sending message: ${uloop.error()}\n`);
 */
static uc_value_t *
uc_uloop_pipe_send(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_pipe_t **pipe = uc_fn_this("uloop.pipe");
	uc_value_t *msg = uc_fn_arg(0);

	if (!pipe || !*pipe)
		err_return(EINVAL);

	if (!(*pipe)->has_receiver)
		err_return(EPIPE);

	ok_return(uc_uloop_pipe_send_common(vm, msg, (*pipe)->output));
}

static bool
uc_uloop_pipe_receive_common(uc_vm_t *vm, int fd, uc_value_t **res, bool skip)
{
	enum json_tokener_error err = json_tokener_error_parse_eof;
	json_tokener *tok = NULL;
	json_object *jso = NULL;
	char buf[1024];
	ssize_t rlen;
	size_t len;

	*res = NULL;

	if (!readall(fd, &len, sizeof(len)))
		err_return(errno);

	/* message length 0 is special, means input requested on other pipe */
	if (len == 0)
		err_return(ENODATA);

	/* valid messages should be at least sizeof(len) plus one byte of payload */
	if (len <= sizeof(len))
		err_return(EINVAL);

	len -= sizeof(len);

	while (len > 0) {
		rlen = read(fd, buf, len < sizeof(buf) ? len : sizeof(buf));

		if (rlen == -1) {
			if (errno == EINTR)
				continue;

			goto read_fail;
		}

		/* premature EOF */
		if (rlen == 0) {
			errno = EPIPE;
			goto read_fail;
		}

		if (!skip) {
			if (!tok)
				tok = xjs_new_tokener();

			jso = json_tokener_parse_ex(tok, buf, rlen);
			err = json_tokener_get_error(tok);
		}

		len -= rlen;
	}

	if (!skip) {
		if (err == json_tokener_continue) {
			jso = json_tokener_parse_ex(tok, "\0", 1);
			err = json_tokener_get_error(tok);
		}

		json_tokener_free(tok);

		if (err != json_tokener_success) {
			errno = EINVAL;
			goto read_fail;
		}

		*res = ucv_from_json(vm, jso);

		json_object_put(jso);
	}

	return true;

read_fail:
	if (tok)
		json_tokener_free(tok);

	json_object_put(jso);
	err_return(errno);
}

/**
 * Reads input from the task handle.
 *
 * This method reads input from the task communication pipe. The input callback
 * function registered with the task handle is invoked to return the input data,
 * which is then serialized, sent over the pipe, and deserialized by the receive
 * method.
 *
 * @function module:uloop.pipe#receive
 *
 * @returns {?*}
 * Returns the deserialized message read from the task communication pipe.
 * Returns `null` on error, such as when there's no input callback registered
 * on the task handle.
 *
 * @example
 * // Read input from the task communication pipe
 * const message = pipe.receive();
 *
 * if (message !== null)
 *     printf("Received message: %s\n", message);
 * else
 *     die(`Error receiving message: ${uloop.error()}\n`);
 */
static uc_value_t *
uc_uloop_pipe_receive(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_pipe_t **pipe = uc_fn_this("uloop.pipe");
	uc_value_t *rv;
	size_t len = 0;

	if (!pipe || !*pipe)
		err_return(EINVAL);

	if (!(*pipe)->has_sender)
		err_return(EPIPE);

	/* send zero-length message to signal input request */
	writeall((*pipe)->output, &len, sizeof(len));

	/* receive input message */
	uc_uloop_pipe_receive_common(vm, (*pipe)->input, &rv, false);

	return rv;
}

/**
 * Checks if the task handle provides input.
 *
 * This method checks if the task handle has an input callback  registered.
 * It returns a boolean value indicating whether an input callback is present.
 *
 * @function module:uloop.pipe#sending
 *
 * @returns {boolean}
 * Returns `true` if the remote task handle has an input callback
 * registered, otherwise returns `false`.
 *
 * @example
 * // Check if the remote task handle has an input callback
 * const hasInputCallback = pipe.sending();
 *
 * if (hasInputCallback)
 *     printf("Input callback is registered on task handle\n");
 * else
 *     printf("No input callback on the task handle\n");
 */
static uc_value_t *
uc_uloop_pipe_sending(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_pipe_t **pipe = uc_fn_this("uloop.pipe");

	if (!pipe || !*pipe)
		err_return(EINVAL);

	ok_return(ucv_boolean_new((*pipe)->has_sender));
}

/**
 * Checks if the task handle reads output.
 *
 * This method checks if the task handle has an output callback registered.
 * It returns a boolean value indicating whether an output callback is present.
 *
 * @function module:uloop.pipe#receiving
 *
 * @returns {boolean}
 * Returns `true` if the task handle has an output callback registered,
 * otherwise returns `false`.
 *
 * @example
 * // Check if the task handle has an output callback
 * const hasOutputCallback = pipe.receiving();
 *
 * if (hasOutputCallback)
 *     printf("Output callback is registered on task handle\n");
 * else
 *     printf("No output callback on the task handle\n");
 */
static uc_value_t *
uc_uloop_pipe_receiving(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_pipe_t **pipe = uc_fn_this("uloop.pipe");

	if (!pipe || !*pipe)
		err_return(EINVAL);

	ok_return(ucv_boolean_new((*pipe)->has_receiver));
}


/**
 * Represents a uloop task instance as returned by
 * {@link module:uloop#task|task()}.
 *
 * @class module:uloop.task
 * @hideconstructor
 *
 * @see {@link module:uloop#task|task()}
 *
 * @example
 *
 * const task = uloop.task(…);
 *
 * task.pid();
 * task.finished();
 *
 * task.kill();
 */
typedef struct {
	struct uloop_process process;
	struct uloop_fd output;
	size_t registry_index;
	bool finished;
	int input_fd;
	uc_vm_t *vm;
	uc_value_t *input_cb;
	uc_value_t *output_cb;
} uc_uloop_task_t;

static int
patch_devnull(int fd, bool write)
{
	int devnull = open("/dev/null", write ? O_WRONLY : O_RDONLY);

	if (devnull != -1) {
		dup2(fd, devnull);
		close(fd);
	}

	return devnull;
}

static void
uloop_fd_close(struct uloop_fd *fd) {
	if (fd->fd == -1)
		return;

	close(fd->fd);
	fd->fd = -1;
}

static void
uc_uloop_task_clear(uc_uloop_task_t **task)
{
	/* drop registry entries and clear data to prevent reuse */
	uc_uloop_reg_remove((*task)->registry_index);
	*task = NULL;
}

/**
 * Returns the process ID.
 *
 * This method returns the process ID (PID) of the underlying forked process
 * launched by {@link module:uloop#task|task().
 *
 * @function module:uloop.task#pid
 *
 * @returns {number}
 * The process ID (PID) of the forked task process.
 *
 * @example
 * const task = uloop.task(…);
 *
 * printf("Process ID: %d\n", task.pid());
 */
static uc_value_t *
uc_uloop_task_pid(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_task_t **task = uc_fn_this("uloop.task");

	if (!task || !*task)
		err_return(EINVAL);

	if ((*task)->finished)
		err_return(ESRCH);

	ok_return(ucv_int64_new((*task)->process.pid));
}

/**
 * Terminates the task process.
 *
 * This method terminates the task process. It sends a termination signal to
 * the task process, causing it to exit. Returns `true` on success, indicating
 * that the task process was successfully terminated. Returns `null` on error,
 * such as when the task process has already terminated.
 *
 * @function module:uloop.task#kill
 *
 * @returns {?boolean}
 * Returns `true` when the task process was successfully terminated.
 * Returns `null` on error, such as when the process has already terminated.
 *
 * @example
 * // Terminate the task process
 * const success = task.kill();
 *
 * if (success)
 *     printf("Task process terminated successfully\n");
 * else
 *     die(`Error terminating task process: ${uloop.error()}\n`);
 */
static uc_value_t *
uc_uloop_task_kill(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_task_t **task = uc_fn_this("uloop.task");
	int rv;

	if (!task || !*task)
		err_return(EINVAL);

	if ((*task)->finished)
		err_return(ESRCH);

	rv = kill((*task)->process.pid, SIGTERM);

	if (rv == -1)
		err_return(errno);

	ok_return(ucv_boolean_new(true));
}

/**
 * Checks if the task ran to completion.
 *
 * This method checks if the task function has already run to completion.
 * It returns a boolean value indicating whether the task function has finished
 * executing.
 *
 * @function module:uloop.task#finished
 *
 * @returns {boolean}
 * Returns `true` if the task function has already run to completion, otherwise
 * returns `false`.
 *
 * @example
 * // Check if the task function has finished executing
 * const isFinished = task.finished();
 *
 * if (isFinished)
 *     printf("Task function has finished executing\n");
 * else
 *     printf("Task function is still running\n");
 */
static uc_value_t *
uc_uloop_task_finished(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_task_t **task = uc_fn_this("uloop.task");

	if (!task || !*task)
		err_return(EINVAL);

	ok_return(ucv_boolean_new((*task)->finished));
}

static void
uc_uloop_task_output_cb(struct uloop_fd *fd, unsigned int flags)
{
	uc_uloop_task_t *task = container_of(fd, uc_uloop_task_t, output);
	uc_value_t *obj = ucv_array_get(object_registry, task->registry_index);
	uc_value_t *msg = NULL;

	if (flags & ULOOP_READ) {
		while (true) {
			if (!uc_uloop_pipe_receive_common(task->vm, fd->fd, &msg, !task->output_cb)) {
				/* input requested */
				if (last_error == ENODATA) {
					uc_vm_stack_push(task->vm, ucv_get(obj));
					uc_vm_stack_push(task->vm, ucv_get(task->input_cb));

					if (uc_vm_call(task->vm, true, 0) != EXCEPTION_NONE) {
						uloop_end();

						return;
					}

					msg = uc_vm_stack_pop(task->vm);
					uc_uloop_pipe_send_common(task->vm, msg, task->input_fd);
					ucv_put(msg);

					continue;
				}

				/* error */
				break;
			}

			if (task->output_cb) {
				uc_vm_stack_push(task->vm, ucv_get(obj));
				uc_vm_stack_push(task->vm, ucv_get(task->output_cb));
				uc_vm_stack_push(task->vm, msg);

				if (uc_vm_call(task->vm, true, 1) == EXCEPTION_NONE) {
					ucv_put(uc_vm_stack_pop(task->vm));
				}
				else {
					uloop_end();

					return;
				}
			}
			else {
				ucv_put(msg);
			}
		}
	}

	if (!fd->registered && task->finished) {
		close(task->input_fd);
		task->input_fd = -1;

		uloop_fd_close(&task->output);
		uloop_process_delete(&task->process);

		uc_uloop_task_clear(&task);
	}
}

static void
uc_uloop_task_process_cb(struct uloop_process *proc, int exitcode)
{
	uc_uloop_task_t *task = container_of(proc, uc_uloop_task_t, process);

	task->finished = true;

	uc_uloop_task_output_cb(&task->output, ULOOP_READ);
}

/**
 * Creates a task instance for executing background tasks.
 *
 * This function creates a task instance for executing background tasks.
 * It takes the task function to be invoked as a background process,
 * an optional output callback function to be invoked when output is received
 * from the task, and an optional input callback function to be invoked
 * when input is required by the task.
 *
 * @function module:uloop#task
 *
 * @param {Function} taskFunction
 * The task function to be invoked as a background process.
 *
 * @param {Function} [outputCallback]
 * Optional. The output callback function to be invoked when output is received
 * from the task. It is invoked with the output data as the argument.
 *
 * @param {Function} [inputCallback]
 * Optional. The input callback function to be invoked when input is required
 * by the task. It is invoked with a function to send input to the task
 * as the argument.
 *
 * @returns {?module:uloop.task}
 * Returns a task instance for executing background tasks.
 * Returns `null` on error, e.g. due to fork failure or invalid arguments.
 *
 * @example
 * // Create a task instance for executing a background task
 * const myTask = uloop.task(
 *     (pipe) => {
 *         // Task logic
 *         pipe.send("Hello from the task\n");
 *         const input = pipe.receive();
 *         printf(`Received input from main thread: ${input}\n`);
 *     },
 *     (output) => {
 *         // Output callback, invoked when task function calls pipe.send()
 *         printf(`Received output from task: ${output}\n`);
 *     },
 *     () => {
 *         // Input callback, invoked when task function calls pipe.receive()
 *         return "Input from main thread\n";
 *     }
 * );
 */
static uc_value_t *
uc_uloop_task(uc_vm_t *vm, size_t nargs)
{
	uc_value_t *func = uc_fn_arg(0);
	uc_value_t *output_cb = uc_fn_arg(1);
	uc_value_t *input_cb = uc_fn_arg(2);
	int outpipe[2] = { -1, -1 };
	int inpipe[2] = { -1, -1 };
	uc_value_t *res, *cbs, *p;
	uc_uloop_pipe_t *tpipe;
	uc_uloop_task_t *task;
	pid_t pid;
	int err;

	if (!ucv_is_callable(func) ||
	    (output_cb && !ucv_is_callable(output_cb)) ||
	    (input_cb && !ucv_is_callable(input_cb)))
	    err_return(EINVAL);

	if (pipe(outpipe) == -1 || pipe(inpipe) == -1) {
		err = errno;

		close(outpipe[0]); close(outpipe[1]);
		close(inpipe[0]); close(inpipe[1]);

		err_return(err);
	}

	pid = fork();

	if (pid == -1)
		err_return(errno);

	if (pid == 0) {
		uloop_done();

		patch_devnull(0, false);
		patch_devnull(1, true);
		patch_devnull(2, true);

		vm->output = fdopen(1, "w");

		close(inpipe[1]);
		close(outpipe[0]);

		tpipe = xalloc(sizeof(*tpipe));
		tpipe->input = inpipe[0];
		tpipe->output = outpipe[1];
		tpipe->has_sender = input_cb;
		tpipe->has_receiver = output_cb;

		p = uc_resource_new(pipe_type, tpipe);

		uc_vm_stack_push(vm, func);
		uc_vm_stack_push(vm, ucv_get(p));

		if (uc_vm_call(vm, false, 1) == EXCEPTION_NONE) {
			res = uc_vm_stack_pop(vm);
			uc_uloop_pipe_send_common(vm, res, tpipe->output);
			ucv_put(res);
		}

		ucv_put(p);

		_exit(0);
	}

	close(inpipe[0]);
	close(outpipe[1]);

	task = xalloc(sizeof(*task));
	task->process.pid = pid;
	task->process.cb = uc_uloop_task_process_cb;

	task->vm = vm;

	task->output.fd = outpipe[0];
	task->output.cb = uc_uloop_task_output_cb;
	task->output_cb = output_cb;
	uloop_fd_add(&task->output, ULOOP_READ);

	if (input_cb) {
		task->input_fd = inpipe[1];
		task->input_cb = input_cb;
	}
	else {
		task->input_fd = -1;
		close(inpipe[1]);
	}

	uloop_process_add(&task->process);

	res = uc_resource_new(task_type, task);

	cbs = ucv_array_new(NULL);
	ucv_array_set(cbs, 0, ucv_get(output_cb));
	ucv_array_set(cbs, 1, ucv_get(input_cb));

	task->registry_index = uc_uloop_reg_add(res, cbs);

	ok_return(res);
}


/**
 * Represents a uloop interval timer instance as returned by
 * {@link module:uloop#interval|interval()}.
 *
 * @class module:uloop.interval
 * @hideconstructor
 *
 * @see {@link module:uloop#interval|interval()}
 *
 * @example
 *
 * const intv = uloop.interval(…);
 *
 * intv.set(…);
 * intv.remaining();
 * intv.expirations();
 * intv.cancel();
 */
#ifdef HAVE_ULOOP_INTERVAL
typedef struct {
	struct uloop_interval interval;
	size_t registry_index;
	uc_vm_t *vm;
} uc_uloop_interval_t;

static void
uc_uloop_interval_clear(uc_uloop_interval_t **interval)
{
	/* drop registry entries and clear data to prevent reuse */
	uc_uloop_reg_remove((*interval)->registry_index);
	free(*interval);
	*interval = NULL;
}

/**
 * Rearms the uloop interval timer with the specified interval.
 *
 * This method rearms the interval timer with the specified interval value,
 * allowing it to trigger repeatedly after the specified amount of time. If no
 * interval value is provided or if the provided value is negative, the interval
 * remains disabled until rearmed with a positive interval value.
 *
 * @function module:uloop.interval#set
 *
 * @param {number} [interval=-1]
 * Optional. The interval value in milliseconds specifying when the interval
 * triggers again. Defaults to -1, which disables the interval until rearmed
 * with a positive interval value.
 *
 * @returns {?boolean}
 * Returns `true` on success, `null` on error, such as an invalid interval argument.
 *
 * @example
 * // Rearm the uloop interval with a interval of 1000 milliseconds
 * const success = interval.set(1000);
 *
 * if (success)
 *     printf("Interval rearmed successfully\n");
 * else
 *     printf("Error occurred while rearming interval: ${uloop.error()}\n");
 *
 * // Disable the uloop interval
 * const success = interval.set();
 *
 * if (success)
 *     printf("Interval disabled successfully\n");
 * else
 *     printf("Error occurred while disabling interval: ${uloop.error()}\n");
 */
static uc_value_t *
uc_uloop_interval_set(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_interval_t **interval = uc_fn_this("uloop.interval");
	uc_value_t *timeout = uc_fn_arg(0);
	int t, rv;

	if (!interval || !*interval)
		err_return(EINVAL);

	errno = 0;
	t = timeout ? (int)ucv_int64_get(timeout) : -1;

	if (errno)
		err_return(errno);

	rv = uloop_interval_set(&(*interval)->interval, t);

	ok_return(ucv_boolean_new(rv == 0));
}

/**
 * Returns the milliseconds until the next expiration.
 *
 * This method returns the remaining time until the uloop interval expires
 * and triggers again. If the interval is not armed (i.e., disabled),
 * it returns -1.
 *
 * @function module:uloop.interval#remaining
 *
 * @returns {number}
 * The milliseconds until the next expiration of the uloop interval, or -1 if
 * the interval is not armed.
 *
 * @example
 * // Get the milliseconds until the next expiration of the uloop interval
 * const remainingTime = interval.remaining();
 *
 * if (remainingTime !== -1)
 *     printf("Milliseconds until next expiration: %d\n", remainingTime);
 * else
 *     printf("Interval is not armed\n");
 */
static uc_value_t *
uc_uloop_interval_remaining(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_interval_t **interval = uc_fn_this("uloop.interval");

	if (!interval || !*interval)
		err_return(EINVAL);

	ok_return(ucv_int64_new(uloop_interval_remaining(&(*interval)->interval)));
}

/**
 * Returns number of times the interval timer fired.
 *
 * This method returns the number of times the uloop interval timer has expired
 * (fired) since it was instantiated.
 *
 * @function module:uloop.interval#expirations
 *
 * @returns {number}
 * The number of times the uloop interval timer has expired (fired).
 *
 * @example
 * // Get the number of times the uloop interval timer has expired
 * const expirations = interval.expirations();
 * printf("Number of expirations: %d\n", expirations);
 */
static uc_value_t *
uc_uloop_interval_expirations(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_interval_t **interval = uc_fn_this("uloop.interval");

	if (!interval || !*interval)
		err_return(EINVAL);

	ok_return(ucv_int64_new((*interval)->interval.expirations));
}

/**
 * Cancels the uloop interval.
 *
 * This method cancels the uloop interval, disarming it and removing it from the
 * event loop. Associated resources are released.
 *
 * @function module:uloop.interval#cancel
 *
 * @returns {boolean}
 * Returns `true` on success.
 *
 * @example
 * // Cancel the uloop interval
 * interval.cancel();
 */
static uc_value_t *
uc_uloop_interval_cancel(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_interval_t **interval = uc_fn_this("uloop.interval");
	int rv;

	if (!interval || !*interval)
		err_return(EINVAL);

	rv = uloop_interval_cancel(&(*interval)->interval);

	uc_uloop_interval_clear(interval);

	ok_return(ucv_boolean_new(rv == 0));
}

static void
uc_uloop_interval_cb(struct uloop_interval *uintv)
{
	uc_uloop_interval_t *interval = (uc_uloop_interval_t *)uintv;

	uc_uloop_reg_invoke(interval->vm, interval->registry_index, NULL);
}

/**
 * Creates an interval instance for scheduling repeated callbacks.
 *
 * This function creates an interval instance for scheduling repeated callbacks
 * to be executed at regular intervals. It takes an optional timeout parameter,
 * which defaults to -1, indicating that the interval is initially not armed
 * and can be armed later with the `.set(timeout)` method. A callback function
 * must be provided to be executed when the interval expires.
 *
 * @function module:uloop#interval
 *
 * @param {number} [timeout=-1]
 * Optional. The interval duration in milliseconds. Defaults to -1, indicating
 * the interval is not initially armed.
 *
 * @param {Function} callback
 * The callback function to be executed when the interval expires.
 *
 * @returns {?module:uloop.interval}
 * Returns an interval instance for scheduling repeated callbacks.
 * Returns `null` when the timeout or callback arguments are invalid.
 *
 * @example
 * // Create an interval with a callback to be executed every 1000 milliseconds
 * const myInterval = uloop.interval(1000, () => {
 *     printf("Interval callback executed!\n");
 * });
 *
 * // Later arm the interval to start executing the callback every 500 milliseconds
 * myInterval.set(500);
 */
static uc_value_t *
uc_uloop_interval(uc_vm_t *vm, size_t nargs)
{
	uc_value_t *timeout = uc_fn_arg(0);
	uc_value_t *callback = uc_fn_arg(1);
	uc_uloop_interval_t *interval;
	uc_value_t *res;
	int t;

	errno = 0;
	t = timeout ? ucv_int64_get(timeout) : -1;

	if (errno)
		err_return(errno);

	if (!ucv_is_callable(callback))
		err_return(EINVAL);

	interval = xalloc(sizeof(*interval));
	interval->interval.cb = uc_uloop_interval_cb;
	interval->vm = vm;

	if (t >= 0)
		uloop_interval_set(&interval->interval, t);

	res = uc_resource_new(interval_type, interval);

	interval->registry_index = uc_uloop_reg_add(res, callback);

	ok_return(res);
}
#endif


/**
 * Represents a uloop signal Unix process signal handler as returned by
 * {@link module:uloop#signal|signal()}.
 *
 * @class module:uloop.signal
 * @hideconstructor
 *
 * @see {@link module:uloop#signal|signal()}
 *
 * @example
 *
 * const sighandler = uloop.signal(…);
 *
 * sighandler.signo();
 * sighandler.delete();
 */
#ifdef HAVE_ULOOP_SIGNAL
typedef struct {
	struct uloop_signal signal;
	size_t registry_index;
	uc_vm_t *vm;
} uc_uloop_signal_t;

static void
uc_uloop_signal_clear(uc_uloop_signal_t **signal)
{
	/* drop registry entries and clear data to prevent reuse */
	uc_uloop_reg_remove((*signal)->registry_index);
	free(*signal);
	*signal = NULL;
}

/**
 * Returns the associated signal number.
 *
 * This method returns the signal number that this uloop signal handler is
 * configured to respond to.
 *
 * @function module:uloop.signal#signo
 *
 * @returns {number}
 * The signal number that this handler is responding to.
 *
 * @example
 * // Get the signal number that the uloop signal handler is responding to
 * const sighandler = uloop.signal("SIGINT", () => printf("Cought INT\n"));
 * printf("Signal number: %d\n", sighandler.signo());
 */
static uc_value_t *
uc_uloop_signal_signo(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_signal_t **signal = uc_fn_this("uloop.signal");

	if (!signal || !*signal)
		err_return(EINVAL);

	ok_return(ucv_int64_new((*signal)->signal.signo));
}

/**
 * Uninstalls the signal handler.
 *
 * This method uninstalls the signal handler, restoring the previous or default
 * handler for the signal, and releasing any associated resources.
 *
 * @function module:uloop.signal#delete
 *
 * @returns {boolean}
 * Returns `true` on success.
 *
 * @example
 * // Uninstall the signal handler and restore the previous/default handler
 * const sighandler = uloop.signal(…);
 * sighandler.delete();
 */
static uc_value_t *
uc_uloop_signal_delete(uc_vm_t *vm, size_t nargs)
{
	uc_uloop_signal_t **signal = uc_fn_this("uloop.signal");
	int rv;

	if (!signal || !*signal)
		err_return(EINVAL);

	rv = uloop_signal_delete(&(*signal)->signal);

	uc_uloop_signal_clear(signal);

	if (rv != 0)
		err_return(EINVAL);

	ok_return(ucv_boolean_new(true));
}

static void
uc_uloop_signal_cb(struct uloop_signal *usig)
{
	uc_uloop_signal_t *signal = (uc_uloop_signal_t *)usig;

	uc_uloop_reg_invoke(signal->vm, signal->registry_index, NULL);
}

static int
parse_signo(uc_value_t *sigspec)
{
	if (ucv_type(sigspec) == UC_STRING) {
		const char *signame = ucv_string_get(sigspec);

		if (!strncasecmp(signame, "SIG", 3))
			signame += 3;

		for (size_t i = 0; i < UC_SYSTEM_SIGNAL_COUNT; i++) {
			if (!uc_system_signal_names[i])
				continue;

			if (strcasecmp(uc_system_signal_names[i], signame))
				continue;

			return i;
		}
	}

	uc_value_t *signum = ucv_to_number(sigspec);
	int64_t signo = ucv_int64_get(signum);
	ucv_put(signum);

	if (signo < 1 || signo >= UC_SYSTEM_SIGNAL_COUNT)
		return -1;

	return signo;
}

/**
 * Creates a signal instance for handling Unix signals.
 *
 * This function creates a signal instance for handling Unix signals.
 * It takes the signal name string (with or without "SIG" prefix) or signal
 * number, and a callback function to be invoked when the specified Unix signal
 * is caught.
 *
 * @function module:uloop#signal
 *
 * @param {string|number} signal
 * The signal name string (with or without "SIG" prefix) or signal number.
 *
 * @param {Function} callback
 * The callback function to be invoked when the specified Unix signal is caught.
 *
 * @returns {?module:uloop.signal}
 * Returns a signal instance representing the installed signal handler.
 * Returns `null` when the signal or callback arguments are invalid.
 *
 * @example
 * // Create a signal instance for handling SIGINT
 * const mySignal = uloop.signal("SIGINT", () => {
 *     printf("SIGINT caught!\n");
 * });
 */
static uc_value_t *
uc_uloop_signal(uc_vm_t *vm, size_t nargs)
{
	int signo = parse_signo(uc_fn_arg(0));
	uc_value_t *callback = uc_fn_arg(1);
	uc_uloop_signal_t *signal;
	uc_value_t *res;

	if (signo == -1 || !ucv_is_callable(callback))
		err_return(EINVAL);

	signal = xalloc(sizeof(*signal));
	signal->signal.signo = signo;
	signal->signal.cb = uc_uloop_signal_cb;
	signal->vm = vm;

	uloop_signal_add(&signal->signal);

	res = uc_resource_new(signal_type, signal);

	signal->registry_index = uc_uloop_reg_add(res, callback);

	ok_return(res);
}
#endif


static const uc_function_list_t timer_fns[] = {
	{ "set",		uc_uloop_timer_set },
	{ "remaining",	uc_uloop_timer_remaining },
	{ "cancel",		uc_uloop_timer_cancel },
};

static const uc_function_list_t handle_fns[] = {
	{ "fileno",		uc_uloop_handle_fileno },
	{ "handle",		uc_uloop_handle_handle },
	{ "delete",		uc_uloop_handle_delete },
};

static const uc_function_list_t process_fns[] = {
	{ "pid",		uc_uloop_process_pid },
	{ "delete",		uc_uloop_process_delete },
};

static const uc_function_list_t task_fns[] = {
	{ "pid",		uc_uloop_task_pid },
	{ "kill",		uc_uloop_task_kill },
	{ "finished",	uc_uloop_task_finished },
};

static const uc_function_list_t pipe_fns[] = {
	{ "send",		uc_uloop_pipe_send },
	{ "receive",	uc_uloop_pipe_receive },
	{ "sending",	uc_uloop_pipe_sending },
	{ "receiving",	uc_uloop_pipe_receiving },
};

#ifdef HAVE_ULOOP_INTERVAL
static const uc_function_list_t interval_fns[] = {
	{ "set",		uc_uloop_interval_set },
	{ "remaining",	uc_uloop_interval_remaining },
	{ "expirations",
					uc_uloop_interval_expirations },
	{ "cancel",		uc_uloop_interval_cancel },
};
#endif

#ifdef HAVE_ULOOP_SIGNAL
static const uc_function_list_t signal_fns[] = {
	{ "signo",		uc_uloop_signal_signo },
	{ "delete",		uc_uloop_signal_delete },
};
#endif

static const uc_function_list_t global_fns[] = {
	{ "error",		uc_uloop_error },
	{ "init",		uc_uloop_init },
	{ "run",		uc_uloop_run },
	{ "timer",		uc_uloop_timer },
	{ "handle",		uc_uloop_handle },
	{ "process",	uc_uloop_process },
	{ "task",		uc_uloop_task },
	{ "cancelling",	uc_uloop_cancelling },
	{ "running",	uc_uloop_running },
	{ "done",		uc_uloop_done },
	{ "end",		uc_uloop_end },
#ifdef HAVE_ULOOP_INTERVAL
	{ "interval",	uc_uloop_interval },
#endif
#ifdef HAVE_ULOOP_SIGNAL
	{ "signal",		uc_uloop_signal },
#endif
};


static void close_timer(void *ud)
{
	uc_uloop_timer_t *timer = ud;

	if (!timer)
		return;

	uloop_timeout_cancel(&timer->timeout);
	free(timer);
}

static void close_handle(void *ud)
{
	uc_uloop_handle_t *handle = ud;

	if (!handle)
		return;

	uloop_fd_delete(&handle->fd);
	ucv_put(handle->handle);
	free(handle);
}

static void close_process(void *ud)
{
	uc_uloop_process_t *process = ud;

	if (!process)
		return;

	uloop_process_delete(&process->process);
	free(process);
}

static void close_task(void *ud)
{
	uc_uloop_task_t *task = ud;

	if (!task)
		return;

	uloop_process_delete(&task->process);
	uloop_fd_close(&task->output);

	if (task->input_fd != -1)
		close(task->input_fd);

	free(task);
}

static void close_pipe(void *ud)
{
	uc_uloop_pipe_t *pipe = ud;

	if (!pipe)
		return;

	close(pipe->input);
	close(pipe->output);

	free(pipe);
}

#ifdef HAVE_ULOOP_INTERVAL
static void close_interval(void *ud)
{
	uc_uloop_interval_t *interval = ud;

	if (!interval)
		return;

	uloop_interval_cancel(&interval->interval);
	free(interval);
}
#endif

#ifdef HAVE_ULOOP_SIGNAL
static void close_signal(void *ud)
{
	uc_uloop_signal_t *signal = ud;

	if (!signal)
		return;

	uloop_signal_delete(&signal->signal);
	free(signal);
}
#endif


static struct {
	struct uloop_fd ufd;
	uc_vm_t *vm;
} signal_handle;

static void
uc_uloop_vm_signal_cb(struct uloop_fd *ufd, unsigned int events)
{
	if (uc_vm_signal_dispatch(signal_handle.vm) != EXCEPTION_NONE)
		uloop_end();
}

void uc_module_init(uc_vm_t *vm, uc_value_t *scope)
{
	int signal_fd;

	uc_function_list_register(scope, global_fns);

#define ADD_CONST(x) ucv_object_add(scope, #x, ucv_int64_new(x))

	/**
	 * @typedef
	 * @name Event Mode Constants
	 * @description
	 * The `ULOOP_*` constants are passed as bitwise OR-ed number to the
	 * {@link module:uloop.handle#handle|handle()} function to specify the IO
	 * events that should be monitored on the given handle.
	 * @property {number} ULOOP_READ - File or socket is readable.
	 * @property {number} ULOOP_WRITE - File or socket is writable.
	 * @property {number} ULOOP_EDGE_TRIGGER - Enable edge-triggered event mode.
	 * @property {number} ULOOP_BLOCKING - Do not make descriptor non-blocking.
	 */
	ADD_CONST(ULOOP_READ);
	ADD_CONST(ULOOP_WRITE);
	ADD_CONST(ULOOP_EDGE_TRIGGER);
	ADD_CONST(ULOOP_BLOCKING);

	timer_type = uc_type_declare(vm, "uloop.timer", timer_fns, close_timer);
	handle_type = uc_type_declare(vm, "uloop.handle", handle_fns, close_handle);
	process_type = uc_type_declare(vm, "uloop.process", process_fns, close_process);
	task_type = uc_type_declare(vm, "uloop.task", task_fns, close_task);
	pipe_type = uc_type_declare(vm, "uloop.pipe", pipe_fns, close_pipe);

#ifdef HAVE_ULOOP_INTERVAL
	interval_type = uc_type_declare(vm, "uloop.interval", interval_fns, close_interval);
#endif

#ifdef HAVE_ULOOP_SIGNAL
	signal_type = uc_type_declare(vm, "uloop.signal", signal_fns, close_signal);
#endif

	object_registry = ucv_array_new(vm);

	uc_vm_registry_set(vm, "uloop.registry", object_registry);

	signal_fd = uc_vm_signal_notifyfd(vm);

	if (signal_fd != -1 && uloop_init() == 0) {
		signal_handle.vm = vm;
		signal_handle.ufd.cb = uc_uloop_vm_signal_cb;
		signal_handle.ufd.fd = signal_fd;

		uloop_fd_add(&signal_handle.ufd, ULOOP_READ);
	}
}
