/**

 * $Id$

 *

 * Simple implementation of one-shot timers. Effectively this allows IO

 * devices to wait until a particular time before completing. We expect 

 * there to be at least half a dozen or so continually scheduled events

 * (TMU and PVR2), peaking around 20+.

 *

 * Copyright (c) 2005 Nathan Keynes.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 */

#include <assert.h>

#include "dream.h"

#include "dreamcast.h"

#include "eventq.h"

#include "asic.h"

#include "sh4/sh4.h"

#define LONG_SCAN_PERIOD 1000000000 /* 1 second */

typedef struct event {

    uint32_t id;

    uint32_t seconds;

    uint32_t nanosecs;

    event_func_t func;

    struct event *next;

} *event_t;

static struct event events[MAX_EVENT_ID];

/**

 * Countdown to the next scan of the long-duration list (greater than 1 second).

 */

static int long_scan_time_remaining;

static event_t event_head;

static event_t long_event_head;

void event_reset();

void event_init();

uint32_t event_run_slice( uint32_t nanosecs );

void event_save_state( FILE *f );

int event_load_state( FILE * f );

struct dreamcast_module eventq_module = { "EVENTQ", NULL, event_reset, NULL, event_run_slice,

        NULL, event_save_state, event_load_state };

static void event_update_pending( ) 

{

    if( event_head == NULL ) {

        if( !(sh4r.event_types & PENDING_IRQ) ) {

            sh4r.event_pending = NOT_SCHEDULED;

        }

        sh4r.event_types &= (~PENDING_EVENT);

    } else {

        if( !(sh4r.event_types & PENDING_IRQ) ) {

            sh4r.event_pending = event_head->nanosecs;

        }

        sh4r.event_types |= PENDING_EVENT;

    }

}

uint32_t event_get_next_time( ) 

{

    if( event_head == NULL ) {

        return NOT_SCHEDULED;

    } else {

        return event_head->nanosecs;

    }

}

/**

 * Add the event to the short queue.

 */

static void event_enqueue( event_t event ) 

{

    if( event_head == NULL || event->nanosecs < event_head->nanosecs ) {

        event->next = event_head;

        event_head = event;

        event_update_pending();

    } else {

        event_t cur = event_head;

        event_t next = cur->next;

        while( next != NULL && event->nanosecs >= next->nanosecs ) {

            cur = next;

            next = cur->next;

        }

        event->next = next;

        cur->next = event;

    }

}

static void event_dequeue( event_t event )

{

    if( event_head == NULL ) {

        ERROR( "Empty event queue but should contain event %d", event->id );

    } else if( event_head == event ) {

        /* removing queue head */

        event_head = event_head->next;

        event_update_pending();

    } else {

        event_t cur = event_head;

        event_t next = cur->next;

        while( next != NULL ) {

            if( next == event ) {

                cur->next = next->next;

                break;

            }

            cur = next;

            next = cur->next;

        }

    }

}

static void event_dequeue_long( event_t event ) 

{

    if( long_event_head == NULL ) {

        ERROR( "Empty long event queue but should contain event %d", event->id );

    } else if( long_event_head == event ) {

        /* removing queue head */

        long_event_head = long_event_head->next;

    } else {

        event_t cur = long_event_head;

        event_t next = cur->next;

        while( next != NULL ) {

            if( next == event ) {

                cur->next = next->next;

                break;

            }

            cur = next;

            next = cur->next;

        }

    }

}

void register_event_callback( int eventid, event_func_t func )

{

    events[eventid].func = func;

}

void event_schedule( int eventid, uint32_t nanosecs )

{

    nanosecs += sh4r.slice_cycle;

    event_t event = &events[eventid];

    if( event->nanosecs != NOT_SCHEDULED ) {

        /* Event is already scheduled. Remove it from the list first */

        event_cancel(eventid);

    }

    event->id = eventid;

    event->seconds = 0;

    event->nanosecs = nanosecs;

    event_enqueue( event );

}

void event_schedule_long( int eventid, uint32_t seconds, uint32_t nanosecs ) {

    if( seconds == 0 ) {

        event_schedule( eventid, nanosecs );

    } else {

        event_t event = &events[eventid];

        if( event->nanosecs != NOT_SCHEDULED ) {

            /* Event is already scheduled. Remove it from the list first */

            event_cancel(eventid);

        }

        event->id = eventid;

        event->seconds = seconds;

        event->nanosecs = nanosecs + sh4r.slice_cycle + (LONG_SCAN_PERIOD - long_scan_time_remaining);

        event->next = long_event_head;

        long_event_head = event;

    }

}

