#define _GNU_SOURCE
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <inttypes.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sched.h>
#include <poll.h>
#include <errno.h>
#include <sched.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>

#include "main.h"
#include "uring.h"
#include "server.h"
#include "proxy.h"
#include "utils.h"
#include "config.h"
#include "idle.h"
#include "rcon.h"
#include "systemd.h"

struct server_local {
	struct saddr local;
	struct saddr client;
	struct uring_task task;
	struct list_head list;
};

static bool
set_property(struct cfg *cfg, struct server *server, char **property, const char *value)
{
	assert_return(cfg && server && !*property && !empty_str(value), false);

	*property = xstrdup(value);
	if (!*property) {
		error("strdup: %m");
		return false;
	}

	return true;
}

void
server_refdump(struct server *server)
{
	struct server_local *local;
	struct server_proxy *proxy;

	assert_return(server);

	uring_task_refdump(&server->task);
	list_for_each_entry(local, &server->locals, list)
		uring_task_refdump(&local->task);
	list_for_each_entry(proxy, &server->proxys, list)
		proxy_refdump(proxy);
	idle_refdump(server->idle);
	rcon_refdump(server->rcon);
}

static void
server_free(struct uring_task *task)
{
	struct server *server = container_of(task, struct server, task);

	assert_return(task);

	debug(DBG_SRV, "freeing server %s (%p)", server->name, server);
	list_del(&server->list);
	xfree(server->pretty_name);
	xfree(server->start_exec);
	xfree(server->stop_exec);
	xfree(server->systemd_service);
	xfree(server->systemd_obj);
	xfree(server->rcon_password);
	xfree(server->name);
	xfree(server);
}

void
server_delete(struct cfg *cfg, struct server *server)
{
	struct server_local *local, *ltmp;
	struct server_proxy *proxy, *ptmp;
	struct saddr *remote;
	struct saddr *rcon;
	struct saddr *tmp;
	struct dns_async *dns, *dtmp;

	assert_return(cfg && server);

	verbose("Removing server %s", server->name);

	idle_delete(cfg, server);
	rcon_delete(cfg, server);

	list_for_each_entry_safe(local, ltmp, &server->locals, list)
		uring_task_destroy(cfg, &local->task);

	list_for_each_entry_safe(proxy, ptmp, &server->proxys, list)
		proxy_delete(cfg, proxy);

	list_for_each_entry_safe(rcon, tmp, &server->rcons, list) {
		list_del(&rcon->list);
		xfree(rcon);
	}

	list_for_each_entry_safe(remote, tmp, &server->remotes, list) {
		list_del(&remote->list);
		xfree(remote);
	}

	list_for_each_entry_safe(dns, dtmp, &server->dnslookups, list)
		gai_cancel(&dns->gcb);
		
	uring_poll_cancel(cfg, &server->exec_task);
	uring_task_put(cfg, &server->exec_task);
	uring_task_destroy(cfg, &server->task);
}

void
server_delete_by_name(struct cfg *cfg, const char *name)
{
	struct server *server;

	assert_return(cfg && !empty_str(name));

	list_for_each_entry(server, &cfg->servers, list) {
		if (streq(server->name, name)) {
			server_delete(cfg, server);
			return;
		}
	}
}

static void
server_dump(struct server *server)
{
	struct server_local *local;
	struct saddr *remote;
	struct saddr *rcon;

	assert_return(server);

	verbose("Server %s:", server->name);
	switch (server->type) {
	case SERVER_TYPE_ANNOUNCE:
		verbose("  * Type: announce");
		break;
	case SERVER_TYPE_PROXY:
		verbose("  * Type: proxy");
		break;
	default:
		verbose("  * Type: unknown");
		break;
	}
	verbose("  * Name: %s", server->pretty_name ? server->pretty_name : "<undefined>");
	verbose("  * Announce port: %" PRIu16, server->announce_port); 

	if (!list_empty(&server->locals)) {
		verbose("  * Local:");
		list_for_each_entry(local, &server->locals, list)
			verbose("    * %s", local->local.addrstr);
	}

	if (!list_empty(&server->remotes)) {
		verbose("  * Remote:");
		list_for_each_entry(remote, &server->remotes, list)
			verbose("    * %s", remote->addrstr);
	}

	if (!list_empty(&server->rcons)) {
		verbose("  * RCon:");
		list_for_each_entry(rcon, &server->rcons, list)
			verbose("    * %s", rcon->addrstr);
	}

	verbose("");
}

