local component = require("component")
local event = require("event")
local fs = require("filesystem")
local computer = require("computer")
local gpu = component.gpu
local items = {
  {"dwcity:Materia", 0},
  {"minecraft:iron_ingot", 0},
  {"IC2:itemIngot", 0},
  {"IC2:itemIngot", 1},
  {"minecraft:gold_ingot", 0},
  {"minecraft:redstone", 0},
  {"minecraft:coal", 0},
  {"dwcity:X32", 0}
}
--------------------------------------------------------------
local colors= {
    blue = 0x05F5F0,
    black = 0x000000,
    bred = 0xFF2400,
    green = 0x99FF33,
    sun = 0xFFFF00,
    red = 0x0052A3,
    orange = 0xFFA500,
    mem = 0xFFFFFF, -- память
    gray = 0x939393,
    hex = 0xC522A9,
    pur = 0x00FF00,
    red1 = 0xFF2400,
}
-----------------------------------------------------------------------
local friendList = {
  "Skayrons",
  "Lovense",
  "Truncator",
  "Lovense1",
}
local players = {
 {"Skayrons",false},
 {"Lovense",false},
 {"Lovense1",false},
 {"Truncator",false},
}
local blackList = {
    "krissss",
    "combomaster",
    "AliceWay",
    "sima21",
    "SkyDrive_",
    "Phenomenoon",
    "jewiven",
    "_Desert_Eagle_",
    "Samaya",
}
--------------------------------------------------------------------
local chat_box, me, sensor, counter, bridge
local euWorking, average, cb, me_a, s, bridgeCom, allow_mem = true, false, false, false, false,
    false, false
-------------{OPTIONS}------------------
local TIME_ZONE = 3
local widthBox = 90
local transBox = 0.3
local timeConstant = 1
local getY = 24
---------------------------------------------
local TC, RO, RN, RD, TPS = 2, 0, 0, 0, 0
local strTPS = ""
---------------------------------------------
local t_correction = TIME_ZONE * 3600
local chat_box_name = "§8[§4Малышка§8]"
local adm = "Truncator" -- Ник админа компа
local allow_mem = false -- Отображать на экране кол-во памяти или нет
--------------------------------------------------ENERGY-PROXY-----------------------------------------------------
 local average_counter = {
  molecular = {
    name = "Молекулярка",
    proxy=component.proxy("1f86c069-deca-433e-960b-2c75Fd811e0d"),
    icon="AdvancedSolarPanel:BlockMolecularTransformer",
    use=true,
    coordinates = {x = 1, y = getY + 75},
    color = colors.orange
  }
}
---------------------------------------------------------------------------------------------------------------------------------
local localize = {
  join_in_game = " §7вошел в игру!",
  left_from_game = " §7покинул игру!",
}

---------------------VISUAL----------------------------------------VISUAL-------------------------------------------------------------
local function addBox(x, y, w, h, color, tran)
    return bridge.addBox(x, y, w, h, color, tran)
end

local function addText(x, y, text, color)
    return bridge.addText(x, y, text, color)
end

local function addIcon(x, y, name, meta)
    return bridge.addIcon(x, y, name, meta)
end

function gui()
  w, h = gpu.maxResolution()
  gpu.fill(1, 1, w, h, " ")
end
------------------------------------------------------------CHECK-COM---------------------------------------------------
local function digital(n)
  local text=''
  for f in string.gmatch(n,'%d') do text=text..f end
  return text
end

function check()
  if component.isAvailable("average_counter") then
    average = true
    counter = component.average_counter
  end
  if component.isAvailable("chat_box") then
    cb = true
    chat_box = component.chat_box
    chat_box.setName(chat_box_name)
  end
  if component.isAvailable("me_interface") then
    me_a = true
    me = component.me_interface
  end
    if component.isAvailable("openperipheral_sensor") then
     s = true
     sensor = component.openperipheral_sensor
  end
    if component.isAvailable("openperipheral_bridge") then
     bridgeCom = true
     bridge = component.openperipheral_bridge
 end
  componentsOnScreen()
    return false
