#define _GNU_SOURCE
#include <wayland-server.h>
#include <X11/Xlib.h>
#include <linux/input.h>
#include <EGL/egl.h>
#include <X11/Xlib-xcb.h>
#include <xkbcommon/xkbcommon-x11.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
#include <poll.h>
#include <signal.h>
#include <execinfo.h>
#include "backend.h"
#include "log.h"

#define WINDOW_WIDTH 1024
#define WINDOW_HEIGHT 600

static struct {
	Window window;
	EGLContext context;
	EGLSurface surface;
} window;
static Display *x_display;
static EGLDisplay egl_display;
static struct callbacks callbacks;
static xcb_connection_t *xcb_connection;
static int32_t keyboard_device_id;
static struct xkb_keymap *keymap;
static struct xkb_state *state;
static Atom  atom1, atom2;

static void create_window (void) {
	// setup EGL	
	static EGLint ctxattr[] = {
		EGL_CONTEXT_CLIENT_VERSION, 2,  // Request opengl ES2.0
		EGL_NONE
	};
	
	static const EGLint attribs[] = {
		EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
		EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
		EGL_BLUE_SIZE, 8,
		EGL_GREEN_SIZE, 8,
		EGL_RED_SIZE, 8,
		EGL_NONE
	};
	EGLConfig config;
	EGLint num_configs_returned;
	eglChooseConfig (egl_display, attribs, &config, 1, &num_configs_returned);
	
	// get the visual from the EGL config
	EGLint visual_id;
	eglGetConfigAttrib (egl_display, config, EGL_NATIVE_VISUAL_ID, &visual_id);
	XVisualInfo visual_template;
	visual_template.visualid = visual_id;
	int num_visuals_returned;
	XVisualInfo *visual = XGetVisualInfo (x_display, VisualIDMask, &visual_template, &num_visuals_returned);
	
	// create a window
	XSetWindowAttributes window_attributes;
	window_attributes.event_mask = ExposureMask | StructureNotifyMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | EnterWindowMask | LeaveWindowMask | FocusChangeMask;
	window_attributes.colormap = XCreateColormap (x_display, RootWindow(x_display,DefaultScreen(x_display)), visual->visual, AllocNone);
	window.window = XCreateWindow (
		x_display,
		RootWindow(x_display, DefaultScreen(x_display)),
		0, 0,
		WINDOW_WIDTH, WINDOW_HEIGHT,
		0, // border width
		visual->depth, // depth
		InputOutput, // class
		visual->visual, // visual
		CWEventMask|CWColormap, // attribute mask
		&window_attributes // attributes
	);
	
    atom1 = XInternAtom(x_display, "WM_PROTOCOLS", 0);
    atom2 = XInternAtom(x_display, "WM_DELETE_WINDOW", 0);
    XSetWMProtocols(x_display, window.window, &atom2, 1);
	
	// EGL context and surface	
	eglBindAPI (EGL_OPENGL_ES_API);
	window.context = eglCreateContext (egl_display, config, EGL_NO_CONTEXT, ctxattr);
	window.surface = eglCreateWindowSurface (egl_display, config, window.window, NULL);
	eglMakeCurrent (egl_display, window.surface, window.surface, window.context);
	
	XFree (visual);
	
	XMapWindow (x_display, window.window);
}

void handler(int sig) {
  void *array[10];
  size_t size;

  // get void*'s for all entries on the stack
  size = backtrace(array, 10);

  // print out all the frames to stderr
  fprintf(stderr, "Error: signal %d:\n", sig);
  backtrace_symbols_fd(array, size, STDERR_FILENO);
  exit(1);
}

void backend_init (struct callbacks *_callbacks) {
	signal(SIGSEGV, handler);
	callbacks = *_callbacks;
	x_display = XOpenDisplay (NULL);
	
	xcb_connection = XGetXCBConnection (x_display);
	struct xkb_context *context = xkb_context_new (XKB_CONTEXT_NO_FLAGS);
	xkb_x11_setup_xkb_extension (xcb_connection, XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION, 0, NULL, NULL, NULL, NULL);
	keyboard_device_id = xkb_x11_get_core_keyboard_device_id (xcb_connection);
	keymap = xkb_x11_keymap_new_from_device (context, xcb_connection, keyboard_device_id, XKB_KEYMAP_COMPILE_NO_FLAGS);
	state = xkb_x11_state_new_from_device (keymap, xcb_connection, keyboard_device_id);
	
	egl_display = eglGetDisplay (x_display);
	eglInitialize (egl_display, NULL, NULL);
	create_window ();
}

EGLDisplay backend_get_egl_display (void) {
	return egl_display;
}

void backend_swap_buffers (void) {
	eglSwapBuffers (egl_display, window.surface);
}

