-- local Turtle = {}
-- Turtle.__index = Turtle

local Network = {}
Network.__index = Network

function Network.new(modem)
	local self = setmetatable({}, Network)

	self.DEFAULT_CHANNEL = 42424
	self.expectedPackets = {}
	self.connectedTurtles = {}
	self.modems = { modem }

	return self
end

function Network:Listen()
	while true do
		local event, id, channel, reply, message = os.pullEvent()

		if event == "network_disconnect" then
			self.expectedPackets = {}
			break
		end

		if event == "timer" or event == "modem_message" then
			local closed = {}

			for i = 1, #self.expectedPackets do
				local packet = self.expectedPackets[i]

				if event == "timer" and id == packet.timeout then
					table.remove(self.expectedPackets, i)
					i = i - 1
				end

				if event == "modem_message" and channel == packet.channel and message == packet.message then
					table.remove(self.expectedPackets, i)
					table.insert(closed, channel)
					os.queueEvent(packet.uuid)
					os.cancelTimer(packet.timout)
					i = i - 1
				end
			end

			for i = 1, #closed do
				local required = false

				for _, packet in pairs(self.expectedPackets) do
					local channel = closed[i]

					if packet.channel == channel then
						required = true
						break
					end
				end

				if not required then
					self:CloseChannel(channel)
				end
			end
		end
	end
end

-- https://gist.github.com/jrus/3197011
function Network:GenerateEventUUID()
	local template = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"
	return string.gsub(template, "[xy]", function(c)
		local v = (c == "x") and math.random(0, 0xf) or math.random(8, 0xb)
		return string.format("%x", v)
	end)
end

function Network:Stop()
	os.queueEvent("network_disconnect")
end

function Network:WaitForBatch(batch, timeout)
	local events = {}
	local result = {}

	for i, packet in pairs(batch) do
		table.insert(
			events,
			Network:Expect(packet.channel, packet.message, timeout, function(success)
				result[i] = success
				return packet.callback(success)
			end)
		)
	end

	parallel.waitForAll(unpack(events))

	return result
end

function Network:Wait(channel, message, timeout, callback)
	return self:Expect(channel, message, timeout, callback)()
end

function Network:Expect(channel, message, timeout, callback)
	local packetUUID = self:GenerateEventUUID()
	local timerID = timeout == false and -1 or os.startTimer(timeout or 30)

	self:OpenChannel(channel)

	table.insert(self.expectedPackets, {
		channel = channel,
		message = message,
		timeout = timerID,
		uuid = packetUUID,
	})

	return function()
		while true do
			local event, id = os.pullEvent()

			if event == "timer" and id == timerID then
				if callback then
					return callback(false)
				end
				return false
			end

			if event == packetUUID then
				if callback then
					return callback(false)
				end
				return true
			end
		end
	end
end

function Network:HasModem(otherModem)
	for i, modem in pairs(self.modems) do
		for channel = 1, 65535 do
			if not (modem.isOpen(channel) or otherModem.isOpen(channel)) then
				modem.open(channel)

				local newOpen = otherModem.isOpen(channel)
				modem.close(channel)

				return newOpen
			end
		end
	end
	return false
end

function Network:AddModem(newModem)
	if self:HasModem(newModem) then
		return false
	end

	table.insert(self.modems, newModem)

	return true
end

function Network:OpenChannel(channel)
	for i, v in pairs(self.modems) do
		if v.isOpen(channel) then
			return
		end
	end

	for i, v in pairs(self.modems) do
		if pcall(v.open, channel) then
			return
		end
	end

	error("Too many channels open, no modems available")
end

function Network:Send() end

function Network:Connect() end

local remote = Network.new(peripheral.wrap("top"))
print(remote:HasModem(peripheral.wrap("right")))

-- parallel.waitForAll(Network.Listen(Network), Network.Wait(Network, 30, "cats", 60))