Module:Shop

Documentation for this module may be created at Module:Shop/doc

local p = {}

local ShopData = mw.loadData('Module:Shop/data')

local Shared = require('Module:Shared')
local Items = require('Module:Items')
local Icons = require('Module:Icons')
local Constants = require('Module:Constants')
local Areas = require('Module:CombatAreas')

--Cape of Completion is a special purchase that has to be spoofed since it's not in the code
function p.getCapeOfCompletionPurchase()
  local item = Items.getItem('Cape of Completion')

  local purchase = { category = 'Skillcape', id = -1}
  purchase.name = 'Cape of Completion'
  purchase.description = item.description
  purchase.cost = {gp = item.buysFor}
  purchase.unlockRequirements = {text = '100% Completion Log', items = {}}
  purchase.contains = {items = {{item.id, 1}}}

  return purchase
end

function p.processPurchase(category, purchaseID)
  local purchase = Shared.clone(ShopData.Shop[category][purchaseID + 1])
  purchase.id = purchaseID
  purchase.category = category
  return purchase
end

function p.getCostString(cost)
  local costArray = {}
  if cost.gp ~= nil and cost.gp > 0 then
    table.insert(costArray, Icons.GP(cost.gp))
  end
  if cost.slayerCoins ~= nil and cost.slayerCoins > 0 then
    table.insert(costArray, Icons.SC(cost.slayerCoins))
  end
  local itemArray = {}
  if cost.items ~= nil then
    for i, itemCost in Shared.skpairs(cost.items) do
      local item = Items.getItemByID(itemCost[1])
      table.insert(itemArray, Icons.Icon({item.name, type="item", notext=true, qty=itemCost[2]}))
    end

    if Shared.tableCount(itemArray) > 0 then
      table.insert(costArray, table.concat(itemArray, ", "))
    end
  end

  return table.concat(costArray, "<br/>")
end

function p.getRequirementString(reqs)
  if reqs == nil or Shared.tableCount(reqs) == 0 then
    return "None"
  end

  local reqArray = {}
  if reqs.slayerTaskCompletion ~= nil then
    for i, taskReq in Shared.skpairs(reqs.slayerTaskCompletion) do
      local tierName = Constants.getSlayerTierName(taskReq[1])
      table.insert(reqArray, 'Complete '..taskReq[2]..' '..tierName..' Slayer Tasks')
    end
  end

  if reqs.dungeonCompletion ~= nil then
    for i, dungReq in Shared.skpairs(reqs.dungeonCompletion) do
      local dung = Areas.getAreaByID('dungeon', dungReq[1])
      local dungStr = 'Complete '..Icons.Icon({dung.name, type='dungeon'})
      if dungReq[2] > 1 then
        dungStr = dungStr..' '..dungReq[2]..' times'
      end
      table.insert(reqArray, dungStr)
    end
  end

  if reqs.skillLevel ~= nil then
    for i, skillReq in Shared.skpairs(reqs.skillLevel) do
      local skillName = Constants.getSkillName(skillReq[1])
      table.insert(reqArray, Icons._SkillReq(skillName, skillReq[2]))
    end
  end

  if reqs.shopItemPurchased ~= nil then
    for i, shopReq in Shared.skpairs(reqs.shopItemPurchased) do
      local purchase = ShopData.Shop[shopReq[1]][shopReq[2] + 1]
      local isUpgrade = purchase.contains.items == nil or Shared.tableCount(purchase.contains.items) == 0
      table.insert(reqArray, Icons.Icon({purchase.name, type=(isUpgrade and 'upgrade' or 'item')})..' Purchased')
    end
  end

  if reqs.text ~= nil then
    table.insert(reqArray, reqs.text)
  end

  return table.concat(reqArray, '<br/>')
end