static void update_modifiers (void) {
	if (!callbacks.modifiers) return;
	struct modifier_state modifier_state;
	modifier_state.depressed = xkb_state_serialize_mods (state, XKB_STATE_MODS_DEPRESSED);
	modifier_state.latched = xkb_state_serialize_mods (state, XKB_STATE_MODS_LATCHED);
	modifier_state.locked = xkb_state_serialize_mods (state, XKB_STATE_MODS_LOCKED);
	modifier_state.group = xkb_state_serialize_layout (state, XKB_STATE_LAYOUT_EFFECTIVE);
	callbacks.modifiers (modifier_state);
}

void backend_dispatch_nonblocking (void) {
	XEvent event;
	while (XPending(x_display)) {
		XNextEvent (x_display, &event);
		if (event.type == ConfigureNotify && callbacks.resize) {
			callbacks.resize (event.xconfigure.width, event.xconfigure.height);
		}
		else if (event.type == Expose && callbacks.draw) {
			callbacks.draw ();
		}
		else if (event.type == MotionNotify && callbacks.mouse_motion) {
			callbacks.mouse_motion (event.xbutton.x, event.xbutton.y);
		}
		else if (event.type == ButtonPress && callbacks.mouse_button) {
			if (event.xbutton.button == Button1)
				callbacks.mouse_button (BTN_LEFT, WL_POINTER_BUTTON_STATE_PRESSED);
			else if (event.xbutton.button == Button2)
				callbacks.mouse_button (BTN_MIDDLE, WL_POINTER_BUTTON_STATE_PRESSED);
			else if (event.xbutton.button == Button3)
				callbacks.mouse_button (BTN_RIGHT, WL_POINTER_BUTTON_STATE_PRESSED);
		}
		else if (event.type == ButtonRelease && callbacks.mouse_button) {
			if (event.xbutton.button == Button1)
				callbacks.mouse_button (BTN_LEFT, WL_POINTER_BUTTON_STATE_RELEASED);
			else if (event.xbutton.button == Button2)
				callbacks.mouse_button (BTN_MIDDLE, WL_POINTER_BUTTON_STATE_RELEASED);
			else if (event.xbutton.button == Button3)
				callbacks.mouse_button (BTN_RIGHT, WL_POINTER_BUTTON_STATE_RELEASED);
		}
		else if (event.type == KeyPress && callbacks.key) {
			callbacks.key (event.xkey.keycode - 8, WL_KEYBOARD_KEY_STATE_PRESSED);
			xkb_state_update_key (state, event.xkey.keycode, XKB_KEY_DOWN);
			update_modifiers ();
		}
		else if (event.type == KeyRelease && callbacks.key) {
			callbacks.key (event.xkey.keycode - 8, WL_KEYBOARD_KEY_STATE_RELEASED);
			xkb_state_update_key (state, event.xkey.keycode, XKB_KEY_UP);
			update_modifiers ();
		}
		else if (event.type == FocusIn) {
			xkb_state_unref (state);
			state = xkb_x11_state_new_from_device (keymap, xcb_connection, keyboard_device_id);
			update_modifiers ();
		}
		else if (event.type == ClientMessage && callbacks.terminate) {
		if(event.xclient.message_type == atom1 &&
			event.xclient.data.l[0] == atom2) {
				//XDestroyWindow(x_display, event.xclient.window);
				callbacks.terminate();
			}
			break;
		}
		else if (event.type == DestroyNotify && callbacks.terminate) {
			callbacks.terminate();
			break;
		}
	}
}

void backend_wait_for_events (int wayland_fd) {
	struct pollfd fds[2] = {{ConnectionNumber(x_display), POLLIN}, {wayland_fd, POLLIN}};
	poll (fds, 2, -1);
}

void backend_get_keymap (int *fd, int *size) {
	char *string = xkb_keymap_get_as_string (keymap, XKB_KEYMAP_FORMAT_TEXT_V1);
	*size = strlen (string) + 1;
	char *xdg_runtime_dir = getenv ("XDG_RUNTIME_DIR");
	*fd = open (xdg_runtime_dir, O_TMPFILE|O_RDWR|O_EXCL, 0600);
	ftruncate (*fd, *size);
	char *map = mmap (NULL, *size, PROT_READ|PROT_WRITE, MAP_SHARED, *fd, 0);
	strcpy (map, string);
	munmap (map, *size);
	free (string);
}

long backend_get_timestamp (void) {
	struct timespec t;
	clock_gettime (CLOCK_MONOTONIC, &t);
	return t.tv_sec * 1000 + t.tv_nsec / 1000000;
}

void backend_get_dimensions(uint32_t *width, uint32_t *height) {
	if (width != NULL)  *width  = WINDOW_WIDTH;
	if (height != NULL) *height = WINDOW_HEIGHT;
}

int main(int argc, char *argv[]) {
#ifndef __ANDROID__
	if (argc == 2 && !strcmp("-f", argv[1])) trace_funcs = 1;
#endif
	lorie_start();
	return 0;
}