#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <SDL2/SDL.h>

#define GRAVITY -9.8
#define PI 3.141592
#define WINDOW_W 1280
#define WINDOW_H 720
#define WALK_VEL 20

typedef struct {
	float x;
	float y;
	float vy;
	float angle;
	float power;
} Cannon;

typedef struct {
	float x;
	float y;
	float vy;
	float vx;
	int alive;
} Projectile;

typedef struct {
	float *mask;
	int width;
	int height;
	int updated;
} Terrain;

void PaintTerrain(Terrain *t, float x, float y, float color, float size) {
	for (int j = y - size; j < y + size; j++) {
		for (int i = x - size; i < x + size; i++) {
			float dj = y - j;
			float di = x - i;
			if (i > 0 && i < t->width && j > 0 && j < t->height
					&& dj * dj + di * di <= size * size / 2) {
				size_t index = i + j * t->width;
				t->mask[index] = color;
			}
		}
	}
	t->updated = 1;
}

static inline double GetCurrentTimestamp() {
	return (double) SDL_GetTicks64() / 1000.0;
}

SDL_Texture *CreateTiledTexture(SDL_Renderer *context, const char *filename, int width, int height) {
	SDL_Surface *texture_surface = SDL_LoadBMP(filename);
	SDL_Texture *texture_tile = SDL_CreateTextureFromSurface(context, texture_surface);
	int tile_w = texture_surface->w;
	int tile_h = texture_surface->h;
	SDL_FreeSurface(texture_surface);

	SDL_Texture *texture = SDL_CreateTexture(context,
			SDL_PIXELFORMAT_RGBA8888,
			SDL_TEXTUREACCESS_TARGET,
			width, height);
	SDL_SetRenderTarget(context, texture);
	for (int y = 0; y < height; y += tile_h) {
		for (int x = 0; x < width; x += tile_w) {
			SDL_Rect tile_rect = { x, y, tile_w, tile_h };
			SDL_RenderCopy(context, texture_tile, 0, &tile_rect);
		}
	}
	SDL_DestroyTexture(texture_tile);
	SDL_SetRenderTarget(context, 0);
	return texture;
}

