/* $Id$ */

#include <GL/gl.h>
#include <Mw/Milsko.h>

#include <assert.h>
#include <cairo/cairo.h>
#include <fcntl.h>
#include <errno.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <wayland-client-protocol.h>

#include "../../external/stb_ds.h"
#include "Mw/BaseTypes.h"
#include "Mw/LowLevel.h"

#include <sys/mman.h>
#include <wayland-egl-core.h>
#include <wayland-util.h>

PFNGLGENFRAMEBUFFERSPROC      glGenFramebuffers;
PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D;
PFNGLGENRENDERBUFFERSPROC     glGenRenderbuffers;
// PFNGLRENDERBUFFERSTORAGEPROC	 glRenderbufferStorage;
PFNGLFRAMEBUFFERRENDERBUFFERPROC   glFramebufferRenderbuffer;
PFNGLBINDRENDERBUFFERPROC	   glBindRenderbuffer;
PFNGLBINDFRAMEBUFFERPROC	   glBindFramebuffer;
PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatus;

#define WAYLAND_GET_INTERFACE(r, inter) shget(r.wl_protocol_map, inter##_interface.name)

static void new_protocol(void* data, struct wl_registry* registry,
			 MwU32 name, const char* interface,
			 MwU32 version) {
	struct _MwLLWayland* wayland = data;

	wl_setup_func* func = shget(wayland->wl_protocol_setup_map, interface);
	if(func != NULL) {
		// printf("registering interface %s\n", interface);
		shput(wayland->wl_protocol_map, interface, func(name, data));
	} else {
		// printf("unknown interface %s\n", interface);
	}
};

static void protocol_removed(void*		 data,
			     struct wl_registry* registry,
			     MwU32		 name) {

};

static void wl_seat_name(void* data, struct wl_seat* wl_seat, const char* name) {};
static void wl_seat_capabilities(void* data, struct wl_seat* wl_seat,
				 MwU32 capabilities) {};

void xdg_wm_base_ping(void*		  data,
		      struct xdg_wm_base* xdg_wm_base,
		      MwU32		  serial) {
	// The compositor will send us a ping event to check that we're responsive.
	// We need to send back a pong request immediately.
	xdg_wm_base_pong(xdg_wm_base, serial);
};

static wayland_protocol_t* wl_shm_setup(MwU32 name, struct _MwLLWayland* wayland) {
	wayland->shm = wl_registry_bind(wayland->registry, name, &wl_shm_interface, 1);
	return NULL;
}
// static void buffer_setup(struct _MwLLWayland* wayland) {
// }

static wayland_protocol_t* wl_seat_setup(MwU32 name, struct _MwLLWayland* wayland) {
	wayland_protocol_t* proto = malloc(sizeof(wayland_protocol_t));
	proto->listener		  = malloc(sizeof(struct wl_seat_listener));

	((struct wl_seat_listener*)proto->listener)->name	  = wl_seat_name;
	((struct wl_seat_listener*)proto->listener)->capabilities = wl_seat_capabilities;

	proto->context = wl_registry_bind(wayland->registry, name, &wl_seat_interface, 1);
	wl_seat_add_listener(proto->context, proto->listener, wayland);

	return proto;
}

static wayland_protocol_t* wl_compositor_setup(MwU32 name, struct _MwLLWayland* wayland) {
	wayland->compositor = wl_registry_bind(wayland->registry, name, &wl_compositor_interface, 1);

	return NULL;
}

static wayland_protocol_t* wl_subcompositor_setup(MwU32 name, struct _MwLLWayland* wayland) {
	wayland->subcompositor = wl_registry_bind(wayland->registry, name, &wl_subcompositor_interface, 1);

	return NULL;
}

