#include <glib.h></glib.h>

#include <gtk gtk.h=""></gtk>

#include <gdk gdk.h=""></gdk>

#include "private.h"

#include "world.h"

static GtkWidget *window;

static int started;

static int stopped;

static unsigned long long frameCount;

static gint64 startTime;

static gint64 currentTime;

static Callback initCallback;

static Callback drawCallback;

static cairo_surface_t *cairoSurface;

static int width = 400;

static int height = 400;

static double frameRate = 30;

static int cameraEnabled;

static double cameraX;

static double cameraY;

static double cameraZoom = 1;

static HeliArray keysPressed;

static HeliArray keysPressedInFrame;

static HeliArray keysReleasedInFrame;

static HeliArray buttonsPressed;

static HeliArray buttonsPressedInFrame;

static HeliArray buttonsReleasedInFrame;

static int mouseMovedInFrame;

static double _mouseX;

static double _mouseY;

static char* buttonNames[] = {

	"left",

	"middle",

	"right" };

static int buttonsCount = (int)(sizeof(buttonNames)/sizeof(*buttonNames));

int keyDown(const char *code)

	{ return heliStringmapGet(&keysPressed, code) != NULL; }

int keyWentDown(const char *code)

	{ return heliStringmapGet(&keysPressedInFrame, code) != NULL; }

int keyWentUp(const char *code)

	{ return heliStringmapGet(&keysReleasedInFrame, code) != NULL; }

int mouseDidMove()

	{ return mouseMovedInFrame; }

int mouseDown(const char *code)

	{ return heliStringmapGet(&buttonsPressed, code) != NULL; }

int mouseWentDown(const char *code)

	{ return heliStringmapGet(&buttonsPressedInFrame, code) != NULL; }

int mouseWentUp(const char *code)

	{ return heliStringmapGet(&buttonsReleasedInFrame, code) != NULL; }

double mouseX()

	{ return _mouseX; }

double mouseY()

	{ return _mouseY; }

int mousePressedOver(Sprite sprite)

	{ return buttonsPressed.count && mouseIsOver(sprite); }

static void resize(int w, int h) {

	width  = w > 200 ? w : 100;

	height = h > 200 ? h : 200;

	if (started) {

		gtk_window_set_default_size(GTK_WINDOW(window), width, height);

		gtk_widget_set_size_request(window, width, height);

	}

}

int worldGetWidth()

	{ return width; }

void worldSetWidth(int w)

	{ resize(w, height); }

int worldGetHeight()

	{ return height; }

void worldSetHeight(int h)

	{ resize(width, h); }

double worldGetFrameRate()

	{ return frameRate; }

void worldSetFrameRate(double frameRate) {

	if (!(frameRate > 1)) frameRate = 1;

	if (!(frameRate < 100)) frameRate = 100;

}

double worldGetTimeStep()

	{ return 1/frameRate; }

int worldGetFrameCount()

	{ return (int)frameCount; }

double worldGetSeconds()

	{ return started ? (currentTime - startTime)*1e-6 : 0.0; }

void worldSetInit(Callback init)

	{ initCallback = init; }

void worldSetDraw(Callback draw)

	{ drawCallback = draw; }

void worldStop()

	{ if (started) stopped = TRUE; }

void cameraOn()

	{ cameraEnabled = TRUE; }

void cameraOff()

	{ cameraEnabled = FALSE; }

int cameraIsActive()

	{ return cameraEnabled; }

double cameraMouseX()

	{ return _mouseX/cameraZoom + cameraX; }

double cameraMouseY()

	{ return _mouseY/cameraZoom + cameraY; }

double cameraGetX()

	{ return cameraX; }

void cameraSetX(double x)

	{ cameraX = x; }

double cameraGetY()

	{ return cameraY; }

void cameraSetY(double y)

	{ cameraY = y; }

double cameraGetZoom()

	{ return cameraZoom; }

void cameraSetZoom(double x)

	{ cameraZoom = x > 1e-6 ? x : 1e-6; }

static gboolean idle(gpointer data G_GNUC_UNUSED) {

	if (stopped) {

		if (window) {

			gtk_window_close(GTK_WINDOW(window));

			window = NULL;

		}

		return FALSE;

	}

	gtk_widget_queue_draw(window);

	return TRUE;

}

