#include "input.h"
#include "renderer.h"

#include <assert.h>
#include <linux/input-event-codes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h>
#include <sys/time.h>

#define SHIP 0

#define FIRE 1
#define FIRE_MEAN -0.15
#define FIRE_JITTER 0.01

#define LIN_PWR 0.0001
#define ROT_PWR 0.002

#define SHOT_VEL 0.04

#define MAX_SHAPES 8U
#define MAX_ENTITIES 8U
#define MAX_SHAPES_PER_ENTITY 2

#define MAX(a, b) ((a) < (b) ? (b) : (a))
#define NELEMS(arr) (sizeof(arr) / sizeof(arr[0]))

typedef struct {
	bool visible;
	int entity;
	unsigned vert_count;
	vec2_t verts[MAX_VERTS];
	uint8_t flags;
} shape_t;

typedef struct {
	vec2_t pos;
	vec2_t vel;
	mat2_t dir;
	float omg;
	unsigned shapes[MAX_SHAPES_PER_ENTITY];
	unsigned shape_count;
	bool wrap;
} entity_t;

static vec2_t shot_verts[] = { { 0.0, -0.015 }, { 0.0, 0.015 } };

static shape_t shapes[MAX_SHAPES] = {
	{
		.visible = true,
		.entity = SHIP,
		.vert_count = 4,
		.verts = {
			{ 0.0, 0.11 },
			{ 0.05, -0.07 },
			{ 0.0, -0.04 },
			{ -0.05, -0.07 },
		},
		.flags = WRAP | CONNECT,
	},
	{
		.visible = false,
		.entity = SHIP,
		.vert_count = 3,
		.verts = {
			{ 0.0, -0.15 },
			{ 0.015, -0.07 },
			{ -0.015, -0.07 },
		},
		.flags = WRAP | CONNECT,
	},
};

static entity_t entities[MAX_ENTITIES] = {
	{
	    .dir = { { 1, 0 }, { 0, 1 } },
	    .shape_count = 2,
	    .shapes = { 0, 1 },
	    .wrap = true,
	},
};

static mat3_t transforms[MAX_ENTITIES];

static unsigned shape_count = 2;
static unsigned entity_count = 1;
static float aspect;
static bool quit = false;

static struct {
	int rot;
	int fwd;
} input;

static void shoot()
{
	if (entity_count >= MAX_ENTITIES || shape_count >= MAX_SHAPES)
		return;

	const entity_t *ship = entities + SHIP;
	const shape_t *ship_shape = shapes + SHIP;

	const int id = entity_count++;
	entity_t *e = entities + id;
	e->dir = ship->dir;
	e->pos = vec2_add(
	    ship->pos, mat2_mul_vec2(ship->dir, ship_shape->verts[0]));
	e->vel = vec2_add(
	    ship->vel, mat2_mul_vec2(ship->dir, (vec2_t) { 0, SHOT_VEL }));
	e->omg = 0;

	const int shape_id = shape_count++;
	shape_t *s = shapes + shape_id;
	s->visible = true;
	s->entity = id;
	s->vert_count = NELEMS(shot_verts);
	memcpy(s->verts, shot_verts, sizeof(shot_verts));
	s->flags = 0;

	e->shapes[0] = shape_id;
	e->shape_count = 1;
}

static void remove_shape(unsigned id)
{
	if (id < shape_count - 1) {
		const shape_t *last = shapes + shape_count - 1;
		memcpy(shapes + id, shapes + shape_count - 1, sizeof(shape_t));
		for (unsigned i = 0; i < entities[last->entity].shape_count; ++i) {
			if (entities[last->entity].shapes[i] == shape_count - 1) {
				entities[last->entity].shapes[i] = id;
				break;
			}
		}
	}
	--shape_count;
}

