core.lua

--[[ Stash --------------------------------------------------------------------

  Remembers what is in your bank (and guild bank, where the client has one) so
  you can look at it from anywhere.

  Nothing here draws a bank. The cached contents are poured into whichever bank
  window you already use - Blizzard's BankFrame, Bagnon's Banknon, anything else
  registered as a backend - so the cached bank looks exactly like the real one.

  For windows that have no cache of their own, the data reaches them by wrapping
  the container and inventory API: while the cached view is up,
  GetContainerItemInfo and friends answer from the cache for bank containers.
  Any bag addon asking the usual questions therefore sees it too.

  Files
    core.lua       saved variables, shared helpers, slash commands
    cache.lua      captures the bank when it is opened, changed and closed
    shim.lua       the container/inventory API wrappers
    tooltip.lua    the same for GameTooltip, which reads slots inside the client
    backends.lua   the bank windows that can be opened, and picking between them
    viewer.lua     turns the cached view on and off
    guildbank.lua  the same for the guild bank, if this client has one
    minimap.lua    the button

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

Stash = {}

-- Every file registers itself here. Vanilla only enumerates an addon's files
-- when the client starts, so a newly added file stays missing until a full
-- restart even though /reload brings back the edited ones. Checking at login
-- turns that silent half-load into a message that says what to do.
Stash.modules = {}
Stash.required = { "cache", "shim", "tooltip", "backends", "viewer", "minimap" }

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

Stash.version = "1.0.1"

-- Containers that make up the bank. -1 is the bank window itself, and the
-- purchasable bank bags follow it starting at 5.
--
-- Stock 1.12 has six of them, but derived clients do not all agree - this one
-- draws seven bag buttons. FrameXML is loaded before addons, so counting the
-- buttons the client actually has is more reliable than trusting a constant.
Stash.BANK_CONTAINER = -1
Stash.FIRST_BANK_BAG = 5

local function CountBankBags()
  local buttons = 0
  while getglobal("BankFrameBag" .. (buttons + 1)) do
    buttons = buttons + 1
    if buttons > 24 then
      break
    end
  end

  local declared = NUM_BANKBAGSLOTS or 0
  local count = buttons > declared and buttons or declared

  return count > 0 and count or 6
end

Stash.NUM_BANK_BAGS = CountBankBags()
Stash.LAST_BANK_BAG = Stash.FIRST_BANK_BAG + Stash.NUM_BANK_BAGS - 1

Stash.bankbags = { [Stash.BANK_CONTAINER] = true }
for bag = Stash.FIRST_BANK_BAG, Stash.LAST_BANK_BAG do
  Stash.bankbags[bag] = true
end

-- --------------------------------------------------------------------------
-- saved variables
-- --------------------------------------------------------------------------

local DBVERSION = 1

function Stash:InitDB()
  if not StashDB or StashDB.version ~= DBVERSION then
    StashDB = { version = DBVERSION, realms = {} }
  end

  -- There is no player unit yet while addons are loading, so both of these can
  -- come back nil at ADDON_LOADED. Indexing a table with nil is an error, so
  -- leave the database alone and let the PLAYER_LOGIN pass finish the job.
  local realm = GetRealmName()
  local player = UnitName("player")
  if not realm or realm == "" or not player or player == "" then
    return nil
  end

  StashDB.realms[realm] = StashDB.realms[realm] or { chars = {}, guilds = {} }

  local chars = StashDB.realms[realm].chars
  if not chars[player] then
    chars[player] = { containers = {} }
  end

  local _, class = UnitClass("player")
  chars[player].class = class

  return chars[player]
end

function Stash:GetRealm()
  local realm = GetRealmName()
  return StashDB and StashDB.realms and StashDB.realms[realm]
end

-- The cache entry for a character, defaulting to the one that is logged in.
function Stash:GetChar(name)
  local realm = Stash:GetRealm()
  if not realm then
    return nil
  end
  return realm.chars[name or UnitName("player")]
end

function Stash:GetCharNames()
  local names = {}
  local realm = Stash:GetRealm()

  if realm then
    for name in pairs(realm.chars) do
      names[getn(names) + 1] = name
    end
    sort(names)
  end

  return names
end

-- --------------------------------------------------------------------------
-- output
-- --------------------------------------------------------------------------

function Stash:Print(msg)
  DEFAULT_CHAT_FRAME:AddMessage("|cffffcc00Stash|r: " .. msg)
end

function Stash:Error(msg)
  DEFAULT_CHAT_FRAME:AddMessage("|cffffcc00Stash|r: |cffff5555" .. msg .. "|r")
end

-- --------------------------------------------------------------------------
-- helpers
-- --------------------------------------------------------------------------

-- true while the player is standing at a real bank
function Stash:AtBank()
  return Stash.atbank and true or nil
end

-- The cached container record for a bank bag, or nil when nothing is stored.
function Stash:GetContainer(bag, name)
  local char = Stash:GetChar(name or Stash.viewing)
  if not char or not char.containers then
    return nil
  end
  return char.containers[bag]
end

function Stash:CountItems(name)
  local char = Stash:GetChar(name)
  if not char or not char.containers then
    return 0, 0
  end

  local items, slots = 0, 0
  for _, container in pairs(char.containers) do
    slots = slots + (container.size or 0)
    for _ in pairs(container.items or {}) do
      items = items + 1
    end
  end

  return items, slots
end

-- Chains a frame's OnHide so leaving the window leaves the cached view too.
-- 1.12 has no HookScript, so the old handler is called by hand. Lives here
-- rather than in backends.lua because the fallback path needs it too.
function Stash:HookClose(frame)
  if not frame or frame.stashhooked then
    return
  end

  local orig = frame:GetScript("OnHide")
  frame:SetScript("OnHide", function()
    if orig then
      orig()
    end
    Stash:EndOffline()
  end)

  frame.stashhooked = true
end

function Stash:CheckModules()
  local missing = {}
  for _, name in ipairs(Stash.required) do
    if not Stash.modules[name] then
      missing[getn(missing) + 1] = name .. ".lua"
    end
  end

  if getn(missing) > 0 then
    Stash:Error("these files did not load: " .. table.concat(missing, ", "))
    Stash:Error("exit the game completely and start it again - /reload does not pick up newly added addon files.")
  end

  return getn(missing) == 0
end

-- --------------------------------------------------------------------------
-- slash commands
-- --------------------------------------------------------------------------

SLASH_STASH1 = "/stash"
SlashCmdList["STASH"] = function(msg)
  msg = string.lower(msg or "")
  local _, _, cmd, rest = string.find(msg, "^(%a*)%s*(.*)$")

  if cmd == "" or cmd == "bank" then
    Stash:ShowBank(rest ~= "" and rest or nil)
  elseif cmd == "guild" then
    Stash:ShowGuildBank()
  elseif cmd == "list" then
    local names = Stash:GetCharNames()
    if getn(names) == 0 then
      Stash:Print("nothing cached yet - visit a bank once.")
    end
    for _, name in ipairs(names) do
      local items, slots = Stash:CountItems(name)
      Stash:Print(name .. ": |cff33ff33" .. items .. "|r items in " .. slots .. " slots")
    end
  elseif cmd == "ui" then
    Stash:SetBackendCommand(rest)
  elseif cmd == "probe" then
    Stash:ProbeGuildBank()
  elseif cmd == "reset" then
    StashDB = nil
    Stash:InitDB()
    Stash:Print("cache cleared.")
  else
    Stash:Print("commands:")
    Stash:Print("  |cffffcc00/stash|r - show your cached bank")
    Stash:Print("  |cffffcc00/stash bank <name>|r - show another character's cached bank")
    Stash:Print("  |cffffcc00/stash guild|r - show the cached guild bank")
    Stash:Print("  |cffffcc00/stash list|r - what is cached")
    Stash:Print("  |cffffcc00/stash ui|r - choose which bank window to open")
    Stash:Print("  |cffffcc00/stash probe|r - report this client's guild bank support")
    Stash:Print("  |cffffcc00/stash reset|r - wipe the cache")
  end
end

-- Picks which bag addon's bank window the cached view uses. With no argument
-- it reports what is available and which one is in use.
function Stash:SetBackendCommand(name)
  local current = Stash:GetBackend()

  if name == "" then
    Stash:Print("bank window: |cff33ff33" .. (current and current.label or "none") .. "|r"
      .. (StashDB.ui and " (pinned)" or " (auto)"))
    for _, available in ipairs(Stash:ListBackends()) do
      local backend = Stash.backends[available]
      local state = backend.detect() and "|cff33ff33loaded|r" or "|cff888888not loaded|r"
      Stash:Print("  |cffffcc00" .. available .. "|r - " .. backend.label .. ", " .. state)
    end
    Stash:Print("use |cffffcc00/stash ui <name>|r, or |cffffcc00/stash ui auto|r to pick automatically.")
    return
  end

  if name == "auto" then
    StashDB.ui = nil
    local picked = Stash:GetBackend()
    Stash:Print("bank window: automatic (" .. (picked and picked.label or "none") .. ").")
    return
  end

  if not Stash.backends[name] then
    Stash:Error("no bank window called '" .. name .. "'. Try |cffffcc00/stash ui|r.")
    return
  end

  StashDB.ui = name
  Stash:Print("bank window pinned to " .. Stash.backends[name].label .. ".")

  if not Stash.backends[name].detect() then
    Stash:Print("|cffff5555that addon is not loaded right now; falling back until it is.|r")
  end
end

-- --------------------------------------------------------------------------
-- init
-- --------------------------------------------------------------------------

local init = CreateFrame("Frame")
init:RegisterEvent("ADDON_LOADED")
init:RegisterEvent("PLAYER_LOGIN")
init:SetScript("OnEvent", function()
  if event == "ADDON_LOADED" and arg1 ~= "Stash" then
    return
  end

  Stash:InitDB()

  if event == "PLAYER_LOGIN" then
    Stash:CaptureMoney()
    Stash:CheckModules()
  end
end)