static wayland_protocol_t* xdg_wm_base_setup(MwU32 name, struct _MwLLWayland* wayland) {
	wayland_protocol_t* proto = malloc(sizeof(wayland_protocol_t));
	proto->listener		  = malloc(sizeof(struct xdg_wm_base_listener));

	((struct xdg_wm_base_listener*)proto->listener)->ping = xdg_wm_base_ping;

	proto->context = wl_registry_bind(wayland->registry, name, &xdg_wm_base_interface, 1);
	xdg_wm_base_add_listener(proto->context, proto->listener, wayland);

	return proto;
}

static wayland_protocol_t* wp_cursor_shape_manager_v1_setup(MwU32 name, struct _MwLLWayland* wayland) {
	wayland_protocol_t* proto = malloc(sizeof(wayland_protocol_t));
	proto->listener		  = NULL;

	proto->context = wl_registry_bind(wayland->registry, name, &wp_cursor_shape_manager_v1_interface, 1);

	return proto;
}

typedef struct zxdg_decoration_manager_v1_context {
	struct zxdg_decoration_manager_v1* manager;
	// struct zxdg_decoration_toplevel_v1* toplevel;
	struct zxdg_toplevel_decoration_v1* decoration;
} zxdg_decoration_manager_v1_context_t;

static wayland_protocol_t* zxdg_decoration_manager_v1_setup(MwU32 name, struct _MwLLWayland* wayland) {
	wayland_protocol_t*		      proto = malloc(sizeof(wayland_protocol_t));
	zxdg_decoration_manager_v1_context_t* ctx   = malloc(sizeof(zxdg_decoration_manager_v1_context_t));
	proto->listener				    = NULL;

	ctx->manager = wl_registry_bind(wayland->registry, name, &zxdg_decoration_manager_v1_interface, 1);
	;

	proto->context = ctx;

	return proto;
}

