#include <stdio.h>
#include <unistd.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include <gfatimer.h>

/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////

typedef struct _T_PARAMS
{
	unsigned long nTriggers;
	struct timespec *ptsStart;
}T_PARAMS, *PT_PARAMS;

#define _NANOSECS_PER_SEC					1000000000

static const int g_cpt[GTCP_Last] = {250, 500, 750, 1000, 1500, 2000, 5000, 10000};

/////////////////////////////////////////////////////////////////////////////////////////

static long long _TimeSpecDiffNs(const struct timespec *pts1, const struct timespec *pts2)
{
	long long ns1 = (long long)pts1->tv_sec * _NANOSECS_PER_SEC + pts1->tv_nsec;
	long long ns2 = (long long)pts2->tv_sec * _NANOSECS_PER_SEC + pts2->tv_nsec;
	return (ns2 - ns1);
}

/////////////////////////////////////////////////////////////////////////////////////////
// callback are always called in the thread context of the timer thread!

static void _TimerCallback(int tnum, void *pContext)
{
	struct timespec tsCur;
	PT_PARAMS ptp = (PT_PARAMS)pContext;
	clock_gettime(CLOCK_MONOTONIC, &tsCur);
	long long elps = _TimeSpecDiffNs(ptp->ptsStart, &tsCur) / 1000000;
	ptp->nTriggers++;

	printf("Timer[%d] triggerd (%lu) at: %lld ms.\n", tnum, ptp->nTriggers, elps);

	if(ptp->nTriggers < 4)
		tw_set(tnum,  1000 * ptp->nTriggers); // restrigger timer
	else
	{
		printf("Timer[%d] released!\n", tnum);
		GfaUnregisterTimerCallback(tnum);
	}
}

/////////////////////////////////////////////////////////////////////////////////////////
// callback are always called in the thread context of the timer thread!

static void _ClockPulseCallback(GfaTimerClockPulse cp, int state, void *pContext)
{
	struct timespec tsCur;
	PT_PARAMS ptp = (PT_PARAMS)pContext;
	clock_gettime(CLOCK_MONOTONIC, &tsCur);
	long long elps = _TimeSpecDiffNs(ptp->ptsStart, &tsCur) / 1000000;
	
	switch(cp)
	{
	case GTCP_250ms:
		ptp->nTriggers++;
		printf("Clock pulse[%dms] triggerd (%s) at: %lld ms.\n", g_cpt[cp], state ? "+" : "-", elps);
		break;
	case GTCP_500ms:
		ptp->nTriggers++;
		printf("Clock pulse[%dms] triggerd (%s) at: %lld ms.\n", g_cpt[cp], state ? "+" : "-", elps);
		break;
	case GTCP_750ms:
		ptp->nTriggers++;
		printf("Clock pulse[%dms] triggerd (%s) at: %lld ms.\n", g_cpt[cp], state ? "+" : "-", elps);
		break;
	case GTCP_1000ms:
		ptp->nTriggers++;
		printf("Clock pulse[%dms] triggerd (%s) at: %lld ms.\n", g_cpt[cp], state ? "+" : "-", elps);
		break;
	case GTCP_1500ms:
		ptp->nTriggers++;
		printf("Clock pulse[%dms] triggerd (%s) at: %lld ms.\n", g_cpt[cp], state ? "+" : "-", elps);
		break;
	case GTCP_2000ms:
		ptp->nTriggers++;
		printf("Clock pulse[%dms] triggerd (%s) at: %lld ms.\n", g_cpt[cp], state ? "+" : "-", elps);
		break;
	case GTCP_5000ms:
		ptp->nTriggers++;
		printf("Clock pulse[%dms] triggerd (%s) at: %lld ms.\n", g_cpt[cp], state ? "+" : "-", elps);
		break;
	case GTCP_10000ms:
		ptp->nTriggers++;
		printf("Clock pulse[%dms] triggerd (%s) at: %lld ms.\n", g_cpt[cp], state ? "+" : "-", elps);
		break;
	default:
		printf("Clock pulse %d invalid!\n", cp);
		break;
	}
}

/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////

int main(int argc, char **argv)
{
	T_PARAMS tp1, tp2, tp3;
	long long elps;
	int tnum1 = 0, tnum2 = 2, nPulse, nOldPulse = 0;
	unsigned long tw = 1;
	struct timespec tsStart, tsCur, tsEnd;

	memset(&tsCur, 0, sizeof(tsCur));
	memset(&tsEnd, 0, sizeof(tsEnd));
	clock_gettime(CLOCK_MONOTONIC, &tsStart);

	/////////////////////////////////////////////////////////////////////////////////////

	if(!GfaTimerInit(32, GTR_50ms))
	{
		printf("GfaTimerInit failed!\n");
		return 1;
	}

	/////////////////////////////////////////////////////////////////////////////////////

	tp1.nTriggers = 0;
	tp1.ptsStart = &tsStart;
	GfaRegisterTimerCallback(tnum2, _TimerCallback, &tp1);

	tp2.nTriggers = 0;
	tp2.ptsStart = &tsStart;
	GfaRegisterClockPulseCallback(GTCP_500ms, _ClockPulseCallback, &tp2);

	tp3.nTriggers = 0;
	tp3.ptsStart = &tsStart;
	GfaRegisterClockPulseCallback(GTCP_1500ms, _ClockPulseCallback, &tp3);

	/////////////////////////////////////////////////////////////////////////////////////

	tf_set(tnum1);
	tf_set(tnum2);

	tw_set(tnum1, 20000);
	tw_set(tnum2,   500);

	/////////////////////////////////////////////////////////////////////////////////////
	/////////////////////////////////////////////////////////////////////////////////////
	
	do
	{
		nPulse = cp_test(GTCP_750ms);

		if(nOldPulse != nPulse)
		{
			clock_gettime(CLOCK_MONOTONIC, &tsCur);
			elps = _TimeSpecDiffNs(&tsStart, &tsCur);
			printf("    Clock pulse[%dms] polled (%s) at: %lld ms.\n", g_cpt[GTCP_750ms], nPulse ? "+" : "-", elps / 1000000);
			nOldPulse = nPulse;
		}

		if(tw && !(tw = tw_read(tnum1)))
		{
			clock_gettime(CLOCK_MONOTONIC, &tsEnd);
			printf("    Timer[%d] (polled) expired.\n", tnum1);
		}
		
		// do work ...

		usleep(25000);
	}
	while(tw);

	GfaUnregisterTimerCallback(tnum2);
	GfaUnregisterClockPulseCallback(GTCP_500ms);
	GfaUnregisterClockPulseCallback(GTCP_1500ms);
	
	GfaTimerRelease();

	/////////////////////////////////////////////////////////////////////////////////////

	elps = _TimeSpecDiffNs(&tsStart, &tsEnd);
	printf("\nTimer[%d] (polled) - effective measured time: %lld ms.\n\n", tnum1, elps / 1000000);
	return 0;
}