local DEFAULT_TIMEOUT = 2
local QUERY_PROTO = 'trap/query'
local QUERY_RESPONSE_PROTO = 'trap/query:response'

local serializeOpts = {
  compact = true
}

local net = {}

local function assertRednetIsOpened()
  if not rednet.isOpen() then
    error('rednet should be enabled with rednet.open(modemName)')
  end
end

net.openRednet = function(modem)
  modem = modem or peripheral.find("modem") or error("No modem attached", 0)
  return rednet.open(peripheral.getName(modem))
end

net.closeRednet = function(modem)
  modem = modem or peripheral.find("modem") or error("No modem attached", 0)
  return rednet.close(peripheral.getName(modem))
end

net.listenQuery = function(hostname, processQueryMessage)
  assertRednetIsOpened()

  local serverRunning = true

  local function stopServer()
    serverRunning = false
  end

  rednet.host(QUERY_PROTO, hostname)

  while serverRunning do
    local computerId, message = rednet.receive(QUERY_PROTO)
    local responseMessage = processQueryMessage(textutils.unserialize(message), computerId, stopServer)
    rednet.send(computerId, textutils.serialize(responseMessage, serializeOpts), QUERY_RESPONSE_PROTO)
  end

  rednet.unhost(QUERY_PROTO)
end

net.sendQuery = function(hostname, message, timeout)
  timeout = timeout or DEFAULT_TIMEOUT
  assertRednetIsOpened()

  local serverId = rednet.lookup(QUERY_PROTO, hostname)

  if not serverId then
    return nil, 'hostname lookup error'
  end

  local sendOk = rednet.send(serverId, textutils.serialize(message, serializeOpts), QUERY_PROTO)

  if not sendOk then
    return nil, 'rednet error'
  end

  local responseServerId, responseMessage = rednet.receive(QUERY_RESPONSE_PROTO, timeout)

  if not responseServerId then
    return nil, 'timeout'
  end

  return textutils.unserialize(responseMessage)
end

return net