void GameMain(SDL_Renderer *context) {
	SDL_Texture *background = CreateTiledTexture(context, "background.bmp", WINDOW_W, WINDOW_H);

	SDL_Texture *foreground = CreateTiledTexture(context, "foreground.bmp", WINDOW_W, WINDOW_H);
	SDL_SetTextureBlendMode(foreground, SDL_BLENDMODE_MOD);

	SDL_Texture *terrain_texture = SDL_CreateTexture(context,
			SDL_PIXELFORMAT_RGBA8888,
			SDL_TEXTUREACCESS_TARGET,
			WINDOW_W, WINDOW_H);
	SDL_SetTextureBlendMode(terrain_texture, SDL_BLENDMODE_BLEND);

	SDL_Texture *mask_texture = SDL_CreateTexture(context,
			SDL_PIXELFORMAT_RGBA8888,
			SDL_TEXTUREACCESS_STREAMING,
			WINDOW_W, WINDOW_H);

	Terrain terrain = {0};
	terrain.width = WINDOW_W;
	terrain.height = WINDOW_H;
	terrain.mask = calloc(WINDOW_W * WINDOW_H, sizeof(float));
	for (int i = 0; i < 100 * WINDOW_W; i++) {
		terrain.mask[i] = 1.0;
	}
	terrain.updated = 1;

	Cannon player = {0};
	player.x = 100;
	player.y = 500;
	player.power = 100;

	Projectile projectile = {0};

	float old_t = 0.0;

	int exit = 0;
	while (!exit) {
		SDL_Event event;
		while (SDL_PollEvent(&event)) {
			if (event.type == SDL_QUIT) {
				exit = 1;
			} else if (event.type == SDL_KEYDOWN && event.key.state == SDL_PRESSED &&
					event.key.keysym.sym == SDLK_SPACE && !projectile.alive) {
				projectile.alive = 1;
				projectile.x = player.x;
				projectile.y = player.y;
				projectile.vy = sin(player.angle) * player.power;
				projectile.vx = cos(player.angle) * player.power;
			}
		}

		double new_t = GetCurrentTimestamp();
		double dt = (new_t - old_t);
		old_t = new_t;

		int times_to_simulate = 10;
		while (times_to_simulate > 0) {
			times_to_simulate--;

			int mouse_x, mouse_y;
			Uint32 mouse_state = SDL_GetMouseState(&mouse_x, &mouse_y);
			float size = 20;
			if (mouse_state & SDL_BUTTON_LMASK) {
				PaintTerrain(&terrain, mouse_x, WINDOW_H - mouse_y, 1.0, size);
			} else if (mouse_state & SDL_BUTTON_RMASK) {
				PaintTerrain(&terrain, mouse_x, WINDOW_H - mouse_y, 0.0, size);
			}

			const Uint8 *keys = SDL_GetKeyboardState(0);
			if (keys[SDL_SCANCODE_D] && player.x < WINDOW_W) {
				player.x += WALK_VEL * dt;
			}
			if (keys[SDL_SCANCODE_A] && player.x >= 0) {
				player.x -= WALK_VEL * dt;
			}
			if (keys[SDL_SCANCODE_W] && player.angle < PI / 2) {
				player.angle += PI / 180 * dt;
			}
			if (keys[SDL_SCANCODE_S] && player.angle > 0) {

				player.angle -= PI / 180 * dt;
			}

			if (player.y >= WINDOW_H) {
				player.y  = WINDOW_H - 1;
				player.vy = 0;
			}
			if (terrain.mask[(int)player.x + (int)player.y * WINDOW_W] == 0.0 &&
					player.y >= 0) {
				player.y += player.vy * dt;
				player.vy += GRAVITY * dt;
				while (terrain.mask[(int)player.x + (int)player.y * WINDOW_W] != 0.0) {
					player.y += 1;
					player.vy = 0;
				}
			}

			if (projectile.alive) {
				if (projectile.y >= 0 && projectile.y < WINDOW_H &&
						projectile.x >= 0 && projectile.x < WINDOW_W &&
						terrain.mask[(int)projectile.x + (int)projectile.y * WINDOW_W] == 0.0) {
					projectile.x += projectile.vx * dt;
					projectile.y += projectile.vy * dt;
					projectile.vy += GRAVITY * dt;
				} else {
					projectile.alive = 0;
					PaintTerrain(&terrain, projectile.x, projectile.y, 0.0, 40);
				}
			}

			if (terrain.updated) {
				void *pixels;
				int pitch;
				SDL_LockTexture(mask_texture, 0, &pixels, &pitch);
				Uint32 *p = (Uint32 *) pixels;
				for (int j = 0; j < WINDOW_H; j++) {
					for (int i = 0; i < WINDOW_W; i++) {
						p[i + j * WINDOW_W] = terrain.mask[i + (WINDOW_H - j) * WINDOW_W] ? 0xffffffff : 0x00000000;
					}
				}
				SDL_UnlockTexture(mask_texture);
				terrain.updated = 0;
			}
		}

		SDL_SetRenderDrawColor(context, 40, 40, 40, 255);
		SDL_RenderClear(context);

		SDL_RenderCopy(context, background, 0, 0);

		SDL_SetRenderTarget(context, terrain_texture);
		SDL_SetRenderDrawColor(context, 0, 0, 0, 0);
		SDL_RenderClear(context);
		SDL_RenderCopy(context, mask_texture, 0, 0);
		SDL_RenderCopy(context, foreground, 0, 0);
		SDL_SetRenderTarget(context, 0);
		SDL_RenderCopy(context, terrain_texture, 0, 0);

		SDL_SetRenderDrawColor(context, 255, 0, 0, 255);
		SDL_Rect player_rect = {player.x - 5, WINDOW_H - player.y - 10, 10, 10 };
		SDL_RenderFillRect(context, &player_rect);

		SDL_RenderDrawLine(context, player.x, WINDOW_H - player.y, 
				player.x + cos(player.angle) * 100, WINDOW_H - player.y - sin(player.angle) * 100);

		if (projectile.alive) {
			SDL_SetRenderDrawColor(context, 0, 255, 0, 255);
			SDL_Rect projectile_rect = {projectile.x - 5, WINDOW_H - projectile.y - 10, 10, 10 };
			SDL_RenderFillRect(context, &projectile_rect);
		}

		SDL_RenderPresent(context);
		SDL_Delay(1);
	}
}

int main() {
	SDL_Init(SDL_INIT_VIDEO);

	SDL_Window *window = SDL_CreateWindow("Cannons",
			SDL_WINDOWPOS_UNDEFINED,
			SDL_WINDOWPOS_UNDEFINED,
			WINDOW_W,
			WINDOW_H,
			0);

	SDL_Renderer *context = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);

	GameMain(context);

	SDL_DestroyRenderer(context);
	SDL_DestroyWindow(window);
	SDL_Quit();
	return 0;
}