guildbank.lua

--[[ Stash / guild bank --------------------------------------------------------

  Vanilla 1.12 has no guild bank; it arrived with patch 2.3. Whether this client
  backported one is a runtime question, so everything here is feature detected
  against the standard API and stays dormant when it is missing.

    /stash probe   reports exactly which pieces this client has

  When the API is present the flow mirrors the player bank: capture the tabs
  while the guild bank window is open, then replay them through Blizzard's own
  GuildBankFrame by diverting the same functions it reads.

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

Stash.modules.guildbank = true

local pairs, ipairs = pairs, ipairs
local getn = table.getn

local SLOTS_PER_TAB = 98 -- MAX_GUILDBANK_SLOTS_PER_TAB in 2.3
local QUERYDELAY = 0.6 -- seconds between tab queries, the server rate limits

local queryqueue, capturequeue, nextquery

-- The functions a working guild bank needs, in probe order.
local required = {
  "GetNumGuildBankTabs",
  "GetGuildBankTabInfo",
  "GetGuildBankItemInfo",
  "GetGuildBankItemLink",
  "QueryGuildBankTab",
}

local optional = {
  "GetCurrentGuildBankTab",
  "GetGuildBankMoney",
  "GuildBankFrame",
  "SetCurrentGuildBankTab",
}

-- --------------------------------------------------------------------------
-- detection
-- --------------------------------------------------------------------------

function Stash:HasGuildBank()
  for _, name in ipairs(required) do
    if not getglobal(name) then
      return nil
    end
  end
  return true
end

function Stash:ProbeGuildBank()
  Stash:Print("guild bank support on this client:")

  for _, name in ipairs(required) do
    local present = getglobal(name) and "|cff33ff33yes|r" or "|cffff5555no|r"
    Stash:Print("  " .. name .. ": " .. present)
  end
  for _, name in ipairs(optional) do
    local present = getglobal(name) and "|cff33ff33yes|r" or "|cff888888no|r"
    Stash:Print("  " .. name .. " (optional): " .. present)
  end

  local ui = "|cffff5555no|r"
  if IsAddOnLoaded and GetAddOnInfo and GetAddOnInfo("Blizzard_GuildBankUI") then
    ui = "|cff33ff33present|r"
  end
  Stash:Print("  Blizzard_GuildBankUI: " .. ui)

  if Stash:HasGuildBank() then
    Stash:Print("|cff33ff33guild bank API found - caching is active.|r")
  else
    Stash:Print("|cffff5555no guild bank on this client; that half stays off.|r")
  end
end

-- --------------------------------------------------------------------------
-- storage
-- --------------------------------------------------------------------------

local function GuildKey()
  local guild = GetGuildInfo("player")
  return guild
end

function Stash:GetGuild(name)
  local realm = Stash:GetRealm()
  if not realm then
    return nil
  end
  realm.guilds = realm.guilds or {}
  return realm.guilds[name or Stash.viewingguild or GuildKey()]
end

local function EnsureGuild()
  local realm = Stash:GetRealm()
  local guild = GuildKey()
  if not realm or not guild then
    return nil
  end

  realm.guilds = realm.guilds or {}
  realm.guilds[guild] = realm.guilds[guild] or { tabs = {} }
  return realm.guilds[guild]
end

-- --------------------------------------------------------------------------
-- capture
-- --------------------------------------------------------------------------

function Stash:CaptureGuildTab(tab)
  local store = EnsureGuild()
  if not store then
    return
  end

  local name, icon = GetGuildBankTabInfo(tab)
  local record = { name = name, icon = icon, items = {} }

  for slot = 1, (MAX_GUILDBANK_SLOTS_PER_TAB or SLOTS_PER_TAB) do
    local texture, count = GetGuildBankItemInfo(tab, slot)
    if texture then
      record.items[slot] = {
        texture = texture,
        count = count or 1,
        link = GetGuildBankItemLink(tab, slot),
      }
    end
  end

  store.tabs[tab] = record
  store.updated = time()

  if GetGuildBankMoney then
    store.money = GetGuildBankMoney()
  end

  Stash:Debug("captured guild bank tab " .. tab)
end

-- Tabs have to be asked for one at a time and the answer arrives later, so the
-- queue queries a tab, then reads it back on the following tick.
local function StartCapture()
  local tabs = GetNumGuildBankTabs()
  if not tabs or tabs < 1 then
    return
  end

  queryqueue, capturequeue, nextquery = {}, {}, nil
  for tab = 1, tabs do
    queryqueue[getn(queryqueue) + 1] = tab
  end
end

-- --------------------------------------------------------------------------
-- api diversion
-- --------------------------------------------------------------------------

local function Serving()
  return Stash.gboffline and true or nil
end

if Stash:HasGuildBank() then
  local origNumTabs = GetNumGuildBankTabs
  function GetNumGuildBankTabs()
    if Serving() then
      local store = Stash:GetGuild()
      if store then
        local highest = 0
        for tab in pairs(store.tabs) do
          if tab > highest then
            highest = tab
          end
        end
        return highest
      end
    end
    return origNumTabs()
  end

  local origTabInfo = GetGuildBankTabInfo
  function GetGuildBankTabInfo(tab)
    if Serving() then
      local store = Stash:GetGuild()
      local record = store and store.tabs[tab]
      if record then
        -- name, icon, isViewable, canDeposit, numWithdrawals, remaining
        return record.name, record.icon, 1, nil, 0, 0
      end
      return nil
    end
    return origTabInfo(tab)
  end

  local origItemInfo = GetGuildBankItemInfo
  function GetGuildBankItemInfo(tab, slot)
    if Serving() then
      local store = Stash:GetGuild()
      local record = store and store.tabs[tab]
      local item = record and record.items[slot]
      if not item then
        return nil
      end
      return item.texture, item.count, nil
    end
    return origItemInfo(tab, slot)
  end

  local origItemLink = GetGuildBankItemLink
  function GetGuildBankItemLink(tab, slot)
    if Serving() then
      local store = Stash:GetGuild()
      local record = store and store.tabs[tab]
      local item = record and record.items[slot]
      return item and item.link
    end
    return origItemLink(tab, slot)
  end

  local origQuery = QueryGuildBankTab
  function QueryGuildBankTab(tab)
    if Serving() then
      return
    end
    return origQuery(tab)
  end

  if GetGuildBankMoney then
    local origMoney = GetGuildBankMoney
    function GetGuildBankMoney()
      if Serving() then
        local store = Stash:GetGuild()
        return store and store.money or 0
      end
      return origMoney()
    end
  end
end

-- --------------------------------------------------------------------------
-- viewer
-- --------------------------------------------------------------------------

function Stash:ShowGuildBank()
  if not Stash:HasGuildBank() then
    Stash:Error("this client has no guild bank API - run |cffffcc00/stash probe|r for details.")
    return
  end

  if Stash.atguildbank then
    Stash:Print("you are standing at the guild bank - that is the real thing.")
    return
  end

  local guild = GuildKey()
  if not guild then
    Stash:Error("you are not in a guild.")
    return
  end

  local store = Stash:GetGuild(guild)
  if not store or not next(store.tabs) then
    Stash:Error("nothing cached for " .. guild .. " yet - open the guild bank once.")
    return
  end

  if not IsAddOnLoaded("Blizzard_GuildBankUI") then
    LoadAddOn("Blizzard_GuildBankUI")
  end

  if not GuildBankFrame then
    Stash:Error("the default guild bank frame is missing on this client.")
    return
  end

  if Stash.gboffline and GuildBankFrame:IsShown() then
    HideUIPanel(GuildBankFrame)
    return
  end

  Stash.viewingguild = guild
  Stash.gboffline = true

  if ShowUIPanel then
    ShowUIPanel(GuildBankFrame)
  else
    GuildBankFrame:Show()
  end

  if GuildBankFrame_Update then
    GuildBankFrame_Update()
  end

  Stash:Print(guild .. "'s guild bank, cached copy.")
end

function Stash:EndGuildOffline()
  if not Stash.gboffline then
    return
  end

  Stash.gboffline = nil
  Stash.viewingguild = nil

  if GuildBankFrame and GuildBankFrame:IsShown() and GuildBankFrame_Update then
    GuildBankFrame_Update()
  end
end

-- --------------------------------------------------------------------------
-- events
-- --------------------------------------------------------------------------

if Stash:HasGuildBank() then
  local gb = CreateFrame("Frame")

  -- Registering an event this client does not know about would error, so each
  -- one is attempted on its own.
  for _, name in ipairs({ "GUILDBANKFRAME_OPENED", "GUILDBANKFRAME_CLOSED", "GUILDBANKBAGSLOTS_CHANGED" }) do
    pcall(function()
      gb:RegisterEvent(name)
    end)
  end

  gb:SetScript("OnEvent", function()
    if event == "GUILDBANKFRAME_OPENED" then
      Stash:EndGuildOffline()
      Stash.atguildbank = true
      StartCapture()
    elseif event == "GUILDBANKFRAME_CLOSED" then
      Stash.atguildbank = nil
      queryqueue, capturequeue = nil, nil
    elseif event == "GUILDBANKBAGSLOTS_CHANGED" then
      if Stash.atguildbank and GetCurrentGuildBankTab then
        local tab = GetCurrentGuildBankTab()
        if tab and tab > 0 then
          Stash:CaptureGuildTab(tab)
        end
      end
    end
  end)

  gb:SetScript("OnUpdate", function()
    if not Stash.atguildbank or not queryqueue then
      return
    end

    local now = GetTime()
    if nextquery and now < nextquery then
      return
    end
    nextquery = now + QUERYDELAY

    -- read back whatever was asked for last tick
    if capturequeue and getn(capturequeue) > 0 then
      local tab = table.remove(capturequeue, 1)
      Stash:CaptureGuildTab(tab)
    end

    if getn(queryqueue) > 0 then
      local tab = table.remove(queryqueue, 1)
      QueryGuildBankTab(tab)
      capturequeue[getn(capturequeue) + 1] = tab
    end
  end)

  if GuildBankFrame then
    local origOnHide = GuildBankFrame:GetScript("OnHide")
    GuildBankFrame:SetScript("OnHide", function()
      if origOnHide then
        origOnHide()
      end
      Stash:EndGuildOffline()
    end)
  end
end