#import "interpolation.h"
#import "memory.h"
#import "oops.h"

#include "SDL.h"

// Currently supports only vectors.

typedef struct _glide {
    void (*func)(void *obj, vector delta);
    void *obj;
    vector delta_per_tick;
    long long ticks_left;
    struct _glide *next;
} glide;

glide *glides = NULL;

void run_glides()
{
    static Uint32 last_tick = 0;
    glide *curr_glide = glides;
    glide *prev_glide = NULL;
    while (curr_glide != NULL) {
        Uint32 delta_tick = SDL_GetTicks() - last_tick;
        curr_glide->ticks_left -= delta_tick;
        if (curr_glide->ticks_left < 0) {
            delta_tick += curr_glide->ticks_left; // Make sure it doesn't overshoot the target.
        }

        // Calculate the delta since last time
        vector delta = vec_mult(curr_glide->delta_per_tick, delta_tick);
        curr_glide->func(curr_glide->obj, delta);

        if (curr_glide->ticks_left <= 0) {
            // Remove the glide once it's finished.
            glide *next = curr_glide->next;
            
            release(curr_glide);
            
            if (prev_glide == NULL) {
                glides = next;
            } else {
                prev_glide->next = next;
            }
            curr_glide = next;
        } else {
            prev_glide = curr_glide;
            curr_glide = curr_glide->next;
        }
    }
    last_tick = SDL_GetTicks();
}

void register_vector_glide(void *obj, vector delta, void (*func)(void *obj, vector delta), float duration)
{
    glide *new = alloc(sizeof(glide));
    new->func = func;
    new->obj = obj;

    new->ticks_left = duration * 1000;
    new->delta_per_tick = vec_div(delta, duration * 1000);
    
    new->next = glides;
    glides = new;
}