local paddle_x = nil
local paddle_y = nil
local paddle_width = 0.1
local paddle_height = 0.02

local wall_thickness = 0.01

local missiles = nil
local missile_radius = 0.005
local missile_trail_fade = 0.4
local missile_trail_min_visibility = 0.03
local missile_trail_length = math.log(missile_trail_min_visibility, missile_trail_fade)
local missile_speed_min = 0.15
local missile_speed_max = 0.25

local unreflected_missiles = nil
local unreflected_missiles_allowed = nil
local unreflected_missiles_allowed_ramp_up = 10
local unreflected_missiles_max = nil

local cities = nil
local city_radius = 0.05

local explosions = nil
local explosion_radius = 0.08
local explosion_duration = 0.4

local enemies = nil
local enemy_radius = 0.025
local enemy_min_shoot = 2
local enemy_max_shoot = 10
local enemy_inaccuracy = 0.05

local intro_duration = 1
local outro_duration = 0.5

local stage = nil

local window_width = nil
local window_height = nil
local viewport_x_offset = nil
local viewport_y_offset = nil
local scale = nil

local time = nil

local states = {title = 0, intro = 1, outro = 2, gameplay = 3, game_over = 4}
local state = nil

font = require("font")

function setScreenDimensions(width, height)
	window_width = width
	window_height = height

	viewport_x_offset = 0
	viewport_y_offset = 0
	scale = math.min(width, height)
	viewport_x_offset = (window_width - scale) / 2
	viewport_y_offset = (window_height - scale) / 2
end

function toScreenCoordinates(x, y)
	local screen_x = x * scale + viewport_x_offset
	local screen_y = y * scale + viewport_y_offset
	return screen_x, screen_y
end

function toScreenSize(size)
	return size * scale
end

function fromScreenCoordinate(x, y)
	local logical_x = (x - viewport_x_offset) / scale
	local logical_y = (y - viewport_y_offset) / scale
	return logical_x, logical_y
end

function startStage()
	missiles = {}
	unreflected_missiles = 0
	unreflected_missiles_allowed = 0
	explosions = {}
	enemies = {}
	time = 0

	-- First row
	if stage >= 3 then
		spawnEnemy(0.1, 0.1)
	end
	if stage >= 2 then
		spawnEnemy(0.2, 0.1)
		spawnEnemy(0.3, 0.1)
	end
	spawnEnemy(0.4, 0.1)
	spawnEnemy(0.5, 0.1)
	spawnEnemy(0.6, 0.1)
	if stage >= 2 then
		spawnEnemy(0.7, 0.1)
		spawnEnemy(0.8, 0.1)
	end
	if stage >= 3 then
		spawnEnemy(0.9, 0.1)
	end

	-- Second row
	if stage >= 3 then
		spawnEnemy(0.15, 0.2)
	end
	if stage >= 2 then
		spawnEnemy(0.25, 0.2)
	end
	spawnEnemy(0.35, 0.2)
	spawnEnemy(0.45, 0.2)
	spawnEnemy(0.55, 0.2)
	spawnEnemy(0.65, 0.2)
	if stage >= 2 then
		spawnEnemy(0.75, 0.2)
	end
	if stage >= 3 then
		spawnEnemy(0.85, 0.2)
	end

	-- Third row
	if stage >= 4 then
		spawnEnemy(0.1, 0.3)
		spawnEnemy(0.2, 0.3)
		spawnEnemy(0.3, 0.3)
		spawnEnemy(0.4, 0.3)
		spawnEnemy(0.5, 0.3)
		spawnEnemy(0.6, 0.3)
		spawnEnemy(0.7, 0.3)
		spawnEnemy(0.8, 0.3)
		spawnEnemy(0.9, 0.3)
	end

	if stage == 3 or stage >= 5 then
		unreflected_missiles_max = unreflected_missiles_max + 1
	end

	state = states.intro
end

