--!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 = ReplicatedStorage:WaitForChild("LightNetStorage")

local ReliableEvent = LightNetFolder:WaitForChild("ReliableEvent") :: RemoteEvent
local UnreliableEvent = LightNetFolder:WaitForChild("UnreliableRemoteEvent") :: UnreliableRemoteEvent
local Function = LightNetFolder:WaitForChild("Function") :: RemoteFunction

local function CreateReceiver()
	local DataReader = Reader.new()
	
	return function(data: buffer, references: { any }?)
		for _, item in DataReader:ReadEvent(data, references) do
			local packet = Registry.get("Event", item.packetid) :: Types.Event
			for _, listener in packet._listeners do
				listener(item.value)
			end
		end
	end
end

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

	return function(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.OnClientEvent:Connect(CreateReceiver())
UnreliableEvent.OnClientEvent:Connect(CreateReceiver())
Function.OnClientInvoke = CreateCallback()

local ReliableWriter = Writer.new()
local UnreliableWriter = Writer.new()

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

RunService.Heartbeat:Connect(function()
	if ReliableWriter._cursor > 0 then
		ReliableEvent:FireServer(ReliableWriter:Dump())
		ReliableWriter:Clear()
	end
	
	if UnreliableWriter._cursor > 0 then
		UnreliableEvent:FireServer(UnreliableWriter:Dump())
		UnreliableWriter:Clear()
	end
end)

return {
	Send = function(self: Types.Event, data: any)
		if self._packettype.Name == "Reliable" then
			ReliableWriter:Append(self, data)
		elseif self._packettype.Name == "Unreliable" then
			UnreliableWriter:Append(self, data)
		end
	end,
	Invoke = function(self: Types.Function, data: any)
		local callback = Function:InvokeServer(
			FunctionWriter:WriteRequest(self, data)
		)
		return FunctionReader:ReadResponse(callback).value
	end,
} :: Types.ClientProcesser