#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 GtkWidget *dialogMessage;

static GtkWidget *dialogMessageLabel;

static GtkWidget *dialogAsk;

static GtkWidget *dialogAskLabel;

static GtkWidget *dialogAskEntry;

static GtkWidget *dialogAskMultiline;

static GtkWidget *dialogAskMultilineLabel;

static GtkWidget *dialogAskMultilineEntry;

static int started;

static int stopped;

static int inDialog;

static unsigned long long frameCount;

static gint64 startTime;

static gint64 currentTime;

static gint64 dialogTime;

static Callback initCallback;

static Callback drawCallback;

static Callback deinitCallback;

static cairo_surface_t *cairoSurface;

static int width = 400;

static int height = 400;

static int resizable;

static char title[1000];

static int titleSize = (int)(sizeof(title)/sizeof(*title));

static double frameRate = 24;

static int cameraEnabled;

static double cameraX;

static double cameraY;

static double cameraZoom = 1;

static HeliArray keyEvents[6];

static int keyEventsCount = (int)(sizeof(keyEvents)/sizeof(*keyEvents));

static int mouseMovedInFrame;

static double _mouseX;

static double _mouseY;

static char* buttonNames[] = {

	"left",

	"middle",

	"right" };

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

int keyEventGetCount(KeyEvent mode)

	{ return (int)mode >= 0 && (int)mode <= keyEventsCount ? keyEvents[mode].count : 0; }

const char *keyEventGet(KeyEvent mode, int i)

	{ return (int)mode >= 0 && (int)mode <= keyEventsCount ? heliArrayGetValue(&keyEvents[mode], i) : NULL; }

static int keyEventCheck(KeyEvent mode, const char *code) {

	int count = keyEventGetCount(mode);

	for(int i = 0; i < count; ++i)

		if (strcmp(keyEventGet(mode, i), code) == 0)

			return TRUE;

	return FALSE;

}

static void keyEventAdd(KeyEvent mode, const char *code) {

	if ((int)mode >= 0 && mode <= (int)keyEventsCount && !keyEventCheck(mode, code))

		heliArrayInsert(&keyEvents[mode], -1, heliStringCopy(code), &free);

}

static void keyEventRemove(KeyEvent mode, const char *code) {

	if ((int)mode >= 0 && mode <= (int)keyEventsCount)

		for(int i = keyEvents[mode].count-1; i >= 0; --i)

			if (strcmp(keyEvents[mode].items[i].value, code) == 0)

				heliArrayRemove(&keyEvents[mode], i);

}

int keyDown(const char *code)

	{ return keyEventCheck(KEYEVENT_KEY_DOWN, code); }

int keyWentDown(const char *code)

	{ return keyEventCheck(KEYEVENT_KEY_WENTDOWN, code); }

int keyWentUp(const char *code)

	{ return keyEventCheck(KEYEVENT_KEY_WENTUP, code); }

int mouseDidMove()

	{ return mouseMovedInFrame; }

int mouseDown(const char *code)

	{ return keyEventCheck(KEYEVENT_MOUSE_DOWN, code); }

int mouseWentDown(const char *code)

	{ return keyEventCheck(KEYEVENT_MOUSE_WENTDOWN, code); }

int mouseWentUp(const char *code)

	{ return keyEventCheck(KEYEVENT_MOUSE_WENTUP, code); }

double mouseX()

	{ return _mouseX; }

double mouseY()

	{ return _mouseY; }

int mousePressedOver(Sprite sprite)

	{ return keyEventGetCount(KEYEVENT_MOUSE_DOWN) && mouseIsOver(sprite); }

static void resize(int w, int h) {

	width  = w > 200 ? w : 100;

	height = h > 200 ? h : 200;

	if (started && !stopped && window) {

		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); }

int worldGetResizable()

	{ return resizable; }

void worldSetResizable(int r) {

	if (resizable == r) return;

	resizable = r ? TRUE : FALSE;

	if (started && !stopped && window)

		gtk_window_set_resizable(GTK_WINDOW(window), resizable);

}

const char* worldGetTitle()

	{ return title; }

void worldSetTitle(const char *t) {

	int changed = FALSE;

	for(int i = 0; i < titleSize-1; ++i) {

		if (title[i] != t[i]) changed = TRUE;

		title[i] = t[i];

		if (!t[i]) break;

	}

	if (changed && started && !stopped && window)

		gtk_window_set_title(GTK_WINDOW(window), title);

}

