/* See LICENSE file for copyright and license details. */
#include "servers-master.h"
#include "servers-crtc.h"
#include "servers-gamma.h"
#include "servers-coopgamma.h"
#include "util.h"
#include "communication.h"
#include "state.h"

#include <sys/socket.h>
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>


/**
 * All poll(3p) events that are not for writing
 */
#define NON_WR_POLL_EVENTS (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI | POLLERR | POLLHUP | POLLNVAL)


/**
 * Extract headers from an inbound message and pass
 * them on to appropriate message handling function
 * 
 * @param   conn  The index of the connection
 * @param   msg   The inbound message
 * @return        1: The connection as closed
 *                0: Successful
 *                -1: Failure
 */
static int
dispatch_message(size_t conn, struct message *restrict msg)
{
	size_t i;
	int r = 0;
	const char *header;
	const char *value;
	const char *command       = NULL;
	const char *crtc          = NULL;
	const char *coalesce      = NULL;
	const char *high_priority = NULL;
	const char *low_priority  = NULL;
	const char *priority      = NULL;
	const char *class         = NULL;
	const char *lifespan      = NULL;
	const char *message_id    = NULL;

	for (i = 0; i < msg->header_count; i++) {
		value = strstr((header = msg->headers[i]), ": ") + 2;
		if      (strstr(header, "Command: ")       == header)  command       = value;
		else if (strstr(header, "CRTC: ")          == header)  crtc          = value;
		else if (strstr(header, "Coalesce: ")      == header)  coalesce      = value;
		else if (strstr(header, "High priority: ") == header)  high_priority = value;
		else if (strstr(header, "Low priority: ")  == header)  low_priority  = value;
		else if (strstr(header, "Priority: ")      == header)  priority      = value;
		else if (strstr(header, "Class: ")         == header)  class         = value;
		else if (strstr(header, "Lifespan: ")      == header)  lifespan      = value;
		else if (strstr(header, "Message ID: ")    == header)  message_id    = value;
		else if (strstr(header, "Length: ")        == header)  ;/* Handled transparently */
		else
			fprintf(stderr, "%s: ignoring unrecognised header: %s\n", argv0, header);
	}

	if (!command) {
		fprintf(stderr, "%s: ignoring message without Command header\n", argv0);

	} else if (!message_id) {
		fprintf(stderr, "%s: ignoring message without Message ID header\n", argv0);

	} else if (!strcmp(command, "enumerate-crtcs")) {
		if (crtc || coalesce || high_priority || low_priority || priority || class || lifespan)
			fprintf(stderr, "%s: ignoring superfluous headers in Command: enumerate-crtcs message\n", argv0);
		r = handle_enumerate_crtcs(conn, message_id);

	} else if (!strcmp(command, "get-gamma-info")) {
		if (coalesce || high_priority || low_priority || priority || class || lifespan)
			fprintf(stderr, "%s: ignoring superfluous headers in Command: get-gamma-info message\n", argv0);
		r = handle_get_gamma_info(conn, message_id, crtc);

	} else if (!strcmp(command, "get-gamma")) {
		if (priority || class || lifespan)
			fprintf(stderr, "%s: ignoring superfluous headers in Command: get-gamma message\n", argv0);
		r = handle_get_gamma(conn, message_id, crtc, coalesce, high_priority, low_priority);

	} else if (!strcmp(command, "set-gamma")) {
		if (coalesce || high_priority || low_priority)
			fprintf(stderr, "%s: ignoring superfluous headers in Command: set-gamma message\n", argv0);
		r = handle_set_gamma(conn, message_id, crtc, priority, class, lifespan);

	} else {
		fprintf(stderr, "%s: ignoring unrecognised command: Command: %s\n", argv0, command);
	}

	return r;
}


/**
 * Sets the file descriptor set that includes
 * the server socket and all connections
 * 
 * The file descriptor will be ordered as in
 * the array `connections`, `socketfd` will
 * be last.
 * 
 * @param   fds        Reference parameter for the array of file descriptors
 * @param   fdn        Output parameter for the number of file descriptors
 * @param   fds_alloc  Reference parameter for the allocation size of `fds`, in elements
 * @return             Zero on success, -1 on error
 */
static int
update_fdset(struct pollfd **restrict fds, nfds_t *restrict fdn, nfds_t *restrict fds_alloc)
{
	size_t i;
	nfds_t j = 0;
	void *new;

	if (connections_used + 1 > *fds_alloc) {
		new = realloc(*fds, (connections_used + 1) * sizeof(**fds));
		if (!new)
			return -1;
		*fds = new;
		*fds_alloc = connections_used + 1;
	}

	for (i = 0; i < connections_used; i++) {
		if (connections[i] >= 0) {
			(*fds)[j].fd = connections[i];
			(*fds)[j].events = NON_WR_POLL_EVENTS;
			j++;
		}
	}

	(*fds)[j].fd = socketfd;
	(*fds)[j].events = NON_WR_POLL_EVENTS;
	j++;

	*fdn = j;
	return 0;
}


/**
 * Handle event on the server socket
 * 
 * @return  1: New connection accepted
 *          0: Successful
 *          -1: Failure
 */
