local Chest = require("storage.chest")
local Storage = {}

function Storage.assumeHomogeneous(names)
  local mappings = {}
  for _,name in ipairs(names) do
    mappings[name] = true
  end
  return mappings
end

function Storage:fromPeripherals(names)
  local obj = {
    count = #names
  }
  for name,homogeneous in names do
    table.insert(obj, Chest:fromPeripheral(name, homogeneous))
  end

  setmetatable(obj, self)
  obj.__index = obj

  return obj
end

function Storage:toSerializable()
  local ser = {
    count = self.count
  }
  for _,chest in ipairs(self) do
    table.insert(ser, chest:toSerializable())
  end

  return ser
end

function Storage:fromSerializable(ser)
  local obj = { count = ser.count }

  for _,chestSer in ipairs(ser) do
    local chest = Chest:fromSerializable(chestSer)
    if chest ~= nil then
        table.insert(obj, chest)
    end
  end
  
  setmetatable(obj, self)
  obj.__index = obj

  return obj
end

function Storage:isAttached(name)
  for index,chest in ipairs(self) do
    if chest:getName() == name then
        return true, chest, index
    end
  end
  return false, nil, nil
end

function Storage:attach(name, homogeneous)
  if self:isAttached(name) then
    return
  end

  table.insert(self, Chest:fromPeripheral(name, homogeneous))
end

function Storage:detach(name)
  local attached, _, index = self:isAttached(name)
  if attached then
    return table.remove(self, index)
  end
  return nil
end

function Storage:find(query)
  local result = {}
  for _,chest in ipairs(self) do
    for _,stack in chest:find(query) do
        table.insert(result, stack)
    end
  end

  return result
end

-- Find all stacks eligible to accept the given query
function Storage:findInsertTargets(query)
  local result = self:find(function(stack) return stack:isEmpty() or stack:matches(query) end)

  -- Insertion should prioritize filling populated stacks
  table.sort(result, function(a, b) return a:getcount() > b:getCount() end)

  return result
end

function Storage:findExtractTargets(query)
    local result = self:find(query)

    -- Extraction should prioritize emptying populated stacks
    table.sort(result, function(a, b) return a:getcount() < b:getCount() end)

    return result
end

return Storage