#include <time.h></time.h>

#include <sdl.h></sdl.h>

#include "private.h"

#include "world.h"

static int sdlInitialized = 0;

SDL_Window *window;

SDL_GLContext context;

static int started;

static int stopped;

static unsigned long long frameCount;

static unsigned long long elapsedTimeUs;

static unsigned long long elapsedTimeSinceLastFrameUs;

static unsigned int prevFrameTimeMs;

static Callback initCallback;

static Callback drawCallback;

static Callback deinitCallback;

static int width = 512;

static int height = 512;

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;

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

	w = w > 200 ? w : 100;

	h = h > 200 ? h : 200;

	if (width != w || height != h) {

		width = w;

		height = h;

		if (started && !stopped && window)

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

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

		SDL_SetWindowTitle(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 ? elapsedTimeUs*1e-6 : 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; }

void messageBox(const char *message) {

	SDL_ShowSimpleMessageBox(

		SDL_MESSAGEBOX_INFORMATION,

		title,

		message,

		window );

}

static void draw() {

	unsigned int currentFrameTimeMs = SDL_GetTicks();

	unsigned long long deltaUs = frameCount == 0 ? 0 : (currentFrameTimeMs - prevFrameTimeMs)*1000ull;

	prevFrameTimeMs = currentFrameTimeMs;

	double dt = 1/frameRate;

	unsigned long long timeStepUs = (unsigned long long)round(dt*1e6);

	elapsedTimeSinceLastFrameUs += deltaUs;

	if (elapsedTimeSinceLastFrameUs > 2000000)

		elapsedTimeSinceLastFrameUs = 2000000;

	if (frameCount == 0 || elapsedTimeSinceLastFrameUs >= timeStepUs) {

		elapsedTimeUs += timeStepUs;

		if (frameCount != 0) elapsedTimeSinceLastFrameUs -= timeStepUs;

		++frameCount;

		heliSpriteUpdate(dt);

		heliSoundUpdate();

		glViewport(0, 0, width, height);

		glMatrixMode(GL_PROJECTION);

		glLoadIdentity();

		glOrtho(0, width, height, 0, -1.0, 1.0);

		glMatrixMode(GL_MODELVIEW);

		heliDrawingPrepareFrame();

		if (drawCallback) drawCallback();

		heliArrayClear(&keyEvents[KEYEVENT_KEY_WENTDOWN]);

		heliArrayClear(&keyEvents[KEYEVENT_KEY_WENTUP]);

		heliArrayClear(&keyEvents[KEYEVENT_MOUSE_WENTDOWN]);

		heliArrayClear(&keyEvents[KEYEVENT_MOUSE_WENTUP]);

		SDL_GL_SwapWindow(window);

	}

	unsigned long long addUs = elapsedTimeSinceLastFrameUs + (SDL_GetTicks() - prevFrameTimeMs)*1000ull;

	if (addUs < timeStepUs) {

		unsigned long long waitUs = timeStepUs - addUs;

		if (waitUs > 2000)

			SDL_Delay( (unsigned int)((waitUs + 500)/1000ull) );

	}

}

static void deinit() {

	if (context) SDL_GL_DeleteContext(context);

	context = NULL;

	if (window) SDL_DestroyWindow(window);

	window = NULL;

	if (sdlInitialized) SDL_Quit();

	sdlInitialized = FALSE;

}

static int init() {

	if (SDL_Init(SDL_INIT_EVERYTHING) < 0) {

		fprintf(stderr, "helianthus: SDL_Init failed\n");

		deinit();

		return FALSE;

	}

	sdlInitialized = TRUE;

	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);

	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);

	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);

	SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);

	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);

	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 8);

	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);

	SDL_GL_SetSwapInterval(1);

	unsigned int flags = SDL_WINDOW_OPENGL;

	if (resizable) flags |= SDL_WINDOW_RESIZABLE;

	window = SDL_CreateWindow(

		title,

		SDL_WINDOWPOS_CENTERED,

		SDL_WINDOWPOS_CENTERED,

		width,

		height,

		flags );

	if (!window) {

		fprintf(stderr, "helianthus: cannot create window: %s\n", SDL_GetError());

		SDL_ClearError();

		deinit();

		return FALSE;

	}

	context = SDL_GL_CreateContext(window);

	if (!context) {

		fprintf(stderr, "helianthus: cannot create OpenGL context: %s\n", SDL_GetError());

		SDL_ClearError();

		deinit();

		return FALSE;

	}

	return TRUE;

}

