MEWarehouse

-- RSWarehouse.lua
-- Author: Chuck Burgess
-- Updated: 2024-01-15

local logFile = "RSWarehouse.log"
local time_between_runs = 30

-- Initialize Monitor
-- see: https://www.computercraft.info/wiki/Advanced_Monitor
local monitor = peripheral.find("monitor")
if not monitor then error("Monitor not found.") end
monitor.setTextScale(0.5)
monitor.clear()
monitor.setCursorPos(1, 1)
monitor.setCursorBlink(false)
print("Monitor initialized.")

-- Initialize RS Bridge
-- see: https://advancedperipherals.madefor.cc/peripherals/rs_bridge/
local bridge = peripheral.find("meBridge")
if not bridge then error("ME Bridge not found.") end
print("ME Bridge initialized.")

-- Initialize Colony Integrator
-- see: https://docs.advanced-peripherals.de/peripherals/colony_integrator/
local colony = peripheral.find("colonyIntegrator")
if not colony then error("Colony Integrator not found.") end
if not colony.isInColony then error("Colony Integrator is not in a colony.") end
print("Colony Integrator initialized.")

-- Establish the direction to transport the items into the Warehouse based on
-- where the entnglement block is sitting. Default to empty string.
local storage = peripheral.find("entangled:tile")
if not storage then error("Warehouse storage not found.") end
local direction = ""
local names = peripheral.getNames()
for _, pos in ipairs(names) do
  if peripheral.getType(pos) == "entangled:tile" then
    direction = pos
    end
end
print("Warehouse storage initialized.")

----------------------------------------------------------------------------
-- FUNCTIONS
----------------------------------------------------------------------------
--[[
  Table.Empty
  @desc     check to see if a table contains any data
  @return   boolean
]]
function table.empty (self)
    for _, _ in pairs(self) do
        return false
    end
    return true
end

--[[
    Write To Log
    @desc   Write the specified `table` to the file surrounded by the `blockTop` and `blockBottom`
    @return void
]]
function writeToLog(data, blockTop, blockBottom)
  file.write("\n")
  file.write(blockTop)
  file.write("\n")
  file.write(textutils.serialize(data, { allow_repetitions = true }))
  file.write("\n")
  file.write(blockBottom)
  file.write("\n")
end

--[[
    Process Work Request Item
    @desc Determine if this item can be delivered to the warehouse from the storage
    @return boolean
]]
function processWorkRequestItem(request)
  if string.find(request.desc, "Tool of class") then return false end
  if string.find(request.name, "Hoe") then return false end
  if string.find(request.name, "Shovel") then return false end
  if string.find(request.name, "Axe") then return false end
  if string.find(request.name, "Pickaxe") then return false end
  if string.find(request.name, "Bow") then return false end
  if string.find(request.name, "Sword") then return false end
  if string.find(request.name, "Shield") then return false end
  if string.find(request.name, "Helmet") then return false end
  if string.find(request.name, "Leather Cap") then return false end
  if string.find(request.name, "Chestplate") then return false end
  if string.find(request.name, "Tunic") then return false end
  if string.find(request.name, "Pants") then return false end
  if string.find(request.name, "Leggings") then return false end
  if string.find(request.name, "Boots") then return false end
  if request.name == "Rallying Banner" then return false end --bugged in alpha versions
  if request.name == "Crafter" then return false end
  if request.name == "Compostable" then return false end
  if request.name == "Fertilizer" then return false end
  if request.name == "Flowers" then return false end
  if request.name == "Food" then return false end
  if request.name == "Fuel" then return false end
  if request.name == "Smeltable Ore" then return false end
  if request.name == "Stack List" then return false end
  -- you can add any new items here if they are found
  return true
end

