#include <stdint.h>
#include <stdio.h>
#include <string.h>

#include <sys/mman.h>
#include <syscall.h>
#include <unistd.h>

#include <xdg-shell.h>
#include <wayland-client-protocol.h>
#include <wayland-client.h>

struct wl_compositor *compositor;
struct wl_shm *shm;
struct xdg_wm_base *xdg_shell;
struct wl_seat *wl_seat;

int running = 1;

// registry
void registry_global_handler(
	void *data, struct wl_registry *registry,
	uint32_t name, const char *interface,
	uint32_t version)
{
	//  printf(" -> %s\n", interface);
	if (strcmp(interface, wl_compositor_interface.name) == 0)
	{
		compositor = wl_registry_bind(registry, name, &wl_compositor_interface, 3);
		printf("Got wl_compositor\n");
	}
	else if (strcmp(interface, wl_shm_interface.name) == 0)
	{
		shm = wl_registry_bind(registry, name, &wl_shm_interface, 1);
		printf("Got wl_shm\n");
	}
	else if (strcmp(interface, xdg_wm_base_interface.name) == 0)
	{
		xdg_shell = wl_registry_bind(registry, name, &xdg_wm_base_interface, 4);
		printf("Got xdg_wm_base\n");
	}
	else if (strcmp(interface, wl_seat_interface.name) == 0)
	{
		wl_seat = wl_registry_bind(registry, name, &wl_seat_interface, 5);
		printf("Got wl_seat (%d)\n", version);
	}
}

void registry_global_remove_handler(
	void *data, struct wl_registry *registry,
	uint32_t name)
{
	// notging
}

const struct wl_registry_listener registry_listener = {
	.global = registry_global_handler,
	.global_remove = registry_global_remove_handler};

// xdg_toplevel
void xdg_toplevel_configure_handler(
	void *data,
	struct xdg_toplevel *xdg_toplevel,
	int32_t width, int32_t height,
	struct wl_array *states)
{
	printf("xdg_toplevel_configure: %dx%d\n", width, height);
}

void xdg_toplevel_close_handler(void *data, struct xdg_toplevel *xdg_toplevel)
{
	printf("xdg_toplevel_close\n");
	running = 0;
}

void xdg_toplevel_configure_bounds_handler(
	void *data,
	struct xdg_toplevel *xdg_toplevel,
	int32_t width,
	int32_t height)
{
	// nothing
}

const struct xdg_toplevel_listener xdg_toplevel_listener = {
	.configure = xdg_toplevel_configure_handler,
	.close = xdg_toplevel_close_handler,
	.configure_bounds = xdg_toplevel_configure_bounds_handler};

// xdg_surface
void xdg_surface_configure_handler(void *data, struct xdg_surface *xdg_surface,
								   uint32_t serial)
{
	printf("xdg_surface_configure\n");
	xdg_surface_ack_configure(xdg_surface, serial);
}

const struct xdg_surface_listener xdg_surface_listener = {
	.configure = xdg_surface_configure_handler};

// xdg_shell
void xdg_wm_base_ping_handler(void *data, struct xdg_wm_base *xdg_shell,
							  uint32_t serial)
{
	xdg_wm_base_pong(xdg_shell, serial);
	printf("wm_base ping-pong\n");
}

const struct xdg_wm_base_listener xdg_shell_listener = {
	.ping = xdg_wm_base_ping_handler};

// main

int main(void)
{
	struct wl_display *display = wl_display_connect(NULL);
	struct wl_registry *registry = wl_display_get_registry(display);
	wl_registry_add_listener(registry, &registry_listener, NULL);

	// wait for the "initial" set of globals to appear
	wl_display_roundtrip(display);

	xdg_wm_base_add_listener(xdg_shell, &xdg_shell_listener, NULL);

	struct wl_surface *surface = wl_compositor_create_surface(compositor);
	struct xdg_surface *xdg_surface = xdg_wm_base_get_xdg_surface(xdg_shell, surface);
	struct xdg_toplevel *xdg_toplevel = xdg_surface_get_toplevel(xdg_surface);

	xdg_surface_add_listener(xdg_surface, &xdg_surface_listener, NULL);
	xdg_toplevel_add_listener(xdg_toplevel, &xdg_toplevel_listener, NULL);

	xdg_toplevel_set_app_id(xdg_toplevel, "ark-1");
	xdg_toplevel_set_title(xdg_toplevel, "Ark Jeden.");

	// signal that the surface is ready to be configured
	wl_surface_commit(surface);

	struct wl_keyboard *wl_keyboard = wl_seat_get_keyboard(wl_seat);

	int width = 600;
	int height = 800;
	int stride = width * 4;
	int size = stride * height; // bytes

	// open an anonymous file and write some zero bytes to it
	int fd = syscall(SYS_memfd_create, "buffer", 0);
	ftruncate(fd, size);

	// map it to the memory
	unsigned char *data =
		mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

	// turn it into a shared memory pool
	struct wl_shm_pool *pool = wl_shm_create_pool(shm, fd, size);

	// allocate the buffer in that pool
	struct wl_buffer *buffer = wl_shm_pool_create_buffer(
		pool, 0, width, height, stride, WL_SHM_FORMAT_ARGB8888);

	// draw into buffer
	for (int x = 0; x < width; x++)
	{
		for (int y = 0; y < height; y++)
		{

			struct pixel
			{
				// little-endian ARGB
				unsigned char blue;
				unsigned char green;
				unsigned char red;
				unsigned char alpha;
			} *px = (struct pixel *)(data + y * stride + x * 4);

			// draw a stripes pattern
			if ((x + y) % 30 < 10)
			{
				// transparent
				px->alpha = 0;
			}
			else if ((x + y) % 30 < 20)
			{
				// yellow
				px->alpha = 255;
				px->red = 255;
				px->green = 255;
				px->blue = 0;
			}
			else
			{
				// semitransparent red
				px->alpha = 128;
				px->red = 255;
				px->green = 0;
				px->blue = 0;
			}
		}
	}

	// wait for the surface to be configured
	wl_display_roundtrip(display);

	wl_surface_attach(surface, buffer, 0, 0);
	wl_surface_damage(surface, 0, 0, UINT32_MAX, UINT32_MAX);
	wl_surface_commit(surface);

	while (wl_display_dispatch(display) != -1 && running)
	{
		// nothing inside
	}

	xdg_toplevel_destroy(xdg_toplevel);
	xdg_surface_destroy(xdg_surface);
	wl_surface_destroy(surface);
	wl_registry_destroy(registry);
}