static void
server_local_free(struct uring_task *task)
{
	struct server_local *local = container_of(task, struct server_local, task);

	assert_return(task);

	debug(DBG_SRV, "task %p, local %p", task, local);
	list_del(&local->list);
	xfree(local);
}

static void
server_local_accept(struct cfg *cfg, struct uring_task *task, int res)
{
	struct server_local *local = container_of(task, struct server_local, task);
	struct server *server = container_of(task->parent, struct server, task);
	struct server_proxy *proxy;

	assert_return(cfg && task);
	assert_task_alive(DBG_SRV, task);

	debug(DBG_SRV, "task %p, res %i, server %s", task, res, server->name);

	if (res < 0) {
		error("result was %i", res);
		goto out;
	}

	saddr_set_addrstr(&local->client);

	verbose("%s: incoming proxy connection: %s -> %s",
		server->name, local->client.addrstr, local->local.addrstr);

	if (list_empty(&server->remotes)) {
		/* This shouldn't be possible, checked before opening local */
		error("server->remotes empty!");
		uring_close(cfg, &local->task, res);
		goto out;
	}

	proxy = proxy_new(cfg, server, &local->client, res);
	if (!proxy)
		uring_close(cfg, &local->task, res);

out:
	uring_accept(cfg, &local->task, &local->client, server_local_accept);
}

static bool
server_local_open(struct cfg *cfg, struct server *server, struct server_local *local)
{
	int sfd;
	int option;
	int r;

	assert_return(cfg && server && local, false);

	sfd = socket(local->local.storage.ss_family, SOCK_STREAM | SOCK_CLOEXEC, 0);
	if (sfd < 0) {
		error("socket: %m");
		goto error;
	}

	option = true;
	if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)) < 0) {
		error("setsockopt: %m");
		goto error;
	}

	/* The MC protocol expects the client to send data first */
	/* FIXME: could make this configurable */
	option = true;
	if (setsockopt(sfd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &option, sizeof(option)) < 0)
		error("setsockopt: %m");

	/* FIXME: could make this configurable */
	option = true;
	if (setsockopt(sfd, IPPROTO_IP, IP_FREEBIND, &option, sizeof(option)) < 0)
		error("setsockopt: %m");

	socket_set_low_latency(cfg, sfd);

	r = bind(sfd, (struct sockaddr *)&local->local.storage, local->local.addrlen);
	if (r < 0) {
		error("bind: %m");
		goto error;
	}

	r = listen(sfd, 100);
	if (r < 0) {
		error("listen: %m");
		goto error;
	}

	uring_task_set_fd(&local->task, sfd);
	uring_accept(cfg, &local->task, &local->client, server_local_accept);
	return true;

error:
	if (sfd >= 0)
		close(sfd);
	return false;
}

static void
server_exec_free(struct uring_task *task)
{
	assert_return(task);

	debug(DBG_SRV, "called");
}

#ifndef P_PIDFD
#define P_PIDFD 3
#endif

/* FIXME: update states */
static void
server_exec_done(struct cfg *cfg, struct uring_task *task, int res)
{
	struct server *server = container_of(task, struct server, exec_task);
	int r;
	siginfo_t info;

	assert_return(cfg && task);
	assert_task_alive_or(DBG_SRV, task, goto out);
	/* Should we leave child processes running? */

	if (!(res & POLLIN)) {
		error("unexpected result: %i", res);
		goto out;
	}

	r = waitid(P_PIDFD, server->exec_task.fd, &info, WEXITED);
        if (r < 0) {
                error("waitid: %m");
		goto out;
        }

	if (info.si_status == 0)
		debug(DBG_SRV, "command successfully executed");
	else
		error("command failed: %i", info.si_status);

out:
	uring_task_close_fd(cfg, &server->exec_task);
}

static int
server_exec_child(void *ptr)
{
	const char *cmd = ptr;

	assert_return(ptr, EINVAL);

	execl(cmd, cmd, NULL);
	return errno;
}

#ifndef CLONE_PIDFD
#define CLONE_PIDFD 0x00001000
#endif