--[[
    Monitor Print Row Justified
    @desc   Print a line of data to the in-game monitor
    @return void
]]
function mPrintRowJustified(mon, y, pos, text, textcolor)
    w, h = mon.getSize()
    fg = colors.white
    bg = colors.black

    if pos == "left" then x = 1 end
    if pos == "center" then x = math.floor((w - #text) / 2) end
    if pos == "right" then x = w - #text end

    mon.setTextColor(textcolor)
    mon.setCursorPos(x, y)
    mon.write(text)
    mon.setTextColor(fg)
    mon.setBackgroundColor(bg)
end

--[[
    Display Timer
    @desc   Update the time on the monitor
    @return void
]]
function displayTimer(mon, t)
    now = os.time()
    cycle = "day"
    cycle_color = colors.orange
    if now >= 4 and now < 6 then
        cycle = "sunrise"
        cycle_color = colors.yellow
    elseif now >= 6 and now < 18 then
        cycle = "day"
        cycle_color = colors.lightBlue
    elseif now >= 18 and now < 19.5 then
        cycle = "sunset"
        cycle_color = colors.magenta
    elseif now >= 19.5 or now < 5 then
        cycle = "night"
        cycle_color = colors.red
    end

    timer_color = colors.green
    if t < 15 then timer_color = colors.yellow end
    if t < 5 then timer_color = colors.orange end

    mPrintRowJustified(mon, 1, "left", string.format("Time: %s [%s]    ", textutils.formatTime(now, false), cycle), cycle_color)
    if cycle ~= "night" then
      mPrintRowJustified(mon, 1, "right", string.format("    Remaining: %ss", t), timer_color)
    else
      mPrintRowJustified(mon, 1, "right", "    Remaining: PAUSED", colors.red)
    end
end

--[[
    Create Colonist Data
    @desc   Build a table of Colonist making the request
    @return table
]]
function createColonistData(colonist)
  title_words = {}
  words_in_name = 0
  colonist_job = ""
  word_count = 1

  for word in colonist:gmatch("%S+") do
    table.insert(title_words, word)
    words_in_name = words_in_name + 1
  end

  if words_in_name >= 3 then colonist_name = title_words[words_in_name-2] .. " " .. title_words[words_in_name]
  else colonist_name = colonist end

  repeat
    if colonist_job ~= "" then colonist_job = colonist_job .. " " end
    colonist_job = colonist_job .. title_words[word_count]
    word_count = word_count + 1
  until word_count > words_in_name - 3

  return  { fullName = colonist, titleWords = title_words, job = colonist_job, name = colonist_name, wordsInName = words_in_name }
end

--[[
    Get Work Request List (from colony)
    @desc   Build a table of the work request data from the colony
    @return table
]]
function getWorkRequestList(colony)
    requestList = {}
    workRequests = colony.getRequests()
    file = fs.open(logFile, "w")

    for w in pairs(workRequests) do
        writeToLog(workRequests[w], "--- Request start ---", "--- Request end ---");
        name = workRequests[w].name -- the name of the count/item being requested
        colonist = createColonistData(workRequests[w].target)
        desc = workRequests[w].desc -- the request description
        item = {}
        -- create the filter item for the transfer request through the bridge
        if workRequests[w].items and workRequests[w].items[1] then
          if not workRequests[w].items[1].nbt or table.empty(workRequests[w].items[1].nbt) then
            item = { name = workRequests[w].items[1].name, count =  workRequests[w].count, displayName = workRequests[w].items[1].displayName}
          else
            item = { name = workRequests[w].items[1].name, count = workRequests[w].count, displayName = workRequests[w].items[1].displayName, nbt =  workRequests[w].items[1].nbt}
          end
        end
        -- how many items are needed to fulfill this request?
        needed = workRequests[w].count

        local newRecord = {}
        newRecord.name = name
        newRecord.desc = desc
        newRecord.needed = needed
        newRecord.item = item
        newRecord.colonist = colonist
        table.insert(requestList, newRecord)
        writeToLog(newRecord, "--- Record start ---", "--- Record end ---");
      end
      file.close()
  return requestList
end

--[[
    Display List
    @desc   Update the monitor with the work request items currently in the system
    @return void
]]
function displayList(mon, listName, itemList)
  -- show the list header first
  mPrintRowJustified(mon, row, "center", listName, colors.white)
  row = row + 1
  for e in pairs(itemList) do
      record = itemList[e]
      text = string.format("%d %s", record.provided , record.name)
      mPrintRowJustified(mon, row, "left", text, record.color)
      mPrintRowJustified(mon, row, "right", " " .. record.colonist, record.color)
      row = row + 1
  end
  -- add a space at the end of the list
  row = row + 1
end

-- Color References:
-- RED:     work order can't be satisfied by Refined Storage (lack of pattern or lack of
--            required crafting ingredients).
-- YELLOW:  order partially filled and a crafting job was scheduled for the rest.
-- GREEN:   order fully filled.
-- BLUE:    the Player needs to manually fill the work order. This includes some equipment as well as generic requests ike Compostables, Fuel, Food, Flowers, etc.
--[[
    Scan Work Requests
    @desc   Manages all of the open work requests in the system and attempts to fulfill them from the inventory
    @desc   Not called at night (as determined by the server) since requests cannot be fulfilled anyway
    @return void
]]
function scanWorkRequests(mon, bridge, direction)

    print("\nScan starting at", textutils.formatTime(os.time(), false) .. " (" .. os.time() ..").")
    builder_list = {}
    nonbuilder_list = {}
    equipment_list = {}
    requestList = getWorkRequestList(colony)

    for j, data in ipairs(requestList) do
        color = colors.blue
        provided = 0

        if processWorkRequestItem(data) then
            provided = bridge.exportItemToPeripheral(data.item, direction)
            color = colors.lightGray
            if provided >= data.needed then
              color = colors.green
            end
            -- only handle the Non-NBT data items or empty nbt table item records
            if provided < data.needed then
                if bridge.isItemCrafting(data.item) then
                    color = colors.yellow
                    print("[Crafting]", data.name)
                else
                    if bridge.craftItem(data.item) then
                      color = colors.yellow
                      print("[Scheduled]", data.item.count, "x", data.name)
                    else
                      color = colors.red
                      print("[Failed]", data.name)
                    end
                end
            end
        else
           nameString = data.name .. " [" .. data.colonist.fullName .. "]"
           print("[Skipped]", nameString)
        end
        -- ---------------------------------------------------------------------
        -- Build the newList data
        -- ---------------------------------------------------------------------
        -- create the target text
        expectedList = "Builder"
        colonist = data.colonist.name
        if not string.find(data.colonist.fullName, "Builder") then
            expectedList = ""
            colonist = data.colonist.job .. " " .. data.colonist.name
            if data.colonist.wordsInName < 3 then
                colonist = data.colonist.name
            end
        end

        -- create the name
        listName = data.name
        if string.find(data.desc, "level") then
            expectedList = "Equipment"
            level = "Any Level"
            if string.find(data.desc, "with maximal level: Leather") then level = "Leather" end
            if string.find(data.desc, "with maximal level: Gold") then level = "Gold" end
            if string.find(data.desc, "with maximal level: Chain") then level = "Chain" end
            if string.find(data.desc, "with maximal level: Wood or Gold") then level = "Wood or Gold" end
            if string.find(data.desc, "with maximal level: Stone") then level = "Stone" end
            if string.find(data.desc, "with maximal level: Iron") then level = "Iron" end
            if string.find(data.desc, "with maximal level: Diamond") then level = "Diamond" end
            listName = level .. " " .. data.name
            if level == "Any Level" then listName = data.name .. " of any level" end
        end

        -- create the new list table defining what is inserted into a specific list
        newList = { name=listName, colonist=colonist, needed=data.needed, provided=provided, color=color}

        if expectedList == "Equipment" then
            table.insert(equipment_list, newList)
        elseif expectedList == "Builder" then
            table.insert(builder_list, newList)
        else
            table.insert(nonbuilder_list, newList)
        end
        -- ---------------------------------------------------------------------
    end

  -- Show the various lists on the attached monitor.
  mon.clear()
  row = 3
  if not table.empty(builder_list) then displayList(mon, "Builder Requests", builder_list) end
  if not table.empty(nonbuilder_list) then displayList(mon, "Nonbuilder Requests", nonbuilder_list) end
  if not table.empty(equipment_list) then displayList(mon, "Equipment", equipment_list) end

  -- no requests
  if row == 3 then
    mPrintRowJustified(mon, row, "center", "No Open Requests", colors.white)
  end
  print("Scan completed at", textutils.formatTime(os.time(), false) .. " (" .. os.time() ..").")
end


--[[
    MAIN
    @desc   establish the run times and execute the work request management
    @return void
]]
local current_run = time_between_runs
scanWorkRequests(monitor, bridge, direction)
displayTimer(monitor, current_run)
local TIMER = os.startTimer(1)

while true do
  local e = {os.pullEvent()}
  if e[1] == "timer" and e[2] == TIMER then
    now = os.time()
    if now >= 5 and now < 19.5 then
      current_run = current_run - 1
      if current_run <= 0 then
        scanWorkRequests(monitor, bridge, direction)
        current_run = time_between_runs
      end
    end
    displayTimer(monitor, current_run)
    TIMER = os.startTimer(1)
  elseif e[1] == "monitor_touch" then
    os.cancelTimer(TIMER)
    scanWorkRequests(monitor, bridge, direction)
    current_run = time_between_runs
    displayTimer(monitor, current_run)
    TIMER = os.startTimer(1)
  end
end