#define _POSIX_C_SOURCE 200809L

#include <assert.h>
#include <fcntl.h>
#include <linux/input.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/select.h>
#include <unistd.h>
#include <xf86drm.h>
#include <xf86drmMode.h>

#define MAX(a, b) ((a) < (b) ? (b) : (a))

typedef struct {
	uint32_t *buf;
	uint32_t handle;
	uint32_t id;
	uint32_t pitch;
	uint32_t size;
} fb_info_t;

static fb_info_t fbs[2];
static int front = 0, back = 1;

static fb_info_t fb_init(int drm_fd, drmModeModeInfo mode)
{
	int err;

	struct drm_mode_create_dumb create = {
		.width = mode.hdisplay,
		.height = mode.vdisplay,
		.bpp = 32,
	};
	err = ioctl(drm_fd, DRM_IOCTL_MODE_CREATE_DUMB, &create);
	assert(err != -1);

	uint32_t id;
	err = drmModeAddFB(
	    drm_fd, create.width, create.height, 24, 32, create.pitch,
	    create.handle, &id);
	assert(err == 0);

	struct drm_mode_map_dumb map = { .handle = create.handle };
	err = ioctl(drm_fd, DRM_IOCTL_MODE_MAP_DUMB, &map);
	assert(err != -1);

	uint32_t *buf = mmap(
	    0, create.size, PROT_READ | PROT_WRITE, MAP_SHARED, drm_fd,
	    map.offset);
	assert(buf != MAP_FAILED);

	return (fb_info_t) {
		.buf = buf,
		.handle = create.handle,
		.id = id,
		.pitch = create.pitch,
		.size = create.size,
	};
}

static void fb_cleanup(int drm_fd, fb_info_t fb)
{
	munmap(fb.buf, fb.size);
	drmModeRmFB(drm_fd, fb.id);
	struct drm_mode_destroy_dumb delete = { .handle = fb.handle };
	ioctl(drm_fd, DRM_IOCTL_MODE_DESTROY_DUMB, &delete);
}

static void page_flip_handler(int, unsigned, unsigned, unsigned, void *)
{
}

static void swap_buffers(int drm_fd, uint32_t crtc_id)
{
	const int err = drmModePageFlip(
	    drm_fd, crtc_id, fbs[back].id, DRM_MODE_PAGE_FLIP_EVENT, nullptr);
	assert(err == 0);

	front = (front + 1) & 1;
	back = (back + 1) & 1;
}

int main()
{
	int err;

	const int input_fd = open("/dev/input/event0", O_RDONLY);
	assert(input_fd != -1);

	const int drm_fd = open("/dev/dri/card1", O_RDWR | O_CLOEXEC);
	assert(drm_fd != -1);

	drmModeRes *res = drmModeGetResources(drm_fd);
	assert(res != nullptr);
	drmModeConnector *conn = drmModeGetConnector(drm_fd, res->connectors[0]);
	assert(conn != nullptr);
	drmModeModeInfo mode = conn->modes[0];
	uint32_t conn_id = conn->connector_id;

	fbs[0] = fb_init(drm_fd, mode);
	fbs[1] = fb_init(drm_fd, mode);

	err = drmModeSetCrtc(
	    drm_fd, res->crtcs[0], fbs[front].id, 0, 0, &conn_id, 1, &mode);
	assert(err == 0);
	drmModeCrtc *crtc = drmModeGetCrtc(drm_fd, res->crtcs[0]);
	assert(crtc != nullptr);

	memset(fbs[back].buf, 0, fbs[back].size);
	swap_buffers(drm_fd, crtc->crtc_id);

	const int max_fd = MAX(input_fd, drm_fd);
	fd_set set;
	bool running = true;
	uint64_t frame = 0;
	while (running) {
		FD_ZERO(&set);
		FD_SET(input_fd, &set);
		FD_SET(drm_fd, &set);
		select(max_fd + 1, &set, nullptr, nullptr, nullptr);

		if (FD_ISSET(input_fd, &set)) {
			struct input_event ev;
			const int len = read(input_fd, &ev, sizeof(ev));
			assert(len == sizeof(ev));

			if (ev.type == EV_KEY && ev.value >= 0 && ev.value <= 2) {
				if (ev.code == KEY_Q && ev.value == 1)
					running = false;
			}
		}

		if (FD_ISSET(drm_fd, &set)) {
			drmEventContext ev = {
				.version = DRM_EVENT_CONTEXT_VERSION,
				.page_flip_handler = page_flip_handler,
			};
			drmHandleEvent(drm_fd, &ev);

			for (int y = 0; y < mode.vdisplay; ++y) {
				for (int x = 0; x < mode.hdisplay; ++x) {
					const uint8_t r = (x + frame) % 256;
					const uint8_t g = (y + frame) % 256;
					const uint8_t b = (x + y + frame) % 256;
					fbs[back].buf[y * (fbs[back].pitch / 4) + x]
					    = (r << 16) | (g << 8) | b;
				}
			}

			swap_buffers(drm_fd, crtc->crtc_id);
			++frame;
		}
	}

	drmModeSetCrtc(
	    drm_fd, crtc->crtc_id, crtc->buffer_id, crtc->x, crtc->y, &conn_id,
	    1, &crtc->mode);

	fb_cleanup(drm_fd, fbs[0]);
	fb_cleanup(drm_fd, fbs[1]);
	drmModeFreeCrtc(crtc);
	drmModeFreeConnector(conn);
	drmModeFreeResources(res);
	close(drm_fd);

	return 0;
}