--!strict
--!optimize 2
--!native

local Reader = {}
Reader.__index = Reader

local Types = require("../Types")
local Registry = require("../Modules/Registry")

function Reader.new()
	local self = setmetatable({
		_cursor = 0,
		_refcursor = 1,
		_data = nil,
		_references = nil
	}, Reader) :: Types.Reader
	
	return self
end

function Reader.GetPacketID(self : Types.Reader, data: buffer)
	local packetid = buffer.readu8(data, self._cursor)
	self._cursor += 1
	
	return packetid
end

function Reader.ReadEvent(self : Types.Reader, data: buffer, references: { any }?)
	local starttime = os.clock()
	local len = buffer.len(data)
	local parameters = {}
	
	self._data = data
	self._references = references
	
	while self._cursor ~= len do
		--if os.clock()-starttime > 111111111111 then error("reader caused excessive performance degradation.") end
		
		local packetid = self:GetPacketID(data)
		local solver = Registry.get("Event", packetid)._solver :: Types.DataTypeInterface
		table.insert(parameters, {
			packetid = packetid,
			value = solver.read(self)
		})
	end
	
	return parameters
end

function Reader.ReadRequest(self: Types.Reader, data: buffer, references: { any }?)
	local packetid = self:GetPacketID(data)
	local solver = Registry.get("Function", packetid)._request :: Types.DataTypeInterface
	
	self._data = data
	self._references = references
	
	local value = solver.read(self)
	self:Clear()
	
	return {
		packetid = packetid,
		value = value
	}
end

function Reader.ReadResponse(self: Types.Reader, data: buffer, references: { any }?)
	local packetid = self:GetPacketID(data)
	local solver = Registry.get("Function", packetid)._response :: Types.DataTypeInterface

	self._data = data
	self._references = references
	
	return {
		packetid = packetid,
		value = solver.read(self)
	}
end


function Reader.Clear(self: Types.Reader)
	self._cursor = 0
	self._refcursor = 1
	self._data = nil
	self._references = nil
	
end

return Reader