static gboolean draw(GtkWidget *widget G_GNUC_UNUSED, cairo_t *cr, gpointer data G_GNUC_UNUSED) {

	int doFrame = FALSE;

	if ( cairoSurface

	  && cairo_image_surface_get_width(cairoSurface) != width

	  && cairo_image_surface_get_height(cairoSurface) != height )

		{ cairo_surface_destroy(cairoSurface); cairoSurface = NULL; }

	if (!cairoSurface) {

		cairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);

		doFrame = TRUE;

	}

	if (frameCount == 0) {

		currentTime = startTime = g_get_monotonic_time();

		doFrame = TRUE;

	}

	double dt = 1/frameRate;

	gint64 timeStep = (gint64)round(dt*1e6);

	gint64 newTime = g_get_monotonic_time();

	if (currentTime < newTime)

		doFrame = TRUE;

	if (doFrame) {

		if (frameCount == 0) heliDoTests();

		heliCairo = cairo_create(cairoSurface);

		heliDrawingPrepareFrame();

		if (drawCallback) drawCallback();

		cairo_surface_flush(cairoSurface);

		cairo_destroy(heliCairo);

		heliCairo = NULL;

		currentTime += timeStep;

		++frameCount;

		heliSpriteUpdate(dt);

		heliSoundUpdate();

		heliArrayClear(&keysPressedInFrame);

		heliArrayClear(&keysReleasedInFrame);

		heliArrayClear(&buttonsPressedInFrame);

		heliArrayClear(&buttonsReleasedInFrame);

		if (stopped) g_idle_add_full(G_PRIORITY_DEFAULT, idle, NULL, NULL);

	}

	gint64 delta = newTime - currentTime - 2000000;

	if (delta > 0) {

		startTime += delta;

		currentTime += delta;

	}

	heliDrawingClearFrame(cr);

	cairo_save(cr);

	cairo_set_source_surface(cr, cairoSurface, 0, 0);

	cairo_paint(cr);

	cairo_restore(cr);

	if (!stopped) gtk_widget_queue_draw(window);

	delta = currentTime - g_get_monotonic_time();

	if (delta > 100) g_usleep(delta - 100);

	return TRUE;

}

static gboolean handleEvent(GtkWidget *widget G_GNUC_UNUSED, GdkEvent *event, gpointer data G_GNUC_UNUSED) {

	gchar *keyname;

	int button;

	switch(event->type) {

	case GDK_KEY_PRESS:

		keyname = heliStringCopy( gdk_keyval_name(event->key.keyval) );

		heliLowercase(keyname);

		heliStringmapAdd(&keysPressed, keyname, NULL, NULL);

		heliStringmapAdd(&keysPressedInFrame, keyname, NULL, NULL);

		free(keyname);

		return TRUE;

	case GDK_KEY_RELEASE:

		keyname = heliStringCopy( gdk_keyval_name(event->key.keyval) );

		heliLowercase(keyname);

		heliStringmapRemove(&keysPressed, keyname);

		heliStringmapAdd(&keysReleasedInFrame, keyname, NULL, NULL);

		free(keyname);

		return TRUE;

	case GDK_BUTTON_PRESS:

		button = event->button.button;

		if (button >= 1 && button <= buttonsCount) {

			heliStringmapAdd(&buttonsPressed, buttonNames[button - 1], NULL, NULL);

			heliStringmapAdd(&buttonsPressedInFrame, buttonNames[button - 1], NULL, NULL);

		}

		_mouseX = event->button.x;

		_mouseY = event->button.y;

		return TRUE;

	case GDK_BUTTON_RELEASE:

		button = event->button.button;

		if (button >= 1 && button <= buttonsCount) {

			heliStringmapRemove(&buttonsPressed, buttonNames[button - 1]);

			heliStringmapAdd(&buttonsReleasedInFrame, buttonNames[button - 1], NULL, NULL);

		}

		_mouseX = event->button.x;

		_mouseY = event->button.y;

		return TRUE;

	case GDK_MOTION_NOTIFY:

		_mouseX = event->motion.x;

		_mouseY = event->motion.y;

		return TRUE;

	case GDK_DELETE:

		stopped = TRUE;

		window = NULL;

		break;

	default:

		break;

	}

	return FALSE;

}

static void activate(GtkApplication* app, gpointer data G_GNUC_UNUSED) {

	window = gtk_application_window_new(app);

	g_signal_connect(window, "draw", G_CALLBACK(draw), NULL);

	g_signal_connect(window, "event", G_CALLBACK(handleEvent), NULL);

	gtk_window_set_resizable(GTK_WINDOW(window), FALSE);

	gtk_window_set_default_size(GTK_WINDOW(window), width, height);

	gtk_widget_add_events( window,

						   GDK_POINTER_MOTION_MASK

						 | GDK_BUTTON_PRESS_MASK

						 | GDK_BUTTON_RELEASE_MASK

						 | GDK_KEY_PRESS_MASK

						 | GDK_KEY_RELEASE_MASK );

	gtk_widget_set_size_request(window, width, height);

	gtk_widget_show(window);

	currentTime = startTime = 0;

	if (initCallback) initCallback();

	g_idle_add(idle, NULL);

}

void worldRun() {

	if (started) return;

	started = TRUE;

	stopped = FALSE;

	frameCount = 0;

	srand(time(NULL));

	GtkApplication *application = gtk_application_new(NULL, 0);

	g_signal_connect(application, "activate", G_CALLBACK(activate), NULL);

	g_application_run(G_APPLICATION(application), 0, NULL);

	g_object_unref(application);

	heliSpriteFinish();

	heliDrawingFinish();

	heliAnimationFinish();

	heliSoundFinish();

	if (cairoSurface) cairo_surface_destroy(cairoSurface);

	cairoSurface = NULL;

	heliArrayDestroy(&keysPressed);

	heliArrayDestroy(&keysPressed);

	heliArrayDestroy(&keysPressedInFrame);

	heliArrayDestroy(&keysReleasedInFrame);

	heliArrayDestroy(&buttonsPressed);

	heliArrayDestroy(&buttonsPressedInFrame);

	heliArrayDestroy(&buttonsReleasedInFrame);

	started = FALSE;

}