use errors;
use io;
use rt;

export type op = enum {
	NONE,
	READV,
	WRITEV,
};

export type file = struct {
	fd: io::file,
	ev: *loop,
	// Pending operation on this file object
	op: op,
	cb: nullable *void,

	// Operation-specific data
	vbuf: rt::iovec,
	union {
		vec: []rt::iovec,
	},
};

// Registers a file descriptor with an event loop.
export fn register(
	loop: *loop,
	fd: io::file,
) (*file | errors::error) = {
	const file = alloc(file {
		fd = fd,
		ev = loop,
		op = op::NONE,
		...
	});

	let ev = rt::epoll_event {
		events = 0,
		...
	};
	ev.data.ptr = file;
	match (rt::epoll_ctl(loop.fd, rt::EPOLL_CTL_ADD, fd, &ev)) {
	case void =>
		yield;
	case let err: rt::errno =>
		return errors::errno(err);
	};

	return file;
};

// Unregisters a file object with an event loop and frees resources associated
// with it. Does not close the underlying file descriptor.

export fn unregister(loop: *loop, file: *file) void = {

export fn unregister(file: *file) void = {
	const loop = file.ev;

	// The only way that this could fail is in the event of a use-after-free
	// or if the user fucks around and constructs a custom [[file]] which
	// was never registered, so assert on error.
	rt::epoll_ctl(loop.fd, rt::EPOLL_CTL_DEL, file.fd, null)!;
	free(file);

};

// Returns the file descriptor for a given file. Note that ev assumes that it
// will be responsible for all I/O on the file and any user modifications may
// cause the event loop to enter an invalid state.
export fn file_getfd(file: *file) io::file = {
	return file.fd;
};

// Returns the event loop for a given file.
export fn file_getloop(file: *file) *loop = {
	return file.ev;

};

// Modifies the epoll events for a given file. For internal use.
fn filemod(file: *file, events: u32) void = {
	let ev = rt::epoll_event {
		events = events | rt::EPOLLONESHOT,
		...
	};
	ev.data.ptr = file;
	// This can only fail under conditions associated with EPOLLEXCLUSIVE,
	// which we do not support.
	rt::epoll_ctl(file.ev.fd, rt::EPOLL_CTL_MOD, file.fd, &ev)!;
};

use io;
use rt;

// A callback for a [[read]] or [[readv]] operation.

export type readcb = *fn(file: *file, result: (size | io::EOF | io::error)) void;

export type readcb = fn(file: *file, result: (size | io::EOF | io::error)) void;

// Schedules a read operation on a file object.
export fn read(
	file: *file,
	cb: *readcb,
	buf: []u8,
) req = {
	file.vbuf = io::mkvector(buf);
	// XXX: Bit of a hack to avoid allocating a slice
	const vec = (&file.vbuf: *[*]io::vector)[..1];
	return readv(file, cb, vec...);
};

// Schedules a vectored read operation on a file object.
export fn readv(
	file: *file,
	cb: *readcb,
	vec: io::vector...
) req = {
	assert(file.op == op::NONE);
	file.op = op::READV;
	file.cb = cb;
	file.vec = vec;

	filemod(file, rt::EPOLLOUT);

	filemod(file, rt::EPOLLIN | rt::EPOLLHUP);

	return req { ... };
};

fn readv_finish(file: *file, ev: *rt::epoll_event) void = {

	assert(file.op == op::READV && ev.events & rt::EPOLLIN != 0);

	assert(file.op == op::READV);
	assert(ev.events & (rt::EPOLLIN | rt::EPOLLHUP) != 0);

	assert(file.cb != null);

	const r = io::readv(file.fd, file.vec...);

	const cb = file.cb: *readcb;

	cb(file, r);

	file.op = op::NONE;

	if (ev.events & rt::EPOLLHUP != 0) {
		cb(file, io::EOF);
	} else {
		const r = io::readv(file.fd, file.vec...);
		cb(file, r);
	};

};

// A callback for a [[write]] or [[writev]] operation.

export type writecb = *fn(file: *file, result: (size | io::error)) void;

export type writecb = fn(file: *file, result: (size | io::error)) void;

// Schedules a write operation on a file object.
export fn write(
	file: *file,
	cb: *writecb,
	buf: []u8,
) req = {
	file.vbuf = io::mkvector(buf);
	// XXX: Bit of a hack to avoid allocating a slice
	const vec = (&file.vbuf: *[*]io::vector)[..1];
	return writev(file, cb, vec...);
};

// Schedules a vectored read operation on a file object.
export fn writev(
	file: *file,
	cb: *writecb,
	vec: io::vector...
) req = {
	// XXX: Should we support both pending reads and writes at the same
	// time? (yes)
	assert(file.op == op::NONE);
	file.op = op::WRITEV;
	file.cb = cb;
	file.vec = vec;

	filemod(file, rt::EPOLLOUT);

	filemod(file, rt::EPOLLOUT | rt::EPOLLHUP);

	return req { ... };
};

fn writev_finish(file: *file, ev: *rt::epoll_event) void = {
	assert(file.op == op::WRITEV && ev.events & rt::EPOLLOUT != 0);
	assert(file.cb != null);
	const r = io::writev(file.fd, file.vec...);
	const cb = file.cb: *writecb;

	cb(file, r);

	file.op = op::NONE;

	cb(file, r);

};

use errors;
use io;
use rt;
use time;
use types;

export type loop = struct {
	fd: io::file,
	events: []rt::epoll_event,

	stop: bool,

};

// Creates a new event loop. The user must pass the return value to
// [[loop_finish]] to free associated resources when done using the loop.

// Creates a new event loop. The user must pass the return value to [[finish]]
// to free associated resources when done using the loop.

export fn newloop() (loop | errors::error) = {
	const fd = match (rt::epoll_create1(rt::EPOLL_CLOEXEC)) {
	case let fd: int =>
		yield fd: io::file;
	case let err: rt::errno =>
		return errors::errno(err);
	};

	return loop {
		fd = fd,

		events = [],

		// XXX: Should the number of events be customizable?
		events = alloc([rt::epoll_event { ... }...], 256),
		stop = false,

	};
};

// Frees resources associated with an event loop. Must only be called once per

// event loop object.
export fn loop_finish(loop: *loop) void = {

// event loop object. Calling finish invalidates all I/O objects associated with
// the event loop.
export fn finish(loop: *loop) void = {
	free(loop.events);

	io::close(loop.fd)!;
};

// Returns an [[io::file]] for this event loop which can be polled on when
// events are available for processing, for chaining together different event
// loops. The exact semantics of this function are platform-specific, and it may
// not be available for all implementations.
export fn loop_file(loop: *loop) io::file = {
	return loop.fd;
};

// Dispatches the event loop. A timeout of 0 specifies an indefinite timeout,
// and will cause dispatch to block until the next event is available. A timeout
// of -1 will return immediately if no events are available.

// Dispatches the event loop, waiting for new events and calling their callbacks
// as appropriate.

//

// Portable use of the timeout argument supports only millisecond granularity of
// up to 24 days (INT_MAX milliseconds). Negative values other than -1 will
// cause the program to abort.

// A timeout of -1 will block indefinitely until the next event occurs. A
// timeout of 0 will cause dispatch to return immediately if no events are
// available to process. Portable use of the timeout argument supports only
// millisecond granularity of up to 24 days (INT_MAX milliseconds). Negative
// values other than -1 will cause the program to abort.

//

// Returns false if there are no events to process.

// Returns false if the loop has been stopped via [[stop]], or true otherwise.

export fn dispatch(
	loop: *loop,
	timeout: time::duration,
) (bool | errors::error) = {
	const millis: int = if (timeout == -1) {
		yield -1;
	} else if (timeout < 0) {
		abort("ev::dispatch: invalid timeout");
	} else {
		yield (timeout / time::MILLISECOND): int;
	};

	if (len(loop.events) == 0) {

	if (loop.stop) {

		return false;
	};

	if (len(loop.events) == 0) {
		return true;
	};

	// TODO: Deal with signals
	const maxev = len(loop.events);
	assert(maxev <= types::INT_MAX: size, "ev::dispatch: too many events");

	const events = rt::epoll_pwait(

	const nevent = rt::epoll_pwait(

		loop.fd, &loop.events[0],
		maxev: int, millis, null)!;

	for (let i = 0z; i < maxev; i += 1) {

	for (let i = 0; i < nevent; i += 1) {

		const ev = &loop.events[i];
		const file = ev.data.ptr: *file;
		if (ev.events == 0) {
			continue;
		};
		switch (file.op) {
		case op::NONE =>
			abort("Invalid pending operation");
		case op::READV =>
			readv_finish(file, ev);
		case op::WRITEV =>
			writev_finish(file, ev);
		};
	};

	return events != 0;

	return !loop.stop;
};

// Signals the loop to stop processing events. If called during a callback, it
// will cause that invocation of [[dispatch]] to return false. Otherwise, false
// will be returned only upon the next call to [[dispatch]].
export fn stop(loop: *loop) void = {
	loop.stop = true;

};