/*
 * Countdown timer
 *
 * Copyright (C) 2014-2015  Tomasz Kramkowski <tk@the-tk.com>
 *
 * This program is free software. It is licensed under version 3 of the
 * GNU General Public License.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see [http://www.gnu.org/licenses/].
 */

#include <errno.h>
#include <error.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <time.h>
#include <unistd.h>
#include <limits.h>

static const unsigned long long SEC_SECOND = 1, SEC_MINUTE = 60,
	     SEC_HOUR = 3600, SEC_DAY = 86400, SEC_MONTH = 2629746,
	     SEC_YEAR = 31556940;
static const unsigned long interval_nsec = 1000000000 / 4;

volatile unsigned short term_width = 0;

void sigwinch(int sig) {
	struct winsize ws;

	if (sig != SIGWINCH)
		return;

	if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == -1)
		error(1, errno, "Failed to get terminal width");

	term_width = ws.ws_col;
}

void clear_line(void)
{
	if (term_width <= 1)
		return;

	for (unsigned short i = 0; i < term_width - 1; i++)
		putchar(' ');
	putchar('\r');

	if (fflush(stdout) != 0)
		error(1, errno, "Failed to flush stdout");
}

void format_dmy(char *dest, size_t size, const char *name,
		unsigned long long count)
{
	if (count == 1)
		snprintf(dest, size, "%llu %s, ", count, name);
	else if (count > 1)
		snprintf(dest, size, "%llu %ss, ", count, name);
	else
		dest[0] = '\0';
}

void print_time(unsigned long long total_sec, bool show_colon)
{
	unsigned long long count, hours, minutes, seconds;
	char colon = show_colon ? ':' : ' ', syears[128], smonths[16], sdays[16];

	count = total_sec / SEC_YEAR;
	total_sec %= SEC_YEAR;
	format_dmy(syears, sizeof syears, "year", count);

	count = total_sec / SEC_MONTH;
	total_sec %= SEC_MONTH;
	format_dmy(smonths, sizeof smonths, "month", count);

	count = total_sec / SEC_DAY;
	total_sec %= SEC_DAY;
	format_dmy(sdays, sizeof sdays, "day", count);

	hours = total_sec / SEC_HOUR;
	total_sec %= SEC_HOUR;

	minutes = total_sec / SEC_MINUTE;
	total_sec %= SEC_MINUTE;

	seconds = total_sec / SEC_SECOND;
	total_sec %= SEC_SECOND;

	if (total_sec != 0)
		error(1, 0, "A bug occured during time formatting");

	printf(" %s%s%s%.2llu%c%.2llu%c%.2llu\r", syears, smonths, sdays, hours,
	       colon, minutes, colon, seconds);

	if (fflush(stdout) != 0)
		error(1, errno, "Failed to flush stdout");
}

unsigned long long get_seconds(char *code)
{
	size_t length = strlen(code);
	unsigned long long multiplier, retval;
	char suffix, value[length];

	if (length < 2)
		return 0;

	suffix = code[length - 1];
	switch (suffix) {
		case 's': multiplier = SEC_SECOND; break; /* 1 second */
		case 'm': multiplier = SEC_MINUTE; break; /* 1 minute */
		case 'h': multiplier = SEC_HOUR; break;	  /* 1 hour */
		case 'D': multiplier = SEC_DAY; break;	  /* 1 day */
		case 'M': multiplier = SEC_MONTH; break;  /* 30.4368 days */
		case 'Y': multiplier = SEC_YEAR; break;	  /* 365.242 days */
		default: return 0;
	}

	strncpy(value, code, sizeof value);

	value[sizeof value - 1] = '\0';

	errno = 0;
	retval = strtoul(value, NULL, 10) * multiplier; /* Possibly might overflow */
	if (retval == ULONG_MAX && errno != 0)
		error(1, errno, "Error converting time specifier %s", code);

	return retval;
}

int main(int argc, char **argv)
{
	bool blink = false;
	int sig;
	sigset_t sigset;
	struct itimerspec its = {{0, interval_nsec}, {0, interval_nsec}};
	struct sigaction sigact = {.sa_handler = sigwinch};
	timer_t timerid;
	struct sigevent sev = {.sigev_notify = SIGEV_SIGNAL,
		.sigev_signo = SIGRTMIN, .sigev_value.sival_ptr = &timerid};
	unsigned long long total_seconds = 0;

	if (!isatty(STDOUT_FILENO))
		error(1, 0, "Error: stdout is not a tty");

	if (argc < 2)
		error(1, 0, "Not enough arguments.\nUsage:\n"
		      "\t%s <n>{s,m,h,D,M,Y} ...", argv[0]);

	for (int i = 1; i < argc; i++)
		total_seconds += get_seconds(argv[i]);

	if (sigaction(SIGWINCH, &sigact, NULL) != 0)
		error(1, errno, "Unable to set SIGWINCH signal action");

	if (timer_create(CLOCK_MONOTONIC, &sev, &timerid) != 0)
		error(1, errno, "Could not create timer");

	if (sigemptyset(&sigset) != 0)
		error(1, errno, "Could not empty signal set");

	if (sigaddset(&sigset, SIGRTMIN) != 0)
		error(1, errno, "Could not add SIGRTMIN to signal set");

	if (sigprocmask(SIG_BLOCK, &sigset, NULL) != 0)
		error(1, errno, "Could not block SIGRTMIN");

	if (timer_settime(timerid, 0, &its, NULL) != 0)
		error(1, errno, "Could not set timer");

	sigwinch(SIGWINCH);

	for (unsigned long long i = 0; i < total_seconds; i++)
		for (int ii = 0; ii < 4; ii++) {
			if (sigwait(&sigset, &sig), sig != SIGRTMIN)
				error(1, 0, "sigwait returned unexpected signal %d", sig);
			if (sigaddset(&sigset, SIGRTMIN) != 0)
				error(1, errno, "Could not add SIGRTMIN to signal set");

			clear_line();
			print_time(total_seconds - i, ii < 2);
		}

	if (sigaddset(&sigset, SIGINT) != 0)
		error(1, errno, "Could not add SIGINT to signal set");

	while (true) {
		blink = !blink;
		sigwait(&sigset, &sig);
		if (sig != SIGRTMIN)
			break;

		if (sigaddset(&sigset, SIGRTMIN) != 0)
			error(1, errno, "Could not add SIGRTMIN to signal set");

		clear_line();

		if (blink)
			printf(" -- BEEP -- \a\r");

		if (fflush(stdout) != 0)
			error(1, errno, "Failed to flush stdout");
	}

	timer_delete(timerid);

	clear_line();

	return 0;
}