Minecraft ComputerCraft Modem ArchaeologistManager

--
-- Desc: An Unearther Archaeologist manager program for FTB Stoneblock 4
-- Manages the Archaeologist with specific slot handling:
-- Slot 1: Material input (dirt, sand, dust)
-- Slot 2: Food (optional, improves processing speed)
-- Slot 3: Brush (required, auto-supplied from inventory)
-- Slots 4-12: Output slots (carefully managed to avoid disrupting hidden token slot)
-- IMPORTANT!: as you connect modems to archaeologists/chests, update the config to match
-- their names, or this will not work correctly.
--

-- By: hornedcommando

-- =========================
-- ========== CONFIG =======
-- =========================

local CONFIG = {
  -- Your Unearther Archaeologist peripheral name
  archaeologist = "ftbunearthed:frame_1",

  -- by default inputs where their outputs > 128 are trashed here, leave as nil to disable
  trashPeripheral = "trashcans:item_trash_can_tile_1",

  -- Optional: a fallback output chest if no merge target exists
  fallbackOutputChest = "metalbarrels:crystal_2",

  -- Brush priority order (best to worst)
  brushes = {
    "ftbunearthed:unbreakable_brush",
    "ftbunearthed:reinforced_brush",
    "minecraft:brush",
    "ftbunearthed:crude_brush"
  },

  -- Food items that can be used in slot 2
  foods = {
    "minecraft:bread",
    "minecraft:cooked_beef",
    "minecraft:cooked_porkchop",
    "minecraft:cooked_chicken",
    "minecraft:apple",
    "minecraft:baked_potato"
  },

  -- Inputs and their outputs (used for balance comparisons).
  -- change this if your modpack has different archaeologist recipes
  inputs = {
    ["minecraft:dirt"] = {
      outputs = {
        "ars_nouveau:blue_archwood_sapling",
        "ars_nouveau:red_archwood_sapling",
        "ars_nouveau:green_archwood_sapling",
        "ars_elemental:yellow_archwood_sapling",
        "ars_nouveau:purple_archwood_sapling",
        "ftb:andesite_pebble",
        "ftb:diorite_pebble",
        "jags:grass_seed"
      }
    },

    ["minecraft:sand"] = {
      outputs = {
        "minecraft:clay_ball",
        "ftbmaterials:copper_chunk",
        "ftbmaterials:silver_chunk",
        "ftbmaterials:nickel_chunk",
        "ftbmaterials:uranium_chunk"
      }
    },

    ["ftbstuff:dust"] = {
      outputs = {
        "minecraft:redstone",
        "ftbmaterials:gold_chunk",
        "ftbmaterials:tin_chunk",
        "minecraft:bone_meal"
      }
    },
},

  -- Balancer thresholds
  scarceLT = 9,      -- <9 scarce
  availLE = 64,      -- 9..64 available
  abundLE = 128,     -- 64..128 abundant
  reserveCount = 8,  -- keep at least this many of the INPUT unprocessed in Case #2

  -- Push/pull parameters
  maxPushPerCycle = 9,         -- conservative push to prevent depleting scarce resources
  maxOutputPullPerCycle = 512, -- cap pulls per loop to avoid huge bursts

  -- Sleep timings
  sleepShort = 2,   -- after any action
  sleepIdle = 5,    -- when nothing to do
  sleepError = 5,   -- on warnings

  -- Logging
  verbose = true,
}

