levelloop = {}
levelloop.CLIENT = true
levelloop.world = nil
levelloop.textures = {}
levelloop.avatars = {}
commands = {}
require("lua.commands")(commands)
require("shared.commands")(commands)

local protocolVersion = "PPY\x03"

local socket = require "socket"

local utils = require("shared.utils")
local fonts = require("shared.fonts")
local errorHandler = require("shared.error")

local rpc = require("server.rpc")
local constants = require("server.constants")

local format = require("shared.networkFormat")

levelloop.nwChecklist = {}
levelloop.Canvas = {}
local count = 1
local function normalDraw()
	if count == 1 then print("use canvas!") count = 2 end
	local layerTransform = love.math.newTransform(math.floor(view.x) * scale, math.floor(view.y) * scale, 0, scale, scale)

	-- Draw background
    if drawBackground then
    	utils.color_push()
        love.graphics.setColor(0.05, 0.05, 0.05)
        love.graphics.rectangle("fill", math.floor(view.x) * scale, math.floor(view.y) * scale, levelloop.world.x * scale, levelloop.world.y * scale)
        love.graphics.setColor(1, 1, 1, 1)
        love.graphics.draw(levelloop.Canvas.bg, layerTransform)
        utils.color_pop()
    end

	-- draw player
	for i, player in pairs(participants) do
		local playerTransform = love.math.newTransform(
			math.floor(player.x) * scale + math.floor(view.x) * scale,
			math.floor(player.y) * scale + math.floor(view.y) * scale,
			0, scale, scale)

		love.graphics.draw(player.avatar, playerTransform)
		if player.name then
			if not player.label then
				player.label = love.graphics.newText(fonts.smallFont, player.name)
			end
			local labelTransform = love.math.newTransform(
				math.floor(player.x - (player.label:getWidth() / 2) +
				(player.avatar:getPixelWidth() /2)) * scale + math.floor(view.x) * scale,
				math.floor(player.y - (player.label:getHeight())) * scale +
				math.floor(view.y) * scale, 0, scale, scale)
			love.graphics.draw(player.label, labelTransform)
		end
	end

	-- Draw foreground
	love.graphics.draw(levelloop.Canvas.fg, layerTransform)

	-- Draw UI
	love.graphics.draw(ui.buffer)
end


local function debugDraw()
	normalDraw()
	local layerTransform = love.math.newTransform(math.floor(view.x) * scale, math.floor(view.y) * scale, 0, scale, scale)
	for i = 30, 120, 30 do
		love.graphics.draw(ui.speedText[i/30], 400, i-30)
	end
	love.graphics.draw(levelloop.Canvas.dbg, layerTransform)
	love.graphics.draw(levelloop.Canvas.dbg2, layerTransform)

	love.graphics.setCanvas(levelloop.Canvas.dbg2)
		love.graphics.clear()
	love.graphics.setCanvas()
end


local function remoteCall(name, ...)
	local request = protocolVersion .. format.encodeFunction(name, levelloop.clientID or 0, ...)
	levelloop.client:send(request)
end


