-- Copyright (C) 2017-2020 DBotThePony

-- Permission is hereby granted, free of charge, to any person obtaining a copy
-- of this software and associated documentation files (the "Software"), to deal
-- in the Software without restriction, including without limitation the rights
-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-- of the Software, and to permit persons to whom the Software is furnished to do so,
-- subject to the following conditions:

-- The above copyright notice and this permission notice shall be included in all copies
-- or substantial portions of the Software.

-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
-- INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
-- PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
-- FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-- OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-- DEALINGS IN THE SOFTWARE.


local net = net
local table = table
local Entity = Entity
local type = type
local error = error

net.pool = util.AddNetworkString

--[[
	@doc
	@fname net.WritePlayer
	@args Player ply
]]
function net.WritePlayer(ply)
	local i = ply:EntIndex()
	net.WriteUInt(i, 8)
	return i
end

--[[
	@doc
	@fname net.ReadPlayer
	@returns
	Player
]]
function net.ReadPlayer()
	return Entity(net.ReadUInt(8))
end

--[[
	@doc
	@fname net.WriteTypedArray
	@args table input, function callback

	@desc
	callback should write value provided in first argument
	example usage: `net.WriteTypedArray(arr, net.WriteType)`
	@enddesc
]]
function net.WriteTypedArray(input, callFunc)
	net.WriteUInt(#input, 16)

	for i, value in ipairs(input) do
		callFunc(value)
	end
end

--[[
	@doc
	@fname net.ReadTypedArray
	@args function callback

	@desc
	callback should read next value
	@enddesc

	@returns
	table
]]
function net.ReadTypedArray(callFunc)
	return table.construct({}, callFunc, net.ReadUInt(16))
end

--[[
	@doc
	@fname net.WriteArray
	@args table arrayIn
]]
function net.WriteArray(input)
	net.WriteTypedArray(input, net.WriteType)
end

--[[
	@doc
	@fname net.ReadArray
	@returns
	table
]]
function net.ReadArray()
	return table.construct({}, net.ReadType, net.ReadUInt(16))
end

--[[
	@doc
	@fname net.WriteStringArray
	@args table arrayOfStrings
]]
function net.WriteStringArray(input)
	net.WriteTypedArray(input, net.WriteString)
end

--[[
	@doc
	@fname net.ReadStringArray
	@returns
	table: array of strings
]]
function net.ReadStringArray()
	return table.construct({}, net.ReadString, net.ReadUInt(16))
end

--[[
	@doc
	@fname net.WriteEntityArray
	@args Entity input
]]
function net.WriteEntityArray(input)
	net.WriteTypedArray(input, net.WriteEntity)
end

--[[
	@doc
	@fname net.ReadEntityArray
	@returns
	table: array of entities
]]
function net.ReadEntityArray()
	return table.construct({}, net.ReadEntity, net.ReadUInt(16))
end

--[[
	@doc
	@fname net.WritePlayerArray
	@args table arrayOfPlayers
]]
function net.WritePlayerArray(input)
	net.WriteTypedArray(input, net.WritePlayer)
end

--[[
	@doc
	@fname net.ReadPlayerArray
	@returns
	table: array of players
]]
function net.ReadPlayerArray()
	return table.construct({}, net.ReadPlayer, net.ReadUInt(16))
end

--[[
	@doc
	@fname net.WriteFloatArray
	@args table arrayOfFloats
]]

--[[
	@doc
	@fname net.ReadFloatArray
	@returns
	table: array of floats
]]
function net.WriteFloatArray(input)
	net.WriteTypedArray(input, net.WriteFloat)
end

function net.ReadFloatArray()
	return table.construct({}, net.ReadFloat, net.ReadUInt(16))
end

--[[
	@doc
	@fname net.WriteDoubleArray
	@args table arrayOfDoubles
]]

--[[
	@doc
	@fname net.ReadDoubleArray
	@returns
	table: array of doubles
]]
function net.WriteDoubleArray(input)
	net.WriteTypedArray(input, net.WriteDouble)
end

function net.ReadDoubleArray()
	return table.construct({}, net.ReadDouble, net.ReadUInt(16))
end

--[[
	@doc
	@fname net.GReadUInt
	@args number bits

	@returns
	function: alias of `net.ReadUInt(bits)`
]]

--[[
	@doc
	@fname net.GWriteUInt
	@args number bits

	@returns
	function: alias of `net.WriteUInt(..., bits)`
]]
function net.GReadUInt(val)
	return function()
		return net.ReadUInt(val)
	end
end

function net.GWriteUInt(val)
	return function(val2)
		return net.WriteUInt(val2, val)
	end
end

--[[
	@docpreprocess

	const bits = [8, 16, 32, 64]

	const reply = []

	for (const bit of bits) {
		let output = []

		output.push(`@fname net.ReadUInt${bit}`)
		output.push(`@desc`)
		output.push(`typical single-argument alias of it's corresponding call`)
		output.push(`@enddesc`)
		output.push(`@returns`)
		output.push(`number`)

		reply.push(output)

		output = []

		output.push(`@fname net.ReadInt${bit}`)
		output.push(`@desc`)
		output.push(`typical single-argument alias of it's corresponding call`)
		output.push(`@enddesc`)
		output.push(`@returns`)
		output.push(`number`)

		reply.push(output)
	}

	return reply
]]
net.ReadUInt8 = net.GReadUInt(8)
net.ReadUInt16 = net.GReadUInt(16)
net.ReadUInt32 = net.GReadUInt(32)

net.WriteUInt8 = net.GWriteUInt(8)
net.WriteUInt16 = net.GWriteUInt(16)
net.WriteUInt32 = net.GWriteUInt(32)

--[[
	@doc
	@fname net.GReadInt
	@args number bits

	@returns
	function: alias of `net.ReadInt(bits)`
]]

--[[
	@doc
	@fname net.GWriteInt
	@args number bits

	@returns
	function: alias of `net.WriteInt(..., bits)`
]]
function net.GReadInt(val)
	return function()
		return net.ReadInt(val)
	end
end

function net.GWriteInt(val)
	return function(val2)
		return net.WriteInt(val2, val)
	end
end

net.ReadInt8 = net.GReadInt(8)
net.ReadInt16 = net.GReadInt(16)
net.ReadInt32 = net.GReadInt(32)

net.WriteInt8 = net.GWriteInt(8)
net.WriteInt16 = net.GWriteInt(16)
net.WriteInt32 = net.GWriteInt(32)

local maxint = 0x100000000

--[[
	@doc
	@fname net.WriteBigUInt
	@args number value

	@desc
	due to percision errors, not actually accurate
	this function attempts to write a unsigned 64 bits integer to the stream
	@enddesc
]]

--[[
	@doc
	@fname net.WriteBigInt
	@args number value

	@desc
	due to percision errors, not actually accurate
	this function attempts to write a 64 bits integer to the stream
	@enddesc
]]

--[[
	@doc
	@fname net.ReadBigUInt

	@returns
	number: 64 bit unsigned integer
]]

--[[
	@doc
	@fname net.ReadBigInt

	@returns
	number: 64 bit integer
]]
function net.WriteBigUInt(val)
	local first = val % maxint
	local second = (val - first) / maxint
	net.WriteUInt32(first)
	net.WriteUInt32(second)
end

function net.ReadBigUInt(val)
	local first = net.ReadUInt32()
	local second = net.ReadUInt32()

	return first + second * maxint
end

function net.WriteBigInt(val)
	net.WriteBool(val >= 0)
	net.WriteBigUInt(val:abs())
end

function net.ReadBigInt()
	local sign = net.ReadBool()
	local value = net.ReadBigUInt()

	if sign then
		return value
	end

	return -value
end

net.WriteUInt64 = net.WriteBigUInt
net.WriteInt64 = net.WriteBigInt

net.ReadUInt64 = net.ReadBigUInt
net.ReadInt64 = net.ReadBigInt

--[[
	@doc
	@fname net.ChooseOptimalBits
	@args number maximumPossibilities

	@returns
	number: minimal amount of bits required for sending all possible values
]]
function net.ChooseOptimalBits(amount)
	local bits = 1

	while 2 ^ bits <= amount do
		bits = bits + 1
	end

	return math.max(bits, 4)
end

--[[
	@doc
	@fname net.WriteVectorDouble
	@args Vector value

	@desc
	uses `net.WriteDouble` instead of `net.WriteFloat`
	@enddesc
]]
function net.WriteVectorDouble(vecIn)
	if type(vecIn) ~= 'Vector' then
		error('WriteVectorDouble - input is not a vector!')
	end

	net.WriteDouble(vecIn.x)
	net.WriteDouble(vecIn.y)
	net.WriteDouble(vecIn.z)

	return self
end

--[[
	@doc
	@fname net.WriteAngleDouble
	@args Angle value

	@desc
	uses `net.WriteDouble` instead of `net.WriteFloat`
	@enddesc
]]
function net.WriteAngleDouble(angleIn)
	if type(angleIn) ~= 'Angle' then
		error('WriteAngleDouble - input is not an angle!')
	end

	net.WriteDouble(angleIn.p)
	net.WriteDouble(angleIn.y)
	net.WriteDouble(angleIn.r)

	return self
end

--[[
	@doc
	@fname net.ReadVectorDouble

	@returns
	Vector
]]
function net.ReadVectorDouble()
	return Vector(net.ReadDouble(), net.ReadDouble(), net.ReadDouble())
end

--[[
	@doc
	@fname net.ReadAngleDouble

	@returns
	Angle
]]
function net.ReadAngleDouble()
	return Angle(net.ReadDouble(), net.ReadDouble(), net.ReadDouble())
end

local Color = Color

function net.WriteColor(colIn)
	if not IsColor(colIn) then
		error('Attempt to write a color which is not a color! ' .. type(colIn))
	end

	net.WriteUInt(colIn.r, 8)
	net.WriteUInt(colIn.g, 8)
	net.WriteUInt(colIn.b, 8)
	net.WriteUInt(colIn.a, 8)
end

function net.ReadColor()
	return Color(net.ReadUInt(8), net.ReadUInt(8), net.ReadUInt(8), net.ReadUInt(8))
end