viewer.lua

--[[ Stash / viewer ------------------------------------------------------------

  Turns the cached view on and off.

  The window itself belongs to whichever backend is active (see backends.lua) -
  Blizzard's BankFrame, Bagnon's Banknon, or anything else registered. This file
  only decides what to show, asks the backend to open it, and makes sure leaving
  the window leaves the cached view.

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

Stash.modules.viewer = true

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

-- Other addons can register here to find out when the cached view opens or
-- closes, e.g. to repaint a frame that caches item data itself.
Stash.callbacks = {}

local function Fire(state)
  for _, callback in ipairs(Stash.callbacks) do
    callback(state, Stash.viewing)
  end
end

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

-- Case insensitive so "/stash bank ana" finds "Ana".
local function ResolveName(name)
  if not name or name == "" then
    return UnitName("player")
  end

  for _, candidate in ipairs(Stash:GetCharNames()) do
    if string.lower(candidate) == string.lower(name) then
      return candidate
    end
  end

  return nil
end

local function Ago(stamp)
  if not stamp then
    return "unknown"
  end

  local seconds = time() - stamp
  if seconds < 120 then
    return "just now"
  elseif seconds < 7200 then
    return math.floor(seconds / 60) .. " minutes ago"
  elseif seconds < 172800 then
    return math.floor(seconds / 3600) .. " hours ago"
  end
  return math.floor(seconds / 86400) .. " days ago"
end

-- --------------------------------------------------------------------------
-- repaint (Blizzard backend)
-- --------------------------------------------------------------------------

-- How many buttons the bank window actually has. Counting them beats trusting
-- a constant: this client draws 28 item buttons and 7 bag buttons where stock
-- 1.12 has 24 and 6.
local function CountButtons(prefix, fallback)
  local found = 0
  while getglobal(prefix .. (found + 1)) do
    found = found + 1
    if found > 64 then
      break
    end
  end
  return found > 0 and found or fallback
end

-- Paints one bank button from a texture and a stack size.
--
-- BankFrameItemButton_Update would normally do this, but it cannot be relied on
-- here: it does not exist on every 1.12 derived client, and a guarded call that
-- silently does nothing leaves whatever the buttons last had on them. That is
-- invisible right after a real bank visit, when the buttons are already painted,
-- and shows up as an empty window on a fresh login. So the icon and the count
-- are set directly, using the <name>IconTexture / <name>Count anatomy every
-- other bag addon on this client relies on.
local function PaintButton(name, texture, count)
  local icon = getglobal(name .. "IconTexture")
  if icon then
    if texture then
      icon:SetTexture(texture)
      icon:Show()
    else
      icon:SetTexture(nil)
      icon:Hide()
    end
  end

  local text = getglobal(name .. "Count")
  if text then
    if count and count > 1 then
      text:SetText(count)
      text:Show()
    else
      text:SetText("")
      text:Hide()
    end
  end
end

function Stash:RefreshBankFrame()
  if not BankFrame or not BankFrame:IsShown() then
    return
  end

  local slots = GetContainerNumSlots(Stash.BANK_CONTAINER) or 0

  -- Both reads below go through the wrappers in shim.lua, so this paints the
  -- cache while the cached view is up and the live bank the rest of the time.
  for slot = 1, CountButtons("BankFrameItem", NUM_BANKGENERIC_SLOTS or 24) do
    local name = "BankFrameItem" .. slot
    local button = getglobal(name)

    if button then
      if BankFrameItemButton_Update then
        pcall(BankFrameItemButton_Update, button)
      end

      local texture, count
      if slot <= slots then
        texture, count = GetContainerItemInfo(Stash.BANK_CONTAINER, slot)
      end
      PaintButton(name, texture, count)
    end
  end

  for index = 1, CountButtons("BankFrameBag", NUM_BANKBAGSLOTS or 6) do
    local name = "BankFrameBag" .. index
    local button = getglobal(name)

    if button then
      if BankFrameItemButton_Update then
        pcall(BankFrameItemButton_Update, button)
      end

      local bag = Stash.FIRST_BANK_BAG + index - 1
      local inventory = ContainerIDToInventoryID and ContainerIDToInventoryID(bag)
      PaintButton(name, inventory and GetInventoryItemTexture("player", inventory), nil)
    end
  end

  if UpdateBagSlotStatus then
    pcall(UpdateBagSlotStatus)
  end

  if BankFrame_UpdateCooldowns then
    pcall(BankFrame_UpdateCooldowns)
  end

  -- Say whose bank this is, and that it is a copy rather than the real thing.
  if BankFrameTitleText then
    if Stash.viewing then
      BankFrameTitleText:SetText(Stash.viewing .. " |cffffcc00(cached)|r")
    else
      BankFrameTitleText:SetText(UnitName("player"))
    end
  end
end

-- --------------------------------------------------------------------------
-- the cached view
-- --------------------------------------------------------------------------

-- backends.lua is a separate file, and vanilla only enumerates an addon's files
-- when the client starts: a newly added one is missing until a full restart,
-- even though /reload brings back the edited ones. Rather than blowing up on a
-- half loaded addon, fall back to Blizzard's frame and say what happened.
local warned

local function FallbackBackend()
  if not warned then
    Stash:Error("backends.lua is not loaded, falling back to the default bank window.")
    Stash:Error("exit the game completely and start it again - /reload does not pick up newly added addon files.")
    warned = true
  end

  if not BankFrame then
    return nil
  end

  Stash:HookClose(BankFrame)

  return {
    name = "blizzard",
    label = "Blizzard BankFrame",
    isopen = function()
      return BankFrame:IsShown() and true or nil
    end,
    open = function()
      if ShowUIPanel then
        ShowUIPanel(BankFrame)
      else
        BankFrame:Show()
      end
    end,
    close = function()
      if HideUIPanel then
        HideUIPanel(BankFrame)
      else
        BankFrame:Hide()
      end
    end,
    refresh = function()
      Stash:RefreshBankFrame()
    end,
  }
end

function Stash:ShowBank(name)
  if Stash:AtBank() then
    Stash:Print("you are standing at your bank - that is the real thing.")
    return
  end

  local backend
  if Stash.GetBackend then
    backend = Stash:GetBackend()
  else
    backend = FallbackBackend()
  end

  if not backend then
    Stash:Error("no bank window available on this client.")
    return
  end

  -- clicking again closes it
  if Stash.viewing and backend.isopen() then
    backend.close()
    return
  end

  local target = ResolveName(name)
  if not target then
    Stash:Error("no character called '" .. name .. "'. Try |cffffcc00/stash list|r.")
    return
  end

  local char = Stash:GetChar(target)
  if not char or not char.containers or not char.containers[Stash.BANK_CONTAINER] then
    Stash:Error("nothing cached for " .. target .. " yet - open a bank once on that character.")
    return
  end

  Stash.viewing = target
  Stash.backend = backend

  -- A backend with its own cache shows that; diverting the API underneath it
  -- would only give the screen two disagreeing sources.
  Stash.offline = not backend.ownscache and true or nil

  -- The frame may belong to an addon that was not loaded at PLAYER_LOGIN.
  if backend.install then
    backend.install()
  end

  backend.open()

  if backend.refresh then
    backend.refresh()
  end

  Fire("open")

  if backend.ownscache then
    Stash:Print(backend.label .. " keeps its own copy of the bank - showing that.")
  else
    local items = Stash:CountItems(target)
    Stash:Print(target .. "'s bank: |cff33ff33" .. items .. "|r items, saved " .. Ago(char.updated) .. ".")
  end
end

-- Leaves the cached view. Never closes the window itself - it is called from
-- the window's own OnHide, and from BANKFRAME_OPENED when a real bank arrives.
function Stash:EndOffline()
  if not Stash.viewing then
    return
  end

  local backend = Stash.backend

  Stash.offline = nil
  Stash.viewing = nil
  Stash.backend = nil

  if backend and backend.refresh then
    backend.refresh()
  end

  Fire("close")
end