/* ZkwuL by Massena */
/* Optimisation and rewrite thanks to KikooDX */

#include <gint/display.h>
#include <gint/keyboard.h>
#include <gint/std/string.h>
#include "main.h"

Vec2 search(tile_t x, tile_t level[16][16]) {
	/* Search for x in a given matrix. */
	/* If x is found, return it coordinates */
	Vec2 coordinates = {0, 0};
	for(int m = 0; m < LEVEL_SIZE; ++m) {
			for(int n = 0; n < LEVEL_SIZE; ++n) {
				if(level[m][n] == x) {
					/* idk why m and n are inversed but it works kek */
					coordinates.x = n * 12;
					coordinates.y = m * 12;
					return coordinates;
				}
			}
		}
	return coordinates;
}

int collide_pixel(Vec2 pos, tile_t obj, tile_t level[LEVEL_SIZE][LEVEL_SIZE]) {
	/* Check if there's something in (x, y) */
	if(obj == level[pos.y / TILE_SIZE][pos.x / TILE_SIZE]) {
		return 1;
	}
	else {
		return 0;
	}
}

int collide(Vec2 pos, int h, tile_t obj, tile_t level[LEVEL_SIZE][LEVEL_SIZE]) {
	/* tl = top left */
	/* br = bottom right */
	const Vec2 pos_tl = (Vec2){pos.x + h, pos.y + h};
	const Vec2 pos_br = (Vec2){pos.x + PLAYER_SIZE - h - 1, pos.y + PLAYER_SIZE - h - 1};
	/* Check if there's something in */
	/* the square (x + 1, y + 1, x + 11, y + 11) */
	/* The size of the hitbox changes with h */
	if(collide_pixel(pos_tl, obj, level) ||
	   collide_pixel(pos_br, obj, level) ||
	   collide_pixel((Vec2){pos_tl.x, pos_br.y}, obj, level) ||
	   collide_pixel((Vec2){pos_br.x, pos_tl.y}, obj, level))
	{
		return 1;
	}
	return 0;
}

int object_delete(Vec2 pos, tile_t obj, tile_t level[LEVEL_SIZE][LEVEL_SIZE]) {
	/* delete the object if it touches the player */
	const Vec2 pos_tl = (Vec2){pos.x, pos.y};
	const Vec2 pos_br = (Vec2){pos.x + PLAYER_SIZE - 1, pos.y + PLAYER_SIZE - 1};

	if(collide_pixel(pos_tl, obj, level)) { 
		level[pos_tl.y / TILE_SIZE][pos_tl.x / TILE_SIZE] = 0;
	}
	if(collide_pixel(pos_br, obj, level)) { 
		level[pos_br.y / TILE_SIZE][pos_br.x / TILE_SIZE] = 0;
	}
	if(collide_pixel((Vec2){pos_tl.x, pos_br.y}, obj, level)) { 
		level[pos_br.y / TILE_SIZE][pos_tl.x / TILE_SIZE] = 0;
	}
	if(collide_pixel((Vec2){pos_br.x, pos_tl.y}, obj, level)) { 
		level[pos_tl.y / TILE_SIZE][pos_br.x / TILE_SIZE] = 0;
	}
	return 1;
}

Player player_reset(Player player, tile_t level[LEVEL_SIZE][LEVEL_SIZE]) {
	/* reset the level */
	player.spawn = search(1, level);
	player.pos = player.spawn;
	return player;
}