double worldGetFrameRate()

	{ return frameRate; }

void worldSetFrameRate(double fps) {

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

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

	frameRate = fps;

}

double worldGetTimeStep()

	{ return 1/frameRate; }

int worldGetFrameCount()

	{ return (int)frameCount; }

double worldGetSeconds()

	{ return started ? (currentTime - startTime)*HELI_PRECISION : 0.0; }

void worldSetInit(Callback init)

	{ initCallback = init; }

void worldSetDraw(Callback draw)

	{ drawCallback = draw; }

void worldSetDeinit(Callback deinit)

	{ deinitCallback = deinit; }

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 > HELI_PRECISION ? x : HELI_PRECISION; }

static void beginDialog() {

	inDialog = TRUE;

	dialogTime = g_get_monotonic_time() - startTime;

}

static void endDialog() {

	for(int i = 0; i < 100; ++i) gtk_main_iteration();

	currentTime = g_get_monotonic_time();

	startTime = currentTime - dialogTime;

	inDialog = FALSE;

}

void messageBox(const char *message) {

	if (!started || stopped || !window)

		return;

	beginDialog();

	gtk_label_set_label(GTK_LABEL(dialogMessageLabel), message);

	gtk_dialog_run(GTK_DIALOG(dialogMessage));

	gtk_widget_hide(dialogMessage);

	endDialog();

}

void askTextEx(const char *question, char *answer, int maxAnswerSize, int multiline, int password) {

	if (!started || stopped || !window)

		return;

	beginDialog();

	if (multiline) {

		gtk_label_set_label(GTK_LABEL(dialogAskMultilineLabel), question);

		GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(dialogAskMultilineEntry));

		gtk_text_buffer_set_text(buffer, answer, -1);

		gtk_dialog_run(GTK_DIALOG(dialogAskMultiline));

		gtk_widget_hide(dialogAskMultiline);

		GtkTextIter start, end;

		gtk_text_buffer_get_bounds(buffer, &start, &end);

		const char *a = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);

		for(int i = 0; i < maxAnswerSize; ++i)

			{ answer[i] = a[i]; if (!a[i]) break; }

	} else {

		gtk_label_set_label(GTK_LABEL(dialogAskLabel), question);

		gtk_entry_set_text(GTK_ENTRY(dialogAskEntry), answer);

		gtk_entry_set_input_purpose(GTK_ENTRY(dialogAskEntry), password ? GTK_INPUT_PURPOSE_PASSWORD : GTK_INPUT_PURPOSE_FREE_FORM);

		gtk_entry_set_visibility(GTK_ENTRY(dialogAskEntry), !password);

		gtk_dialog_run(GTK_DIALOG(dialogAsk));

		gtk_widget_hide(dialogAsk);

		const char *a = gtk_entry_get_text(GTK_ENTRY(dialogAskEntry));

		for(int i = 0; i < maxAnswerSize; ++i)

			{ answer[i] = a[i]; if (!a[i]) break; }

	}

	endDialog();

}