function love.load()
	math.randomseed(os.time())

	local width, height = love.graphics.getDimensions()
	setScreenDimensions(width, height)

	movePaddle(window_width / 2)

	unreflected_missiles_max = 1

	cities = {}
	spawnCities()

	stage = 1

	state = states.title
end

function spawnCities()
	local number_of_cities = 7
	cities = {}
	for i = 1, number_of_cities do
		local city_x = ((i - 0.5) / number_of_cities) * (1 - 2*wall_thickness) + wall_thickness
		local city_y = 1

		table.insert(cities, {
			x = city_x,
			y = city_y,
			alive = true
		})
	end
end

function spawnMissile(x, y, target_x, target_y, speed)
	local dx = target_x - x
	local dy = target_y - y
	local length = math.sqrt(dx * dx + dy * dy)
	local dx = dx / length * speed
	local dy = dy / length * speed
	table.insert(missiles, {
		x = x,
		y = y,
		dx = dx,
		dy = dy,
		reflected = false,
		history = {
			{x = x, y = y}
		},
		trail_length = 0,
		alive = true
	})
	unreflected_missiles = unreflected_missiles + 1
end

function spawnExplosion(x, y)
	table.insert(explosions, {
		x = x,
		y = y,
		radius = 0,
		remaining = explosion_duration,
	})
end

function spawnEnemy(x, y)
	table.insert(enemies, {
		x = x,
		y = y,
		until_shoot = enemy_min_shoot + math.random() * (enemy_max_shoot - enemy_min_shoot),
		angle = math.random() * 2 * math.pi,
		alive = true
	})
end

