Minecraft ComputerCraft SifterManager

--
-- Desc: A sifter manager program for FTB Skies 2
-- Indexes primary inventory and attempts to balance sifter inputs/outputs
-- simplifies setup because modem can connect directly to sifter inventory
-- outputs are returned to chests that already contain them by default
-- IMPORTANT!: as you connect modems to sifters/chests, update the config to match
-- their names, or this will not work correctly.
--

-- By: hornedcommando

-- =========================
-- ========== CONFIG =======
-- =========================
local CONFIG = {
  -- Your sifter peripheral name
  sifter = "createsifter:sifter_0",

  -- 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 = "sophisticatedstorage:chest_7",

  -- Inputs and their outputs (used for balance comparisons).
  -- change this if your modpack has different sifter recipes
  inputs = {
    ["ftbstuff:crushed_netherrack"] = {
      outputs = {
        "mysticalagriculture:soulium_dust",
        "minecraft:glowstone_dust",
        "minecraft:quartz",
        "ftbmaterials:quartz_dust",
        "ftbmaterials:dust_sulfur",
        "actuallyadditions:black_quartz",
        "minecraft:blaze_powder",
      }
    },

    ["minecraft:gravel"] = {
      outputs = {
        "ftbmaterials:iron_chunk",
        "ftbmaterials:copper_chunk",
        "minecraft:coal",
        "ftbmaterials:lapis_lazuli_chunk",
        "ftbmaterials:lead_chunk",
        "ftbmaterials:aluminum_chunk",
        "ftbmaterials:tin_chunk",
        "ftbmaterials:osmium_chunk",
        "ftbmaterials:emerald_chunk",
        "ftbmaterials:diamond_chunk",
      }
    },

    ["minecraft:sand"] = {
      outputs = {
        "ftbmaterials:copper_chunk",
        "ftbmaterials:iron_chunk",
        "ftbmaterials:aluminum_chunk",
        "ftbmaterials:gold_chunk",
        "ftbmaterials:silver_chunk",
        "ftbmaterials:nickel_chunk",
        "ftbmaterials:osmium_chunk",
        "ftbmaterials:lead_chunk",
        "ftbmaterials:tin_chunk",
        "mysticalagriculture:prosperity_shard",
      }
    },

    ["minecraft:red_sand"] = {
      outputs = {
        "ftbmaterials:copper_chunk",
        "ftbmaterials:iron_chunk",
        "ftbmaterials:aluminum_chunk",
        "ftbmaterials:gold_chunk",
        "ftbmaterials:silver_chunk",
        "ftbmaterials:nickel_chunk",
        "ftbmaterials:osmium_chunk",
        "ftbmaterials:lead_chunk",
        "ftbmaterials:tin_chunk",
        "mysticalagriculture:prosperity_shard",
      }
    },

    ["ftb:crushed_kivi"] = {
      outputs = {
        "xycraft_world:xychorium_gem_light",
        "xycraft_world:xychorium_gem_dark",
        "xycraft_world:xychorium_gem_blue",
        "xycraft_world:xychorium_gem_green",
        "xycraft_world:xychorium_gem_red",
      }
    },

    ["ftbstuff:crushed_basalt"] = {
      outputs = {
        "minecraft:netherrack",
        "ftbmaterials:dust_sulfur",
        "mekanism:dirty_netherite_scrap",
      }
    },

    ["ftbstuff:dust"] = {
      outputs = {
        "minecraft:bone_meal",
        "ftbmaterials:niter_dust",
        "minecraft:gunpowder",
        "ftbmaterials:redstone_chunk",
        "ftbmaterials:gold_chunk",
        "ftbmaterials:bauxite_dust",
        "ftbmaterials:silver_chunk",
        "ftbmaterials:nickel_chunk",
        "minecraft:redstone",
        "ftbmaterials:aluminum_dust",
        "minecraft:gold_ingot",
        "ftbmaterials:silver_ingot",
        "ftbmaterials:nickel_ingot",
      }
    },
  },

  -- 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 = 64,        -- don't overfill in one tick
  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, sifter, fallback)
  local best, bestCount = nil, -1
  for _, n in ipairs(invs) do
    if n ~= sifter then
      local c = countInInv(n, itemId)
      if c > 0 and canReach(sifter, n) then
        if c > bestCount then best, bestCount = n, c end
      end
    end
  end
  if best then return best end
  if fallback and fallback ~= sifter and canReach(sifter, fallback) then return fallback end
  -- else pick most free slots
  local mfName, mf = nil, -1
  for _, n in ipairs(invs) do
    if n ~= sifter and canReach(sifter, 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 ======
-- =========================
local function pushToSifter(fromStacks, sifter, 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()
      -- No toSlot: let the sifter route to valid input
      return peripheral.call(st.periph, "pushItems", sifter, st.slot, move)
    end)
    if ok and type(movedOrErr) == "number" and movedOrErr > 0 then
      remain = remain - movedOrErr
      movedTotal = movedTotal + movedOrErr
      log("[SIFTER] Pushed ", movedOrErr, " from ", st.periph, " -> ", sifter)
    else
      log("[WARN] push to sifter failed from ", st.periph, ": ", tostring(movedOrErr))
    end
  end
  return movedTotal
end

local function pullOutputsFromSifter(sifter, invs, inputsSet)
  local lst = list(sifter)
  local pulled = 0
  local pulledItems = {}

  for slot, it in pairs(lst) do
    if it and it.name then
      local id = it.name
      local isInput = inputsSet[id] == true
      local looksLikeMesh = string.find(id, "mesh", 1, true) ~= nil

      if (not isInput) and (not looksLikeMesh) and it.count > 0 then
        local dest = chooseOutputTarget(id, invs, sifter, CONFIG.fallbackOutputChest)
        if dest then
          local moved = peripheral.call(sifter, "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, " -> ", dest)
          end
        else
          log("[WARN] No reachable output destination for ", id, " (holding in sifter for now)")
        end
      end
    end
  end

  return pulled, pulledItems
end

local function disposeExcessInput(inputId, overAmount, invs, sifter, 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, sifter)
  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 sifter = CONFIG.sifter
  if not peripheral.isPresent(sifter) then
    log("[WARN] Sifter not present: ", sifter)
    sleep(CONFIG.sleepError)
    return
  end

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

  -- 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 = 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 below abundant
      if anyBelowAbundant then
        local stacks = stacksAcrossNetwork(inputId, invs, sifter)
        -- 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 = pushToSifter(stacks, sifter, pushBudget)
          if moved > 0 then didSomething = true end
        else
          log("[OK] Reserve intact; nothing to push for ", inputId)
        end
      else
        log("[OK] All outputs already abundant; skipping processing for ", inputId)
      end
    elseif inputBand == "abundant" then
      -- Process if ANY output is below abundant; otherwise skip
      if anyBelowAbundant then
        local stacks = stacksAcrossNetwork(inputId, invs, sifter)
        local moved = pushToSifter(stacks, sifter, CONFIG.maxPushPerCycle)
        if moved > 0 then didSomething = true end
      else
        log("[OK] All outputs abundant; nothing to process for ", inputId)
      end

    else -- inputBand == "trash" (> 128)
      if anyBelowAbundant then
        -- Still need outputs: process rather than dispose
        local stacks = stacksAcrossNetwork(inputId, invs, sifter)
        local moved = pushToSifter(stacks, sifter, 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, sifter, 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 = pullOutputsFromSifter(sifter, 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("Sifter Manager starting...")
  while true do
    tick()
  end
end

main()