static MwBool egl_setup(MwLL self, int width, int height) {
	int	   err;
	EGLint	   numConfigs;
	EGLint	   majorVersion;
	EGLint	   minorVersion;
	EGLContext context;
	EGLSurface surface;
	EGLConfig  config;
	EGLint	   fbAttribs[] =
	    {
		EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
		EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
		EGL_RED_SIZE, 8,
		EGL_GREEN_SIZE, 8,
		EGL_BLUE_SIZE, 8,
		EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
		EGL_NONE};
	EGLint contextAttribs[] = {
	    EGL_CONTEXT_CLIENT_VERSION, 1,
	    EGL_CONTEXT_MAJOR_VERSION, 1,
	    EGL_CONTEXT_MINOR_VERSION, 1,
	    EGL_NONE};

	EGLDisplay display = eglGetDisplay(self->wayland.display);
	if(display == EGL_NO_DISPLAY) {
		printf("ERROR: eglGetDisplay, %0X\n", eglGetError());
		return MwFALSE;
	}

	// Initialize EGL
	if(!eglInitialize(display, &majorVersion, &minorVersion)) {
		printf("ERROR: eglInitialize, %0X\n", eglGetError());
		return MwFALSE;
	}

	// Get configs
	if((eglGetConfigs(display, NULL, 0, &numConfigs) != EGL_TRUE) || (numConfigs == 0)) {
		printf("ERROR: eglGetConfigs, %0X\n", eglGetError());
		return MwFALSE;
	}

	// Choose config
	if((eglChooseConfig(display, fbAttribs, &config, 1, &numConfigs) != EGL_TRUE) || (numConfigs != 1)) {
		printf("ERROR: eglChooseConfig, %0X\n", eglGetError());
		return MwFALSE;
	}

	self->wayland.egl_window_native =
	    wl_egl_window_create(self->wayland.surface, width, height);
	if(self->wayland.egl_window_native == EGL_NO_SURFACE) {
		printf("ERROR: wl_egl_window_create, EGL_NO_SURFACE\n");
		return MwFALSE;
	}

	// Create a surface
	surface = eglCreateWindowSurface(display, config, self->wayland.egl_window_native, NULL);
	if(surface == EGL_NO_SURFACE) {
		printf("ERROR: eglCreateWindowSurface, %0X\n", eglGetError());
		return MwFALSE;
	}

	eglBindAPI(EGL_OPENGL_API);

	// Create a GL context
	context = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttribs);
	if(context == EGL_NO_CONTEXT) {
		printf("ERROR: eglCreateContext, %0X\n", eglGetError());
		return MwFALSE;
	}

	// Make the context current
	if(!eglMakeCurrent(display, surface, surface, context)) {
		printf("ERROR: eglMakeCurrent, %0X\n", eglGetError());
		return MwFALSE;
	}

	glGenFramebuffers      = (PFNGLGENFRAMEBUFFERSPROC)eglGetProcAddress("glGenFramebuffers");
	glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)eglGetProcAddress("glFramebufferTexture2D");
	glGenRenderbuffers     = (PFNGLGENRENDERBUFFERSPROC)eglGetProcAddress("glGenRenderbuffers");
	// glRenderbufferStorage	  = (PFNGLRENDERBUFFERSTORAGEPROC)eglGetProcAddress("glRenderbufferStorage");
	glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)eglGetProcAddress("glFramebufferRenderbuffer");
	glBindRenderbuffer	  = (PFNGLBINDRENDERBUFFERPROC)eglGetProcAddress("glBindRenderbuffer");
	glBindFramebuffer	  = (PFNGLBINDFRAMEBUFFERPROC)eglGetProcAddress("glBindFramebuffer");
	glCheckFramebufferStatus  = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)eglGetProcAddress("glCheckFramebufferStatus");

	glGenTextures(1, &self->wayland.fbo_texture);
	glBindTexture(GL_TEXTURE_2D, self->wayland.fbo_texture);

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);

	glBindTexture(GL_TEXTURE_2D, 0);

	glGenRenderbuffers(1, &self->wayland.rbo);
	// glBindRenderbuffer(GL_RENDERBUFFER, self->wayland.rbo));
	// glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, 768, 1024);
	// glBindRenderbuffer(GL_RENDERBUFFER, 0);

	glGenFramebuffers(1, &self->wayland.fbo);
	glBindFramebuffer(GL_FRAMEBUFFER_BINDING, self->wayland.fbo);

	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self->wayland.fbo_texture, 0);

	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, self->wayland.rbo);

	if((err = glCheckFramebufferStatus(GL_FRAMEBUFFER)) != GL_FRAMEBUFFER_COMPLETE) {
		printf("Error binding framebuffer: %0X\n", err);
		return MwFALSE;
	}

	glBindFramebuffer(GL_FRAMEBUFFER_BINDING, 0);

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(0, width, height, -13, -1, 1);

	self->wayland.egl_display = display;
	self->wayland.egl_surface = surface;
	self->wayland.egl_context = context;
	printf("EGL success\n");
	return MwTRUE;
}

static void xdg_toplevel_configure(void*		data,
				   struct xdg_toplevel* xdg_toplevel,
				   MwI32 width, MwI32 height,
				   struct wl_array* states) {
	MwLL			      self		     = data;
	PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)eglGetProcAddress("glFramebufferTexture2D");

	if(width == 0 && height == 0) {
		width  = self->wayland.ww;
		height = self->wayland.wh;
	}
	self->wayland.ww = width;
	self->wayland.wh = height;
	xdg_surface_set_window_geometry(self->wayland.toplevel->xdg_surface, self->wayland.x, self->wayland.y, self->wayland.ww, self->wayland.wh);

	MwLLSetWH(self, width, height);
	MwLLDispatch(self, resize, NULL);

	if(!self->wayland.egl_setup) {
		self->wayland.egl_setup = egl_setup(self, width, height);
	} else {
		wl_egl_window_resize(self->wayland.egl_window_native, width, height, 0, 0);
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		glOrtho(0, width, height, -13, -1, 1);
		self->wayland.do_clear = MwTRUE;

		// glDeleteTextures(1, &self->wayland.fbo_texture);
		// glGenTextures(1, &self->wayland.fbo_texture);
		// glBindTexture(GL_TEXTURE_2D, self->wayland.fbo_texture);

		// glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		// glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		// glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		// glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		// glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);

		// glBindTexture(GL_TEXTURE_2D, 0);
	}

	MwLLForceRender(self);

	return;
};