function p._getShopTable(Purchases)
  local result = '{| class="wikitable sortable stickyHeader"'
  result = result..'\r\n|- class="headerRow-0"'
  result = result..'\r\n!colspan="2"|Purchase!!Type!!Description!!style="min-width:100"|Cost!!Requirements'

  for i, purchase in Shared.skpairs(Purchases) do
    result = result..'\r\n|-\r\n|'

    local isUpgrade = purchase.contains.items == nil or Shared.tableCount(purchase.contains.items) == 0
    local isBundle = purchase.contains.items ~= nil and Shared.tableCount(purchase.contains.items) > 1
    local iconTxt = purchase.name
    result = result..Icons.Icon({purchase.name, type=(isUpgrade and 'upgrade' or 'item'), notext=true, size='50'})
    result = result..'||'..purchase.name..'||'
    if isUpgrade then
      result = result..'Upgrade'
    elseif isBundle then
      result = result..'Item Bundle'
    else
      result = result..'Item'
    end

    result = result..'||'..purchase.description..'||style="text-align:right;"'
    if purchase.cost.gp ~= nil and purchase.cost.gp > 0 then
      result = result..' data-sort-value="'..purchase.cost.gp..'"'
    elseif purchase.cost.slayerCoins ~= nil and purchase.cost.slayerCoins > 0 then
      result = result..' data-sort-value="'..purchase.cost.slayerCoins..'"'
    end
    result = result..'|'..p.getCostString(purchase.cost)..'||'..p.getRequirementString(purchase.unlockRequirements)
  end

  result = result..'\r\n|}'
  return result
end

function p.getShopTable(frame)
  local cat = frame.args ~= nil and frame.args[1] or frame
  local shopCat = ShopData.Shop[cat]
  if shopCat == nil then
    return 'ERROR: Invalid category '..cat..'[[Category:Pages with script errors]]'
  else
    return p._getShopTable(shopCat)
  end
end

function p.getItemCostArray(itemID)
  local purchaseArray = {}

  for catName, cat in Shared.skpairs(ShopData.Shop) do
    for j, purchase in Shared.skpairs(cat) do
      if purchase.cost.items ~= nil then
        for k, costLine in Shared.skpairs(purchase.cost.items) do
          if costLine[1] == itemID then
            table.insert(purchaseArray, p.processPurchase(catName, j - 1))
            break
          end
        end
      end
    end
  end

  return purchaseArray
end

function p.getItemSourceArray(itemID)
  local purchaseArray = {}

  for catName, cat in Shared.skpairs(ShopData.Shop) do
    for j, purchase in Shared.skpairs(cat) do
      if purchase.contains.items ~= nil and purchase.contains.items ~= nil then
        for k, containsLine in Shared.skpairs(purchase.contains.items) do
          if containsLine [1] == itemID then
            table.insert(purchaseArray, p.processPurchase(catName, j - 1))
            break
          end
        end
      end
    end
  end

  if itemID == 903 then --Special Cape of Completion thing
    table.insert(purchaseArray, p.getCapeOfCompletionPurchase())
  end

  return purchaseArray
end

function p._getPurchaseTable(purchase)
  local result = '{| class="wikitable"\r\n|-'
  result = result..'\r\n!colspan="2"|[[Shop]] Purchase'
  if purchase.contains.items ~= nil and Shared.tableCount(purchase.contains.items) > 1 then
    result = result..' - '..Icons.Icon({purchase.name, type='item'})
  end

  result = result..'\r\n|-\r\n!style="text-align:right;"|Cost'
  result = result..'\r\n|'..p.getCostString(purchase.cost)

  result = result..'\r\n|-\r\n!style="text-align:right;"|Requirements'
  result = result..'\r\n|'..p.getRequirementString(purchase.unlockRequirements)

  result = result..'\r\n|-\r\n!style="text-align:right;"|Contains'
  local containArray = {}
  if purchase.contains.items ~= nil then
    for i, itemLine in Shared.skpairs(purchase.contains.items) do
      local item = Items.getItemByID(itemLine[1])
      table.insert(containArray, Icons.Icon({item.name, type='item', qty=itemLine[2]}))
    end
  end
  if purchase.charges ~= nil and purchase.charges > 0 then
    table.insert(containArray, '+'..purchase.charges..' '..Icons.Icon({purchase.name, type='item'})..' Charges')
  end
  result = result..'\r\n|style="text-align:right;"|'..table.concat(containArray, '<br/>')

  result = result..'\r\n|}'
  return result
end

function p._getItemShopTable(item)
  local tableArray = {}
  local purchaseArray = p.getItemSourceArray(item.id)

  for i, purchase in Shared.skpairs(purchaseArray) do
    table.insert(tableArray, p._getPurchaseTable(purchase))
  end

  return table.concat(tableArray, '\r\n\r\n')
end

function p.getItemShopTable(frame)
  local itemName = frame.args ~= nil and frame.args[1] or frame
  local item = Items.getItem(itemName)
  if item == nil then
    return "ERROR: No item named "..itemName.." exists in the data module"
  end

  return p._getItemShopTable(item)
end

return p