static int
handle_server(void)
{
	int fd, flags, saved_errno;
	void *new;

	fd = accept(socketfd, NULL, NULL);
	if (fd < 0) {
		switch (errno) {
		case ECONNABORTED:
		case EINVAL:
			terminate = 1;
			/* fall through */
		case EINTR:
			return 0;
		default:
			return -1;
		}
	}

	flags = fcntl(fd, F_GETFL);
	if (flags < 0 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
		goto fail;

	if (connections_ptr == connections_alloc) {
		new = realloc(connections, (connections_alloc + 10) * sizeof(*connections));
		if (!new)
			goto fail;
		connections = new;
		connections[connections_ptr] = fd;

		new = realloc(outbound, (connections_alloc + 10) * sizeof(*outbound));
		if (!new)
			goto fail;
		outbound = new;
		ring_initialise(&outbound[connections_ptr]);

		new = realloc(inbound, (connections_alloc + 10) * sizeof(*inbound));
		if (!new)
			goto fail;
		inbound = new;
		connections_alloc += 10;
		if (message_initialise(&inbound[connections_ptr]))
			goto fail;
	} else {
		connections[connections_ptr] = fd;
		ring_initialise(&outbound[connections_ptr]);
		if (message_initialise(&inbound[connections_ptr]))
			goto fail;
	}

	connections_ptr++;
	while (connections_ptr < connections_used && connections[connections_ptr] >= 0)
		connections_ptr++;
	if (connections_used < connections_ptr)
		connections_used = connections_ptr;

	return 1;
fail:
	saved_errno = errno;
	shutdown(fd, SHUT_RDWR);
	close(fd);
	errno = saved_errno;
	return -1;
}


/**
 * Handle event on a connection to a client
 * 
 * @param   conn  The index of the connection
 * @return        1: The connection as closed
 *                0: Successful
 *                -1: Failure
 */
static int
handle_connection(size_t conn)
{
	struct message *restrict msg = &inbound[conn];
	int r, fd = connections[conn];

again:
	errno = 0;
	switch (message_read(msg, fd)) {
	default:
		break;

	case -1:
		switch (errno) {
		case EINTR:
#if defined(EAGAIN)
		case EAGAIN:
#endif
#if defined(EWOULDBLOCK) && (!defined(EAGAIN) || EAGAIN != EWOULDBLOCK)
		case EWOULDBLOCK:
#endif
			return 0;
		default:
			return -1;
		case ECONNRESET:;
			/* Fall through to `case -2` in outer switch */
		}

	case -2:
		shutdown(fd, SHUT_RDWR);
		close(fd);
		connections[conn] = -1;
		if (conn < connections_ptr)
			connections_ptr = conn;
		while (connections_used > 0 && connections[connections_used - 1] < 0)
			connections_used -= 1;
		message_destroy(msg);
		ring_destroy(&outbound[conn]);
		if (connection_closed(fd) < 0)
			return -1;
		return 1;
	}

	if ((r = dispatch_message(conn, msg)))
		return r;

	goto again;
}


/**
 * Disconnect all clients
 */
void
disconnect_all(void)
{
	size_t i;
	for (i = 0; i < connections_used; i++) {
		if (connections[i] >= 0) {
			shutdown(connections[i], SHUT_RDWR);
			close(connections[i]);
		}
	}
}


/**
 * The program's main loop
 * 
 * @return  Zero on success, -1 on error
 */
int
main_loop(void)
{
	struct pollfd *fds = NULL;
	nfds_t i, fdn = 0, fds_alloc = 0;
	int r, update, do_read, do_write, fd;
	size_t j;

	if (update_fdset(&fds, &fdn, &fds_alloc) < 0)
		goto fail;

	while (!reexec && !terminate) {
		if (connection) {
			if ((connection == 1 ? disconnect() : reconnect()) < 0) {
				connection = 0;
				goto fail;
			}
			connection = 0;
		}

		for (j = 0, i = 0; j < connections_used; j++) {
			if (connections[j] >= 0) {
				fds[i].revents = 0;
				if (ring_have_more(outbound + j))
					fds[(size_t)i++ + j].events |= POLLOUT;
				else
					fds[(size_t)i++ + j].events &= ~POLLOUT;
			}
		}
		fds[i].revents = 0;

		if (poll(fds, fdn, -1) < 0) {
			if (errno == EAGAIN)
				perror(argv0);
			else if (errno != EINTR)
				goto fail;
		}

		update = 0;
		for (i = 0; i < fdn; i++) {
			do_read  = fds[i].revents & NON_WR_POLL_EVENTS;
			do_write = fds[i].revents & POLLOUT;
			fd = fds[i].fd;
			if (!do_read && !do_write)
				continue;

			if (fd == socketfd) {
				r = handle_server();
			} else {
				for (j = 0; connections[j] != fd; j++);
				r = do_read ? handle_connection(j) : 0;
			}

			if (r >= 0 && do_write)
				r |= continue_send(j);
			if (r < 0)
				goto fail;
			update |= r > 0;
		}
		if (update && update_fdset(&fds, &fdn, &fds_alloc) < 0)
			goto fail;
	}

	free(fds);
	return 0;

fail:
	free(fds);
	return -1;
}