static void decoration_configure(
    void* data, struct zxdg_toplevel_decoration_v1* zxdg_toplevel_decoration_v1,
    MwU32 mode) {
}

static void xdg_toplevel_close(
    void* data, struct xdg_toplevel* xdg_toplevel) {
	MwLL self = data;

	// Stop running if the user requests to close the toplevel
	self->wayland.toplevel->running = MwFALSE;
};

static void xdg_surface_configure(
    void* data, struct xdg_surface* xdg_surface, MwU32 serial) {
	MwLL self = data;

	// The compositor configures our surface, acknowledge the configure event
	xdg_surface_ack_configure(xdg_surface, serial);

	if(self->wayland.configured) {
		// If this isn't the first configure event we've received, we already
		// have a buffer attached, so no need to do anything. Commit the
		// surface to apply the configure acknowledgement.
		// wl_surface_attach(self->surface, self->buffer, 0, 0);
		wl_surface_commit(self->wayland.surface);
	}

	self->wayland.configured = MwTRUE;
}

#define WL_INTERFACE(interface) \
	shput(wayland->wl_protocol_setup_map, interface##_interface.name, (wl_setup_func*)interface##_setup);

static void setup_callbacks(struct _MwLLWayland* wayland) {
	wayland->registry_listener.global	 = new_protocol;
	wayland->registry_listener.global_remove = protocol_removed;
	wayland->wl_protocol_setup_map		 = NULL;
	wayland->wl_protocol_map		 = NULL;

	WL_INTERFACE(wl_shm);
	WL_INTERFACE(wl_compositor);
	WL_INTERFACE(wl_subcompositor);
	if(wayland->type == MWLL_WAYLAND_TOPLEVEL) {
		WL_INTERFACE(wl_seat);
		WL_INTERFACE(xdg_wm_base);
		WL_INTERFACE(zxdg_decoration_manager_v1);
		WL_INTERFACE(wp_cursor_shape_manager_v1);
	}
}

#undef WL_INTERFACE

static MwBool flush_display(struct wl_display* display) {
	while(wl_display_flush(display) == -1) {
		if(errno != EAGAIN) {
			return MwFALSE;
		}

		struct pollfd fd = {wl_display_get_fd(display), POLL_OUT};

		while(poll(&fd, 1, -1) == -1) {
			if(errno != EINTR && errno != EAGAIN)
				return MwFALSE;
		}
	}
	return MwTRUE;
}

static void setup_toplevel(MwLL r, int x, int y, int width, int height) {
	r->wayland.type	    = MWLL_WAYLAND_TOPLEVEL;
	r->wayland.toplevel = malloc(sizeof(struct _MwLLWaylandTopLevel));

	setup_callbacks(&r->wayland);

	// Connect to the Wayland compositor
	r->wayland.display = wl_display_connect(NULL);
	if(r->wayland.display == NULL) {
		printf("wayland: failed to create display\n");
		r->common.success = MwFALSE;
		return;
	}

	// Do a roundtrip to ensure all interfaces are setup.
	r->wayland.registry = wl_display_get_registry(r->wayland.display);
	wl_registry_add_listener(r->wayland.registry, &r->wayland.registry_listener, r);
	if(wl_display_roundtrip(r->wayland.display) == -1) {
		printf("roundtrip failed\n");
		r->common.success = MwFALSE;
		return;
	}

	// Check that all globals we require are available
	if(
	    r->wayland.compositor == NULL ||
	    WAYLAND_GET_INTERFACE(r->wayland, xdg_wm_base)->context == NULL ||
	    WAYLAND_GET_INTERFACE(r->wayland, wl_seat)->context == NULL) {

		printf("no wl_shm, wl_compositor, wl_seat, or xdg_wm_base support\n");
		r->common.success = MwFALSE;
		return;
	}

	r->wayland.toplevel->xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);

	// Create a wl_surface, a xdg_surface and a xdg_toplevel
	r->wayland.surface = wl_compositor_create_surface(r->wayland.compositor);
	r->wayland.toplevel->xdg_surface =
	    xdg_wm_base_get_xdg_surface(WAYLAND_GET_INTERFACE(r->wayland, xdg_wm_base)->context, r->wayland.surface);
	r->wayland.toplevel->xdg_top_level = xdg_surface_get_toplevel(r->wayland.toplevel->xdg_surface);

	// setup mandatory listeners
	r->wayland.toplevel->xdg_surface_listener.configure  = xdg_surface_configure;
	r->wayland.toplevel->xdg_toplevel_listener.configure = xdg_toplevel_configure;
	r->wayland.toplevel->xdg_toplevel_listener.close     = xdg_toplevel_close;

	xdg_surface_add_listener(r->wayland.toplevel->xdg_surface, &r->wayland.toplevel->xdg_surface_listener, r);
	xdg_toplevel_add_listener(r->wayland.toplevel->xdg_top_level, &r->wayland.toplevel->xdg_toplevel_listener,
				  r);

	xdg_toplevel_set_title(r->wayland.toplevel->xdg_top_level, "Milsko Wayland App");
	xdg_toplevel_set_app_id(r->wayland.toplevel->xdg_top_level, "MilskoWaylandApp");

	// Perform the initial commit and wait for the first configure event
	wl_surface_commit(r->wayland.surface);
	while(wl_display_dispatch(r->wayland.display) != -1 && !r->wayland.configured) {
	}

	// setup decorations if we can
	if(WAYLAND_GET_INTERFACE(r->wayland, zxdg_decoration_manager_v1)->context != NULL) {
		zxdg_decoration_manager_v1_context_t* dec = WAYLAND_GET_INTERFACE(r->wayland, zxdg_decoration_manager_v1)->context;

		dec->decoration = zxdg_decoration_manager_v1_get_toplevel_decoration(
		    dec->manager, r->wayland.toplevel->xdg_top_level);

		zxdg_toplevel_decoration_v1_set_mode(
		    dec->decoration, ZXDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
	} else {
		printf("zxdg null\n");
	}

	// buffer_setup(&r->wayland);

	wl_surface_commit(r->wayland.surface);
}

static void setup_subsurface(MwLL parent, MwLL r, int x, int y, int width, int height) {
	struct wl_compositor*	 compositor	= parent->wayland.compositor;
	struct wl_subcompositor* subcompositor	= parent->wayland.subcompositor;
	struct wl_surface*	 parent_surface = parent->wayland.surface;

	r->wayland.type = MWLL_WAYLAND_SUBSURFACE;

	r->wayland.display = parent->wayland.display;

	r->wayland.surface = wl_compositor_create_surface(compositor);

	r->wayland.subsurface = wl_subcompositor_get_subsurface(subcompositor, r->wayland.surface, parent_surface);

	wl_subsurface_set_position(r->wayland.subsurface, x, y);

	// printf("position %d %d\n", x, y);

	setup_callbacks(&r->wayland);

	r->wayland.registry = wl_display_get_registry(parent->wayland.display);
	r->wayland.display  = parent->wayland.display;

	wl_registry_add_listener(r->wayland.registry, &r->wayland.registry_listener, r);
	if(wl_display_roundtrip(r->wayland.display) == -1) {
		printf("roundtrip failed\n");
		raise(SIGTRAP);
		return;
	}

	// arrpush(parent->wayland.subsurfaces, r);

	r->wayland.configured = MwTRUE;

	r->wayland.egl_context = parent->wayland.egl_context;
	r->wayland.egl_display = parent->wayland.egl_display;
	r->wayland.egl_surface = parent->wayland.egl_surface;
	r->wayland.fbo	       = parent->wayland.fbo;
	r->wayland.fbo_texture = parent->wayland.fbo_texture;
	r->wayland.rbo	       = parent->wayland.rbo;
}
static MwLL MwLLCreateImpl(MwLL parent, int x, int y, int width, int height) {
	MwLL r;
	r = malloc(sizeof(*r));
	MwLLCreateCommon(r);

	r->common.type = MwLLBackendWayland;

	if(width == 0) width = 1;
	if(height == 0) height = 1;

	r->wayland.ww	  = width;
	r->wayland.wh	  = height;
	r->wayland.parent = parent;

	r->wayland.force_redraw = MwFALSE;
	r->wayland.do_clear	= MwFALSE;
	r->common.success	= MwTRUE;

	if(parent == NULL) {
		setup_toplevel(r, x, y, width, height);
	} else {
		setup_subsurface(parent, r, x, y, width, height);
	}

	// buffer_setup(&r->wayland);

	return r;
}

static void MwLLDestroyImpl(MwLL handle) {
	MwLLDestroyCommon(handle);

	free(handle);
}

static void MwLLGetXYWHImpl(MwLL handle, int* x, int* y, unsigned int* w, unsigned int* h) {
	*x = handle->wayland.x;
	*y = handle->wayland.y;
	*w = handle->wayland.ww;
	*h = handle->wayland.wh;
}

static void MwLLSetXYImpl(MwLL handle, int x, int y) {

	if(handle->wayland.type != MWLL_WAYLAND_TOPLEVEL) {
		handle->wayland.x = x;
		handle->wayland.y = y;
		wl_subsurface_set_position(handle->wayland.subsurface, x, y);
		MwLLForceRender(handle);
	}
}

static void MwLLSetWHImpl(MwLL handle, int w, int h) {
	handle->wayland.ww = w;
	handle->wayland.wh = h;

	if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
		xdg_surface_set_window_geometry(handle->wayland.toplevel->xdg_surface, handle->wayland.x, handle->wayland.y, handle->wayland.ww, handle->wayland.wh);
	} else {
	}
}