void askText(const char *question, char *answer, int maxAnswerSize)

	{ askTextEx(question, answer, maxAnswerSize, FALSE, FALSE); }

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 (inDialog)

		doFrame = FALSE;

	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(&keyEvents[KEYEVENT_KEY_WENTDOWN]);

		heliArrayClear(&keyEvents[KEYEVENT_KEY_WENTUP]);

		heliArrayClear(&keyEvents[KEYEVENT_MOUSE_WENTDOWN]);

		heliArrayClear(&keyEvents[KEYEVENT_MOUSE_WENTUP]);

		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);

		keyEventAdd(KEYEVENT_KEY_DOWN, keyname);

		keyEventAdd(KEYEVENT_KEY_WENTDOWN, keyname);

		free(keyname);

		return TRUE;

	case GDK_KEY_RELEASE:

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

		heliLowercase(keyname);

		keyEventRemove(KEYEVENT_KEY_DOWN, keyname);

		keyEventAdd(KEYEVENT_KEY_WENTUP, keyname);

		free(keyname);

		return TRUE;

	case GDK_BUTTON_PRESS:

		button = event->button.button;

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

			keyEventAdd(KEYEVENT_MOUSE_DOWN, buttonNames[button - 1]);

			keyEventAdd(KEYEVENT_MOUSE_WENTDOWN, buttonNames[button - 1]);

		}

		_mouseX = event->button.x;

		_mouseY = event->button.y;

		return TRUE;

	case GDK_BUTTON_RELEASE:

		button = event->button.button;

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

			keyEventRemove(KEYEVENT_MOUSE_DOWN, buttonNames[button - 1]);

			keyEventAdd(KEYEVENT_MOUSE_WENTUP, buttonNames[button - 1]);

		}

		_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_FOCUS_CHANGE:

		if (!event->focus_change.in) {

			int count = keyEventGetCount(KEYEVENT_KEY_DOWN);

			for(int i = 0; i < count; ++i)

				keyEventAdd(KEYEVENT_KEY_WENTUP, keyEventGet(KEYEVENT_KEY_DOWN, i));

			heliArrayClear(&keyEvents[KEYEVENT_KEY_DOWN]);

		}

		break;

	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), resizable);

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

	gtk_window_set_title(GTK_WINDOW(window), title);

	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

						 | GDK_FOCUS_CHANGE_MASK );

	gtk_widget_set_size_request(window, width, height);

	gtk_widget_show(window);

	dialogMessage = gtk_dialog_new_with_buttons(

		"", GTK_WINDOW(window),

		GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,

		"_OK", GTK_RESPONSE_OK, NULL);

	gtk_dialog_set_default_response(GTK_DIALOG(dialogMessage), GTK_RESPONSE_OK);

	dialogMessageLabel = gtk_label_new("");

	gtk_widget_show(dialogMessageLabel);

	gtk_container_add(

		GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialogMessage))),

		dialogMessageLabel );

	dialogAsk = gtk_dialog_new_with_buttons(

		"", GTK_WINDOW(window),

		GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,

		"_OK", GTK_RESPONSE_OK, NULL);

	gtk_dialog_set_default_response(GTK_DIALOG(dialogAsk), GTK_RESPONSE_OK);

	GtkWidget *askBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);

	dialogAskLabel = gtk_label_new("");

	dialogAskEntry = gtk_entry_new();

	gtk_entry_set_activates_default(GTK_ENTRY(dialogAskEntry), TRUE);

	gtk_container_add(GTK_CONTAINER(askBox), dialogAskLabel);

	gtk_container_add(GTK_CONTAINER(askBox), dialogAskEntry);

	gtk_widget_show_all(askBox);

	gtk_container_add(

		GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialogAsk))),

		askBox );

	dialogAskMultiline = gtk_dialog_new_with_buttons(

		"", GTK_WINDOW(window),

		GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,

		"_OK", GTK_RESPONSE_OK, NULL);

	gtk_dialog_set_default_response(GTK_DIALOG(dialogAskMultiline), GTK_RESPONSE_OK);

	GtkWidget *askMultilineBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);

	dialogAskMultilineLabel = gtk_label_new("");

	dialogAskMultilineEntry = gtk_text_view_new();

	GtkWidget *askMultilineScrollBox = gtk_scrolled_window_new(NULL, NULL);

	gtk_container_add(GTK_CONTAINER(askMultilineScrollBox), dialogAskMultilineEntry);

	gtk_container_add(GTK_CONTAINER(askMultilineBox), dialogAskMultilineLabel);

	gtk_container_add_with_properties(

		GTK_CONTAINER(askMultilineBox), askMultilineScrollBox,

		"expand", TRUE, "fill", TRUE, NULL );

	gtk_widget_show_all(askMultilineBox);

	gtk_container_add_with_properties(

		GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialogAskMultiline))),

		askMultilineBox,

		"expand", TRUE, "fill", TRUE, NULL );

	currentTime = startTime = 0;

	heliInitialized = TRUE;

	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);

	window = NULL;

	dialogMessage = NULL;

	dialogMessageLabel = NULL;

	dialogAsk = NULL;

	dialogAskEntry = NULL;

	dialogAskLabel = NULL;

	dialogAskMultiline = NULL;

	dialogAskMultilineEntry = NULL;

	dialogAskMultilineLabel = NULL;

	if (deinitCallback) deinitCallback();

	heliArrayClear(&heliObjectsSet);

	heliSpriteFinish();

	heliDrawingFinish();

	heliAnimationFinish();

	heliSoundFinish();

	heliArrayDestroy(&heliObjectsSet);

	heliInitialized = FALSE;

	if (cairoSurface) cairo_surface_destroy(cairoSurface);

	cairoSurface = NULL;

	for(int i = 0; i < keyEventsCount; ++i)

		heliArrayDestroy(&keyEvents[i]);

	started = FALSE;

}