int main(void) {
	extern bopti_image_t img_player;
	extern bopti_image_t img_wall;
	extern bopti_image_t img_spike;
	extern bopti_image_t img_end;
	extern bopti_image_t img_door;
	extern bopti_image_t img_key;
	extern bopti_image_t img_conveyor_u;
	extern bopti_image_t img_conveyor_r;
	extern bopti_image_t img_conveyor_d;
	extern bopti_image_t img_conveyor_l;

	extern tile_t level[LEVEL_NB][LEVEL_SIZE][LEVEL_SIZE];

	int running = 1;
	int timer = 0; /* lol */
	int lvl = 0;
	tile_t curr_level[LEVEL_SIZE][LEVEL_SIZE];

	/* player */
	Player player = {
		.pos = {0, 0},
		.spawn = {0, 0},
		.frac = {0, 0}
	};
	
	memcpy(curr_level, level[lvl], sizeof(level[lvl]));
	player = player_reset(player, curr_level);

	/* main loop */
	while(running) {

		dclear(C_BLACK);

		/* drawing the level */
		for(int m = 0; m < LEVEL_SIZE; ++m) {
			for(int n = 0; n < LEVEL_SIZE; ++n) {
				switch(curr_level[n][m]) {
					case 2:
						/* walls */
						dimage(m * TILE_SIZE, n * TILE_SIZE, &img_wall);
						break;
					case 3:
						/* end ring */
						dsubimage(m * TILE_SIZE, n * TILE_SIZE, &img_end,
							((timer / 30) % 4) * 12, 0, 12, 12, 0);
						break;
					case 4:
						/* spikes */
						dimage(m * TILE_SIZE, n * TILE_SIZE, &img_spike);
						break;
					case 5:
						/* door */
						dimage(m * TILE_SIZE, n * TILE_SIZE, &img_door);
						break;
					case 6:
						/* key ring */
						dsubimage(m * TILE_SIZE, n * TILE_SIZE, &img_key,
							((timer / 30) % 4) * 12, 0, 12, 12, 0);
						break;

					case 7:
						/* key ring */
						dsubimage(m * TILE_SIZE, n * TILE_SIZE, &img_conveyor_u,
							((timer / 15) % 6) * 12, 0, 12, 12, 0);
						break;
					case 8:
						/* key ring */
						dsubimage(m * TILE_SIZE, n * TILE_SIZE, &img_conveyor_r,
							((timer / 15) % 6) * 12, 0, 12, 12, 0);
						break;
					case 9:
						/* key ring */
						dsubimage(m * TILE_SIZE, n * TILE_SIZE, &img_conveyor_d,
							((timer / 15) % 6) * 12, 0, 12, 12, 0);
						break;
					case 10:
						/* key ring */
						dsubimage(m * TILE_SIZE, n * TILE_SIZE, &img_conveyor_l,
							((timer / 15) % 6) * 12, 0, 12, 12, 0);
						break;
				}
			}
		}

		dprint(0, 0, C_BLACK, "%d", lvl);
		/* drawing the player */
		dimage(player.pos.x, player.pos.y, &img_player);

		dupdate();

		Vec2 mov = {
			.x = keydown(KEY_RIGHT) - keydown(KEY_LEFT),
			.y = keydown(KEY_DOWN) - keydown(KEY_UP)
		};
		clearevents();

		/* conveyors */
		if(collide(player.pos, 0, 7, curr_level)) { player.frac.y -= 0.5; }
		if(collide(player.pos, 0, 8, curr_level)) { player.frac.x += 0.5; }
		if(collide(player.pos, 0, 9, curr_level)) { player.frac.y += 0.5; }
		if(collide(player.pos, 0, 10, curr_level)) { player.frac.x -= 0.5; }

		/* little accelerations (like conveyors) */
		const int ifrac_x = player.frac.x;
		player.frac.x -= ifrac_x;
		mov.x += ifrac_x;

		const int ifrac_y = player.frac.y;
		player.frac.y -= ifrac_y;
		mov.y += ifrac_y;

		/* trying to move the player >w< */
		if(!collide((Vec2){player.pos.x + mov.x, player.pos.y}, 0, 2, curr_level) &&
			!collide((Vec2){player.pos.x + mov.x, player.pos.y}, 1, 5, curr_level)) {
			player.pos.x += mov.x;
		}
		else {
			player.frac = (FVec2){ 0, 0 };
		}

		if(!collide((Vec2){player.pos.x, player.pos.y + mov.y}, 0, 2, curr_level) &&
			!collide((Vec2){player.pos.x, player.pos.y + mov.y}, 1, 5, curr_level)) {
			player.pos.y += mov.y;
		}
		else {
			player.frac = (FVec2){ 0, 0 };
		}

		/* d i e */
		if(collide(player.pos, 2, 4, curr_level)) {
			memcpy(curr_level, level[lvl], sizeof(level[lvl]));
			player = player_reset(player, curr_level);
		}

		/* keys */
		if(collide(player.pos, 0, 6, curr_level)) {
			object_delete(player.pos, 6, curr_level);
			/* check if there is any key */
			Vec2 key_pos = search(6, curr_level);
			if(key_pos.x == 0 && key_pos.y == 0) {
				for(int m = 0; m < LEVEL_SIZE; ++m) {
					for(int n = 0; n < LEVEL_SIZE; ++n) {
						if(curr_level[m][n] == 5) {
							curr_level[m][n] = 0;
						}
					}
				}
			}
		}

		/* end */
		if(keydown(KEY_EXIT)) {
			running = 0;
		}

		if(collide(player.pos, 0, 3, curr_level)) {
			if(lvl != LEVEL_NB - 1) { 
				++lvl;
				memcpy(curr_level, level[lvl], sizeof(level[lvl]));
				player = player_reset(player, curr_level);
			}
			else {
				running = 0;
			}
		}

		++timer; /* lol^2 */
	}

	return 1;
}