static void MwLLPolygonImpl(MwLL handle, MwPoint* points, int points_count, MwLLColor color) {
	/*
	 * TODO: this function sucks shit, ioi needs to make it not suck shit :)
	 */
	int			  i;
	PFNGLBINDFRAMEBUFFERPROC  glBindFramebuffer  = (PFNGLBINDFRAMEBUFFERPROC)eglGetProcAddress("glBindFramebuffer");
	PFNGLBINDRENDERBUFFERPROC glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)eglGetProcAddress("glBindRenderbuffer");
	int			  w, h;

	if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
		w = handle->wayland.ww;
		h = handle->wayland.wh;
	} else {
		MwLL parent = handle->wayland.parent;
		while(parent->wayland.type != MWLL_WAYLAND_TOPLEVEL) {
			parent = parent->wayland.parent;
		}
		w = parent->wayland.ww;
		h = parent->wayland.wh;
	}

	glEnable(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, 0);
	glBindFramebuffer(GL_FRAMEBUFFER, handle->wayland.fbo);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, handle->wayland.fbo_texture, 0);

	glBegin(GL_TRIANGLE_FAN);
	for(i = 0; i < points_count; i++) {
		glColor3f(color->common.red / 255.0, color->common.green / 255.0, color->common.blue / 255.0);
		glVertex2f(
		    (handle->wayland.x + points[i].x),
		    (handle->wayland.y + points[i].y));

		if((i % 3) == 0 && i != 0) {
			glColor3f(color->common.red / 255.0, color->common.green / 255.0, color->common.blue / 255.0);
			glVertex2f(
			    (handle->wayland.x + points[i].x),
			    (handle->wayland.y + points[i].y));
		}
	}
	glEnd();
	glFinish();

	glBindTexture(GL_TEXTURE_2D, handle->wayland.fbo_texture);
	glBindFramebuffer(GL_FRAMEBUFFER, 0);
	glClear(GL_COLOR_BUFFER_BIT);
	glClearColor(0, 0, 0, 1);

	glColor3f(1.0, 1.0, 1.0);

	glBegin(GL_QUADS);
	glTexCoord2f(0.0f, 1);
	glVertex2f(0, 0);
	glTexCoord2f(1, 1);
	glVertex2f(w, 0);
	glTexCoord2f(1, 0.0f);
	glVertex2f(w, h);
	glTexCoord2f(0.0f, 0.0f);
	glVertex2f(0, h);
	glEnd();
	glFinish();

	if(!eglSwapBuffers(handle->wayland.egl_display, handle->wayland.egl_surface)) {
		printf("error swapping buffers! %0X\n", eglGetError());
	} else {
		wl_surface_commit(handle->wayland.surface);
	}
	glDisable(GL_TEXTURE_2D);
	handle->wayland.do_clear = MwFALSE;
}