local function networkSync()
	while true do
		local message, fault = levelloop.client:receive()
		if not message then
			if fault == "timeout" then
				return
			else
				error(fault)
			end
		end
		local protocolVersion, index = string.unpack("<c4", message, 1)
		if protocolVersion ~= "PPY\x03" then
			print("Dropping packet with invalid protocol " .. protocolVersion)
		else
			print("got poppy package")
			local DecoderType, index = string.unpack("<I1", message, index)
			if (DecoderType == 0x81) then
				name, clientID, args = format.decodeFunction(message, index)
				print(name)
				print(#args)
				for i, val in pairs(args) do
					print(i, val)
				end
				commands[name](clientID, table.unpack(args))
			end
		end
	end
end

local function errorhandlerNetwork(msg)
	levelloop.remoteCall("playerLeave")
	return errorHandler.redscreen(msg)
end


function levelloop.mousepressed(mousex, mousey)
	ui.mousepressed(mousex, mousey)
end


function levelloop.loadAvatars()
	local container = {}
	local entries = love.filesystem.getDirectoryItems("textures/player")
	if #entries == 0 then return error("no avatars found") end
	for i, file in pairs(entries) do
		local path = "textures/player" .."/".. file
		local entry = love.filesystem.getInfo(path)
		if entry.type == "directory" then
			local textures = love.filesystem.getDirectoryItems(path)
			for i, texture in pairs(textures) do
				print(path)
				local imageData = love.image.newImageData(path .. "/" .. texture)
				local image = love.graphics.newImage(path .. "/" .. texture)
				local imageHash = love.data.hash("sha512", imageData:getString())
				container[imageHash] = {data = imageData, image = image}
			end
		end
	end
	levelloop.avatars = container
end


function levelloop.init(server, nickname, avatarHash)
	love.errorhandler = errorHandler.redscreen
	assert(server, "levelloop called without server to connect to?")
	assert(nickname, "levelloop called without nickname?")
	assert(avatarHash, "levelloop called without avatar?")
	levelloop.server = server

	scale = 1

	love.graphics.setDefaultFilter("nearest", "nearest", 0)

	layer = true

	grid = 16
	color = {}
	mouse = {}

	window = {}
	window.x, window.y = love.graphics.getDimensions()

	participants = {}
	textures = {}

	view = {}
	view.x = 0
	view.y = 0
	clientID = "0"

	-- Must be done now because it has to be ready before "init" returns from the server
	-- which is /before/ the game world is loaded
	levelloop.loadAvatars()

	levelloop.client = socket.udp()
	levelloop.client:setpeername(server.adress, server.port)
	levelloop.client:settimeout(0)

	CLIENT = true
	SERVER = false
	print("Socketnname: " .. levelloop.client:getsockname())
	print("Connecting to [" .. server.adress .."]:" .. server.port)

	remoteCall("init", nickname, avatarHash)

	levelloop.remoteCall = remoteCall
	levelloop.networkSync = networkSync

	love.update = function(dt)
		networkSync(dt)
		love.timer.sleep((1/60) -dt)
	end

	local infoFont
	if love.filesystem.getInfo("fonts/font.ttf") then
			infoFont = love.graphics.newFont("fonts/font.ttf", 45)
	else
			infoFont = love.graphics.newFont(45)
	end
	local message = love.graphics.newText(infoFont, "Connecting...")
	love.graphics.draw(message, 40, 40, 0, 1, 1)
	love.draw = function(dt)
        love.graphics.setColor(0.05, 0.05, 0.05)
        love.graphics.rectangle("fill", 0, 0, window.x, window.y)
        love.graphics.setColor(1, 1, 1)
		love.graphics.draw(message, 40, 40, 0, 1, 1)
	end
end


function levelloop.normalVisible(dt)
	networkSync(dt)
	camera.input(dt)
	physics.input(dt)
	drawing.input(dt)
	physics.update(dt)
	camera.update(dt)
	love.timer.sleep((1/60) -dt)
end


function levelloop.reducedVisible(dt)
	networkSync(dt)
	physics.update(dt)
	love.timer.sleep((1/60) -dt)
end


function levelloop.keypressed(key, _)
	physics.keypressed(key, _)
	camera.keypressed(key, _)
end


function levelloop.keyreleased(key, _)
	if key == "r" then
		drawBackground = not drawBackground
	end
	ui.keyreleased(key, _)
	camera.keyreleased(key, _)
	drawing.keyreleased(key, _)
end


function levelloop.loadworld(world)
	-- Game connected!
	--love.errorhandler = errorhandlerNetwork
	print("make canvas!")
	levelloop.Canvas.fg = love.graphics.newCanvas(world.x, world.y)
	levelloop.Canvas.bg = love.graphics.newCanvas(world.x, world.y)
	if PHYSICS_DEBUG then
		levelloop.Canvas.dbg = love.graphics.newCanvas(world.x, world.y)
		levelloop.Canvas.dbg2 = love.graphics.newCanvas(world.x, world.y)
	end
	levelloop.Canvas.physics = {}
	levelloop.world = world


	ui.init()
	drawing.init()
	love.update = levelloop.normalVisible
	love.visible = function(visible)
		if visible then
			love.update = levelloop.normalVisible
		else
			love.update = levelloop.reducedVisible
		end
	end


	drawBackground = true

	love.keyreleased = levelloop.keyreleased
	love.keypressed = levelloop.keypressed
	love.mousepressed = levelloop.mousepressed
	if not PHYSICS_DEBUG then
		love.draw = normalDraw
	else
		love.draw = debugDraw
	end

	love.resize = function()
		normalDraw()
		ui.resize()
		camera.resize()
	end

	love.quit = function()
		levelloop.remoteCall("playerLeave")
	end

	levelloop.world = world
end