end
 ------------------------------------------------------------TIME----------------------------------------------------------
local function getTime()
    local f = io.open("/tmp/TF", "w")
    f:write("test")
    f:close()
    return (fs.lastModified("/tmp/TF"))
end

local function drawTime()
    local time = getTime()
    local lastmod = tonumber(string.sub(time, 1, -4)) + TIME_ZONE * 3600
    local dt = os.date('%H:%M', lastmod)

    local x = 1
    local y = getY + 16
    local width = widthBox
    local height = 17
    local backgroundColor = colors.black
    local transparency = transBox

    addBox(x, y, width, height, backgroundColor, transparency)

    local textX = x + 10
    local textY = y + 5

    local textColor = colors.sun

    addText(textX, textY, "Время " .. dt, textColor)
end
--------------------------------------------

--------------------------------------------
function componentsOnScreen()
  gpu.set(1, 1, "Chat-box: " .. tostring(cb))
  gpu.set(1, 2, "ME: " .. tostring(me_a))
  gpu.set(1, 3, "radar: " .. tostring(s))
  gpu.set(1, 4, "Counter: " .. tostring(average))
end

function getSize(name,dmg)
 for _, item in ipairs(me.getItemsInNetwork()) do
  if item.name == name and item.damage == dmg then
   return item.size
  end
 end
 return 0
end