-- =========================
-- ====== UTILITIES ========
-- =========================
local function log(...)
  if CONFIG.verbose then
    local t = {}
    for i = 1, select("#", ...) do t[#t+1] = tostring(select(i, ...)) end
    print(table.concat(t))
  end
end

local function isInv(name)
  if not peripheral.isPresent(name) then return false end
  local m = peripheral.getMethods(name) or {}
  local has = {}
  for _,x in ipairs(m) do has[x] = true end
  return has.list and (has.pushItems or has.pullItems)
end

local function allInventories()
  local out = {}
  for _,n in ipairs(peripheral.getNames()) do
    if isInv(n) then table.insert(out, n) end
  end
  table.sort(out)
  return out
end

local function list(name)
  local ok, res = pcall(function() return peripheral.call(name, "list") end)
  if ok and type(res) == "table" then return res end
  return {}
end
local function getItemDetail(name, slot)
  local ok, d = pcall(function() return peripheral.call(name, "getItemDetail", slot) end)
  if ok then return d end
  return nil
end

local function maxCountFor(name, slot)
  local d = getItemDetail(name, slot)
  if d and d.maxCount then return d.maxCount end
  return 64
end

local function countInInv(name, id)
  local total = 0
  for _, it in pairs(list(name)) do
    if it.name == id then total = total + (it.count or 0) end
  end
  return total
end

local function countAcrossNetwork(id, invs)
  local total = 0
  for _, n in ipairs(invs) do
    total = total + countInInv(n, id)
  end
  return total
end
local function stacksAcrossNetwork(id, invs, exclude)
  local out = {}
  for _, n in ipairs(invs) do
    if n ~= exclude then
      for slot, it in pairs(list(n)) do
        if it.name == id and (it.count or 0) > 0 then
          table.insert(out, { periph = n, slot = slot, count = it.count })
        end
      end
    end
  end
  return out
end

local function invFreeSlots(name)
  local okS, size = pcall(function() return peripheral.call(name, "size") end)
  if not okS or type(size) ~= "number" then return 0 end
  local used = 0
  for _ in pairs(list(name)) do used = used + 1 end
  return math.max(0, size - used)
end

local function canReach(src, dst)
  local ok, err = pcall(function() peripheral.call(src, "pushItems", dst, 1, 0) end)
  if ok then return true end
  local msg = tostring(err or "")
  if msg:find("does not exist") or msg:find("No such peripheral") then return false end
  return true
end

-- Prefer an inventory that already has the item, else fallback chest, else max free slots
local function chooseOutputTarget(itemId, invs, archaeologist, fallback)
  local best, bestCount = nil, -1
  for _, n in ipairs(invs) do
    if n ~= archaeologist then
      local c = countInInv(n, itemId)
      if c > 0 and canReach(archaeologist, n) then
        if c > bestCount then best, bestCount = n, c end
      end
    end
  end
  if best then return best end
  if fallback and fallback ~= archaeologist and canReach(archaeologist, fallback) then return fallback end
  -- else pick most free slots
  local mfName, mf = nil, -1
  for _, n in ipairs(invs) do
    if n ~= archaeologist and canReach(archaeologist, n) then
      local free = invFreeSlots(n)
      if free > mf then mfName, mf = n, free end
    end
  end
  return mfName
end

local function classify(amount)
  if amount < CONFIG.scarceLT then return "scarce"
  elseif amount <= CONFIG.availLE then return "available"
  elseif amount <= CONFIG.abundLE then return "abundant"
  else return "trash" end
end

local function sumCounts(ids, invs)
  local t = 0
  for _, id in ipairs(ids) do
    t = t + countAcrossNetwork(id, invs)
  end
  return t
end

local function outputsStatus(outputs, invs, classifyFn)
  local per = {}
  local allAbundant = true
  local anyBelowAbundant = false
  local anyScarce = false

  for _, oid in ipairs(outputs or {}) do
    local c = countAcrossNetwork(oid, invs)
    local b = classifyFn(c) -- uses CONFIG thresholds
    per[oid] = { count = c, band = b }

    if b == "scarce" or b == "available" then
      anyBelowAbundant = true
    end
    if b == "scarce" then
      anyScarce = true
    end
    if b ~= "abundant" and b ~= "trash" then
      allAbundant = false
    end
  end

  -- If there are no outputs mapped, treat as "unknown" => do not block processing
  if not outputs or #outputs == 0 then
    allAbundant = false
    anyBelowAbundant = true
  end

  return per, allAbundant, anyBelowAbundant, anyScarce
end

-- =========================
-- ===== CORE ACTIONS ======
-- =========================

-- Ensure slot 2 has food if available and slot is empty
local function manageFoodSlot(archaeologist, invs)
  local archList = list(archaeologist)
  local slot2 = archList[2]

  -- If slot 2 is empty or has very little food, try to add more
  if not slot2 or slot2.count < 5 then
    for _, foodId in ipairs(CONFIG.foods) do
      local stacks = stacksAcrossNetwork(foodId, invs, archaeologist)
      for _, st in ipairs(stacks) do
        if st.count > 16 then -- Only use food if we have plenty
          local ok, moved = pcall(function()
            return peripheral.call(st.periph, "pushItems", archaeologist, st.slot, math.min(16, st.count), 2)
          end)
          if ok and moved and moved > 0 then
            log("[FOOD] Added ", moved, " ", foodId, " to slot 2")
            return true
          end
        end
      end
    end
  end
  return false
end

-- Ensure slot 3 has a brush
local function manageBrushSlot(archaeologist, invs)
  local archList = list(archaeologist)
  local slot3 = archList[3]

  -- If slot 3 is empty, find a brush
  if not slot3 then
    for _, brushId in ipairs(CONFIG.brushes) do
      local stacks = stacksAcrossNetwork(brushId, invs, archaeologist)
      for _, st in ipairs(stacks) do
        local ok, moved = pcall(function()
          return peripheral.call(st.periph, "pushItems", archaeologist, st.slot, 1, 3)
        end)
        if ok and moved and moved > 0 then
          log("[BRUSH] Added ", brushId, " to slot 3")
          return true
        end
      end
    end
    log("[WARN] No brush found in inventory!")
    return false
  end
  return true
end

local function pushToArchaeologist(fromStacks, archaeologist, maxToPush)
  local remain = maxToPush
  local movedTotal = 0
  for _, st in ipairs(fromStacks) do
    if remain <= 0 then break end
    local move = math.min(remain, st.count)
    local ok, movedOrErr = pcall(function()
      -- Push to slot 1 (material slot)
      return peripheral.call(st.periph, "pushItems", archaeologist, st.slot, move, 1)
    end)
    if ok and type(movedOrErr) == "number" and movedOrErr > 0 then
      remain = remain - movedOrErr
      movedTotal = movedTotal + movedOrErr
      log("[ARCHAEOLOGIST] Pushed ", movedOrErr, " from ", st.periph, " -> ", archaeologist, " slot 1")
    else
      log("[WARN] push to archaeologist failed from ", st.periph, ": ", tostring(movedOrErr))
    end
  end
  return movedTotal
end

local function pullOutputsFromArchaeologist(archaeologist, invs, inputsSet)
  local lst = list(archaeologist)
  local pulled = 0
  local pulledItems = {}

  -- Only pull from output slots 4-12, avoid disrupting other slots
  for slot = 4, 12 do
    local it = lst[slot]
    if it and it.name then
      local id = it.name
      local isInput = inputsSet[id] == true
      local isBrush = false
      local isFood = false

      -- Check if this is a brush
      for _, brushId in ipairs(CONFIG.brushes) do
        if id == brushId then isBrush = true break end
      end

      -- Check if this is food
      for _, foodId in ipairs(CONFIG.foods) do
        if id == foodId then isFood = true break end
      end

      -- Only move items that are actual outputs (not inputs, brushes, or food)
      if (not isInput) and (not isBrush) and (not isFood) and it.count > 0 then
        local dest = chooseOutputTarget(id, invs, archaeologist, CONFIG.fallbackOutputChest)
        if dest then
          local moved = peripheral.call(archaeologist, "pushItems", dest, slot, it.count)
          if moved and moved > 0 then
            pulled = pulled + moved
            pulledItems[id] = (pulledItems[id] or 0) + moved
            log("[ROUTE] ", id, " x", moved, " from slot ", slot, " -> ", dest)
          end
        else
          log("[WARN] No reachable output destination for ", id, " (holding in archaeologist slot ", slot, " for now)")
        end
      end
    end
  end

  return pulled, pulledItems
end

local function disposeExcessInput(inputId, overAmount, invs, archaeologist, trash)
  if not trash or not peripheral.isPresent(trash) then return 0 end
  if overAmount <= 0 then return 0 end
  local stacks = stacksAcrossNetwork(inputId, invs, archaeologist)
  local remaining = overAmount
  local disposed = 0
  for _, st in ipairs(stacks) do
    if remaining <= 0 then break end
    local move = math.min(remaining, st.count)
    local ok, movedOrErr = pcall(function()
      return peripheral.call(st.periph, "pushItems", trash, st.slot, move)
    end)
    if ok and type(movedOrErr) == "number" and movedOrErr > 0 then
      remaining = remaining - movedOrErr
      disposed = disposed + movedOrErr
      log("[TRASH] ", inputId, " x", movedOrErr, " from ", st.periph, " -> ", trash)
    else
      log("[WARN] Dispose failed from ", st.periph, " -> ", trash, ": ", tostring(movedOrErr))
    end
  end
  return disposed
end

-- =========================
-- ====== MAIN LOOP ========
-- =========================
local function tick()
  local archaeologist = CONFIG.archaeologist
  if not peripheral.isPresent(archaeologist) then
    log("[WARN] Archaeologist not present: ", archaeologist)
    sleep(CONFIG.sleepError)
    return
  end

  local invs = allInventories()
  if #invs == 0 then
    log("[INFO] No inventories on network.")
    sleep(CONFIG.sleepIdle)
    return
  end

  -- Manage food and brush slots first
  manageFoodSlot(archaeologist, invs)
  manageBrushSlot(archaeologist, invs)

  -- Build a set of input IDs for quick checks
  local inputsSet, recipeOrder = {}, {}
  for inputId, _ in pairs(CONFIG.inputs) do
    inputsSet[inputId] = true
    table.insert(recipeOrder, inputId)
  end
  table.sort(recipeOrder)

  local didSomething = false

  for _, inputId in ipairs(recipeOrder) do
    local recipe = CONFIG.inputs[inputId]
    local outputs = recipe.outputs or {}
    local inputCount = countAcrossNetwork(inputId, invs)
    if inputCount <= 0 then
      log("[SKIP] No input found: ", inputId)
      goto continue_input
    end

    local inputBand = classify(inputCount)
    local per, allAbundant, anyBelowAbundant, anyScarce = outputsStatus(outputs, invs, classify)

    -- Debug snapshot
    do
      local dbg = {}
      for oid, st in pairs(per) do
        table.insert(dbg, (oid .. "=" .. st.count .. "(" .. st.band .. ")"))
      end
      table.sort(dbg)
      log(string.format("[EVAL] %s input=%d(%s) | outputs: %s",
        inputId, inputCount, inputBand, table.concat(dbg, ", ")))
    end

    -- Decision rules:

    if inputBand == "scarce" then
      -- Rule: scarce inputs are preserved (don't process)
      log("[HOLD] Scarce input, skipping: ", inputId)

    elseif inputBand == "available" then
      -- Process only if ANY output is SCARCE (not just below abundant)
      if anyScarce then
        local stacks = stacksAcrossNetwork(inputId, invs, archaeologist)
        -- Reserve a floor of input; process only what's above reserve
        local pushBudget = math.max(0, inputCount - CONFIG.reserveCount)
        pushBudget = math.min(pushBudget, CONFIG.maxPushPerCycle)
        if pushBudget > 0 then
          local moved = pushToArchaeologist(stacks, archaeologist, pushBudget)
          if moved > 0 then didSomething = true end
        else
          log("[OK] Reserve intact; nothing to push for ", inputId)
        end
      else
        log("[OK] No scarce outputs; skipping processing for available input ", inputId)
      end
    elseif inputBand == "abundant" then
      -- Continue processing abundant inputs until they reach trash level (>128)
      -- This prevents infinite processing when outputs are abundant but input isn't trash yet
      local stacks = stacksAcrossNetwork(inputId, invs, archaeologist)
      local moved = pushToArchaeologist(stacks, archaeologist, CONFIG.maxPushPerCycle)
      if moved > 0 then didSomething = true end

    else -- inputBand == "trash" (> 128)
      if anyBelowAbundant then
        -- Still need outputs: process rather than dispose
        local stacks = stacksAcrossNetwork(inputId, invs, archaeologist)
        local moved = pushToArchaeologist(stacks, archaeologist, CONFIG.maxPushPerCycle)
        if moved > 0 then didSomething = true end
      else
        -- All outputs abundant: safe to dispose input above 128 if trash is configured
        if CONFIG.trashPeripheral then
          local over = inputCount - CONFIG.abundLE
          if over > 0 then
            local disposed = disposeExcessInput(inputId, over, invs, archaeologist, CONFIG.trashPeripheral)
            if disposed > 0 then didSomething = true end
          else
            log("[OK] No excess to dispose for ", inputId)
          end
        else
          log("[OK] Would dispose excess of ", inputId, " but no trash configured")
        end
      end
    end

    ::continue_input::
  end

  -- After any pushes, pull outputs once to clear machine buffers
  local pulled, pulledItems = pullOutputsFromArchaeologist(archaeologist, invs, inputsSet)
  if pulled > 0 then
    didSomething = true
  end

  if didSomething then
    sleep(CONFIG.sleepShort)
  else
    sleep(CONFIG.sleepIdle)
  end
end

local function main()
  print("Unearther Archaeologist Manager starting...")
  while true do
    tick()
  end
end

main()