shim.lua

--[[ Stash / shim --------------------------------------------------------------

  The bridge between the cache and Blizzard's frames.

  Every function below wraps the real API and only diverts bank containers, and
  only while the offline view is up. Everything else falls straight through, so
  the wrappers are harmless when they are not in use - which also means they can
  be installed once at load and never removed. An error while the view is open
  can therefore never leave the game answering from stale data.

  Because the diversion happens at the API rather than in a window of our own,
  anything that asks the usual questions about bank containers sees the cache:
  Blizzard's BankFrame, and equally any bag addon reading the same functions.

-----------------------------------------------------------------------------]]

Stash.modules.shim = true

local pairs = pairs

-- invSlot -> generic bank slot index, e.g. inventory 40 is bank slot 2
local bankslot_by_inv = {}
-- invSlot -> bank bag container id, e.g. inventory 68 is container 5
local bankbag_by_inv = {}

local function BuildInventoryMaps()
  if BankButtonIDToInvSlotID then
    for slot = 1, (NUM_BANKGENERIC_SLOTS or 24) do
      local inventory = BankButtonIDToInvSlotID(slot)
      if inventory then
        bankslot_by_inv[inventory] = slot
      end
    end
  end

  if ContainerIDToInventoryID then
    for bag = Stash.FIRST_BANK_BAG, Stash.LAST_BANK_BAG do
      local inventory = ContainerIDToInventoryID(bag)
      if inventory then
        bankbag_by_inv[inventory] = bag
      end
    end
  end
end

BuildInventoryMaps()

-- tooltip.lua needs the same lookups
Stash.invmaps = { bankslot = bankslot_by_inv, bankbag = bankbag_by_inv }

-- --------------------------------------------------------------------------
-- predicates
-- --------------------------------------------------------------------------

-- true when a container query should be answered from the cache
function Stash:Serving(bag)
  return Stash.offline and bag and Stash.bankbags[bag] or nil
end

local function ServingUnit(unit)
  return Stash.offline and (unit == "player" or unit == nil)
end

-- --------------------------------------------------------------------------
-- container API
-- --------------------------------------------------------------------------

local origContainerNumSlots = GetContainerNumSlots
function GetContainerNumSlots(bag)
  if Stash:Serving(bag) then
    local container = Stash:GetContainer(bag)
    return container and container.size or 0
  end
  return origContainerNumSlots(bag)
end

local origContainerItemInfo = GetContainerItemInfo
function GetContainerItemInfo(bag, slot)
  if Stash:Serving(bag) then
    local container = Stash:GetContainer(bag)
    local item = container and container.items[slot]
    if not item then
      return nil
    end
    -- texture, count, locked, quality, readable
    return item.texture, item.count, nil, item.quality, nil
  end
  return origContainerItemInfo(bag, slot)
end

local origContainerItemLink = GetContainerItemLink
function GetContainerItemLink(bag, slot)
  if Stash:Serving(bag) then
    local container = Stash:GetContainer(bag)
    local item = container and container.items[slot]
    return item and item.link
  end
  return origContainerItemLink(bag, slot)
end

if GetContainerItemCooldown then
  local origContainerItemCooldown = GetContainerItemCooldown
  function GetContainerItemCooldown(bag, slot)
    if Stash:Serving(bag) then
      return 0, 0, 0
    end
    return origContainerItemCooldown(bag, slot)
  end
end

-- --------------------------------------------------------------------------
-- inventory API
--
-- The 24 bank slots are inventory slots as well as container -1 slots, and
-- Blizzard's own bank buttons read them the inventory way, so both paths have
-- to answer from the same cache.
-- --------------------------------------------------------------------------

-- Resolves an inventory slot to the cached record behind it. Returns the item
-- for a bank slot, or the container for one of the six bag slots.
local function ResolveInventory(slot)
  local bankslot = bankslot_by_inv[slot]
  if bankslot then
    local container = Stash:GetContainer(Stash.BANK_CONTAINER)
    return container and container.items[bankslot], nil
  end

  local bag = bankbag_by_inv[slot]
  if bag then
    return nil, Stash:GetContainer(bag)
  end

  return nil, nil
end

local origInventoryItemTexture = GetInventoryItemTexture
function GetInventoryItemTexture(unit, slot)
  if ServingUnit(unit) then
    local item, container = ResolveInventory(slot)
    if item then
      return item.texture
    end
    if container then
      return container.texture
    end
    if bankslot_by_inv[slot] or bankbag_by_inv[slot] then
      return nil
    end
  end
  return origInventoryItemTexture(unit, slot)
end

local origInventoryItemLink = GetInventoryItemLink
function GetInventoryItemLink(unit, slot)
  if ServingUnit(unit) then
    local item, container = ResolveInventory(slot)
    if item then
      return item.link
    end
    if container then
      return container.link
    end
    if bankslot_by_inv[slot] or bankbag_by_inv[slot] then
      return nil
    end
  end
  return origInventoryItemLink(unit, slot)
end

local origInventoryItemCount = GetInventoryItemCount
function GetInventoryItemCount(unit, slot)
  if ServingUnit(unit) then
    local item, container = ResolveInventory(slot)
    if item then
      return item.count or 1
    end
    if container then
      return container.invcount or 1
    end
    if bankslot_by_inv[slot] or bankbag_by_inv[slot] then
      return 0
    end
  end
  return origInventoryItemCount(unit, slot)
end

if GetInventoryItemCooldown then
  local origInventoryItemCooldown = GetInventoryItemCooldown
  function GetInventoryItemCooldown(unit, slot)
    if ServingUnit(unit) and (bankslot_by_inv[slot] or bankbag_by_inv[slot]) then
      return 0, 0, 0
    end
    return origInventoryItemCooldown(unit, slot)
  end
end

if IsInventoryItemLocked then
  local origIsInventoryItemLocked = IsInventoryItemLocked
  function IsInventoryItemLocked(slot)
    if Stash.offline and (bankslot_by_inv[slot] or bankbag_by_inv[slot]) then
      return nil
    end
    return origIsInventoryItemLocked(slot)
  end
end

-- --------------------------------------------------------------------------
-- bank specific API
-- --------------------------------------------------------------------------

if GetNumBankSlots then
  local origNumBankSlots = GetNumBankSlots
  function GetNumBankSlots()
    if Stash.offline then
      local char = Stash:GetChar(Stash.viewing)
      if char and char.bankslots then
        return char.bankslots, char.bankfull
      end
    end
    return origNumBankSlots()
  end
end

-- Hiding BankFrame runs CloseBankFrame, which talks to the server about a bank
-- the player is not standing at. Swallow it while the offline view is up.
if CloseBankFrame then
  local origCloseBankFrame = CloseBankFrame
  function CloseBankFrame()
    if Stash.offline then
      return
    end
    return origCloseBankFrame()
  end
end

-- Buying bank slots offline would be nonsense, and BankFrame offers the button
-- whenever GetNumBankSlots reports room left.
if PurchaseSlot then
  local origPurchaseSlot = PurchaseSlot
  function PurchaseSlot()
    if Stash.offline then
      Stash:Error("you have to be at a bank to buy slots.")
      return
    end
    return origPurchaseSlot()
  end
end