/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2006 Sam Lantinga

    This library 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 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public

    License along with this library; if not, write to the Free Software

    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga

    slouken@libsdl.org

*/

#include "SDL_config.h"

#include "SDL_timer.h"

#include "SDL_timer_c.h"

#include "SDL_mutex.h"

#include "SDL_systimer.h"

/* #define DEBUG_TIMERS */

int SDL_timer_started = 0;

int SDL_timer_running = 0;

/* Data to handle a single periodic alarm */

Uint32 SDL_alarm_interval = 0;

SDL_TimerCallback SDL_alarm_callback;

/* Data used for a thread-based timer */

static int SDL_timer_threaded = 0;

struct _SDL_TimerID {

	Uint32 interval;

	SDL_NewTimerCallback cb;

	void *param;

	Uint32 last_alarm;

	struct _SDL_TimerID *next;

};

static SDL_TimerID SDL_timers = NULL;

static SDL_mutex *SDL_timer_mutex;

static volatile SDL_bool list_changed = SDL_FALSE;

/* Set whether or not the timer should use a thread.

   This should not be called while the timer subsystem is running.

*/

int SDL_SetTimerThreaded(int value)

{

	int retval;

	if ( SDL_timer_started ) {

		SDL_SetError("Timer already initialized");

		retval = -1;

	} else {

		retval = 0;

		SDL_timer_threaded = value;

	}

	return retval;

}

int SDL_TimerInit(void)

{

	int retval;

	retval = 0;

	if ( SDL_timer_started ) {

		SDL_TimerQuit();

	}

	if ( ! SDL_timer_threaded ) {

		retval = SDL_SYS_TimerInit();

	}

	if ( SDL_timer_threaded ) {

		SDL_timer_mutex = SDL_CreateMutex();

	}

	if ( retval == 0 ) {

		SDL_timer_started = 1;

	}

	return(retval);

}

void SDL_TimerQuit(void)

{

	SDL_SetTimer(0, NULL);

	if ( SDL_timer_threaded < 2 ) {

		SDL_SYS_TimerQuit();

	}

	if ( SDL_timer_threaded ) {

		SDL_DestroyMutex(SDL_timer_mutex);

		SDL_timer_mutex = NULL;

	}

	SDL_timer_started = 0;

	SDL_timer_threaded = 0;

}

void SDL_ThreadedTimerCheck(void)

{

	Uint32 now, ms;

	SDL_TimerID t, prev, next;

	SDL_bool removed;

	SDL_mutexP(SDL_timer_mutex);

	list_changed = SDL_FALSE;

	now = SDL_GetTicks();

	for ( prev = NULL, t = SDL_timers; t; t = next ) {

		removed = SDL_FALSE;

		ms = t->interval - SDL_TIMESLICE;

		next = t->next;

		if ( (int)(now - t->last_alarm) > (int)ms ) {

			struct _SDL_TimerID timer;

			if ( (now - t->last_alarm) < t->interval ) {

				t->last_alarm += t->interval;

			} else {

				t->last_alarm = now;

			}

#ifdef DEBUG_TIMERS

			printf("Executing timer %p (thread = %d)\n",

				t, SDL_ThreadID());

#endif

			timer = *t;

			SDL_mutexV(SDL_timer_mutex);

			ms = timer.cb(timer.interval, timer.param);

			SDL_mutexP(SDL_timer_mutex);

			if ( list_changed ) {

				/* Abort, list of timers modified */

				/* FIXME: what if ms was changed? */

				break;

			}

			if ( ms != t->interval ) {

				if ( ms ) {

					t->interval = ROUND_RESOLUTION(ms);

				} else {

					/* Remove timer from the list */

#ifdef DEBUG_TIMERS

					printf("SDL: Removing timer %p\n", t);

#endif

					if ( prev ) {

						prev->next = next;

					} else {

						SDL_timers = next;

					}

					SDL_free(t);

					--SDL_timer_running;

					removed = SDL_TRUE;

				}

			}

		}

		/* Don't update prev if the timer has disappeared */

		if ( ! removed ) {

			prev = t;

		}

	}

	SDL_mutexV(SDL_timer_mutex);

}