void event_cancel( int eventid )

{

    event_t event = &events[eventid];

    if( event->nanosecs == NOT_SCHEDULED ) {

        return; /* not scheduled */

    } else {

        event->nanosecs = NOT_SCHEDULED;

        if( event->seconds != 0 ) { /* long term event */

            event_dequeue_long( event );

        } else {

            event_dequeue( event );

        }

    }

}

void event_execute()

{

    /* Loop in case we missed some or got a couple scheduled for the same time */

    while( event_head != NULL && event_head->nanosecs <= sh4r.slice_cycle ) {

        event_t event = event_head;

        event_head = event->next;

        event->nanosecs = NOT_SCHEDULED;

        // Note: Make sure the internal state is consistent before calling the

        // user function, as it will (quite likely) enqueue another event.

        event->func( event->id );

    }

    event_update_pending();

}

void event_asic_callback( int eventid )

{

    asic_event( eventid );

}

void event_init()

{

    int i;

    for( i=0; i<MAX_EVENT_ID; i++ ) {

        events[i].id = i;

        events[i].nanosecs = NOT_SCHEDULED;

        if( i < 96 ) {

            events[i].func = event_asic_callback;

        } else {

            events[i].func = NULL;

        }

        events[i].next = NULL;

    }

    event_head = NULL;

    long_event_head = NULL;

    long_scan_time_remaining = LONG_SCAN_PERIOD;

}

void event_reset()

{

    int i;

    event_head = NULL;

    long_event_head = NULL;

    long_scan_time_remaining = LONG_SCAN_PERIOD;

    for( i=0; i<MAX_EVENT_ID; i++ ) {

        events[i].nanosecs = NOT_SCHEDULED;

    }

}

void event_save_state( FILE *f )

{

    int32_t id, i;

    id = event_head == NULL ? -1 : event_head->id;

    fwrite( &id, sizeof(id), 1, f );

    id = long_event_head == NULL ? -1 : long_event_head->id;

    fwrite( &id, sizeof(id), 1, f );

    fwrite( &long_scan_time_remaining, sizeof(long_scan_time_remaining), 1, f );

    for( i=0; i<MAX_EVENT_ID; i++ ) {

        fwrite( &events[i].id, sizeof(uint32_t), 3, f ); /* First 3 words from structure */

        id = events[i].next == NULL ? -1 : events[i].next->id;

        fwrite( &id, sizeof(id), 1, f );

    }

}

int event_load_state( FILE *f )

{

    int32_t id, i;

    fread( &id, sizeof(id), 1, f );

    event_head = id == -1 ? NULL : &events[id];

    fread( &id, sizeof(id), 1, f );

    long_event_head = id == -1 ? NULL : &events[id];

    fread( &long_scan_time_remaining, sizeof(long_scan_time_remaining), 1, f );

    for( i=0; i<MAX_EVENT_ID; i++ ) {

        fread( &events[i].id, sizeof(uint32_t), 3, f );

        fread( &id, sizeof(id), 1, f );

        events[i].next = id == -1 ? NULL : &events[id];

    }

    return 0;

}

/**

 * Scan all entries in the long queue, decrementing each by 1 second. Entries

 * that are now < 1 second are moved to the short queue.

 */

static void event_scan_long()

{

    while( long_event_head != NULL && --long_event_head->seconds == 0 ) {

        event_t event = long_event_head;

        long_event_head = event->next;

        event_enqueue(event);

    }

    if( long_event_head != NULL ) {

        event_t last = long_event_head;

        event_t cur = last->next;

        while( cur != NULL ) {

            if( --cur->seconds == 0 ) {

                last->next = cur->next;

                event_enqueue(cur);

            } else {

                last = cur;

            }

            cur = last->next;

        }

    }

}

/**

 * Decrement the event time on all pending events by the supplied nanoseconds.

 * It may or may not be faster to wrap around instead, but this has the benefit

 * of simplicity.

 */

uint32_t event_run_slice( uint32_t nanosecs )

{

    event_t event = event_head;

    while( event != NULL ) {

        if( event->nanosecs <= nanosecs ) {

            event->nanosecs = 0;

        } else {

            event->nanosecs -= nanosecs;

        }

        event = event->next;

    }

    long_scan_time_remaining -= nanosecs;

    if( long_scan_time_remaining <= 0 ) {

        long_scan_time_remaining += LONG_SCAN_PERIOD;

        event_scan_long();

    }

    event_update_pending();

    return nanosecs;

}