static void MwLLLineImpl(MwLL handle, MwPoint* points, MwLLColor color) {
	//
}

static MwLLColor MwLLAllocColorImpl(MwLL handle, int r, int g, int b) {
	MwLLColor c = malloc(sizeof(*c));

	c->common.red	= r;
	c->common.blue	= b;
	c->common.green = g;

	return c;
}

static void MwLLColorUpdateImpl(MwLL handle, MwLLColor c, int r, int g, int b) {
	c->common.red	= r;
	c->common.blue	= b;
	c->common.green = g;
}

static void MwLLFreeColorImpl(MwLLColor color) {
	free(color);
}

static int MwLLPendingImpl(MwLL handle) {
	enum {
		DISPLAY_FD,
		KEYREPEAT_FD,
		CURSOR_FD
	};
	struct pollfd fd;
	int	      timeout = 1;

	if(handle->wayland.force_redraw) {
		return 1;
	}

	if(handle->wayland.display == NULL) {
		return 0;
	}
	fd.fd	  = wl_display_get_fd(handle->wayland.display);
	fd.events = POLLIN;

	while(wl_display_prepare_read(handle->wayland.display) != 0) {
		if(wl_display_dispatch_pending(handle->wayland.display) > 0) {
			return 0;
		}
	}

	// If an error other than EAGAIN happens, we have likely been disconnected
	// from the Wayland session
	if(!flush_display(handle->wayland.display)) {
		wl_display_cancel_read(handle->wayland.display);

		handle->wayland.toplevel->running = MwFALSE;
		return 0;
	}

	// Condition where no events are being sent.
	if(!poll(&fd, 1, timeout)) {
		wl_display_cancel_read(handle->wayland.display);
		// In this case, we need to commit the surface for any animations, etc.
		wl_surface_commit(handle->wayland.surface);
		return 0;
	}

	if(fd.revents & POLLIN) {
		wl_display_read_events(handle->wayland.display);
		if(wl_display_dispatch_pending(handle->wayland.display) > 0) {
		}
	} else {
		wl_display_cancel_read(handle->wayland.display);
	}

	return 1;
}