local function string_number(num)
    local answer = ""
    local reverse_num = {}
    local num = tostring(num):gsub(".", function(c)
        table.insert(reverse_num, c)
    end)
    for index, _ in pairs(reverse_num) do
        answer = answer .. reverse_num[#reverse_num - index + 1]
        if index % 3 == 0 and index ~= #reverse_num then
            answer = answer .. " "
        end
    end
    return answer:reverse()
end
-------------------------------------------------------------------ITEMS-------------------------------------------------------
local function formatNumber(num)
    if num >= 1000000 then
        return string.format("%.1fM", num / 1000000)
    elseif num >= 1000 then
        return string.format("%.fK", num / 1000)
    else
        return tostring(num)
    end
end

local function drawItems()
    if me_a then
        local y = getY + 100
        local columnWidth = widthBox / 2 -- Ширина каждого столбца
        local itemsPerColumn = math.ceil(#items / 2) -- Количество элементов в каждом столбце

        addBox(1, y - 5, columnWidth, itemsPerColumn * 19, colors.black, transBox) -- Первый столбец
        addBox(columnWidth + 1, y - 5, columnWidth, itemsPerColumn * 19, colors.black, transBox) -- Второй столбец

        for i = 1, #items do
            local column = math.ceil(i / itemsPerColumn) -- Определение текущего столбца
            local offsetX = (column - 1) * columnWidth -- Смещение по горизонтали в зависимости от текущего столбца

            local itemIndex = i % itemsPerColumn -- Индекс элемента в текущем столбце
            if itemIndex == 0 then
                itemIndex = itemsPerColumn
            end

            local itemY = y + (itemIndex - 1) * 18 -- Рассчитываем позицию Y для текущего элемента
            addIcon(offsetX + 3, itemY - 4, items[i][1], items[i][2])
            local formattedNumber = formatNumber(getSize(items[i][1], items[i][2]))
            addText(offsetX + 21, itemY, formattedNumber, colors.blue)
        end
    end
end
-------------------------------------------------------------MOLECULAR-----------------------------------------------------------------
local function toggleMolecular2Energy()
    local molecular2_data = average_counter["molecular2"]
    if molecular2_data and molecular2_data.use then
        local averageEU = molecular2_data.proxy.getAverage()
        local currentRedstoneState = redstone.getOutput(redstoneSide)

        -- Если значение энергии равно нулю и Redstone включен, выключаем Redstone
        if averageEU == 0 and currentRedstoneState == 15 then
            redstone.setOutput(redstoneSide, 0)
            euWorking = true
        -- Если значение энергии больше нуля и Redstone выключен, включаем Redstone
        elseif averageEU > 0 and currentRedstoneState == 0 then
            redstone.setOutput(redstoneSide, 15)
            euWorking = false
        end
    end
end
----------------------------------------------------------------TICK-PER-SECOND-------------------------------------------------------
local function drawTPS()
    local TPS = {}
    local avgTPS = 0


    for tSlot=1, 3 do
        TPS[tSlot] = 0
    end


    for tSlot = 1, 3 do
        local realTimeOld = getTime()
        os.sleep(timeConstant)
        local realTimeNew = getTime()
        local realTimeDiff = realTimeNew - realTimeOld
        TPS[tSlot] = 20000 * timeConstant / realTimeDiff
        avgTPS = (TPS[1] + TPS[2] + TPS[3]) / 3
    end


    local color
    if avgTPS > 18 then
        color = 0x00FF00
    elseif avgTPS > 16 then
        color = 0xAAFF00
    elseif avgTPS > 14 then
        color = 0xFFFF00
    elseif avgTPS > 12 then
        color = 0xFFAA00
    else
        color = 0xFF4400
    end


    local x = 1
    local y = getY -3
    local width = widthBox
    local height = 17


    addBox(x, y, width, height, colors.black, transBox)


    local textOffsetX = 15
    local textX = x + textOffsetX
    local textY = y + 5

    addText(textX, textY, string.format("TPS: %.1f", avgTPS), color)

    return avgTPS
end
-------------------------------------------------------------DRAW-ENERGY---------------------------------------------------------
local function drawEnergy()
  local isMolecularActive = false -- Флаг, сигнализирующий об активности устройства "molecular"

  -- Первый проход - проверяем, активен ли "molecular"
  for device, counter in pairs(average_counter) do
    if device == "molecular" and counter.use and euWorking then
      isMolecularActive = true -- "molecular" активен и работает
      break -- Выходим из цикла, так как нашли активное устройство "molecular"
    end
  end

  -- Второй проход - рисуем информацию о энергии
  for device, counter in pairs(average_counter) do
    if device ~= "molecular2" or not isMolecularActive then -- Если устройство не "molecular2" или "molecular" не активно
      if counter.use then
        print(counter)
        print(counter.name)
        local averageEU = counter.proxy.getAverage()
        local av = ""

        -- Определение единиц для отображения мощности
        if averageEU / 1000 <= 1 then
          av = string.format("%.3f EU/t", averageEU)
        elseif averageEU / 1000000 >= 1 then
          av = string.format("%.3f M EU/t", averageEU / 1000000)
        else
          av = string.format("%.1f k EU/t", averageEU / 1000)
        end

        -- Рисуем прямоугольник и иконку для всех устройств, кроме "molecular2"
        if device ~= "molecular2" then
          addBox(counter.coordinates.x, counter.coordinates.y, widthBox, 18, colors.black, transBox)
          addIcon(counter.coordinates.x + 2, counter.coordinates.y + 1, counter.icon, 0)
        end

        -- Рисуем информацию об энергии
        if device == "molecular" then
          if euWorking then
            addText(counter.coordinates.x + 21, counter.coordinates.y + 5, av, counter.color)
          end
        else
          addText(counter.coordinates.x + 21, counter.coordinates.y + 5, av, counter.color)
        end
      end
    end
  end
end

-----------------------------------------------------------------------------------------
local function updateEnergyStateAndDraw()
    -- Синхронизируем изменение энергии с отображением информации
    toggleMolecular2Energy()
    drawEnergy()
end
-----------------------------------------------------------CHECK-online--------------------------------------------------------
 function checkOnline(n)
  computer.removeUser(adm)
  if computer.addUser(players[n][1]) then
    computer.removeUser(players[n][1])
    if players[n][2] == false then
      if cb then
        chat_box.say("§a"..players[n][1] .. localize.join_in_game)
      end
      players[n][2] = true
    end
    return true
  else
    if players[n][2] == true then
      if cb then
        chat_box.say("§c"..players[n][1] .. localize.left_from_game)
      end
      players[n][2] = false
    end
    computer.removeUser(players[n][1])
    return false
  end
end
-------------------------------------------------------------------
function freeMemory()
  if allow_mem then
    addText(0, 12, "MEM: "..math.floor((computer.freeMemory() / 1000)).."mb".."/"..math.floor((computer.totalMemory() / 1000)).."mb".." "..math.floor(((computer.freeMemory() / computer.totalMemory()) * 100)).."%", colors.mem)
  end
end
-----------------------------------------------------------------------ONLINE-------------------------------------------------
function drawOnline()
  local leftMargin = -19  -- Установите желаемый отступ от левого края экрана
  local yMargin = getY +161
  local onlineCount = 0
  local offlineCount = 0
  local y = getY + 210
  -- Создаем отдельные списки для онлайн и оффлайн игроков
  local onlinePlayers = {}
  local offlinePlayers = {}

  for i = 1, #players do
    if checkOnline(i) then
      onlineCount = onlineCount + 1
      table.insert(onlinePlayers, players[i][1]) -- Добавляем онлайн игроков в список
    else
      offlineCount = offlineCount + 1
      table.insert(offlinePlayers, players[i][1]) -- Добавляем оффлайн игроков в список
    end
  end

  -- Сортируем список онлайн игроков
  table.sort(onlinePlayers)

  -- Показываем сортированный список онлайн игроков и количество оффлайн
  for _, playerName in ipairs(onlinePlayers) do
    y = y + 10
    addText(leftMargin + 23, y, playerName, colors.green, 1) -- Показываем имя игрока с отступом
  end
  addBox(leftMargin + 20, yMargin + 13, widthBox, 18, colors.black, transBox)
  addText(leftMargin + 43, yMargin + 19, "Offline: " .. offlineCount, colors.gray, 1)
  addIcon(leftMargin + 23, yMargin + 14, "dwcity:Dark_spirit")  -- Иконка для оффлайн
  addBox(leftMargin + 20, yMargin + 33, widthBox, 18, colors.black, transBox)
  addText(leftMargin + 43, yMargin + 39, "Online: " .. onlineCount, colors.hex, 1)
  addIcon(leftMargin + 23, yMargin + 34, "dwcity:Dark_spirit2")  -- Иконка для онлайн
end
--------------------------------------------------------------------SENSOR------------------------------------------------------------
local function drawNearPlayers()
    if s then
        local y = getY - 3
        local temp = sensor.getPlayers()
        local actualPlayersCount = 0 -- Переменная для подсчета реального количества игроков (не учитывая тех, кто в блэклисте)

        addBox(93, y, widthBox, 17, colors.black, transBox)

        for i = 1, #temp do
            local playerIsFriend = false
            local playerIsBlacklisted = false

            for j = 1, #blackList do
                if temp[i].name == blackList[j] then
                    playerIsBlacklisted = true
                    break
                end
            end

            for j = 1, #friendList do
                if temp[i].name == friendList[j] then
                    playerIsFriend = true
                    break
                end
            end

            if not playerIsBlacklisted then
                actualPlayersCount = actualPlayersCount + 1

                if playerIsFriend then
                    addText(96, y + 22 + (actualPlayersCount - 1) * 10, temp[i].name, colors.green)
                else
                    addText(96, y + 22 + (actualPlayersCount - 1) * 10, temp[i].name, colors.red1)
                end
            end
        end

        addText(95, y + 5, "§b|| Игроки рядом: §a" .. actualPlayersCount, colors.red1)
    end
    return
end
-----------------------------------------------------------------------
check()
bridge.clear()
addText(10, 150, "Инициализация", colors.blue)
bridge.sync()
gui()

while true do
  check()
  computer.addUser(adm)
  bridge.clear()
  updateEnergyStateAndDraw()
  drawItems()
  drawTPS()
  drawTime()
  drawOnline()
  drawNearPlayers()
  freeMemory()
  os.sleep(0.1)
  bridge.sync()
end