static void handleEvent(SDL_Event *e) {

	if (e->type == SDL_QUIT) {

		stopped = TRUE;

	} else

	if (e->type == SDL_WINDOWEVENT) {

		if (e->window.event == SDL_WINDOWEVENT_CLOSE) {

			stopped = TRUE;

		} else

		if (e->window.event == SDL_WINDOWEVENT_RESIZED) {

			width = e->window.data1;

			height = e->window.data2;

		} else

		if (e->window.event == SDL_WINDOWEVENT_FOCUS_LOST) {

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

			count = keyEventGetCount(KEYEVENT_MOUSE_DOWN);

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

				keyEventAdd(KEYEVENT_MOUSE_WENTUP, keyEventGet(KEYEVENT_MOUSE_DOWN, i));

			heliArrayClear(&keyEvents[KEYEVENT_MOUSE_DOWN]);

		}

	} else

	if (e->type == SDL_KEYDOWN || e->type == SDL_KEYUP) {

		const char *keynameOrig = SDL_GetKeyName(e->key.keysym.sym);

		if (keynameOrig && *keynameOrig) {

			char *keyname = heliStringCopy(keynameOrig);

			heliLowercase(keyname);

			if (e->type == SDL_KEYDOWN) {

				keyEventAdd(KEYEVENT_KEY_DOWN, keyname);

				keyEventAdd(KEYEVENT_KEY_WENTDOWN, keyname);

			} else {

				keyEventRemove(KEYEVENT_KEY_DOWN, keyname);

				keyEventAdd(KEYEVENT_KEY_WENTUP, keyname);

			}

			free(keyname);

		}

	} else

	if (e->type == SDL_MOUSEBUTTONDOWN || e->type == SDL_MOUSEBUTTONUP) {

		char *button = NULL;

		switch(e->button.button) {

			case SDL_BUTTON_LEFT:   button = "left";   break;

			case SDL_BUTTON_MIDDLE: button = "middle"; break;

			case SDL_BUTTON_RIGHT:  button = "right";  break;

			default: break;

		}

		if (button) {

			if (e->type == SDL_MOUSEBUTTONDOWN) {

				keyEventAdd(KEYEVENT_MOUSE_DOWN, button);

				keyEventAdd(KEYEVENT_MOUSE_WENTDOWN, button);

			} else {

				keyEventRemove(KEYEVENT_MOUSE_DOWN, button);

				keyEventAdd(KEYEVENT_MOUSE_WENTUP, button);

			}

		}

		_mouseX = e->button.x;

		_mouseY = e->button.y;

	} else

	if (e->type == SDL_MOUSEMOTION) {

		_mouseX = e->motion.x;

		_mouseY = e->motion.y;

	}

}

static void run() {

	while(!stopped) {

		SDL_Event event;

		while (SDL_PollEvent(&event))

			handleEvent(&event);

		draw();

	}

}

void worldRun() {

	if (started) return;

	started = TRUE;

	stopped = FALSE;

	frameCount = 0;

	elapsedTimeUs = 0;

	elapsedTimeSinceLastFrameUs = 0;

	srand(time(NULL));

	if (init()) {

		heliInitialized = TRUE;

		if (initCallback) initCallback();

		run();

		if (deinitCallback) deinitCallback();

		heliArrayClear(&heliObjectsSet);

		heliSpriteFinish();

		heliDrawingFinish();

		heliFontFinish();

		heliAnimationFinish();

		heliSoundFinish();

		heliArrayDestroy(&heliObjectsSet);

		heliInitialized = FALSE;

		deinit();

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

			heliArrayDestroy(&keyEvents[i]);

	}

	started = FALSE;

}