#include <EXTERN.h>
#include <perl.h>
#include <glib.h>
#include "libvxi11client.h"

static GAsyncQueue* interruptqueue;

typedef struct {
	char* handle;
} Event;

static Event* lastevent = NULL;

static void freeevent(Event* event) {
	g_free(event->handle);
	g_free(event);
}

static void freelast() {
	if (lastevent != NULL) {
		freeevent(lastevent);
		lastevent = NULL;
	}
}

static void interruptcallback(char* handle) {
	Event* event = g_malloc(sizeof(Event));
	int handlelen = strlen(handle);
	event->handle = g_malloc(handlelen + 1);
	strcpy(event->handle, handle);
	g_async_queue_push(interruptqueue, event);
}

VXI11Context* glue_open(char* address, char* device) {
	VXI11Context* context = malloc(sizeof(VXI11Context));
	if (context == NULL)
		return NULL;

	int err = vxi11_open(context, address, device);

	return context;
}

int glue_start_interrupt_server() {
	interruptqueue = g_async_queue_new();
	g_async_queue_ref(interruptqueue);
	return vxi11_start_interrupt_server(interruptcallback);
}

int glue_stop_interrupt_server() {
	int ret = vxi11_stop_interrupt_server();
	Event* event = NULL;
	// clear everything that is left over
	while ((event = (Event*) g_async_queue_try_pop(interruptqueue)) != NULL) {
		freeevent(event);
	}
	freelast();
	g_async_queue_unref(interruptqueue);
	return ret;
}

char* glue_wait_for_interrupt() {
	GTimeVal timeout;
	g_get_current_time(&timeout);
	g_time_val_add(&timeout, 2500);
	freelast();
	lastevent = (Event*) g_async_queue_timed_pop(interruptqueue, &timeout);
	if (lastevent != NULL) {
		return lastevent->handle;
	}
	else
		return NULL;
}