static void MwLLNextEventImpl(MwLL handle) {
	MwBool render = handle->wayland.force_redraw;

	if(render) {
		int	     x, y;
		unsigned int w, h;

		MwLLGetXYWH(handle, &x, &y, &w, &h);

		MwLLDispatch(handle, draw, NULL);
		handle->wayland.force_redraw = MwFALSE;
	}
}

static void MwLLSetTitleImpl(MwLL handle, const char* title) {
	if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
		xdg_toplevel_set_title(handle->wayland.toplevel->xdg_top_level, title);
	}
}

static MwLLPixmap MwLLCreatePixmapImpl(MwLL handle, unsigned char* data, int width, int height) {
	MwLLPixmap r = malloc(sizeof(*r));

	r->common.width	 = width;
	r->common.height = height;
	r->common.raw	 = data;
	return r;
}

static void MwLLPixmapUpdateImpl(MwLLPixmap r) {
}

static void MwLLDestroyPixmapImpl(MwLLPixmap pixmap) {
	free(pixmap);
}

static void MwLLDrawPixmapImpl(MwLL handle, MwRect* rect, MwLLPixmap pixmap) {
}

static void MwLLSetIconImpl(MwLL handle, MwLLPixmap pixmap) {
}

static void MwLLForceRenderImpl(MwLL handle) {
	wl_surface_damage(handle->wayland.surface, 0, 0, handle->wayland.ww, handle->wayland.wh);

	if(handle->wayland.egl_setup) {
		if(!eglSwapBuffers(handle->wayland.egl_display, handle->wayland.egl_surface)) {
			printf("error swapping buffers! %0X\n", eglGetError());
		}
	}

	wl_surface_commit(handle->wayland.surface);

	handle->wayland.force_redraw = MwTRUE;
}