static bool
server_exec(struct cfg *cfg, struct server *server, const char *cmd)
{
	char stack[4096]; /* Beautiful/horrible hack :) */
	int pidfd;
	int r;

	assert_return(cfg && server && cmd && server->exec_task.fd < 1, false);

        r = clone(server_exec_child, stack + sizeof(stack),
                  CLONE_VM | CLONE_VFORK | CLONE_PIDFD | SIGCHLD,
                  (void *)cmd, &pidfd);
	if (r != 0) {
		error("clone: %m");
		return false;
	}

	uring_task_set_fd(&server->exec_task, pidfd);
	uring_poll(cfg, &server->exec_task, POLLIN, server_exec_done);
	return true;
}

static bool
server_check_running(struct cfg *cfg, struct server *server)
{
	assert_return(cfg && server, false);

	/* FIXME: other methods, rcon? */
	if (server->systemd_service) {
		verbose("%s: checking if systemd service is running", server->name);
		if (systemd_service_running(cfg, server)) {
			server->state = SERVER_STATE_RUNNING;
			return true;
		} else {
			server->state = SERVER_STATE_STOPPED;
			return false;
		}
	}

	return false;
}

bool
server_start(struct cfg *cfg, struct server *server)
{
	assert_return(cfg && server, false);
	assert_task_alive_or(DBG_SRV, &server->task, return false);

	switch (server->start_method) {

	case SERVER_START_METHOD_EXEC:
		verbose("Starting server %s via external cmd", server->name);
		return server_exec(cfg, server, server->start_exec);

	case SERVER_START_METHOD_SYSTEMD:
		verbose("Starting server %s via systemd (%s)",
			server->name, server->systemd_service);

		if (systemd_service_start(cfg, server)) {
			server->state = SERVER_STATE_RUNNING;
			return true;
		} else
			return server_check_running(cfg, server);

	case SERVER_START_METHOD_UNDEFINED:
	default:
		break;
	}

	return false;
}

bool
server_stop(struct cfg *cfg, struct server *server)
{
	assert_return(cfg && server, false);
	assert_task_alive_or(DBG_SRV, &server->task, return false);

	switch (server->stop_method) {

	case SERVER_STOP_METHOD_EXEC:
		verbose("Stopping server %s via external cmd", server->name);
		return server_exec(cfg, server, server->stop_exec);

	case SERVER_STOP_METHOD_SYSTEMD:
		verbose("Stopping server %s via systemd (%s)",
			server->name, server->systemd_service);
		if (systemd_service_stop(cfg, server)) {
			server->state = SERVER_STATE_STOPPED;
			return true;
		} else
			return server_check_running(cfg, server);

	case SERVER_STOP_METHOD_RCON:
		verbose("Stopping server %s via rcon", server->name);
		rcon_init(cfg, server);
		return true;

	case SERVER_STOP_METHOD_UNDEFINED:
	default:
		break;
	}

	return false;
}

