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

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local Players = game:GetService("Players")

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

local LightNetFolder = Instance.new("Folder", ReplicatedStorage)
LightNetFolder.Name = "LightNetStorage"

local ReliableEvent = Instance.new("RemoteEvent", LightNetFolder)
ReliableEvent.Name = "ReliableEvent"

local UnreliableEvent = Instance.new("UnreliableRemoteEvent", LightNetFolder)
UnreliableEvent.Name = "UnreliableRemoteEvent"

local Function = Instance.new("RemoteFunction", LightNetFolder)
Function.Name = "Function"

local function CreateReceiver()
	local DataReader = Reader.new()

	return function(sender: Player, data: buffer, references: { any }?)
		for _, item in DataReader:ReadEvent(data, references) do
			local event = Registry.get("Event", item.packetid)
			for _, listener in event._listeners do
				listener(item.value, sender)
			end
		end
		DataReader:Clear()
	end
end

local function CreateCallback()
	local DataReader = Reader.new()
	local DataWriter = Writer.new()

	return function(sender: Player, data: buffer, references: { any }?)
		local item = DataReader:ReadRequest(data, references)
		local packet = Registry.get("Function", item.packetid) :: Types.Function

		return DataWriter:WriteResponse(packet, packet._listener(item.value))
	end
end


ReliableEvent.OnServerEvent:Connect(CreateReceiver())
UnreliableEvent.OnServerEvent:Connect(CreateReceiver())
Function.OnServerInvoke = CreateCallback()

local Workers = {} :: {
	[Player]: {
		Reliable: Types.Writer,
		Unreliable: Types.Writer
	}
}

local function PlayerAdded(user)
	Workers[user] = {
		Reliable = Writer.new(),
		Unreliable = Writer.new()
	}
end

Players.PlayerAdded:Connect(PlayerAdded)
for _, user in Players:GetPlayers() do
	PlayerAdded(user)
end

local FunctionWriter = Writer.new()
local FunctionReader = Reader.new()

RunService.Heartbeat:Connect(function()
	for user, dispatcher in Workers do
		
		local ReliableWriter = dispatcher.Reliable
		local UnreliableWriter = dispatcher.Unreliable

		if ReliableWriter._cursor > 0 then
			ReliableEvent:FireClient(user, ReliableWriter:Dump())
			ReliableWriter:Clear()
		end

		if UnreliableWriter._cursor > 0 then
			UnreliableEvent:FireClient(user, UnreliableWriter:Dump())
			UnreliableWriter:Clear()
		end
	end
end)

return {
	SendTo = function(self: Types.Event, user: Player, data: any)
		if self._packettype.Name == "Reliable" then
			Workers[user].Reliable:Append(self, data)
		elseif self._packettype.Name == "Unreliable" then
			Workers[user].Unreliable:Append(self, data)
		end
		
	end,
	InvokeTo = function(self: Types.Function, user: Player, data: any)

		local callback = Function:InvokeClient(
			user,
			FunctionWriter:WriteRequest(self, data)
		)
		return FunctionReader:ReadResponse(callback).value
	end,
} :: Types.ServerProcesser