#include <time.h>

#include <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;
}