static void MwLLSetCursorImpl(MwLL handle, MwCursor* image, MwCursor* mask) {
}

static void MwLLDetachImpl(MwLL handle, MwPoint* point) {
}

static void MwLLShowImpl(MwLL handle, int show) {
}

static void MwLLMakePopupImpl(MwLL handle, MwLL parent) {
}

static void MwLLSetSizeHintsImpl(MwLL handle, int minx, int miny, int maxx, int maxy) {
	if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
		xdg_toplevel_set_min_size(handle->wayland.toplevel->xdg_top_level, minx, miny);
		xdg_toplevel_set_max_size(handle->wayland.toplevel->xdg_top_level, maxx, maxy);
	}
}

static void MwLLMakeBorderlessImpl(MwLL handle, int toggle) {
	if(handle->wayland.type == MWLL_WAYLAND_TOPLEVEL) {
		if(WAYLAND_GET_INTERFACE(handle->wayland, zxdg_decoration_manager_v1)->context != NULL) {
			zxdg_decoration_manager_v1_context_t* dec = WAYLAND_GET_INTERFACE(handle->wayland, zxdg_decoration_manager_v1)->context;

			dec->decoration = zxdg_decoration_manager_v1_get_toplevel_decoration(
			    dec->manager, handle->wayland.toplevel->xdg_top_level);

			zxdg_toplevel_decoration_v1_set_mode(
			    dec->decoration, ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE);
		} else {
			// TODO: hide our custom window decorations when we have them.
			printf("zxdg null\n");
		}
	}
}

static void MwLLFocusImpl(MwLL handle) {
}

static void MwLLGrabPointerImpl(MwLL handle, int toggle) {
}

static void MwLLSetClipboardImpl(MwLL handle, const char* text) {
}

static char* MwLLGetClipboardImpl(MwLL handle) {
	char* r = NULL;
	return r;
}

static void MwLLMakeToolWindowImpl(MwLL handle) {
}

static void MwLLGetCursorCoordImpl(MwLL handle, MwPoint* point) {
}

static void MwLLGetScreenSizeImpl(MwLL handle, MwRect* rect) {
}

static void MwLLBeginStateChangeImpl(MwLL handle) {
	MwLLShow(handle, 0);
}

static void MwLLEndStateChangeImpl(MwLL handle) {
	MwLLShow(handle, 1);
}

static int MwLLWaylandCallInitImpl(void) {
#ifdef __linux__
	if(strcmp(getenv("XDG_SESSION_TYPE"), "wayland")) {
		return 1;
	}
#endif
	return 0;
}

#include "call.c"
CALL(Wayland);