#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <pthread.h>
#include <string.h>
#include <signal.h>
#include <errno.h>

#define SOCKET_PATH "/tmp/sta.sock"

typedef struct{
	const char *(*func)(const char *);
	const char *fmt;
	const char *parm;
	int id;
	int delay;
}Args;

#include "util.h"
#include "config.h"

pthread_mutex_t list_mutex = PTHREAD_MUTEX_INITIALIZER;

typedef struct {
	int id;
	char *name;
} Pro;

typedef struct {
	Pro *process;
	int count;
} Pros;

typedef struct {
	int id2;
	Pros *list;
} Potato;

Pros *init()
{
	Pros *list = malloc(sizeof(Pros));
	list->process = NULL;
	list->count = 0;
	return list;
}

void add_pro(Pros *list, int id, const char *name)
{
	for (int i = 0; i < list->count; ++i) {
		if (id == list->process[i].id) {
			free(list->process[i].name);
			list->process[i].name = strdup(name);
			return;
		}
	}
	list->count++;
	list->process = realloc(list->process, sizeof(Pro) * list->count);
	if (!list->process) {
		warn("Memory: memory allocation failed.");
		exit(1);
	}
	list->process[list->count - 1].name = strdup(name);
	list->process[list->count - 1].id = id;
}

void show_pros(Pros *list)
{
	for (int i = 0; i < list->count - 1; i++) {
		for (int j = i + 1; j < list->count; j++) {
			if (list->process[i].id > list->process[j].id) {
				Pro temp = list->process[i];
				list->process[i] = list->process[j];
				list->process[j] = temp;
			}
		}
	}
	for (int a = 0; a < list->count; ++a)
		printf("%s", list->process[a].name);
	printf("\n");
	fflush(stdout);
}

void usage()
{
	printf("Usage:\n");
	printf("\t-id        <number>       => process id (id >= 1)\n");
	printf("\t-name      <string>       => process name\n");
	printf("\t-h -help                  => print this help menu\n");
	exit(1);
}

void append(Args *command, Pros *list)
{
	const char *cmd = command->func(command->parm);
	if (!cmd) cmd = "N/A";
	char tmp[256];
	snprintf(tmp, sizeof(tmp), command->fmt, cmd);
	add_pro(list, command->id, tmp);
	show_pros(list);
}

void *worker(void *arg)
{
	Potato *data = arg;
	Args command = commands[data->id2];
	while (1) {
		pthread_mutex_lock(&list_mutex);
		append(&command, data->list);
		pthread_mutex_unlock(&list_mutex);
		usleep(command.delay * 1000);
	}
	return NULL;
}

void run_server(struct sockaddr_un *addr, int sock, Pros *list)
{
	int cmds = sizeof(commands) / sizeof(commands[0]);

	if (bind(sock, (struct sockaddr *)addr, sizeof(*addr)) < 0)
		warn("Bind: failed: %s", strerror(errno));

	if (listen(sock, 5) < 0)
		warn("Listen failed: %s", strerror(errno));

	pthread_t tids[cmds];
	for (int i = 0; i < cmds; ++i) {
		if (commands[i].delay) {
			Potato *info = malloc(sizeof(Potato));
			info->list = list;
			info->id2 = i;
			if (pthread_create(&tids[i], NULL, worker, info))
				warn("Thread: can't create thread for id: %d", info->id2);
		} else {
			append(&commands[i], list);
		}
	}

	while (1) {
		int client = accept(sock, NULL, NULL);
		if (client < 0) continue;

		char buf[256], name[256];
		int n, id;

		while ((n = recv(client, buf, sizeof(buf) - 1, 0)) > 0) {
			buf[n] = '\0';
			char *s = strstr(buf, "|+|");
			if (s) {
				*s = '\0';
				id = atoi(buf);
				strncpy(name, s + 3, sizeof(name) - 1);
				name[sizeof(name) - 1] = '\0';
				add_pro(list, id, name);
				show_pros(list);
			}
		}
		close(client);
	}
}

void run_client(int argc, char const *argv[], struct sockaddr_un *addr, int sock)
{
	int id = -1;
	char *name = NULL;
	char buf[256];

	for (int i = 1; i < argc; i++) {
		if (!strcmp("-h", argv[i]) || !strcmp("-help", argv[i]))
			usage();
		if (!strcmp("-id", argv[i]) && i + 1 < argc)
			id = atoi(argv[++i]);
		else if (!strcmp("-name", argv[i]) && i + 1 < argc)
			name = (char *)argv[++i];
	}

	if (id <= 0)
		usage();

	if (name) {
		snprintf(buf, sizeof(buf), "%d|+|%s", id, name);
	} else {
		buf[0] = '\0';
		for (int i = 0; i < (int)(sizeof(commands) / sizeof(commands[0])); ++i) {
			if (id == commands[i].id) {
				const char *cmd = commands[i].func(commands[i].parm);
				if (!cmd) cmd = "N/A";
				char tmp[256];
				snprintf(tmp, sizeof(tmp), commands[i].fmt, cmd);
				snprintf(buf, sizeof(buf), "%d|+|%s", id, tmp);
				break;
			}
		}
		if (buf[0] == '\0') {
			warn("Client: no command found for id %d", id);
			return;
		}
	}

	if (connect(sock, (struct sockaddr *)addr, sizeof(*addr)) < 0) {
		warn("Connect: failed: %s", strerror(errno));
		return;
	}
	write(sock, buf, strlen(buf));
}

int main(int argc, char const *argv[])
{
	struct sockaddr_un addr = {0};
	addr.sun_family = AF_UNIX;
	strcpy(addr.sun_path, SOCKET_PATH);

	int sock = socket(AF_UNIX, SOCK_STREAM, 0);
	if (sock < 0)
		warn("Socket: failed to create socket: %s", strerror(errno));

	Pros *list = init();

	for (int i = 1; i < argc; ++i) {
		  if (strcmp(argv[i], "-s") == 0 || strcmp(argv[i], "--server") == 0) {
			if (access(SOCKET_PATH, F_OK) == 0){
				int checking_sock = socket(AF_UNIX, SOCK_STREAM, 0);
				if (checking_sock >= 0) {
				  if (connect(checking_sock, (struct sockaddr *)&addr, sizeof(addr)) == 0)
					  die("Socket: socket exists and connectable.");		
				  close(checking_sock);
				}
			if (unlink(SOCKET_PATH) == -1)
			  die("Socket: socket clean up failed.");
			}
			run_server(&addr, sock, list);
		}
	}

	if (access(SOCKET_PATH, F_OK) == 0) {
		run_client(argc, argv, &addr, sock);
		goto clean_up;
	}

	warn("ERROR: server not running (no socket at " SOCKET_PATH ")");
	unlink(SOCKET_PATH);
clean_up:
	close(sock);
	return 0;
}