function updateMissiles(dt)
	for _, missile in ipairs(missiles) do
		missile.x = missile.x + missile.dx * dt
		missile.y = missile.y + missile.dy * dt

		if missile.y < wall_thickness + missile_radius then
			-- Collision with top wall
			missile.y = wall_thickness + missile_radius
			missile.dy = -missile.dy
		end

		if missile.x < wall_thickness + missile_radius then
			-- Collision with left wall
			missile.x = wall_thickness + missile_radius
			missile.dx = -missile.dx
		elseif missile.x > 1 - (wall_thickness + missile_radius) then
			-- Collision with right wall
			missile.x = 1 - (wall_thickness + missile_radius)
			missile.dx = -missile.dx
		end

		local paddle_left = paddle_x - paddle_width/2
		local paddle_right = paddle_x + paddle_width/2
		local paddle_top = paddle_y - paddle_height/2
		if paddle_left <= missile.x and missile.x <= paddle_right and paddle_top <= missile.y and missile.y <= paddle_y then
			-- Collision with the paddle
			missile.y = paddle_top
			missile.dy = -missile.dy
			if not missile.reflected then
				missile.reflected = true
				unreflected_missiles = unreflected_missiles - 1
			end
		end

		for _, city in ipairs(cities) do
			local dx = city.x - missile.x
			local dy = city.y - missile.y
			local distance = math.sqrt(dx * dx + dy * dy)
			if city.alive and distance < city_radius then
				spawnExplosion(missile.x, missile.y)
				-- Freeze the missile in-place
				missile.dx = 0
				missile.dy = 0
			end
		end

		if missile.reflected then
			for _, enemy in ipairs(enemies) do
				local dx = enemy.x - missile.x
				local dy = enemy.y - missile.y
				local distance = math.sqrt(dx * dx + dy * dy)
				if distance < enemy_radius then
					spawnExplosion(missile.x, missile.y)
					-- Freeze the missile in-place
					missile.dx = 0
					missile.dy = 0
				end
			end
		end

		local dx = missile.history[1].x - missile.x
		local dy = missile.history[1].y - missile.y
		local distance = math.sqrt(dx * dx + dy * dy)
		if distance >= 1 / scale then
			missile.history[1].length = distance
			missile.trail_length = missile.trail_length + distance
			table.insert(missile.history, 1, {
				x = missile.x,
				y = missile.y,
				length = nil,
			})
			-- Remove the oldest segments
			while missile.trail_length > missile_trail_length do
				local length = missile.history[#missile.history].length
				missile.trail_length = missile.trail_length - length
				table.remove(missile.history)
			end
		end
	end

	local i = 1
	while i <= #missiles do
		if missiles[i].y > 1 + missile_radius or not missiles[i].alive then
			-- Went off the bottom of the screen or exploded, delete
			if not missiles[i].reflected then
				unreflected_missiles = unreflected_missiles - 1
			end
			table.remove(missiles, i)
		else
			i = i + 1
		end
	end
end

function updateExplosions(dt)
	local i = 1
	while i <= #explosions do
		local explosion = explosions[i]

		local completeness = (explosion_duration - explosion.remaining) / explosion_duration
		explosion.radius = completeness ^ 1.5 * explosion_radius

		-- Destroy missiles within range
		for _, missile in ipairs(missiles) do
			local dx = missile.x - explosion.x
			local dy = missile.y - explosion.y
			local distance = math.sqrt(dx * dx + dy * dy)
			if distance < explosion.radius then
				missile.alive = false
			end
		end

		-- Destroy enemies within range
		for _, enemy in ipairs(enemies) do
			local dx = enemy.x - explosion.x
			local dy = enemy.y - explosion.y
			local distance = math.sqrt(dx * dx + dy * dy)
			if distance < explosion.radius + enemy_radius then
				enemy.alive = false
			end
		end

		explosion.remaining = explosion.remaining - dt

		if explosion.remaining < explosion_duration * 0.2 and state == states.gameplay then
			-- Destroy cities within range
			for _, city in ipairs(cities) do
				local dx = city.x - explosion.x
				local dy = city.y - explosion.y
				local distance = math.sqrt(dx * dx + dy * dy)
				if distance < explosion.radius + city_radius then
					city.alive = false
				end
			end
		end

		if explosion.remaining < 0 then
			table.remove(explosions, i)
		else
			i = i + 1
		end
	end
end

function updateEnemies(dt)
	local i = 1
	while i <= #enemies do
		local enemy = enemies[i]

		enemy.until_shoot = enemy.until_shoot - dt
		if enemy.until_shoot < 0 then
			enemy.until_shoot = enemy_min_shoot + math.random() * (enemy_max_shoot - enemy_min_shoot)
			if unreflected_missiles < unreflected_missiles_allowed then
				local speed = missile_speed_min + math.random() * (missile_speed_max - missile_speed_min)
				local inaccuracy = math.random() * 2 * enemy_inaccuracy - enemy_inaccuracy
				local behaviour = math.random(0, 7)
				if behaviour == 0 then
					spawnMissile(enemy.x, enemy.y, enemy.x + inaccuracy, 1, speed)
				elseif behaviour <= 5 then
					local target = cities[math.random(1, #cities)]
					for i = 1, 7 do
						if target.alive then
							break
						end
						target = cities[math.random(1, #cities)]
					end
					spawnMissile(enemy.x, enemy.y, target.x + inaccuracy, target.y, speed)
				else
					local angle = (math.random() * 140 - 70) * math.pi / 180
					local x = enemy.x + math.sin(angle)
					local y = enemy.y + math.cos(angle)
					spawnMissile(enemy.x, enemy.y, x, y, speed)
				end
			end
		end

		local dangle = 10 / (2 + enemy.until_shoot) * dt
		enemy.angle = enemy.angle + dangle

		if not enemy.alive then
			table.remove(enemies, i)
		else
			i = i + 1
		end
	end
end

function love.update(dt)
	if state == states.gameplay then
		updateMissiles(dt)
		updateExplosions(dt)
		updateEnemies(dt)

		time = time + dt
		if unreflected_missiles_allowed < unreflected_missiles_max and time >= unreflected_missiles_allowed * unreflected_missiles_allowed_ramp_up then
			unreflected_missiles_allowed = unreflected_missiles_allowed + 1
		end

		local cities_remaining = 0
		for _, city in ipairs(cities) do
			if city.alive then
				cities_remaining = cities_remaining + 1
			end
		end
		if cities_remaining == 0 or #enemies == 0 then
			state = states.outro
			time = 0
			explodeAllMissiles()
		end
	elseif state == states.outro then
		updateMissiles(dt)
		updateExplosions(dt)

		if #explosions == 0 then
			time = time + dt
			if time >= outro_duration then
				local cities_remaining = 0
				for _, city in ipairs(cities) do
					if city.alive then
						cities_remaining = cities_remaining + 1
					end
				end
				if cities_remaining == 0 then
					love.mouse.setVisible(true)
					love.mouse.setGrabbed(false)
					state = states.game_over
				else
					time = 0
					stage = stage + 1
					startStage()
				end
			end
		end
	elseif state == states.intro then
		time = time + dt
		if time >= intro_duration then
			time = 0
			state = states.gameplay
		end
	end
end

function explodeAllMissiles()
	for _, missile in ipairs(missiles) do
		spawnExplosion(missile.x, missile.y)
		-- Freeze the missile
		missile.dx = 0
		missile.dy = 0
	end
end

function explodeAllReflected()
	for _, missile in ipairs(missiles) do
		if missile.reflected then
			spawnExplosion(missile.x, missile.y)
			-- Freeze the missile
			missile.dx = 0
			missile.dy = 0
		end
	end
end

function movePaddle(screen_x)
	paddle_x = fromScreenCoordinate(screen_x, 0)
	paddle_x = math.max(paddle_x, paddle_width/2 + wall_thickness)
	paddle_x = math.min(paddle_x, 1 - (paddle_width/2 + wall_thickness))
	paddle_y = 0.8
end

love.mousemoved = movePaddle

function love.mousepressed(x, y, button, istouch, presses)
	love.mouse.setVisible(false)
	love.mouse.setGrabbed(true)

	if state == states.gameplay then
		explodeAllReflected()
	elseif state == states.title then
		startStage()
	elseif state == states.game_over then
		love.event.quit()
	end
end

function love.keypressed(key, scancode, isrepeat)
	-- Ungrab mouse if user tried to do any GUI commands
	if scancode == 'lctrl' or scancode == 'lshift' or scancode == 'lalt' or scancode == 'lgui' or
	   scancode == 'rctrl' or scancode == 'rshift' or scancode == 'ralt' or scancode == 'rgui' then
		love.mouse.setVisible(true)
		love.mouse.setGrabbed(false)
	end
end

love.resize = setScreenDimensions

function drawWalls()
	love.graphics.setColor(0, 0, 1)
	local x, y = toScreenCoordinates(0, 0)
	local width = toScreenSize(1)
	local height =toScreenSize(wall_thickness)
	love.graphics.rectangle('fill', x, y, width, height)
	local width = toScreenSize(wall_thickness)
	local height = toScreenSize(1)
	love.graphics.rectangle('fill', x, y, width, height)
	local x, y = toScreenCoordinates(1 - wall_thickness, 0)
	love.graphics.rectangle('fill', x, y, width, height)
end

function drawMissiles()
	love.graphics.setLineWidth(0.001 * scale)

	-- Trails
	for _, missile in ipairs(missiles) do
		local dx = missile.history[1].x - missile.x
		local dy = missile.history[1].y - missile.y
		local length = math.sqrt(dx * dx + dy * dy)

		local from_x, from_y = toScreenCoordinates(missile.x, missile.y)
		for _, point in ipairs(missile.history) do
			local visibility = missile_trail_fade ^ length
			if point.length ~= nil then
				length = length + point.length
			end

			local x, y = toScreenCoordinates(point.x, point.y)
			if missile.reflected then
				love.graphics.setColor(1, 1, 0.5, visibility)
			else
				love.graphics.setColor(1, 0.4, 0, visibility)
			end
			love.graphics.line(from_x, from_y, x, y)
			from_x = x
			from_y = y
		end
	end

	-- Missiles themselves. Drawn separately so that they're always over the trails
	for _, missile in ipairs(missiles) do
		local style = 'fill'
		if missile.reflected then
			love.graphics.setColor(1, 0.5, 0)
			style = 'line'
		else
			love.graphics.setColor(1, 0.5, 0.5)
		end
		local x, y = toScreenCoordinates(missile.x, missile.y)
		local radius = toScreenSize(missile_radius)
		love.graphics.circle(style, x, y, radius)
	end
end

function drawPaddle()
	love.graphics.setColor(1, 1, 1)
	local x, y = toScreenCoordinates(paddle_x - paddle_width / 2, paddle_y - paddle_height / 2)
	local width = toScreenSize(paddle_width)
	local height = toScreenSize(paddle_height)
	love.graphics.rectangle('fill', x, y, width, height)
end

function drawCities()
	love.graphics.setColor(1, 1, 1)
	for _, city in ipairs(cities) do
		if city.alive then
			local x, y = toScreenCoordinates(city.x, city.y)
			local radius = toScreenSize(city_radius)
			love.graphics.circle('fill', x, y, radius)
		end
	end
end

function drawExplosions()
	for _, explosion in ipairs(explosions) do
		love.graphics.setColor(1, 0, 0)
		local x, y = toScreenCoordinates(explosion.x, explosion.y)
		local radius = toScreenSize(explosion.radius)
		love.graphics.circle('fill', x, y, radius)
	end
end

function drawEnemies()
	for _, enemy in ipairs(enemies) do
		love.graphics.setColor(0.7, 0.5, 1)

		local fifth = 2 * math.pi / 5
		local points = {}
		for i = 0, 4 do
			local x = enemy.x + math.cos(i * fifth + enemy.angle) * enemy_radius
			local y = enemy.y + math.sin(i * fifth + enemy.angle) * enemy_radius
			local x, y = toScreenCoordinates(x, y)
			table.insert(points, x)
			table.insert(points, y)
		end

		love.graphics.polygon('fill', points)
	end
end

function drawText(x, y, text_scale, text)
	love.graphics.setLineWidth(2 / 700 * scale)
	love.graphics.setColor(1, 1, 1)
	for i = 1, #text do
		local char = string.sub(text, i, i)
		local glyph = font[char]
		for _, line in ipairs(glyph) do
			local x0, y0 = toScreenCoordinates(x + (i - 1) * text_scale + line[1] * text_scale, y + line[2] * text_scale)
			local x1, y1 = toScreenCoordinates(x + (i - 1) * text_scale + line[3] * text_scale, y + line[4] * text_scale)
			love.graphics.line(x0, y0, x1, y1)
		end
	end
end

function textWidth(text_scale, text)
	-- Each character is 0.7 wide with 0.3 character spacing before scaling
	-- Width of a text is therefore math.max(#text - 0.3, 0) before scaling
	-- and math.max(#text - 0.3, 0) * text_scale after
	return math.max(#text - 0.3, 0) * text_scale
end

function drawTextCentered(y, text_scale, text)
	local x = (1 - textWidth(text_scale, text)) / 2
	drawText(x, y, text_scale, text)
end

function love.draw()
	if state == states.gameplay or state == states.outro or state == states.intro or state == states.game_over then
		drawCities()
		drawWalls()
		drawMissiles()
		drawPaddle()
		drawEnemies()
		drawExplosions()
		if state == states.intro then
			drawTextCentered(0.4, 0.1, "wave")
			local number = tostring(stage)
			drawTextCentered(0.55, 0.07, number)
		end
		if state == states.game_over then
			drawTextCentered(0.4, 0.1, "game over")
			local number = tostring(stage)
			drawTextCentered(0.55, 0.07, number)
			drawTextCentered(0.7, 0.03, "click to quit")
		end
	elseif state == states.title then
		drawTextCentered(0.3, 0.1, "reflect")
		drawTextCentered(0.45, 0.03, "click to start")
	end
end