#include "game.h"

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

#include <assert.h>
#include <linux/input-event-codes.h>
#include <math.h>
#include <string.h>

#define FIRE_MEAN -0.15
#define FIRE_JITTER 0.01

#define ASTEROID_MIN_VERTS 5
#define ASTEROID_VERT_RANGE (MAX_VERTS - ASTEROID_MIN_VERTS)
#define ASTEROID_A_JITTER 0.8
#define ASTEROID_VEL_JITTER 0.001
#define ASTEROID_OMG_JITTER 0.005
#define INIT_ASTEROIDS 8

#define LIN_PWR 0.0001
#define ROT_PWR 0.002

#define SHOT_VEL 0.04

#define MAX_SHAPES 256U
#define MAX_ENTITIES 128U
#define MAX_SHAPES_PER_ENTITY 2

#define NELEMS(arr) (sizeof(arr) / sizeof(arr[0]))

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;

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

typedef enum {
	ASTEROID_SMALL,
	ASTEROID_MEDIUM,
	ASTEROID_LARGE,
} asteroid_size_t;

static const vec2_t ship_verts[] = {
	{ 0.0, 0.11 },
	{ 0.05, -0.07 },
	{ 0.0, -0.04 },
	{ -0.05, -0.07 },
};
static const vec2_t fire_verts[] = {
	{ 0.0, -0.15 },
	{ 0.015, -0.07 },
	{ -0.015, -0.07 },
};
static const vec2_t shot_verts[] = { { 0.0, -0.02 }, { 0.0, 0.02 } };

static entity_t entities[MAX_ENTITIES];
static mat3_t transforms[MAX_ENTITIES];
static shape_t shapes[MAX_SHAPES];

static unsigned entity_count;
static unsigned shape_count;
static bool quit;
static float aspect;

static unsigned ship_entity_id;
static unsigned ship_shape_id;
static unsigned fire_shape_id;

static entity_t *add_entity(unsigned *id_out)
{
	const unsigned id = entity_count++;
	memset(entities + id, 0, sizeof(entity_t));
	entities[id].dir = (mat2_t) { { 1, 0 }, { 0, 1 } };
	if (id_out != nullptr)
		*id_out = id;
	return entities + id;
}

static shape_t *add_shape(unsigned entity, unsigned *id_out)
{
	assert(entities[entity].shape_count < MAX_SHAPES_PER_ENTITY);
	const int id = shape_count++;
	memset(shapes + id, 0, sizeof(shape_t));
	shapes[id].entity = entity;
	entities[entity].shapes[entities[entity].shape_count++] = id;
	if (id_out != nullptr)
		*id_out = id;
	return shapes + id;
}

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

	const entity_t *ship = entities + ship_entity_id;
	const shape_t *ship_shape = shapes + ship_shape_id;

	unsigned id;
	entity_t *e = add_entity(&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 }));

	shape_t *s = add_shape(id, nullptr);
	s->visible = true;
	s->vert_count = NELEMS(shot_verts);
	memcpy(s->verts, shot_verts, sizeof(shot_verts));
}

static void gen_asteroid_shape(asteroid_size_t size, shape_t *out)
{
	float r_mean, r_jitter;
	switch (size) {
	case ASTEROID_SMALL:
		r_mean = 0.05;
		r_jitter = 0.02;
		break;
	case ASTEROID_MEDIUM:
		r_mean = 0.1;
		r_jitter = 0.02;
		break;
	case ASTEROID_LARGE:
		r_mean = 0.15;
		r_jitter = 0.05;
	}

	const unsigned n
		= ASTEROID_MIN_VERTS + rng_uint32() % (ASTEROID_VERT_RANGE);
	out->vert_count = n;

	const float da = 2.0f * PI / n;
	for (unsigned i = 0; i < n; ++i) {
		const float r = r_mean + rng_plusminus() * r_jitter;
		const float a
		    = i * da + ASTEROID_A_JITTER * rng_plusminus() * da / 2;
		out->verts[i] = (vec2_t) { r * cosf(a), r * sinf(a) };
	}
}

static void add_asteroid()
{
	unsigned id;
	entity_t *e = add_entity(&id);
	e->wrap = true;
	e->pos.y = rng_plusminus();
	e->pos.x = aspect * rng_plusminus();
	e->vel = (vec2_t) {
		ASTEROID_VEL_JITTER * rng_plusminus(),
		ASTEROID_VEL_JITTER * rng_plusminus(),
	};
	e->omg = ASTEROID_OMG_JITTER * rng_plusminus();

	shape_t *s = add_shape(id, nullptr);
	s->visible = true;
	s->flags = WRAP | CONNECT;

	asteroid_size_t size;
	const float r = rng_canon();
	if (r < 0.2)
		size = ASTEROID_SMALL;
	else if (r < 0.5)
		size = ASTEROID_MEDIUM;
	else
		size = ASTEROID_LARGE;

	gen_asteroid_shape(size, s);
}

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_id);

	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 ship_update()
{
	entity_t *ship = entities + ship_entity_id;

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

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

	shape_t *fire = shapes + fire_shape_id;
	fire->visible = input.thrust != 0;
	fire->verts[0].y = FIRE_MEAN + FIRE_JITTER * rng_plusminus();
}

void game_init(float _aspect)
{
	input_on_shoot(shoot);

	aspect = _aspect;
	quit = false;

	entity_t *ship = add_entity(&ship_entity_id);
	ship->wrap = true;

	shape_t *ship_shape = add_shape(ship_entity_id, &ship_shape_id);
	ship_shape->visible = true;
	ship_shape->flags = WRAP | CONNECT;
	ship_shape->vert_count = NELEMS(ship_verts);
	memcpy(ship_shape->verts, ship_verts, sizeof(ship_verts));

	shape_t *fire = add_shape(ship_entity_id, &fire_shape_id);
	fire->visible = true;
	fire->flags = WRAP | CONNECT;
	fire->vert_count = NELEMS(fire_verts);
	memcpy(fire->verts, fire_verts, sizeof(fire_verts));

	for (unsigned i = 0; i < INIT_ASTEROIDS; ++i)
		add_asteroid();
}

void game_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]
		    = mat3_mul_mat3(mat3_translation(e->pos), mat2_extend(e->dir));
	}
}

void game_draw()
{
	renderer_clear();

	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);
	}
}