local enet = require"enet"
local json = require"common.dkjson"

-- local SERVER_HOSTNAME = "ubq323.website"
local SERVER_HOSTNAME = "localhost"
local PLAYER_SIZE = 0.7

local local_player = nil

local drawing = require"drawing"
local coords = require"common.coords"
local Pos = coords.Pos
local camera = require"camera".Camera.make()
local Chunk = require"common.chunk".Chunk
local util = require"util"

-- local pprint=require"common.pprint"
-- pprint.setup{show_all=true}


math.randomseed(os.time())

local host,peer

local chunk

local f3mode = true

function love.keypressed(key,scancode,isrepeat)
	if scancode == "f3" then f3mode = not f3mode end
end

local function draw_player(pl,islocal)
	local hplsz = PLAYER_SIZE/2
	love.graphics.setColor(pl.color)
	love.graphics.rectangle("fill",pl.pos.x-hplsz,pl.pos.y-hplsz,PLAYER_SIZE,PLAYER_SIZE)
	-- love.graphics.print(tostring(pl.id),pl.pos.x,pl.pos.y)
	if islocal then
		love.graphics.setLineWidth(0.01)
		love.graphics.setColor(0.5,0,0)
		love.graphics.rectangle("line",pl.pos.x-hplsz,pl.pos.y-hplsz,PLAYER_SIZE,PLAYER_SIZE)
	end
end

local remote_players = {}

local function update_local_player(pl,dt)
	local SPEED = 10 -- pixels/sec
	local function kd(code)
		if love.keyboard.isScancodeDown(code) then return 1 else return 0 end
	end
	local dx = kd"d"-kd"a"
	local dy = kd"s"-kd"w"

	if dx == 0 and dy == 0 then
		pl.pos_dirty = false
		return
	end

	if dx ~= 0 and dy ~= 0 then
		dx = dx / math.sqrt(2)
		dy = dy / math.sqrt(2)
	end

	pl.pos.x = pl.pos.x + SPEED * dt * dx
	pl.pos.y = pl.pos.y + SPEED * dt * dy
	pl.pos_dirty = true


end

local function sync_local_player(pl,peer)
	-- send updated info about local player to server
	if pl.pos_dirty then
		peer:send(json.encode{t="ppos",x=pl.pos.x,y=pl.pos.y})
	end
end

local function send_settile(hpos,tile)
	peer:send(json.encode{t="settile",q=hpos.q,r=hpos.r,tile=tile})
end

function love.update(dt)
	if local_player then
		update_local_player(local_player,dt)
		if love.keyboard.isScancodeDown"q" then camera.zoom = camera.zoom*1.05 end
		if love.keyboard.isScancodeDown"e" then camera.zoom = camera.zoom/1.05 end
		sync_local_player(local_player,peer)
	end
	if chunk then
		local mh = camera:screen_to_world(Pos.make(love.mouse.getPosition())):to_hex():round()
		if false== chunk:at(mh) and love.mouse.isDown(1) then
			chunk:set_at(mh,true)
			print(mh,true)
			send_settile(mh,true)
		elseif chunk:at(mh) and love.mouse.isDown(2) then
			chunk:set_at(mh,false)
			print(mh,false)
			send_settile(mh,false)
		end
	end

	repeat
		local ev = host:service()
		if ev and ev.type == "receive" then
			print(ev.data)
			local j = json.decode(ev.data)
			local op = j.t
			if op == "join" then
				local pl = j.pl
				remote_players[pl.id] = {pos=coords.Pos.make(pl.x,pl.y),color=pl.color,id=pl.id}
			elseif op == "leave" then
				local id = j.id
				remote_players[id]=nil
			elseif op == "move" then
				local id,x,y = j.id,j.x,j.y
				assert(remote_players[id],"wheeze "..id)
				remote_players[id].pos.x = x
				remote_players[id].pos.y = y
			elseif op == "you" then
				local pl = j.pl
				local_player = {pos=coords.Pos.make(pl.x,pl.y),color=pl.color,id=pl.id}
			elseif op == "chunk" then
				chunk = Chunk.from_packet_data(j)
			elseif op == "settile" then
				local h = coords.Hex.make(j.q,j.r)
				chunk:set_at(h,j.tile)
			end
		end
	until not ev
end

function love.draw()
	love.graphics.clear(1,1,1)
	love.graphics.origin()
	if local_player then
		camera.pos = local_player.pos
	end
	camera:apply_trans()

	if chunk then
		drawing.draw_chunk(camera,chunk)
	end

	if local_player then
		draw_player(local_player,true)
	end
	for _,pl in pairs(remote_players) do
		draw_player(pl)
	end

	love.graphics.setColor(1,0,0)
	love.graphics.rectangle("fill",0,0,1,1)

	local sm = Pos.make(love.mouse.getPosition())
	local wm = camera:screen_to_world(sm)
	local hm = wm:to_hex()

	love.graphics.origin()
	if f3mode and local_player then
		util.print_good({
			 "ms "..tostring(sm),
			 "mw "..tostring(wm),
			 "mh "..tostring(hm).." "..tostring(hm:round()),
			 "-",
			 "pw "..tostring(local_player.pos),
			 "ph "..tostring(local_player.pos:to_hex()).." "..tostring(local_player.pos:to_hex():round())
		 },10,10)
	 end
end

function love.load()
	require"profile".start(10,io.open("./trace","w"))
	host = enet.host_create()
	peer = host:connect(SERVER_HOSTNAME..":8473")
end

function love.quit()
	require"profile".stop()
	peer:disconnect()
	host:flush()
end