bool
server_commit(struct cfg *cfg, struct server *server)
{
	struct server_local *local;
	uint16_t port;

	assert_return(cfg && server && server->name, false);
	assert_task_alive_or(DBG_SRV, &server->task, return false);

	if (server->state != SERVER_STATE_INIT) {
		error("called in wrong state");
		return false;
	}

	if (!list_empty(&server->proxys)) {
		error("%s: proxys not empty?", server->name);
		return false;
	}

	if (!list_empty(&server->dnslookups)) {
		debug(DBG_SRV, "called with pending DNS requests");
		return true;
	}

	if (server->stop_method == SERVER_STOP_METHOD_RCON &&
	    list_empty(&server->rcons)) {
		error("%s: rcon stop method missing rcon address",
		      server->name); 
		return false;
	}

	if (server->stop_method == SERVER_STOP_METHOD_RCON &&
	    !server->rcon_password) {
		error("%s: rcon stop method missing rcon password",
		      server->name); 
		return false;
	}

	if ((server->start_method == SERVER_START_METHOD_SYSTEMD ||
	     server->stop_method == SERVER_STOP_METHOD_SYSTEMD) &&
	    !server->systemd_service) {
		error("%s: systemd start/stop method missing systemd service",
		      server->name); 
		return false;
	}

	if (server->systemd_service && !server->systemd_obj) {
		server->systemd_obj = systemd_service_object_path(cfg,
								server->systemd_service);
		if (!server->systemd_obj) {
			error("%s: failed to create systemd object path (%s)",
			      server->name, server->systemd_service);
			return false;
		}
	}

	if (server->idle_timeout > 0 &&
	    server->stop_method == SERVER_STOP_METHOD_UNDEFINED) {
		error("%s: idle_timeout set but missing stop method", server->name); 
		return false;
	}

	switch (server->type) {
	case SERVER_TYPE_ANNOUNCE:
		if (server->announce_port < 1) {
			error("%s: missing announce port", server->name); 
			return false;
		}

		if (server->start_method != SERVER_START_METHOD_UNDEFINED) {
			error("%s: can't set start_method for announce server", server->name);
			return false;
		}

		if (!list_empty(&server->locals)) {
			error("%s: can't set local addresses for announce server", server->name);
			return false;
		}

		if (!list_empty(&server->remotes)) {
			error("%s: can't set remote addresses for announce server", server->name);
			return false;
		}

		break;

	case SERVER_TYPE_PROXY:
		if (server->announce_port >= 1) {
			error("%s: can't set announce port for proxy server", server->name); 
			return false;
		}

		if (list_empty(&server->locals)) {
			error("%s: missing local addresses for proxy server", server->name);
			return false;
		}

		if (list_empty(&server->remotes)) {
			error("%s: missing remote addresses for proxy server", server->name);
			return false;
		}

		list_for_each_entry(local, &server->locals, list) {
			port = saddr_port(&local->local);

			if (port == 0) {
				error("%s: invalid local port", server->name);
				return false;
			}

			if (server->announce_port < 1)
				server->announce_port = port;

			if (server->announce_port != port) {
				error("%s: multiple local ports", server->name);
				return false;
			}
		}

		if (server->announce_port < 1) {
			error("%s: can't determine which port to announce", server->name);
			return false;
		}

		break;

	default:
		error("%s: can't determine server type", server->name);
		return false;
	}

	if (!server->pretty_name) {
		char *suffix;
		
		suffix = strrchr(server->name, '.');
		if (!suffix || suffix == server->name) {
			error("invalid server name: %s", server->name);
			return false;
		}

		server->pretty_name = xstrndup(server->name, suffix - server->name);
		if (!server->pretty_name) {
			error("failed to create display name: %s", server->name);
			return false;
		}
	}

	/* FIXME: config, dont reread config if server running, make sure fd is available before this is called */
	server_dump(server);

	list_for_each_entry(local, &server->locals, list) {
		server_local_open(cfg, server, local);
	}

	idle_init(cfg, server);
	server->state = SERVER_STATE_CFG_OK;

	server_check_running(cfg, server);

	debug(DBG_SRV, "success");
	return true;
}

bool
server_add_remote(struct cfg *cfg, struct server *server, struct saddr *remote)
{
	assert_return(cfg && server && remote, false);
	assert_task_alive_or(DBG_SRV, &server->task, return false);

	debug(DBG_SRV, "adding remote: %s", remote->addrstr);
	list_add(&remote->list, &server->remotes);
	return true;
}

bool
server_add_local(struct cfg *cfg, struct server *server, struct saddr *saddr)
{
	struct server_local *local;

	assert_return(cfg && server && saddr, false);
	assert_task_alive_or(DBG_SRV, &server->task, return false);

	local = zmalloc(sizeof(*local));
	if (!local) {
		error("malloc: %m");
		return false;
	}

	debug(DBG_SRV, "adding local: %s", saddr->addrstr);
	local->local = *saddr;
	uring_task_init(cfg, &local->task, "local", &server->task, server_local_free);
	list_add(&local->list, &server->locals);
	xfree(saddr);
	return true;
}

bool
server_add_rcon(struct cfg *cfg, struct server *server, struct saddr *rcon)
{
	assert_return(cfg && server && rcon, false);
	assert_task_alive_or(DBG_SRV, &server->task, return false);

	debug(DBG_SRV, "adding rcon: %s", rcon->addrstr);
	list_add(&rcon->list, &server->rcons);
	return true;
}

bool
server_set_rcon_password(struct cfg *cfg, struct server *server,
			 const char *password)
{
	assert_return(cfg && server && !empty_str(password), false);

	return set_property(cfg, server, &server->rcon_password, password);
}

