/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2009 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 = %lu)\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 = %lu\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;

}

/* vi: set ts=4 sw=4 expandtab: */