#define _BSD_SOURCE
#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdnoreturn.h>
#include <unistd.h>

#include "config.h"
#include "project.h"
#include "job.h"
#include "req.h"
#include "util.h"
#include "worker.h"

noreturn static void
usage(void)
{
	fprintf(stderr, "usage: %s [-s sock] command [args...]\n", getprogname());
	exit(1);
}

noreturn static void
help(void)
{
	fprintf(stderr, "usage: %s job-queue project tag\n", getprogname());
	fprintf(stderr, "       %s job-list worker\n", getprogname());
	fprintf(stderr, "       %s job-save id worker status retcode console\n", getprogname());
	fprintf(stderr, "       %s project-add name desc url script\n", getprogname());
	fprintf(stderr, "       %s project-list\n", getprogname());
	fprintf(stderr, "       %s script-get project\n", getprogname());
	fprintf(stderr, "       %s worker-add name desc\n", getprogname());
	fprintf(stderr, "       %s worker-list\n", getprogname());
	exit(0);
}

static char *
readfile(const char *path)
{
	FILE *fp, *str;
	static char console[SCI_MSG_MAX];
	char buf[BUFSIZ], *ret = console;
	size_t nr;

	if (strcmp(path, "-") == 0)
		fp = stdin;
	else if (!(fp = fopen(path, "r")))
		err(1, "%s", path);

	if (!(str = fmemopen(console, sizeof (console), "w")))
		err(1, "fmemopen");

	while ((nr = fread(buf, 1, sizeof (buf), fp)) > 0)
		fwrite(buf, 1, nr, str);

	if ((ferror(fp) && !feof(fp)) || (ferror(str) && !feof(str)))
		ret = NULL;

	fclose(str);
	fclose(fp);

	return ret;
}

static struct req
cmd_job_queue(int argc, char **argv)
{
	struct job job = {0};

	if (argc < 2)
		usage();

	strlcpy(job.project.name, argv[0], sizeof (job.project.name));
	strlcpy(job.tag, argv[1], sizeof (job.tag));

	return req_job_queue(&job);
}

static struct req
cmd_job_list(int argc, char **argv)
{
	struct job_result jobs[SCI_JOB_LIST_MAX];
	size_t jobsz = UTIL_SIZE(jobs);
	struct req req;

	if (argc < 1)
		usage();

	if ((req = req_job_list(jobs, &jobsz, argv[0])).status)
		return req;

	printf("%-16s%-16s%s\n", "ID", "TAG", "PROJECT");

	for (size_t i = 0; i < jobsz; ++i) {
		printf("%-16lld%-16s%s\n", (long long int)jobs[i].job.id,
		    jobs[i].job.tag, jobs[i].job.project.name);
	}

	return req;
}

static struct req
cmd_job_save(int argc, char **argv)
{
	struct job_result res = {0};

	if (argc < 5)
		usage();

	res.job.id = strtoll(argv[0], NULL, 10);
	res.status = strtoll(argv[2], NULL, 10);
	res.retcode = strtoll(argv[3], NULL, 10);
	res.console = readfile(argv[4]);
	strlcpy(res.worker.name, argv[1], sizeof (res.worker.name));

	return req_job_save(&res);
}

static struct req
cmd_project_add(int argc, char **argv)
{
	struct project pc;

	if (argc < 4)
		usage();

	memset(&pc, 0, sizeof (pc));
	strlcpy(pc.name, argv[0], sizeof (pc.name));
	strlcpy(pc.desc, argv[1], sizeof (pc.desc));
	strlcpy(pc.url, argv[2], sizeof (pc.url));
	strlcpy(pc.script, argv[3], sizeof (pc.script));

	return req_project_add(&pc);
}

static struct req
cmd_project_list(int argc, char **argv)
{
	(void)argc;
	(void)argv;

	struct project pc[SCI_PROJECT_MAX];
	struct req req;
	size_t pcsz = UTIL_SIZE(pc);

	memset(pc, 0, sizeof (pc));

	if ((req = req_project_list(pc, &pcsz)).status)
		return req;

	printf("%-16s%-24s%-20s%s\n", "NAME", "DESCRIPTION", "URL", "SCRIPT");

	for (size_t i = 0; i < pcsz; ++i)
		printf("%-16s%-24s%-20s%s\n", pc[i].name, pc[i].desc,
		    pc[i].url, pc[i].script);

	return req;
}

static struct req
cmd_script_get(int argc, char **argv)
{
	char script[SCI_MSG_MAX];
	struct req req;

	if (argc < 1)
		usage();
	if ((req = req_script_get(argv[0], script, sizeof (script))).status)
		return req;

	printf("%s", script);

	/*
	 * Don't break up the terminal output if the script does not contain a
	 * final new line.
	 */
	if (script[strlen(script) - 1] != '\n')
		printf("\n");

	return req;
}

static struct req
cmd_worker_add(int argc, char **argv)
{
	struct worker wk;

	if (argc < 2)
		usage();

	memset(&wk, 0, sizeof (wk));
	strlcpy(wk.name, argv[0], sizeof (wk.name));
	strlcpy(wk.desc, argv[1], sizeof (wk.desc));

	return req_worker_add(&wk);
}

static struct req
cmd_worker_list(int argc, char **argv)
{
	(void)argc;
	(void)argv;

	struct worker wk[SCI_WORKER_MAX];
	struct req req;
	size_t wksz = UTIL_SIZE(wk);

	if ((req = req_worker_list(wk, &wksz)).status)
		return req;

	printf("%-16s%s\n", "NAME", "DESCRIPTION");

	for (size_t i = 0; i < wksz; ++i)
		printf("%-16s%s\n",  wk[i].name, wk[i].desc);

	return req;
}

static struct {
	const char *name;
	struct req (*exec)(int, char **);
} commands[] = {
	{ "job-queue",          cmd_job_queue           },
	{ "job-list",           cmd_job_list            },
	{ "job-save",           cmd_job_save            },
	{ "project-add",        cmd_project_add         },
	{ "project-list",       cmd_project_list        },
	{ "script-get",         cmd_script_get          },
	{ "worker-add",         cmd_worker_add          },
	{ "worker-list",        cmd_worker_list         },
	{ NULL,                 NULL                    }
};

int
main(int argc, char **argv)
{
	const char *sock = VARDIR "/run/sci.sock";
	int ch, cmdfound = 0;

	setprogname("scictl");

	while ((ch = getopt(argc, argv, "s:")) != -1) {
		switch (ch) {
		case 's':
			sock = optarg;
			break;
		default:
			break;
		}
	}

	argc -= optind;
	argv += optind;

	if (argc <= 0)
		usage();
	if (strcmp(argv[0], "help") == 0)
		help();
	if (req_connect(sock) < 0)
		err(1, "%s", sock);

	for (size_t i = 0; commands[i].name; ++i) {
		struct req res;

		if (strcmp(commands[i].name, argv[0]) == 0) {
			res = commands[i].exec(--argc, ++argv);
			cmdfound = 1;

			if (res.status)
				warnx("%s", res.msg);

			break;
		}
	}

	if (!cmdfound)
		errx(1, "abort: command %s not found", argv[0]);

	req_finish();
}