#include <string.h>

#include <errno.h>

#include <stdio.h>

#include <signal.h>

#include <stdlib.h>

#include <event2/bufferevent.h>

#include <event2/buffer.h>

#include <event2/listener.h>

#include <event2/util.h>

#include <event2/event.h>

#include <sys/socket.h>

#include <sys/un.h>

#include <unistd.h>

static const char MESSAGE[] = "Hello, World!\n";

static const char PATH[] = "./roura";

static void listener_cb(evutil_socket_t, short, void *);

static void conn_read_cb(struct bufferevent *, void *);

static void conn_write_cb(struct bufferevent *, void *);

static void conn_event_cb(struct bufferevent *, short, void *);

static void signal_cb(evutil_socket_t, short, void *);

static void print_socket_info(int);

int main(int argc, char **argv) {

	struct event_base *base;

	evutil_socket_t listener;

	struct event *listener_event;

	struct event *signal_event;

	struct sockaddr_un sun;

	setvbuf(stdout, NULL, _IONBF, 0);

	base = event_base_new();

	if (!base) {

		fprintf(stderr, "Could not initialize libevent!\n");

		return 1;

	}

	memset(&sun, 0, sizeof (sun));

	sun.sun_family = AF_UNIX;

	strcpy(sun.sun_path, PATH);

	listener = socket(AF_UNIX, SOCK_STREAM, 0);

	evutil_make_socket_nonblocking(listener);

	if (bind(listener, (struct sockaddr*) &sun, sizeof (sun)) < 0) {

		fprintf(stderr, "Could not create domain socket: %s!\n", PATH);

		return 1;

	}

	if (listen(listener, 16) < 0) {

		fprintf(stderr, "Could not listen\n");

		return 1;

	}

	// identifikátor serverového soketu (v současnosti číslo FD)

	printf("Nasloucháme: sun_path = %s → socketId = %d\n", sun.sun_path, listener);

	listener_event = event_new(base, listener, EV_READ | EV_PERSIST, listener_cb, (void*) base);

	if (!listener_event) {

		fprintf(stderr, "Could not do event_new\n");

		return 1;

	}

	event_add(listener_event, NULL);

	signal_event = evsignal_new(base, SIGINT, signal_cb, (void *) base);

	if (!signal_event || event_add(signal_event, NULL) < 0) {

		fprintf(stderr, "Could not create/add a signal event!\n");

		return 1;

	}

	event_base_dispatch(base);

	event_free(listener_event);

	event_free(signal_event);

	event_base_free(base);

	// smažeme soket na disku / soubor -- jinak by program příště spadl na bind()

	// TODO: co když soket někdo přesune a místo něj dá jiný soubor?

	unlink(PATH);

	printf("done\n");

	return 0;

}

static void listener_cb(evutil_socket_t listener, short event, void *user_data) {

	struct event_base *base = (event_base *) user_data;

	struct bufferevent *bev;

	struct sockaddr_storage ss;

	socklen_t slen = sizeof (ss);

	int fd = accept(listener, (struct sockaddr*) &ss, &slen);

	if (fd < 0) {

		fprintf(stderr, "Unable to accept(): %d", fd);

		return;

	} else if (fd > FD_SETSIZE) {

		// FD_SETSIZE = 1024 -- Proč? Co když bude spojení víc?

		fprintf(stderr, "fd (%d) > FD_SETSIZE (%d)", fd, FD_SETSIZE);

		close(fd);

		return;

	}

	evutil_make_socket_nonblocking(fd);

	print_socket_info(fd);

	bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);

	if (!bev) {

		fprintf(stderr, "Error constructing bufferevent!");

		event_base_loopbreak(base);

		return;

	}

	// identifikátor navázaného spojení (v současnosti číslo FD)

	int * connectionId = (int*) malloc(sizeof (fd));

	*connectionId = fd;

	bufferevent_setcb(bev, conn_read_cb, conn_write_cb, conn_event_cb, (void*) connectionId);

	bufferevent_enable(bev, EV_READ | EV_WRITE);

	printf("někdo se k nám připojil! socketId = %d → connectionId = %d / bev = %p\n", listener, *connectionId, bev);

	bufferevent_write(bev, MESSAGE, strlen(MESSAGE));

}

static void conn_read_cb(struct bufferevent *bev, void *user_data) {

	printf("conn_read_cb: connectionId = %d\n", *((int*) user_data));

	/* This callback is invoked when there is data to read on bev. */

	struct evbuffer *input = bufferevent_get_input(bev);

	struct evbuffer *output = bufferevent_get_output(bev);

	struct event_base *base = bufferevent_get_base(bev);

	size_t len = evbuffer_get_length(input);

	char *data = (char*) malloc(len);

	evbuffer_copyout(input, data, len);

	printf("we got some data: %s\n", data);

	if (memcmp(data, "exit\n", len) == 0) {

		struct timeval delay = {2, 123};

		printf("Klient říká, že máme končit; ukončuji program během %ld sekund a %ld mikrosekund.\n", delay.tv_sec, delay.tv_usec);

		event_base_loopexit(base, &delay);

	}

	evbuffer_add(output, "echo: ", 6);

	/* Copy all the data from the input buffer to the output buffer. */

	evbuffer_add_buffer(output, input);

	free(data);

}

static void conn_write_cb(struct bufferevent *bev, void *user_data) {

	printf("conn_write_cb: connectionId = %d\n", *((int*) user_data));

	struct evbuffer *output = bufferevent_get_output(bev);

	if (evbuffer_get_length(output) == 0) {

		printf("flushed answer / %p\n", bev);

		/* nebudeme ukončovat spojení

		bufferevent_free(bev);

		 */

	}

}

static void conn_event_cb(struct bufferevent *bev, short events, void *user_data) {

	int connectionId = *((int*) user_data);

	printf("conn_event_cb: connectionId = %d\n", connectionId);

	if (events & BEV_EVENT_EOF) {

		printf("Connection closed: connectionId = %d\n", connectionId);

	} else if (events & BEV_EVENT_ERROR) {

		printf("Got an error on the connectionId = %d: %s\n", connectionId, strerror(errno));

	}

	// None of the other events can happen here, since we haven't enabled timeouts

	bufferevent_free(bev);

	free(user_data);

}

static void signal_cb(evutil_socket_t sig, short events, void *user_data) {

	struct event_base *base = (event_base *) user_data;

	struct timeval delay = {2, 123};

	printf("Zachycen SIGINT (Ctrl+C); ukončuji program během %ld sekund a %ld mikrosekund.\n", delay.tv_sec, delay.tv_usec);

	event_base_loopexit(base, &delay);

}

static void print_socket_info(int fd) {

	struct ucred cr;

	unsigned int cl = sizeof (cr);

	if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cr, &cl) == 0) {

		printf("připojený klient: pid=%d, uid=%d, gid=%d\n", cr.pid, cr.uid, cr.gid);

	}

}