static void remove_entity(unsigned id)
{
	assert(id != SHIP);

	entity_t *e = entities + id;
	for (unsigned i = 0; i < e->shape_count; ++i)
		remove_shape(e->shapes[i]);

	if (id < entity_count - 1) {
		const entity_t *last = entities + entity_count - 1;
		memcpy(e, last, sizeof(entity_t));
		for (unsigned i = 0; i < e->shape_count; ++i)
			shapes[e->shapes[i]].entity = id;
	}

	--entity_count;
}

static void key_press_callback(int key)
{
	switch (key) {
	case KEY_Q:
		quit = true;
		break;

	case KEY_UP:
		++input.fwd;
		break;

	case KEY_LEFT:
		++input.rot;
		break;
	case KEY_RIGHT:
		--input.rot;
		break;

	case KEY_SPACE:
		shoot();
		break;

	default:
		break;
	}
}

static void key_release_callback(int key)
{
	switch (key) {
	case KEY_UP:
		--input.fwd;
		break;

	case KEY_LEFT:
		--input.rot;
		break;
	case KEY_RIGHT:
		++input.rot;
		break;

	default:
		break;
	}
}

static void key_repeat_callback(int key)
{
	switch (key) {
	case KEY_SPACE:
		shoot();
		break;
	}
}

static mat3_t entity_transform(unsigned id)
{
	const entity_t *e = entities + id;
	return mat3_mul_mat3(mat3_translation(e->pos), mat2_extend(e->dir));
}

static float rand_plusminus()
{
	return 2.0f * ((float)rand() / RAND_MAX - 0.5f);
}

static void ship_update()
{
	entity_t *ship = entities + SHIP;

	ship->omg += ROT_PWR * (float)input.rot;

	const vec2_t thrust = { 0, (float)input.fwd * LIN_PWR };
	const vec2_t acc = mat2_mul_vec2(ship->dir, thrust);
	ship->vel = vec2_add(ship->vel, acc);

	shapes[FIRE].visible = input.fwd != 0;
	shapes[FIRE].verts[0].y = FIRE_MEAN + FIRE_JITTER * rand_plusminus();
}

static void update()
{
	ship_update();

	for (unsigned i = 0; i < entity_count; ++i) {
		entity_t *e = entities + i;

		e->dir = mat2_mul_mat2(mat2_rotation(e->omg), e->dir);
		e->pos = vec2_add(e->pos, e->vel);

		if (e->wrap) {
			if (e->pos.y > 1)
				e->pos.y -= 2;
			else if (e->pos.y <= -1)
				e->pos.y += 2;
			if (e->pos.x >= aspect)
				e->pos.x -= 2 * aspect;
			else if (e->pos.x < -aspect)
				e->pos.x += 2 * aspect;
		} else if (
		    e->pos.y > 1 || e->pos.y <= -1 || e->pos.x >= aspect
		    || e->pos.x < -aspect) {
			remove_entity(i--);
			continue;
		}

		transforms[i] = entity_transform(i);
	}
}

static void draw()
{
	for (unsigned i = 0; i < shape_count; ++i) {
		if (!shapes[i].visible)
			continue;

		const mat3_t transform = transforms[shapes[i].entity];
		renderer_draw(
		    shapes[i].verts, shapes[i].vert_count, transform,
		    shapes[i].flags);
	}
}

int main()
{
	struct timeval tv;
	gettimeofday(&tv, NULL);
	srand(tv.tv_usec);

	const int input_fd = input_init();
	input_on_press(key_press_callback);
	input_on_release(key_release_callback);
	input_on_repeat(key_repeat_callback);

	const renderer_params_t renderer_params = renderer_init();
	aspect = renderer_params.aspect;
	const int drm_fd = renderer_params.drm_fd;
	renderer_clear();
	renderer_swap();

	const int max_fd = MAX(input_fd, drm_fd);
	fd_set set;

	while (!quit) {
		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))
			input_handle();

		if (FD_ISSET(drm_fd, &set)) {
			renderer_handle();

			update();

			renderer_clear();
			draw();

			renderer_swap();
		}
	}

	renderer_cleanup();
	input_cleanup();

	return 0;
}