#include <stdbool.h>
#include <stdio.h>

#include <SDL3/SDL.h>

#include <vecmath.h>
#include "dat.h"

static void render(void);
static void update(float delta);
static void process_events(void);

static void renderrect(vec2 p, vec2 s);
static void renderfillrect(vec2 p, vec2 s);

static SDL_Window *window;
static SDL_Renderer *renderer;
static bool running;
static Uint64 old_ticks, new_ticks;

static float camera_x, camera_y;
static float camera_vx, camera_vy;

bool shot;
bool moveup, movedown, moveleft, moveright;
int shotx, shoty;

int
main()
{
	if(!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO)) {
		fprintf(stderr, "SDL_Init(): %s\n", SDL_GetError());
		return 1;
	}

	if(!SDL_CreateWindowAndRenderer("window", 800, 600, SDL_WINDOW_OPENGL, &window, &renderer)) {
		fprintf(stderr, "SDL_CreateWindowAndRenderer: %s\n", SDL_GetError());
		return -1;
	}
	SDL_SetRenderVSync(renderer, 1);

	entinit();
	running = true;
	old_ticks = SDL_GetTicksNS();

	while(running) {
		double delta;
		process_events();

		new_ticks = SDL_GetTicksNS();
	    delta = (new_ticks - old_ticks) / 1000000000.0;
		old_ticks = new_ticks;
		update(delta);

		render();
		SDL_RenderPresent(renderer);
	}
	
	SDL_DestroyWindow(window);
	SDL_Quit();
	return 0;
}

void
render(void)
{
	SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0xFF);
	SDL_RenderClear(renderer);

	SDL_SetRenderDrawColor(renderer, 0xAA, 0xAA, 0xAA, 0xFF);
	for(int y = 0; y < map_height; y++)
		for(int x = 0; x < map_width; x++) {
			if(!map_data[x + map_width * y])
				continue;

			renderfillrect(
					(float[]){ 
						2 * ENTITY_SIZE * x, 
						2 * ENTITY_SIZE * y 
					}, (float[]){ 
						ENTITY_SIZE, 
						ENTITY_SIZE 
					});
		}

	for(int i = 0; i < ebufi; i++) {
		Entity *e = entitybuffer + i;
		if(!e->active)
			continue;

		switch (e->type) {
		case EPLAYER:
			if(e->alive)
				SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
			else
			 	SDL_SetRenderDrawColor(renderer, 0x88, 0x00, 0x00, 0xFF);
			renderrect(e->body.pos, e->body.size);
			break;

		case EGHOST:
			if(e->alive)
				SDL_SetRenderDrawColor(renderer, 0xAA, 0xAA, 0xAA, 0xFF);
			else
				SDL_SetRenderDrawColor(renderer, 0x88, 0x00, 0x00, 0xFF);
			renderrect(e->body.pos, e->body.size);
			break;

		case EBULLET:
			SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0x00, 0xFF);
			renderrect(e->body.pos, e->body.size);
			break;

		case ETELEPORTER:
			SDL_SetRenderDrawColor(renderer, 0xFF, 0x00, 0xFF, 0xFF);
			renderrect(e->body.pos, e->body.size);
			break;

		case EGOAL:
			SDL_SetRenderDrawColor(renderer, 0x00, 0xFF, 0x00, 0xFF);
			renderrect(e->body.pos, e->body.size);
			break;
		}
	}
}

void
update(float delta)
{
	entphysics(delta);
	entupdate(delta);

	camera_vx = ((player->body.pos[0] - 400) - camera_x) * 2.0;
	camera_vy = ((player->body.pos[1] - 300) - camera_y) * 2.0;

	camera_x += delta * camera_vx;
	camera_y += delta * camera_vy;
}

void
process_events()
{
	SDL_Event event;

	while(SDL_PollEvent(&event)) {
		switch(event.type) {
			case SDL_EVENT_QUIT:
				running = false;
				break;
			case SDL_EVENT_MOUSE_BUTTON_DOWN:
				shot = true;
				shotx = event.button.x + camera_x;
				shoty = event.button.y + camera_y;
				break;

			case SDL_EVENT_KEY_UP:
			case SDL_EVENT_KEY_DOWN:
				if(event.key.scancode == SDL_SCANCODE_R && player->alive == false)
					entrestart();

				#define DEFINE_KEY(X, VAR) \
					if(event.key.scancode == X) VAR = event.type == SDL_EVENT_KEY_DOWN

				DEFINE_KEY(SDL_SCANCODE_W, moveup);
				DEFINE_KEY(SDL_SCANCODE_A, moveleft);
				DEFINE_KEY(SDL_SCANCODE_S, movedown);
				DEFINE_KEY(SDL_SCANCODE_D, moveright);

				#undef DEFINE_KEY

				break;
		}
	}
}

void
renderrect(vec2 p, vec2 s)
{
	SDL_RenderRect(renderer, &(SDL_FRect){
		.x = p[0] - s[0] - camera_x,
		.y = p[1] - s[1] - camera_y, 
		.w = s[0] * 2.0,
		.h = s[1] * 2.0
	});
}

void
renderfillrect(vec2 p, vec2 s)
{
	SDL_RenderFillRect(renderer, &(SDL_FRect){
		.x = p[0] - s[0] - camera_x,
		.y = p[1] - s[1] - camera_y, 
		.w = s[0] * 2.0,
		.h = s[1] * 2.0
	});
}