static SDL_TimerID SDL_AddTimerInternal(Uint32 interval, SDL_NewTimerCallback callback, void *param)

{

	SDL_TimerID t;

	t = (SDL_TimerID) SDL_malloc(sizeof(struct _SDL_TimerID));

	if ( t ) {

		t->interval = ROUND_RESOLUTION(interval);

		t->cb = callback;

		t->param = param;

		t->last_alarm = SDL_GetTicks();

		t->next = SDL_timers;

		SDL_timers = t;

		++SDL_timer_running;

		list_changed = SDL_TRUE;

	}

#ifdef DEBUG_TIMERS

	printf("SDL_AddTimer(%d) = %08x num_timers = %d\n", interval, (Uint32)t, SDL_timer_running);

#endif

	return t;

}

SDL_TimerID SDL_AddTimer(Uint32 interval, SDL_NewTimerCallback callback, void *param)

{

	SDL_TimerID t;

	if ( ! SDL_timer_mutex ) {

		if ( SDL_timer_started ) {

			SDL_SetError("This platform doesn't support multiple timers");

		} else {

			SDL_SetError("You must call SDL_Init(SDL_INIT_TIMER) first");

		}

		return NULL;

	}

	if ( ! SDL_timer_threaded ) {

		SDL_SetError("Multiple timers require threaded events!");

		return NULL;

	}

	SDL_mutexP(SDL_timer_mutex);

	t = SDL_AddTimerInternal(interval, callback, param);

	SDL_mutexV(SDL_timer_mutex);

	return t;

}

SDL_bool SDL_RemoveTimer(SDL_TimerID id)

{

	SDL_TimerID t, prev = NULL;

	SDL_bool removed;

	removed = SDL_FALSE;

	SDL_mutexP(SDL_timer_mutex);

	/* Look for id in the linked list of timers */

	for (t = SDL_timers; t; prev=t, t = t->next ) {

		if ( t == id ) {

			if(prev) {

				prev->next = t->next;

			} else {

				SDL_timers = t->next;

			}

			SDL_free(t);

			--SDL_timer_running;

			removed = SDL_TRUE;

			list_changed = SDL_TRUE;

			break;

		}

	}

#ifdef DEBUG_TIMERS

	printf("SDL_RemoveTimer(%08x) = %d num_timers = %d thread = %d\n", (Uint32)id, removed, SDL_timer_running, SDL_ThreadID());

#endif

	SDL_mutexV(SDL_timer_mutex);

	return removed;

}

/* Old style callback functions are wrapped through this */

static Uint32 SDLCALL callback_wrapper(Uint32 ms, void *param)

{

	SDL_TimerCallback func = (SDL_TimerCallback) param;

	return (*func)(ms);

}

int SDL_SetTimer(Uint32 ms, SDL_TimerCallback callback)

{

	int retval;

#ifdef DEBUG_TIMERS

	printf("SDL_SetTimer(%d)\n", ms);

#endif

	retval = 0;

	if ( SDL_timer_threaded ) {

		SDL_mutexP(SDL_timer_mutex);

	}

	if ( SDL_timer_running ) {	/* Stop any currently running timer */

		if ( SDL_timer_threaded ) {

			while ( SDL_timers ) {

				SDL_TimerID freeme = SDL_timers;

				SDL_timers = SDL_timers->next;

				SDL_free(freeme);

			}

			SDL_timer_running = 0;

			list_changed = SDL_TRUE;

		} else {

			SDL_SYS_StopTimer();

			SDL_timer_running = 0;

		}

	}

	if ( ms ) {

		if ( SDL_timer_threaded ) {

			if ( SDL_AddTimerInternal(ms, callback_wrapper, (void *)callback) == NULL ) {

				retval = -1;

			}

		} else {

			SDL_timer_running = 1;

			SDL_alarm_interval = ms;

			SDL_alarm_callback = callback;

			retval = SDL_SYS_StartTimer();

		}

	}

	if ( SDL_timer_threaded ) {

		SDL_mutexV(SDL_timer_mutex);

	}

	return retval;

}