#include <time.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <signal.h>

#include "main.h"
#include "list.h"
#include "myTimer.h"

#ifndef PUBLIC_SERVER
#include "interface.h"
#endif

#ifdef __WIN32__
#include <windows.h>
#include <time.h>
#define DELTA_EPOCH_IN_MICROSECS  11644473600000000ULL
struct timezone 
{
  int  tz_minuteswest;
  int  tz_dsttime;
};
 
int gettimeofday(struct timeval *tv, struct timezone *tz)
{
	FILETIME ft;
	unsigned __int64 tmpres = 0;
	static int tzflag;
	if (NULL != tv) {
		GetSystemTimeAsFileTime(&ft);
	    tmpres |= ft.dwHighDateTime;
	    tmpres <<= 32;
	    tmpres |= ft.dwLowDateTime;
	    /*converting file time to unix epoch*/
	    tmpres /= 10;  /*convert into microseconds*/
	    tmpres -= DELTA_EPOCH_IN_MICROSECS; 
	    tv->tv_sec = (long)(tmpres / 1000000UL);
	    tv->tv_usec = (long)(tmpres % 1000000UL);
	}
	if (NULL != tz) {
	    if (!tzflag) {
	      _tzset();
	      tzflag++;
	    }
	    tz->tz_minuteswest = _timezone / 60;
	    tz->tz_dsttime = _daylight;
	}
	return 0;
}
#endif

static struct timeval start = { .tv_sec = 0, .tv_usec = 0 };

list_t* newTimer()
{
	return newList();
}

void restartTimer()
{
	gettimeofday(&start, NULL);
}


my_time_t getMyTime()
{
	struct timeval now;
	my_time_t ticks;

	if(  start.tv_sec == 0 && start.tv_usec == 0 )
	{
		restartTimer();
	}

	gettimeofday(&now, NULL);

	ticks = (now.tv_sec-start.tv_sec)*1000+(now.tv_usec-start.tv_usec)/1000;

	//printf("-> %d\n", ticks);
	return ticks;
}

my_time_t getMyTimeMicro()
{
	static struct timeval start = { .tv_sec = 0, .tv_usec = 0 };
	struct timeval now;
	my_time_t ticks;

	if(  start.tv_sec == 0 && start.tv_usec == 0 )
	{
		gettimeofday(&start, NULL);
	}

	gettimeofday(&now, NULL);

	ticks = (now.tv_sec-start.tv_sec)*1000*1000+(now.tv_usec-start.tv_usec);

	//printf("-> %d\n", ticks);
	return ticks;
}

my_timer_t* newTimerItem(int type, void (*fce)(void *p), void *arg, my_time_t my_time)
{
	static int new_id = 0;
	my_timer_t *new;
	
	assert( fce != NULL );

	new = malloc( sizeof(my_timer_t) );
	memset(new, 0, sizeof(my_timer_t));

	new->id = new_id++;
	new->type = type;
	new->fce = fce;
	new->arg = arg;

	new->createTime = getMyTime();
	new->time = my_time;

	return new;
}

static void destroyTimerItem(my_timer_t *p)
{
	assert( p != NULL );
	free(p);
}

int addTaskToTimer(list_t *listTimer, int type, void (*fce)(void *p), void *arg, my_time_t my_time)
{
	my_timer_t *new;

	new = newTimerItem(type, fce, arg, my_time);
	addList(listTimer, new);

	return new->id;
}

void eventTimer(list_t *listTimer)
{
	int i;
	my_timer_t *thisTimer;
	my_time_t currentTime;

 	currentTime = getMyTime();

	for( i = 0 ; i < listTimer->count ; i++ )
	{
		thisTimer = (my_timer_t *)listTimer->list[i];
		assert( thisTimer != NULL );

		switch( thisTimer->type )
		{
			case TIMER_ONE:
				if( currentTime >= thisTimer->createTime + thisTimer->time )
				{
					thisTimer->fce(thisTimer->arg);
		
					delListItem(listTimer, i, free);
					i--;
				}
			break;
			case TIMER_PERIODIC:
				if( currentTime >= thisTimer->createTime + thisTimer->time )
				{
					thisTimer->fce(thisTimer->arg);
					thisTimer->createTime = getMyTime();
				}
			break;
			default :
				assert( ! "bad timer type !" );
			break;
		}

	}
}

void delTimer(list_t *listTimer, int id)
{
	int i;
	my_timer_t *thisTimer;

	for( i = 0 ; i < listTimer->count ; i++ )
	{
		thisTimer = (my_timer_t *)listTimer->list[i];
		assert( thisTimer != NULL );

		if( thisTimer->id == id )
		{
			delListItem(listTimer, i, free);
			return;
		}
	}

	assert( ! "Uloha s id nenajdena !" );
}


void destroyTimer(list_t *listTimer)
{
	destroyListItem(listTimer, destroyTimerItem);
}