NetAPI

local CHECKTIMER = 10
local TIMEOUT    = 6
local MAXERROR   = 2

local function CompareID(id1, id2, message1, message2)
 if (id1 ~= id2) then return message1
 else return message2 end
end

local function CompareIDs(ids, id)
  if (ids == nil or id == nil) then
   return false
  end

  for i, v in ipairs(ids) do
   if (v == id) then
    return true
   end
  end

  return false
end

local function LoadWhiteList()
 if (fs.exists("NetAPI.WhiteList") == false) then
  return false
 end

 local file = fs.open("NetAPI.WhiteList", "r")

 local _tbl = {}
 local size = f.readline() + 0

 for i = 1, size do
  table.insert(_tbl, f.readline() + 0)
 end

 file.close()

 return _tbl
end

local function getWirelessModemSide()
    for n, sSide in ipairs(rs.getSides()) do
        if peripheral.getType(sSide) == "modem" and peripheral.call(sSide, "isWireless") then
            return sSide
        end
    end
end

ServerSide =
{
 side = nil,
 checktime = nil,
 isWhiteList = true,
 active = false,
 clients = {},
 whitelist = {},

 --Start Server
 StartServer = function(self)
  if isWhiteList then self.whitelist = LoadWhiteList() end

  self.side = getWirelessModemSide()
  if not self.side then error("Wireless modem not found.") end
  rednet.open(self.side)
  self.active = true

  return true
 end,

 --Stop Server
 StopServer = function(self)
  if not self.active then error("The server is not running.") end
  BroadcastMessage("from_server.disconnect")
  self.active = false
  rednet.close(self.side)

  return true
 end,

 --Handler clients connection
 HandleMessages = function(self)
  local _event, _id, _msg = os.pullEvent()
  if _event == "rednet_message" then
   if _msg == "from_client.connect" then
    if not self.checktime then self.checktime = os.startTimer(CHECKTIMER) end

    self.clients[_id] = {true, 0}
    rednet.send(_id, "from_server.connect.processed")

    print("Client ", _id, " connected.")
   elseif _msg == "from_client.check" then
    rednet.send(_id, "from_server.check.processed")
   elseif _msg == "from_client.disconnect" then
    self.clients[_id] = nil
    print("Client " .. _id .. " disconnected.")
   end
  elseif _event == "timer" then
   if _id == self.checktime then
    self.checktime = nil
    if self:CheckClients() then self.checktime = os.startTimer(CHECKTIMER) end
   end
  end
 end,

 BroadcastClientMessage = function(self, message)
  for id, _ in pairs(self.clients) do
   rednet.send(id, message)
  end
 end,

 CheckClient = function(self, id)
  rednet.send(id, "from_server.check")

  _id, _msg = rednet.receive(TIMEOUT)
  --print("id: ", id, ", _id: ", _id, ", msg: ", _msg)
  if _id == id then
  print("ok")
   if _msg == "from_client.check.processed" then
    self.clients[_id][1] = true
    self.clients[_id][2] = 0
    return
   end
  end

  if self.clients[id][2] >= MAXERROR then
    rednet.send(id, "from_server.disconnect")
    print(id, " disconnect")
    self.clients[id] = nil
    return
  end

  self.clients[id][1] = false
  self.clients[id][2] = self.clients[id][2] + 1
  print(self.clients[id][2])
 end,

 CheckClients = function(self)
  --Удалить костыль
  --Обновить на черепашке
  return pcall(
   function()
    for id, clientinfo in pairs(self.clients) do
     self:CheckClient(id)
    end
   end
  )
 end
}

ClientSide =
{
 checktime = nil,
 side = nil,
 active = false,
 serverID = nil,

  --Start Client
 StartClient = function(self)

  self.side = getWirelessModemSide()
  if not self.side then error("Wireless modem not found.") end
  rednet.open(self.side)
  self.active = true

  return true
 end,

 --Stop Client
 StopClient = function(self)
  if not self.active then error("The client is not running.") end
  rednet.send(self.serverID, "from_client.disconnect")
  self.active = false
  rednet.close(self.side)

  return true
 end,

 HandleMessages = function(self)
  local _event, _id, _msg = os.pullEvent()

  if _event == "rednet_message" then
   if _msg == "from_server.check" then
    self.checktime = os.startTimer(CHECKTIMER)
    rednet.send(_id, "from_client.check.processed")
   elseif _msg == "from_server.disconnect" then
    print("Disconnected from server.")
   end
  elseif _event == "timer" then
   if _id == self.checktime then self.checktime = nil self:CheckConnection() self.checktime = os.startTimer(CHECKTIMER) end
  end
 end,

 GetServerID = function(self)
  return self.serverID
 end,

 CheckConnection = function(self)
  rednet.send(self.serverID, "from_client.check")

  _id, _msg = rednet.receive(TIMEOUT)
  if _id == serverID then
   if _msg == "from_server.check.processed" then
    errors = 0
    return
   end
  end

  if self.errors > MAXERROR then
    rednet.send(id, "from_client.disconnect")
    print("Disconnected")
    return
  end
  self.errors = self.errors + 1
 end,

 SendServerMessage = function(self, message, id)
  rednet.send(id, message)
 end,

 ConnectToServer = function(self, id)
  rednet.send(id, "from_client.connect")

  _id, _msg = rednet.receive(TIMEOUT)

  if _msg == "from_server.connect.processed" then
   self.serverID = _id
   self.active = true

   return true
  end

  return false
 end
}