/*
 * fibredemo.c
 *
 * Part of librfn (a general utility library from redfelineninja.org.uk)
 *
 * Copyright (C) 2013 Daniel Thompson <daniel@redfelineninja.org.uk>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 */

#include <assert.h>
#include <stdio.h>
#include <string.h>

#include "librfn.h"


typedef union {
	enum update_event_id {
		UPDATE_EVENT_TIME,
		UPDATE_EVENT_EXIT,
	} id;

	/* all the remaining event structures must commence with enum
	 * update_event_id to ensure we never clobber the event id.
	 */

	struct {
		enum update_event_id id;
		unsigned int minutes;
		unsigned int seconds;
	} time;

	struct {
		enum update_event_id id;
		int status;
	} exit;
} update_event_t;

int update_handler(fibre_t *fibre)
{
	fibre_eventq_t *evtq = containerof(fibre, fibre_eventq_t, fibre);

	PT_BEGIN_FIBRE(fibre);

	while (true) {
		update_event_t *evt;

		/* wait until we receive an event to act upon */
		PT_WAIT_UNTIL(NULL != (evt = fibre_eventq_receive(evtq)));

		/* react to the event */
		switch(evt->id) {
		case UPDATE_EVENT_TIME:
			printf("\r%02d:%02d", evt->time.minutes,
					evt->time.seconds);
			fflush(stdout);
			break;
		case UPDATE_EVENT_EXIT:
			printf("\n\nTime is up\n");
			exit(evt->exit.status);
			break;
		default:
			assert(0);
			break;
		}

		/* the eventq is zero-copy so we must let it know when we
		 * have finished with the event.
		 */
		fibre_eventq_release(evtq, evt);
	}

	PT_END();
}

update_event_t update_eventq[8];
fibre_eventq_t updater = FIBRE_EVENTQ_VAR_INIT(
		update_handler, update_eventq, sizeof(update_eventq),
		sizeof(update_eventq[0]));


typedef struct {
	uint32_t time;
	unsigned int minutes;
	unsigned int seconds;
	unsigned int exit_after_minutes;
	unsigned int exit_after_seconds;
	fibre_t fibre;
} stopwatch_fibre_t;

int stopwatch_fibre(fibre_t *fibre)
{
	stopwatch_fibre_t *clock = containerof(fibre, stopwatch_fibre_t, fibre);

	PT_BEGIN_FIBRE(fibre);

	/* initialize the duetime from the current time (making this the the
	 * time from which the stopwatch will measure time)
	 */
	clock->time = time_now();

	while (true) {
		update_event_t *evt;

		/* send the current time to the event handler */
		if (NULL != (evt = fibre_eventq_claim(&updater))) {
			evt->id = UPDATE_EVENT_TIME;
			evt->time.minutes = clock->minutes;
			evt->time.seconds = clock->seconds;
			(void) fibre_eventq_send(&updater, evt);
		}
		/* "error handling" usually comes from errors being logged as
		 * scheduler "taints"
		 */

		/* has the stopwatch expired? */
		if ((clock->exit_after_minutes || clock->exit_after_seconds) &&
		    clock->exit_after_minutes <= clock->minutes &&
		    clock->exit_after_seconds <= clock->seconds &&
		    NULL != (evt = fibre_eventq_claim(&updater))) {
			evt->id = UPDATE_EVENT_EXIT;
			evt->exit.status = 0;
			(void) fibre_eventq_send(&updater, evt);
		}

		/* increment the duetime by a second and wait for the duetime
		 * to expire.
		 */
		clock->time += 1000000;
		PT_WAIT_UNTIL(fibre_timeout(clock->time));

		/* update the recorded time */
		clock->seconds += 1;
		if (clock->seconds >= 60) {
			clock->seconds = 0;
			clock->minutes += 1;
		}
	}

	PT_END();
}

stopwatch_fibre_t stopwatch = {
		.fibre = FIBRE_VAR_INIT(stopwatch_fibre)
};

int main(int argc, char *argv[])
{
	switch(argc) {
	int n;
	case 0:
	case 1:
		// do nothing
		break;
	default:
		fprintf(stderr, "Too many arguments - "
				"all except '%s' will be ignored\n", argv[1]);
		/* no break */
	case 2:
		n = sscanf(argv[1], "%d:%d",
				&stopwatch.exit_after_minutes,
				&stopwatch.exit_after_seconds);
		switch (n) {
		case 2:
			// do nothing
			break;
		case 1:
			stopwatch.exit_after_seconds =
					stopwatch.exit_after_minutes;
			stopwatch.exit_after_minutes = 0;
			break;
		case 0:
			fprintf(stderr, "Cannot extract meaningful time "
					"from '%s'\n", argv[1]);
			break;
		}
		break;
	}

	fibre_run(&stopwatch.fibre);
	fibre_run(&updater.fibre);

	fibre_scheduler_main_loop();

	return 0;
}