/*
    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"

#ifdef SDL_TIMER_AMIGA

#include <stdio.h>
#include <time.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <exec/types.h>
#ifdef __SASC
#include <proto/dos.h>
#include <clib/graphics_protos.h>
#include <pragmas/graphics.h>
#include <clib/exec_protos.h>
#include <pragmas/exec.h>
#elif defined(STORMC4_WOS)
#include <proto/dos.h>
#include <proto/exec.h>
#include <proto/graphics.h>
#else
#include <inline/dos.h>
#include <inline/exec.h>
#include <inline/graphics.h>
#endif
#include "mydebug.h"

extern struct DosLibrary *DOSBase;
extern struct ExecBase *SysBase;
static struct GfxBase *GfxBase;

#include "SDL_timer.h"
#include "../SDL_timer_c.h"

/* The first ticks value of the application */

#if !defined(__PPC__) || defined(STORMC4_WOS) || defined(MORPHOS)
static clock_t start;

void
SDL_StartTicks(void)
{
    /* Set first ticks value */
    start = clock();
}

Uint32
SDL_GetTicks(void)
{
    clock_t ticks;

    ticks = clock() - start;

#ifdef __SASC
// CLOCKS_PER_SEC == 1000 !

    return (ticks);
#else
// CLOCKS_PER_SEC != 1000 !

    return ticks * (1000 / CLOCKS_PER_SEC);
#endif
}

void
SDL_Delay(Uint32 ms)
{
// Do a busy wait if time is less than 50ms

    if (ms < 50) {
        clock_t to_wait = clock();

#ifndef __SASC
        ms *= (CLOCKS_PER_SEC / 1000);
#endif
        to_wait += ms;

        while (clock() < to_wait);
    } else {
        Delay(ms / 20);
    }
}

#else

ULONG MY_CLOCKS_PER_SEC;

void PPC_TimerInit(void);
APTR MyTimer;

ULONG start[2];

void
SDL_StartTicks(void)
{
    /* Set first ticks value */
    if (!MyTimer)
        PPC_TimerInit();

    PPCGetTimerObject(MyTimer, PPCTIMERTAG_CURRENTTICKS, start);
    start[1] >>= 10;
    start[1] |= ((result[0] & 0x3ff) << 22);
    start[0] >>= 10;
}

Uint32
SDL_GetTicks(void)
{
    ULONG result[2];
    PPCGetTimerObject(MyTimer, PPCTIMERTAG_CURRENTTICKS, result);

//      PPCAsr64p(result,10);
// Non va, la emulo:

    result[1] >>= 10;
    result[1] |= ((result[0] & 0x3ff) << 22);

// Non mi interessa piu' result[0]

    return result[1] * 1000 / MY_CLOCKS_PER_SEC;
}

void
SDL_Delay(Uint32 ms)
{
// Do a busy wait if time is less than 50ms

    if (ms < 50) {
        ULONG to_wait[2], actual[2];
        PPCGetTimerObject(MyTimer, PPCTIMERTAG_CURRENTTICKS, result);
        actual[1] = 0;
        to_wait[1] += ms * 1000 / MY_CLOCKS_PER_SEC;

        while (actual[1] < to_wait[1]) {
            PPCGetTimerObject(MyTimer, PPCTIMERTAG_CURRENTTICKS, actual);
        }
    } else {
        Delay(ms / 50);
    }
}

void
PPC_TimerInit(void)
{
    struct TagItem tags[] = {
        PPCTIMERTAG_CPU, TRUE,
        TAG_DONE, 0
    };


    if (MyTimer = PPCCreateTimerObject(tags)) {
        ULONG result[2];

        PPCGetTimerObject(MyTimer, PPCTIMERTAG_TICKSPERSEC, result);
        D(bug("Timer inizializzato, TPS: %lu - %lu\n", result[0], result[1]));
//              PPCAsr64p(result,10);
        result[1] >>= 10;
        result[1] |= ((result[0] & 0x3ff) << 22);
        result[0] >>= 10;

        D(bug("Shiftato TPS: %lu - %lu\n", result[0], result[1]));
        MY_CLOCKS_PER_SEC = result[1];

        PPCGetTimerObject(MyTimer, PPCTIMERTAG_CURRENTTICKS, result);

        D(bug("Current ticks: %lu - %lu\n", result[0], result[1]));
        result[1] >>= 10;
        result[1] |= ((result[0] & 0x3ff) << 22);
        result[0] >>= 10;
//              PPCAsr64p(result,10);
        D(bug("Shiftato: %lu - %lu\n", result[0], result[1]));
    } else {
        D(bug("Errore nell'inizializzazione del timer!\n"));
    }
}

#endif

#include "SDL_thread.h"

/* Data to handle a single periodic alarm */
static int timer_alive = 0;
static SDL_Thread *timer_thread = NULL;

static int
RunTimer(void *unused)
{
    D(bug("SYSTimer: Entering RunTimer loop..."));

    if (GfxBase == NULL)
        GfxBase = (struct GfxBase *) OpenLibrary("graphics.library", 37);

    while (timer_alive) {
        if (SDL_timer_running) {
            SDL_ThreadedTimerCheck();
        }
        if (GfxBase)
            WaitTOF();          // Check the timer every fifth of seconds. Was SDL_Delay(1)->BusyWait!
        else
            Delay(1);
    }
    D(bug("SYSTimer: EXITING RunTimer loop..."));
    return (0);
}

/* This is only called if the event thread is not running */
int
SDL_SYS_TimerInit(void)
{
    D(bug("Creating thread for the timer (NOITIMER)...\n"));

    timer_alive = 1;
    timer_thread = SDL_CreateThread(RunTimer, NULL);
    if (timer_thread == NULL) {
        D(bug("Creazione del thread fallita...\n"));

        return (-1);
    }
    return (SDL_SetTimerThreaded(1));
}

void
SDL_SYS_TimerQuit(void)
{
    timer_alive = 0;
    if (timer_thread) {
        SDL_WaitThread(timer_thread, NULL);
        timer_thread = NULL;
    }
}

int
SDL_SYS_StartTimer(void)
{
    SDL_SetError("Internal logic error: AmigaOS uses threaded timer");
    return (-1);
}

void
SDL_SYS_StopTimer(void)
{
    return;
}

#endif /* SDL_TIMER_AMIGA */
/* vi: set ts=4 sw=4 expandtab: */