bool
server_set_systemd_service(struct cfg *cfg, struct server *server,
			   const char *service)
{
	const char *suffix;
	char *tmp;

	assert_return(cfg && server && !empty_str(service) && !server->systemd_service, false);

	suffix = strrchr(service, '.');
	if (!suffix || !streq(suffix, ".service")) {
		tmp = zmalloc(strlen(service) + strlen(".service") + 1);
		if (tmp)
			sprintf(tmp, "%s.service", service);
	} else
		tmp = xstrdup(service);

	if (!tmp) {
		error("malloc/strdup: %m");
		return false;
	}

	server->systemd_service = tmp;
	return true;
}

bool
server_set_stop_method(struct cfg *cfg, struct server *server,
		       enum server_stop_method stop_method)
{
	assert_return(server->stop_method == SERVER_STOP_METHOD_UNDEFINED &&
		      stop_method != SERVER_STOP_METHOD_UNDEFINED, false);

	server->stop_method = stop_method;
	return true;
}

bool
server_set_start_method(struct cfg *cfg, struct server *server,
			enum server_start_method start_method)
{
	assert_return(server->start_method == SERVER_START_METHOD_UNDEFINED &&
		      start_method != SERVER_START_METHOD_UNDEFINED, false);

	server->start_method = start_method;
	return true;
}

bool
server_set_stop_exec(struct cfg *cfg, struct server *server, const char *cmd)
{
	assert_return(cfg && server && !empty_str(cmd), false);

	return set_property(cfg, server, &server->stop_exec, cmd);
}

bool
server_set_start_exec(struct cfg *cfg, struct server *server, const char *cmd)
{
	assert_return(cfg && server && !empty_str(cmd), false);

	return set_property(cfg, server, &server->start_exec, cmd);
}

bool
server_set_idle_timeout(struct cfg *cfg, struct server *server, uint16_t timeout)
{
	assert_return(cfg && server && timeout > 0 && server->idle_timeout == 0, false);

	server->idle_timeout = timeout;
	return true;
}

bool
server_set_port(struct cfg *cfg, struct server *server, uint16_t port)
{
	assert_return(cfg && server && port > 0 && server->announce_port == 0, false);

	server->announce_port = htons(port);
	return true;
}

bool
server_set_type(struct cfg *cfg, struct server *server, enum server_type type)
{
	assert_return(cfg && server && type != SERVER_TYPE_UNDEFINED, false);

	switch (type) {
	case SERVER_TYPE_ANNOUNCE:
		server->type = SERVER_TYPE_ANNOUNCE;
		break;
	case SERVER_TYPE_PROXY:
		server->type = SERVER_TYPE_PROXY;
		break;
	default:
		return false;
	}

	return true;
}

bool
server_set_pretty_name(struct cfg *cfg, struct server *server, const char *pretty_name)
{
	assert_return(cfg && server && !empty_str(pretty_name), false);

	return set_property(cfg, server, &server->pretty_name, pretty_name);
}

struct server *
server_new(struct cfg *cfg, const char *name)
{
	struct server *server;

	assert_return(cfg && !empty_str(name), NULL);

	list_for_each_entry(server, &cfg->servers, list) {
		if (!streq(name, server->name))
			continue;
		error("attempt to add duplicate server: %s", name);
		return server;
	}

	verbose("Adding server %s", name);
	server = zmalloc(sizeof(*server));
	if (!server) {
		error("malloc");
		return NULL;
	}

	server->state = SERVER_STATE_INIT;
	server->cfg = cfg;
	server->type = SERVER_TYPE_UNDEFINED;
	server->name = xstrdup(name);
	server->stop_method = SERVER_STOP_METHOD_UNDEFINED;
	server->start_method = SERVER_START_METHOD_UNDEFINED;
	uring_task_init(cfg, &server->task, "server", uring_parent(cfg), server_free);
	uring_task_set_buf(&server->task, &server->tbuf);
	uring_task_init(cfg, &server->exec_task, "exec", &server->task, server_exec_free);
	list_init(&server->remotes);
	list_init(&server->locals);
	list_init(&server->proxys);
	list_init(&server->rcons);
	list_init(&server->dnslookups);
	server->idle_timeout = 0;
	list_add(&server->list, &cfg->servers);

	return server;
}