OutfitterInventory.lua

----------------------------------------
-- Constants
----------------------------------------
if _G["NUM_TOTAL_EQUIPPED_BAG_SLOTS"] == nil then _G["NUM_TOTAL_EQUIPPED_BAG_SLOTS"] = NUM_BAG_SLOTS end

----------------------------------------
-- General
----------------------------------------
function Outfitter:FindNextCooldownItem(pItemCodes, pIgnoreSwapCooldown)
	local vInventoryCache = self:GetInventoryCache()
	local vBestItem, vBestTime

	for _, vItemCode in ipairs(pItemCodes) do
		if type(vItemCode) == "string" then
			local vItemName, vItemLink = GetItemInfo(vItemCode)

			if vItemLink then
				vItemCode = self:ParseItemLink2(vItemLink)[1]
			end
		end

		local vItems = vItemCode and vInventoryCache.ItemsByCode[vItemCode]

		if vItems then
			for _, vItemInfo in ipairs(vItems) do
				local vStart, vDuration, vEnabled

				if vItemInfo.Location.BagIndex then
					vStart, vDuration, vEnabled = C_Container.GetContainerItemCooldown(vItemInfo.Location.BagIndex, vItemInfo.Location.BagSlotIndex)
				elseif vItemInfo.Location.SlotID then
					vStart, vDuration, vEnabled = GetInventoryItemCooldown("player", vItemInfo.Location.SlotID)
				end

				local vRemainingTime

				if vEnabled == 1 and vStart ~= 0 then
					local vElapsed = GetTime() - vStart
					vRemainingTime = vDuration - vElapsed
				elseif self:ItemHasUseFeature(vItemInfo.Link) then
					vRemainingTime = 0
				else
					vRemainingTime = 30 -- Items without a /use are just considered to be 30 secs so that they have lowest priority
				end

				-- If it's in the bag then the minimum is 30 secs

				if vItemInfo.Location.BagIndex
				and not pIgnoreSwapCooldown
				and vRemainingTime < 30 then
					vRemainingTime = 30
				end

				-- Compare it to the current result

				if not vBestTime or vRemainingTime < vBestTime then
					vBestItem = vItemInfo
					vBestTime = vRemainingTime
				end
			end
		end
	end

	return vBestItem, vBestTime
end

function Outfitter:InventorySlotIsEmpty(pInventorySlot)
	return GetInventoryItemTexture("player", self.cSlotIDs[pInventorySlot]) == nil
end

function Outfitter:GetBagItemInfo(bagIndex, slotIndex)
	--print(bagIndex, slotIndex)
	if not bagIndex or not slotIndex then
		return
	end
	local itemLink = C_Container.GetContainerItemLink(bagIndex, slotIndex)
	if not itemLink then
		return
	end

	local itemInfo = self:GetItemInfoFromLink(itemLink)
	if not itemInfo then
		return
	end

	local location = ItemLocation:CreateFromBagAndSlot(bagIndex, slotIndex)

	local containerItemInfo = C_Container.GetContainerItemInfo(bagIndex, slotIndex)
	itemInfo.Texture = containerItemInfo.iconFileID

	local itemLinkInfo = self:ParseItemLink(itemLink)

		_, itemInfo.Gem1Link = GetItemGem(itemLink,1)
	itemInfo.Gem1 = Outfitter:ParseItemLink(itemInfo.Gem1Link)
	_, itemInfo.Gem2Link = GetItemGem(itemLink,2)
	itemInfo.Gem2 = Outfitter:ParseItemLink(itemInfo.Gem2Link)
	_, itemInfo.Gem3Link = GetItemGem(itemLink,3)
	itemInfo.Gem3 = Outfitter:ParseItemLink(itemInfo.Gem3Link)
	_, itemInfo.Gem4Link = GetItemGem(itemLink,4)
	itemInfo.Gem4 = Outfitter:ParseItemLink(itemInfo.Gem4Link)

	--[[-- These steps are recreated in Outfitter:GetSlotIDItemInfo and should get moved to their own function --]]--
	_, _, itemInfo.Gem1, itemInfo.Gem2, itemInfo.Gem3, itemInfo.Gem4 = unpack(self:ParseItemLink(itemLink))

	if itemInfo.Gem1 ~= nil then
		itemInfo.Gem1Link = select(2, GetItemInfo(itemInfo.Gem1))
	end
	if itemInfo.Gem2 ~= nil then
		itemInfo.Gem2Link = select(2, GetItemInfo(itemInfo.Gem2))
	end
	if itemInfo.Gem3 ~= nil then
		itemInfo.Gem3Link = select(2, GetItemInfo(itemInfo.Gem3))
	end
	if itemInfo.Gem4 ~= nil then
		itemInfo.Gem4Link = select(2, GetItemInfo(itemInfo.Gem4))
	end

	itemInfo.Location = {BagIndex = bagIndex, BagSlotIndex = slotIndex}

	return itemInfo
end

function Outfitter:GetBagItemLinkInfo(bagIndex, slotIndex)
	local itemLink = C_Container.GetContainerItemLink(bagIndex, slotIndex)

	if not itemLink then
		return
	end

	return self:ParseItemLink2(itemLink)
end

function Outfitter:GetBagItemInvType(bagIndex, slotIndex)
	local itemLink = C_Container.GetContainerItemLink(bagIndex, slotIndex)

	if not itemLink then
		return
	end

	local _, _, _, _, _, _, _, _, itemInvType = GetItemInfo(itemLink)

	return itemInvType
end

function Outfitter:GetItemLocationLink(pItemLocation)
	if not pItemLocation then
		return
	end

	if pItemLocation.BagIndex then
		return C_Container.GetContainerItemLink(pItemLocation.BagIndex, pItemLocation.BagSlotIndex)
	elseif pItemLocation.SlotName then
		return self:GetInventorySlotIDLink(pSlotID)
	else
		self:ErrorMessage("Unknown location in GetItemLocationLink")
		return
	end
end


function Outfitter:GetItemLocationBagType(pItemLocation)
	if not pItemLocation then
		return
	end

	if pItemLocation.BagIndex then
		return self:GetBagItemBagType(pItemLocation.BagIndex, pItemLocation.BagSlotIndex)
	elseif pItemLocation.SlotName then
		return self:GetSlotIDItemBagType(self.cSlotIDs[pItemLocation.SlotName])
	else
		self:ErrorMessage("Unknown location in GetItemLocationBagType")
		return
	end
end

function Outfitter:GetBagItemBagType(pBagIndex, pSlotIndex)
	local vItemCodes = self:GetBagItemLinkInfo(pBagIndex, pSlotIndex)

	if not vItemCodes then
		return
	end

	return GetItemFamily(vItemCodes[1])
end

function Outfitter:GetSlotIDLinkInfo(pSlotID)
	return self:ParseItemLink2(self:GetInventorySlotIDLink(pSlotID))
end

function Outfitter:GetSlotIDItemBagType(pSlotID)
	local vItemCodes = self:GetSlotIDLinkInfo(pSlotID)

	if not vItemCodes then
		return
	end

	return GetItemFamily(vItemCodes[1])
end

function Outfitter:ParseItemLink(pItemLink)
	if not pItemLink then
		return
	end
	local payload = {}
	local index = 1;
	for info in string.gmatch(pItemLink, "|([^\|]*)") do
		if string.match(info, "^H") then
			for field in string.gmatch(info, ":([^\:]*)") do
				payload[index] = field
				index = index + 1
			end
		end
	end
	return payload
end

function Outfitter:ParseItemLink2(pItemLink)
	if not pItemLink then
		return
	end

	local _, _, vLinkType = pItemLink:find("|H([^:]+):")
	if vLinkType ~= "item" then
		return
	end

	local vStartIndex, vEndIndex, vCodeStrings, vName = pItemLink:find("|Hitem:([^|]*)|h%[([^%]]*)%]|h")
	-- self:DebugMessage("start %s, end %s, codes %s, name %s", tostring(vStartIndex), tostring(vEndIndex), tostring(vCodeStrings), tostring(vName))

	if not vCodeStrings then
		return
	end

	local vCodes = {}
	for vCodeString in string.gmatch(vCodeStrings..":", "%d*:") do
		local vCode = tonumber(strmatch(vCodeString, "(%d+):")) or 0
		vCodes[#vCodes + 1] = vCode
	end

	return vCodes, vName
end

function Outfitter:GetItemInfoFromLink(itemLink)
	-- Return nothing if no link is given
	if not itemLink then
		return
	end

	-- Create the object and have it populate itself
	local itemInfo = Outfitter:New(Outfitter._ItemInfoMetaTable)
	itemInfo:GetItemInfoFromLink(itemLink)

	-- Done
	return itemInfo
end

function Outfitter:GetItemInfoFromCode(itemCode)
	local itemInfo = Outfitter:New(Outfitter._ItemInfoMetaTable)
	itemInfo:GetItemInfoFromCode(itemCode)
	return itemInfo
end

function Outfitter:GetBagSlotItemName(bag, slot)
	local tooltip = self.TooltipLib:SharedTooltip()
	tooltip:ClearLines()
	tooltip:SetBagItem(bag, slot)

	if not tooltip:IsShown() then
		return
	end

	-- Find the first left text line
	local tooltipName = tooltip:GetName()
	local textLeft1Name = tooltipName.."TextLeft1"
	local textLeft1 = _G[textLeft1Name]

	-- Return the item name
	local itemName = textLeft1:GetText()
	return itemName
end

function Outfitter:IsBankBagIndex(pBagIndex)
	return pBagIndex and (pBagIndex > NUM_TOTAL_EQUIPPED_BAG_SLOTS or pBagIndex < 0)
end

----------------------------------------
Outfitter._ItemInfo = {}
setmetatable(Outfitter._ItemInfo, Outfitter.ObjectMetaTable)
Outfitter._ItemInfoMetaTable = {__index = Outfitter._ItemInfo}
----------------------------------------

function Outfitter._ItemInfo:Construct()
end

function Outfitter._ItemInfo:GetItemInfoFromCode(itemCode)
	local itemFamilyName,
	      itemLink,
	      itemQuality,
	      itemLevel,
	      itemMinLevel,
	      itemType,
	      itemSubType,
	      itemCount,
	      itemInvType = GetItemInfo(itemCode)

	--


	self.Name = itemFamilyName
	self.Link = ""
	self.Code = itemCode
	self.SubCode = 0

	self.Quality = itemQuality
	self.Level = itemLevel
	self.MinLevel = itemMinLevel
	self.Type = itemType
	self.SubType = itemSubType

	self.Count = itemCount
	self.InvType = itemInvType

	self.EnchantCode = 0

	self.JewelCode1 = 0
	self.JewelCode2 = 0
	self.JewelCode3 = 0
	self.JewelCode4 = 0

	self.UniqueID = 0
	self.UpgradeTypeID = 0
	self.InstanceDifficultyID = 0
	self.BonusIDs = "::"
	self.UpgradeID = 0

	-- Return if there's no inventory type
	if not itemInvType
	or itemInvType == "" then
		return
	end

	-- If it's a known inventory type add that knowledge to the item info
	local invTypeInfo = Outfitter.cInvTypeToSlotName[itemInvType]
	if invTypeInfo then

		-- Get the slot name
		if not invTypeInfo.SlotName then
			Outfitter:ErrorMessage("Unknown slot name for inventory type "..itemInvType)
			return
		end

		-- Save the slot info
		self.ItemSlotName = invTypeInfo.SlotName
		self.MetaSlotName = invTypeInfo.MetaSlotName
	else
		-- This function can be used to query non-equippable items, so it's not an error for
		-- the inventory type to be unknown.  Should Blizzard ever add a new type though, this
		-- debug message may be useful in figuring out its characteristics

		-- Outfitter:ErrorMessage("Unknown slot type "..itemInvType.." for item "..itemName)
	end
end

function Outfitter._ItemInfo:GetItemInfoFromLink(itemLink)
	-- Do nothing if invalid
	if not itemLink then
		return
	end

	-- Do nothing if the codes can't be extracted
	local itemCodes, itemName = Outfitter:ParseItemLink2(itemLink)
	if not itemCodes then
		return
	end

	-- Start with the base code info
	self:GetItemInfoFromCode(itemCodes[1])

	-- The provided itemLink may have Quality, ItemLevel etc. that differ from the base item.
	-- supersede info from ItemCode with info from the provided itemLink:
	local _, _,
	      itemQuality,
	      itemLevel,
	      itemMinLevel = GetItemInfo(itemLink)

	self.Name = itemName
	self.Link = itemLink
	self.Quality = itemQuality
	self.Level = itemLevel
	self.MinLevel = itemMinLevel

	-- Fill in the rest from itemCodes
	self.EnchantCode = itemCodes[2] or 0
	self.JewelCode1 = itemCodes[3] or 0
	self.JewelCode2 = itemCodes[4] or 0
	self.JewelCode3 = itemCodes[5] or 0
	self.JewelCode4 = itemCodes[6] or 0
	self.SubCode = itemCodes[7] or 0
	self.UniqueID = itemCodes[8] or 0
	-- self.LinkLevel = itemCodes[9]		-- LinkLevel is the level of the player who generated the link, which isn't interesting to us
	-- self.SpecializationID = itemCodes[10]	-- DON'T capture this
	self.UpgradeTypeID = itemCodes[11] or 0
	self.InstanceDifficultyID = itemCodes[12] or 0

	local numBonusIDsString = itemCodes[13]
	local index = 14

	local numBonusIDs = tonumber(numBonusIDsString)
	local bonusID1, bonusID2
	if numBonusIDs > 0 then
		bonusID1 = itemCodes[index]
		index = index + 1
	end
	if numBonusIDs > 1 then
		bonusID2 = itemCodes[index]
		index = index + 1
	end

	self.BonusIDs = (numBonusIDsString ~= 0 and numBonusIDsString or "")..":"..(bonusID1 ~= 0 and bonusID1 or "")..":"..(bonusID2 ~= 0 and bonusID2 or "")
	self.UpgradeID = itemCodes[index] or 0
end

function Outfitter._ItemInfo:ParseTooltip()
	-- Grab a tooltip
	local tooltip = Outfitter.TooltipLib:SharedTooltip()
	tooltip:ClearLines()
	if self.Location and self.Location.BagIndex then
		tooltip:SetBagItem(self.Location.BagIndex, self.Location.BagSlotIndex)
	elseif self.Location and self.Location.SlotID then
		tooltip:SetInventoryItem("player", self.Location.SlotID)
	elseif self.Link then
		tooltip:SetHyperlink(self.Link)
	else
		assert(false, "can't find item for tooltip")
		return
	end

	-- Return if something went wrong
	if not tooltip:IsShown() then
		return
	end

	-- Iterate the lines of the tooltip
	for line in Outfitter.TooltipLib:TooltipLines(tooltip) do
		self:ParseTooltipLine(line.leftText, line.leftColor)
	end

	self.Gem1UniqueType, self.Gem1UniqueCount = self:ParseGemLinkForUniqueEquips(self.Gem1Link)
	self.Gem2UniqueType, self.Gem2UniqueCount = self:ParseGemLinkForUniqueEquips(self.Gem2Link)
	self.Gem3UniqueType, self.Gem3UniqueCount = self:ParseGemLinkForUniqueEquips(self.Gem3Link)
	self.Gem4UniqueType, self.Gem4UniqueCount = self:ParseGemLinkForUniqueEquips(self.Gem4Link)

	-- Done
	self.didParseTooltip = true
end

function Outfitter._ItemInfo:ParseGemLinkForUniqueEquips(link)
	-- Item didnt have that Gem1/Gem2/etc
	if link == nil then
		return nil, nil
	end

	local tooltip = Outfitter.TooltipLib:SharedTooltip()
	tooltip:ClearLines()
	tooltip:SetHyperlink(link)

	-- Return if something went wrong
	if not tooltip:IsShown() then
		return nil, nil
	end

	for line in Outfitter.TooltipLib:TooltipLines(tooltip) do
		-- Check for Unique-Equipped
		local type, count = line.leftText:match(Outfitter.cUniqueEquippedSearchPattern)
		if type then
			return type, tonumber(count)
		end
	end

	return nil, nil
end

function Outfitter._ItemInfo:ParseTooltipLine(text, color)
	-- Check for Binds on Equip
	if text == ITEM_BIND_ON_EQUIP then
		self.BoE = true
		return
	end

	-- Check for Unique-Equipped
	local type, count = text:match(Outfitter.cUniqueEquippedSearchPattern)
	if type then
		self.UniqueType = type
		self.UniqueCount = tonumber(count)
		return
	end

	-- Check for Requires
	if text:match(Outfitter.cRequiresPrefix) then
		local hsvColor = Outfitter:RGBToHSV(color)
		self.FailedRequirements = hsvColor.s > 0.2 and hsvColor.v > 0.2 and (hsvColor.h < 50 or hsvColor.h > 310)
		return
	end
end

function Outfitter._ItemInfo:GetBoE()
	-- Get the info from the tooltip if necessary
	if not self.didParseTooltip then
		self:ParseTooltip()
	end

	-- Return the value
	return self.BoE
end

function Outfitter._ItemInfo:GetMeetsRequirements()
	-- Get the info from the tooltip if necessary
	if not self.didParseTooltip then
		self:ParseTooltip()
	end

	-- Return the value
	return not self.FailedRequirements
end

function Outfitter._ItemInfo:GetUniqueEquipTypes()
	-- Get the info from the tooltip if necessary
	if not self.didParseTooltip then
		self:ParseTooltip()
	end

	local uniqueTypesTable = {}
	if self.UniqueType then
		uniqueTypesTable[self.UniqueType] = self.UniqueCount
	end
	if self.Gem1UniqueType then
		uniqueTypesTable[self.Gem1UniqueType] = self.Gem1UniqueCount
	end
	if self.Gem2UniqueType then
		uniqueTypesTable[self.Gem2UniqueType] = self.Gem2UniqueCount
	end
	if self.Gem3UniqueType then
		uniqueTypesTable[self.Gem3UniqueType] = self.Gem3UniqueCount
	end
	if self.Gem4UniqueType then
		uniqueTypesTable[self.Gem4UniqueType] = self.Gem4UniqueCount
	end
	return uniqueTypesTable
end

----------------------------------------
--
----------------------------------------

function Outfitter:GetInventoryItemInfo(pInventorySlot)
	local vSlotID = self.cSlotIDs[pInventorySlot]

	if not vSlotID then
		return
	end

	local vItemInfo = self:GetSlotIDItemInfo(vSlotID)

	if not vItemInfo then
		return
	end

	vItemInfo.Location.SlotName = pInventorySlot

	return vItemInfo
end

function Outfitter:GetSlotIDItemInfo(slotID)
	local itemLink = self:GetInventorySlotIDLink(slotID)
	if not itemLink then
		return
	end

	local itemInfo = self:GetItemInfoFromLink(itemLink)
	if not itemInfo then
		return
	end

	local location = ItemLocation:CreateFromEquipmentSlot(slotID)

	itemInfo.Quality = GetInventoryItemQuality("player", slotID)
	itemInfo.Texture = GetInventoryItemTexture("player", slotID)

	--[[ Get itemInfo.GemX (ID) and itemInfo.GemXLink (gemLink)
		This way allows all version since GetInventoryItemGems isn't in Vanilla or Retail
		Same steps as Outfitter:GetBagItemInfo
	--]]--
	_, itemInfo.Gem1Link = GetItemGem(itemLink,1)
	itemInfo.Gem1 = Outfitter:ParseItemLink(itemInfo.Gem1Link)
	_, itemInfo.Gem2Link = GetItemGem(itemLink,2)
	itemInfo.Gem2 = Outfitter:ParseItemLink(itemInfo.Gem2Link)
	_, itemInfo.Gem3Link = GetItemGem(itemLink,3)
	itemInfo.Gem3 = Outfitter:ParseItemLink(itemInfo.Gem3Link)
	_, itemInfo.Gem4Link = GetItemGem(itemLink,4)
	itemInfo.Gem4 = Outfitter:ParseItemLink(itemInfo.Gem4Link)

	--[[--
	itemInfo.Gem1, itemInfo.Gem2, itemInfo.Gem3, itemInfo.Gem4 = GetInventoryItemGems(slotID)
	if slotID then
		--_, _, itemInfo.Gem1, itemInfo.Gem2, itemInfo.Gem3, itemInfo.Gem4 = unpack(self:ParseItemLink(itemLink))
		if itemInfo.Gem1 ~= nil then
			itemInfo.Gem1Link = select(2, GetItemInfo(itemInfo.Gem1))
		end
		if itemInfo.Gem2 ~= nil then
			itemInfo.Gem2Link = select(2, GetItemInfo(itemInfo.Gem2))
		end
		if itemInfo.Gem3 ~= nil then
			itemInfo.Gem3Link = select(2, GetItemInfo(itemInfo.Gem3))
		end
		if itemInfo.Gem4 ~= nil then
			itemInfo.Gem4Link = select(2, GetItemInfo(itemInfo.Gem4))
		end
	end
	--]]

	itemInfo.Location = {SlotID = slotID}

	local location = ItemLocation:CreateFromEquipmentSlot(slotID)

	return itemInfo
end

function Outfitter:GetAzeriteCodesForLocation(location)
	local success,isAzeriteItem  = pcall( function() return C_AzeriteEmpoweredItem.IsAzeriteEmpoweredItem(location) end );
	if not (success and isAzeriteItem) then
		return
	end

	local allTierInfo = C_AzeriteEmpoweredItem.GetAllTierInfo(location)
	local powerIDs
	for tierIndex, tierInfo in ipairs(allTierInfo) do
		for _, powerID in ipairs(tierInfo.azeritePowerIDs) do
			if C_AzeriteEmpoweredItem.IsPowerSelected(location, powerID) then
				if not powerIDs then
					powerIDs = {}
				end
				powerIDs[powerID] = true
			end
		end
	end
	return powerIDs
end

function Outfitter:GetNumBags()
	if self.BankFrameIsOpen then
		return NUM_TOTAL_EQUIPPED_BAG_SLOTS + NUM_BANKBAGSLOTS, -1
	else
		return NUM_TOTAL_EQUIPPED_BAG_SLOTS, 0
	end
end

function Outfitter:GetBagList()
	local vBagList = {}
	if self.BankFrameIsOpen then
		for vIndex = -1, NUM_TOTAL_EQUIPPED_BAG_SLOTS + NUM_BANKBAGSLOTS do
			vBagList[vIndex] = true
		end
	else
		for vIndex = 0, NUM_BAG_SLOTS do
			vBagList[vIndex] = true
		end
	end
	--[[
	if self.VoidStorageIsOpen then
		vBagList["VOID_DEPOSIT"] = true
		vBagList["VOID_WITHDRAW"] = true
		vBagList["VOID_STORAGE"] = true
	end
	]]
	return vBagList
end

function Outfitter:GetInventorySlotIDLink(slotID)
	return GetInventoryItemLink("player", slotID)
end

Outfitter.LinkCache =
{
	Inventory = {},
	FirstBagIndex = 0,
	NumBags = 0,
	Bags = {},
}

function Outfitter:ScheduleSynch()
	self.SchedulerLib:RescheduleTask(0.01, self.Synchronize, self)
end

function Outfitter:Synchronize()
	local vBagsChanged, vInventoryChanged = false, false

	if self.Debug.InventoryCache then
		self:DebugMessage("Synchronize()")
	end

	-- Synchronize bag links

	local vNumBags, vFirstBagIndex = self:GetNumBags()

	if self.LinkCache.FirstBagIndex ~= vFirstBagIndex
	or self.LinkCache.NumBags ~= vNumBags then

		self.LinkCache.FirstBagIndex = vFirstBagIndex
		self.LinkCache.NumBags = vNumBags

		vBagsChanged = true
	end

	for vBagIndex = vFirstBagIndex, vNumBags do
		local vBag = self.LinkCache.Bags[vBagIndex]
		local vBagChanged = false

		if not vBag then
			vBag = {}
			self.LinkCache.Bags[vBagIndex] = vBag
		end

		local vNumBagSlots = C_Container.GetContainerNumSlots(vBagIndex)

		if #vBag ~= vNumBagSlots then
			wipe(vBag)
			vBagChanged = true
		end

		for vSlotIndex = 1, vNumBagSlots do
			local vItemLink = C_Container.GetContainerItemLink(vBagIndex, vSlotIndex) or ""

			if vBag[vSlotIndex] ~= vItemLink then
				vBag[vSlotIndex] = vItemLink
				vBagChanged = true
			end
		end

		if vBagChanged then
			if self.InventoryCache then
				self.InventoryCache:FlushBag(vBagIndex)
			end

			vBagsChanged = true
		end
	end

	-- Synchronize inventory links

	for _, vInventorySlot in ipairs(self.cSlotNames) do
		local vItemLink

		vItemLink = GetInventoryItemLink("player", self.cSlotIDs[vInventorySlot])

		if self.Debug.InventoryCache then
			self:DebugMessage("Synchronize: Slot %s contains %s", tostring(vInventorySlot), tostring(vItemLink))
		end

		if self.LinkCache.Inventory[vInventorySlot] ~= vItemLink then
			self.LinkCache.Inventory[vInventorySlot] = vItemLink
			vInventoryChanged = true
		end
	end

	if vInventoryChanged then
		if self.Debug.InventoryCache then
			self:DebugMessage("Synchronize: InventoryChanged")
		end

		if self.InventoryCache then
			self.InventoryCache:FlushInventory()
		end

		self.EventLib:DispatchEvent("OUTFITTER_INVENTORY_CHANGED")
	end

	if vBagsChanged then
		if self.Debug.InventoryCache then
			self:DebugMessage("Synchronize: Bags changed")
		end

		self.EventLib:DispatchEvent("OUTFITTER_BAGS_CHANGED")
	end

	-- Done

	if vBagsChanged or vInventoryChanged then
		self.DisplayIsDirty = true
		self:Update(false)
	end

	--

	self:RunThreads()

	return vBagsChanged or vInventoryChanged, vInventoryChanged, vBagsChanged
end

----------------------------------------
-- InventoryCache
----------------------------------------

function Outfitter:GetInventoryCache()
	if not self.InventoryCache then
		self.InventoryCache = self:New(self._InventoryCache)

		if self.Debug.InventoryCache then
			self:DebugTable(self.InventoryCache, "InventoryCache")
		end
	end

	self.InventoryCache:Synchronize()

	return self.InventoryCache
end

function Outfitter:FlushInventoryCache()
	if self.InventoryCache then
		self.InventoryCache:Flush()
	end
end

----------------------------------------
Outfitter._InventoryCache = {}
----------------------------------------

function Outfitter._InventoryCache:Construct()
	self.ItemsByCode = {}
	self.ItemsBySlot = {}
	self.InventoryItems = nil
	self.BagItems = {}
	self.NeedsUpdate = true

	self.FirstBagIndex = 0
	self.NumBags = 0

	Outfitter.EventLib:RegisterEvent("GET_ITEM_INFO_RECEIVED", self.Flush, self)
end

function Outfitter._InventoryCache:Flush()
	wipe(self.ItemsByCode)
	wipe(self.ItemsBySlot)
	self.InventoryItems = nil
	wipe(self.BagItems)
	self.NeedsUpdate = true

	self.FirstBagIndex = 0
	self.NumBags = 0
end

function Outfitter._InventoryCache:Synchronize()
	-- Check for a change in the number of bags

	local vNumBags, vFirstBagIndex = Outfitter:GetNumBags()

	if self.FirstBagIndex ~= vFirstBagIndex
	or self.NumBags ~= vNumBags then
		for vBagIndex = self.FirstBagIndex, vFirstBagIndex - 1 do
			self:FlushBag(vBagIndex)
		end

		for vBagIndex = vNumBags + 1, self.NumBags do
			self:FlushBag(vBagIndex)
		end

		self.NeedsUpdate = true
	end

	-- If there's a cached copy just clear the IgnoreItem flags and return it

	if not self.NeedsUpdate then
		return
	end

	if not self.InventoryItems then
		self.InventoryItems = {}

		for _, vInventorySlot in ipairs(Outfitter.cSlotNames) do
			local vItemInfo = Outfitter:GetInventoryItemInfo(vInventorySlot)

			if vItemInfo
			and vItemInfo.ItemSlotName
			and vItemInfo.Code ~= 0 then
				vItemInfo.SlotName = vInventorySlot

				self:AddItem(vItemInfo)
			end
		end
	end

	for vBagIndex = vFirstBagIndex, vNumBags do
		local vBagItems = self.BagItems[vBagIndex]

		if not vBagItems then
			self.BagItems[vBagIndex] = {}

			local vNumBagSlots = C_Container.GetContainerNumSlots(vBagIndex)

			if vNumBagSlots > 0 then
				for vBagSlotIndex = 1, vNumBagSlots do
					local vItemInfo = Outfitter:GetBagItemInfo(vBagIndex, vBagSlotIndex)

					if vItemInfo
					and vItemInfo.Code ~= 0
					and vItemInfo.ItemSlotName
					and Outfitter:CanEquipBagItem(vBagIndex, vBagSlotIndex)
					and not vItemInfo:GetBoE() then
						self:AddItem(vItemInfo)
					end
				end -- for vBagSlotIndex
			end -- if vNumBagSlots > 0
		end -- if not BagItems
	end -- for vBagIndex

	self.FirstBagIndex = vFirstBagIndex
	self.NumBags = vNumBags

	self.NeedsUpdate = false
end

function Outfitter._InventoryCache:AddItem(pItem)
	-- Add the item to the code list

	local vItemFamily = self.ItemsByCode[pItem.Code]

	if not vItemFamily then
		vItemFamily = {}
		self.ItemsByCode[pItem.Code] = vItemFamily
	end

	table.insert(vItemFamily, pItem)

	-- Add the item to the slot list

	local vItemSlot = self.ItemsBySlot[pItem.ItemSlotName]

	if not vItemSlot then
		vItemSlot = {}
		self.ItemsBySlot[pItem.ItemSlotName] = vItemSlot
	end

	table.insert(vItemSlot, pItem)

	-- Add the item to the bags

	if pItem.Location.BagIndex then
		local vBagItems = self.BagItems[pItem.Location.BagIndex]

		if not vBagItems then
			vBagItems = {}
			self.BagItems[pItem.Location.BagIndex] = vBagItems
		end

		vBagItems[pItem.Location.BagSlotIndex] = pItem

	-- Add the item to the inventory

	elseif pItem.Location.SlotName then
		self.InventoryItems[pItem.Location.SlotName] = pItem
	end
end

function Outfitter._InventoryCache:RemoveItem(pItem)
	-- Remove the item from the code list

	local vItems = self.ItemsByCode[pItem.Code]

	for vIndex, vItem in ipairs(vItems) do
		if vItem == pItem then
			table.remove(vItems, vIndex)
			break
		end
	end

	-- Remove the item from the slot list

	local vItemSlot = self.ItemsBySlot[pItem.ItemSlotName]

	if vItemSlot then
		for vIndex, vItem in ipairs(vItemSlot) do
			if vItem == pItem then
				table.remove(vItemSlot, vIndex)
				break
			end
		end
	end

	-- Remove the item from the bags list

	if pItem.Location.BagIndex then
		local vBagItems = self.BagItems[pItem.Location.BagIndex]

		if vBagItems then
			vBagItems[pItem.Location.BagSlotIndex] = nil
		end

	-- Remove the item from the inventory list

	elseif pItem.Location.SlotName then
		self.InventoryItems[pItem.Location.SlotName] = nil
	end
end

function Outfitter._InventoryCache:SwapLocations(pLocation1, pLocation2)
	-- if pLocation1.BagIndex then
	-- 	Outfitter:TestMessage("Outfitter._InventoryCache:SwapLocations: Swapping bag "..pLocation1.BagIndex..", "..pLocation1.BagSlotIndex)
	-- elseif pLocation1.SlotName then
	-- 	Outfitter:TestMessage("Outfitter._InventoryCache:SwapLocations: Swapping slot "..pLocation1.SlotName)
	-- end
	-- if pLocation2.BagIndex then
	-- 	Outfitter:TestMessage("Outfitter._InventoryCache:SwapLocations: with bag "..pLocation2.BagIndex..", "..pLocation2.BagSlotIndex)
	-- elseif pLocation2.SlotName then
	-- 	Outfitter:TestMessage("Outfitter._InventoryCache:SwapLocations: with slot "..pLocation2.SlotName)
	-- end
end

function Outfitter._InventoryCache:SwapLocationWithInventorySlot(pLocation, pSlotName)
	-- if pLocation.BagIndex then
	-- 	Outfitter:TestMessage("Outfitter._InventoryCache:SwapLocationWithInventorySlot: Swapping bag "..pLocation.BagIndex..", "..pLocation.BagSlotIndex.." with slot "..pSlotName)
	-- elseif pLocation.SlotName then
	-- 	Outfitter:TestMessage("Outfitter._InventoryCache:SwapLocationWithInventorySlot: Swapping slot "..pLocation.SlotName.." with slot "..pSlotName)
	-- end
end

function Outfitter._InventoryCache:SwapBagSlotWithInventorySlot(pBagIndex, pBagSlotIndex, pSlotName)
	-- Outfitter:TestMessage("Outfitter._InventoryCache:SwapBagSlotWithInventorySlot: Swapping bag "..pBagIndex..", "..pBagSlotIndex.." with slot "..pSlotName)
end

function Outfitter._InventoryCache:FindItemInfoByCode(pItemInfo)
	local vItems = self.ItemsByCode[pItemInfo.Code]

	for _, vItemInfo in ipairs(vItems) do
		if pItemInfo == vItemInfo then
			return true
		end
	end

	return false
end

function Outfitter._InventoryCache:FindItemInfoBySlot(pItemInfo)
	local vItems = self.ItemsBySlot[pItemInfo.ItemSlotName]

	for _, vItemInfo in ipairs(vItems) do
		if pItemInfo == vItemInfo then
			return true
		end
	end

	return false
end

function Outfitter._InventoryCache:FindItem(pOutfitItem, pMarkAsInUse, pAllowSubCodeWildcard)
	local vItem, vIndex, vItemFamily, vIgnoredItem = self:FindItemIndex(pOutfitItem, pAllowSubCodeWildcard)

	if not vItem then
		return nil, vIgnoredItem
	end

	if pMarkAsInUse then
		vItem.IgnoreItem = true
	end

	return vItem
end

function Outfitter._InventoryCache:FindItemIndex(pOutfitItem, pAllowSubCodeWildcard)
	local vItemFamily = self.ItemsByCode[pOutfitItem.Code]

	if not vItemFamily then
		return
	end

	local vBestMatch = nil
	local vBestMatchIndex = nil
	local vNumItemsFound = 0
	local vFoundIgnoredItem = nil

	for vIndex, vItem in ipairs(vItemFamily) do
		-- All done if the caller doesn't care about the SubCode

		if pAllowSubCodeWildcard
		and not pOutfitItem.SubCode then
			if vItem.IgnoreItem then
				vFoundIgnoredItem = vItem
			else
				return vItem, vIndex, vItemFamily, nil
			end

		-- If the subcode matches then check for an enchant match

		elseif vItem.SubCode == pOutfitItem.SubCode then
			-- If the enchant matches then we're all done

			if vItem.InvType == "INVTYPE_AMMO"
			or (vItem.EnchantCode == pOutfitItem.EnchantCode
			and vItem.JewelCode1 == pOutfitItem.JewelCode1
			and vItem.JewelCode2 == pOutfitItem.JewelCode2
			and vItem.JewelCode3 == pOutfitItem.JewelCode3
			and vItem.JewelCode4 == pOutfitItem.JewelCode4
			and vItem.UniqueID == pOutfitItem.UniqueID
			and vItem.UpgradeTypeID == pOutfitItem.UpgradeTypeID
			and vItem.BonusIDs == pOutfitItem.BonusIDs
			and vItem.UpgradeID == pOutfitItem.UpgradeID
			and Outfitter.AzeriteCodesMatch(vItem.AzeriteCodes, pOutfitItem.AzeriteCodes)) then
				if vItem.IgnoreItem then
					vFoundIgnoredItem = vItem
				else
					return vItem, vIndex, vItemFamily
				end

			-- Otherwise save the match in case a better one can
			-- be found

			else
				if vItem.IgnoreItem then
					if not vFoundIgnoredItem then
						vFoundIgnoredItem = vItem
					end
				else
					vBestMatch = vItem
					vBestMatchIndex = vIndex
					vNumItemsFound = vNumItemsFound + 1
				end
			end
		end
	end

	-- Return the match if only one item was found

	if vNumItemsFound == 1
	and not vBestMatch.IgnoreItem then
		return vBestMatch, vBestMatchIndex, vItemFamily, nil
	end

	--Outfitter:DebugMessage("Didn't find item:")
	--Outfitter:DebugTable(pOutfitItem, "pOutfitItem")
	--Outfitter:DebugTable(vItemFamily, "vItemFamily")

	return nil, nil, nil, vFoundIgnoredItem
end

function Outfitter._InventoryCache:FindItemOrAlt(pOutfitItem, pMarkAsInUse, pAllowSubCodeWildcard)
	local vItem, vIgnoredItem = self:FindItem(pOutfitItem, pMarkAsInUse, pAllowSubCodeWildcard)

	if vItem then
		return vItem
	end

	-- See if there's an alias for the item if it wasn't found

	local vAltCode = Outfitter.cItemAliases[pOutfitItem.Code]

	if not vAltCode then
		return nil, vIgnoredItem
	end

	return self:FindItem({Code = vAltCode}, pMarkAsInUse, true)
end

function Outfitter._InventoryCache:FindAllItemsOrAlt(pOutfitItem, pAllowSubCodeWildcard, rItems)
	local vNumItems = self:FindAllItems(pOutfitItem, pAllowSubCodeWildcard, rItems)
	local vAltCode = Outfitter.cItemAliases[pOutfitItem.Code]

	if vAltCode then
		vNumItems = vNumItems + self:FindAllItems({Code = vAltCode}, true, rItems)
	end

	return vNumItems
end

function Outfitter._InventoryCache:FindAllItems(pOutfitItem, pAllowSubCodeWildcard, rItems)
	local vItemFamily = self.ItemsByCode[pOutfitItem.Code]

	if not vItemFamily then
		return 0
	end

	local vNumItemsFound = 0

	for vIndex, vItem in ipairs(vItemFamily) do
		if (pAllowSubCodeWildcard and not pOutfitItem.SubCode)
		or vItem.SubCode == pOutfitItem.SubCode then
			table.insert(rItems, vItem)
			vNumItemsFound = vNumItemsFound + 1
		end
	end

	return vNumItemsFound
end

function Outfitter._InventoryCache:FlushBag(pBagIndex)
	if self.BagItems[pBagIndex] then
		for vBagSlotIndex, vItem in pairs(self.BagItems[pBagIndex]) do
			self:RemoveItem(vItem)
		end

		self.NeedsUpdate = true
		self.BagItems[pBagIndex] = nil
	end
end

function Outfitter._InventoryCache:FlushInventory()
	if Outfitter.Debug.InventoryCache then
		Outfitter:DebugMessage("Outfitter._InventoryCache:FlushInventory()")
	end

	-- Do nothing if no items are cached yet
	if not self.InventoryItems then
		return
	end

	-- Remove each item
	for vInventorySlot, vItem in pairs(self.InventoryItems) do
		self:RemoveItem(vItem)
	end

	self.NeedsUpdate = true
	self.InventoryItems = nil
end

function Outfitter._InventoryCache:ResetIgnoreItemFlags()
	for vItemCode, vItemFamily in pairs(self.ItemsByCode) do
		for _, vItem in ipairs(vItemFamily) do
			vItem.IgnoreItem = nil
		end
	end
end

function Outfitter._InventoryCache:GetMissingItems(pOutfit)
	if not pOutfit then
		Outfitter:DebugMessage("Outfitter._InventoryCache:GetMissingItems: pOutfit is nil")
		Outfitter:DebugStack()
		return
	end

	self:ResetIgnoreItemFlags()

	return pOutfit:GetMissingItems(self)
end

function Outfitter._InventoryCache:CompiledUnusedItemsList()
	-- Reset all the in-use flags in the cache
	self:ResetIgnoreItemFlags()

	-- Iterate the outfits and mark all their items as in-use
	for vCategoryID, vOutfits in pairs(gOutfitter_Settings.Outfits) do
		for vOutfitIndex, vOutfit in ipairs(vOutfits) do
			local vItems = vOutfit:GetItems()
			if vItems then
				for vInventorySlot, vOutfitItem in pairs(vItems) do
					if vOutfitItem.Code ~= 0 then
						local vItem = self:FindItemOrAlt(vOutfitItem, true)

						if vItem then
							vItem.UsedInOutfit = true
						end
					end
				end
			end
		end
	end

	-- Look for items which aren't marked as in-use
	local vUnusedItems = nil
	for vCode, vFamilyItems in pairs(self.ItemsByCode) do
		for vIndex, vOutfitItem in ipairs(vFamilyItems) do
			if not vOutfitItem.UsedInOutfit
			and Outfitter.cIgnoredUnusedItems[vOutfitItem.Code] == nil then
				if not vUnusedItems then
					vUnusedItems = {}
				end

				table.insert(vUnusedItems, vOutfitItem)
			end
		end
	end

	-- Done
	self.UnusedItems = vUnusedItems
end

function Outfitter._InventoryCache:GetBoEItems()
	local items = {}

	-- Iterate the bags
	local numBags, firstBagIndex = Outfitter:GetNumBags()
	for bagIndex = firstBagIndex, numBags do
		local numSlots = C_Container.GetContainerNumSlots(bagIndex)

		if numSlots > 0 then
			for slotIndex = 1, numSlots do
				local itemInfo = Outfitter:GetBagItemInfo(bagIndex, slotIndex)

				if itemInfo
				and itemInfo.Code ~= 0
				and itemInfo.ItemSlotName
				and Outfitter:CanEquipBagItem(bagIndex, slotIndex)
				and itemInfo:GetBoE() then
					table.insert(items, itemInfo)
				end
			end -- for slotIndex
		end -- if numSlots > 0
	end -- for bagIndex

	return items
end

function Outfitter._InventoryCache:ItemsAreSame(pItem1, pItem2)
	if not pItem1 then
		if Outfitter.Debug.TemporaryItems
		and pItem2 ~= nil then
			Outfitter:DebugMessage("ItemsAreSame(nil, %s): false", tostring(pItem2.Name))
		end

		return pItem2 == nil
	end

	if not pItem2 then
		if Outfitter.Debug.TemporaryItems then
			Outfitter:DebugMessage("ItemsAreSame(%s, nil): false", tostring(pItem1.Name))
		end
		return false
	end

	if pItem1.Code == 0 then
		if Outfitter.Debug.TemporaryItems
		and pItem2.Code ~= 0 then
			Outfitter:DebugMessage("ItemsAreSame(EMPTY, %s): false", tostring(pItem2.Name))
		end
		return pItem2.Code == 0
	end

	if (pItem1.Code ~= pItem2.Code and Outfitter.cItemAliases[pItem1.Code] ~= pItem2.Code)
	or (pItem1.Code == pItem2.Code and pItem1.SubCode ~= pItem2.SubCode) then
		if Outfitter.Debug.TemporaryItems then
			Outfitter:DebugMessage("ItemsAreSame(%s, %s): false", tostring(pItem1.Name), tostring(pItem2.Name))
		end
		return false
	end

	local vItems = {}
	local vNumItems = self:FindAllItemsOrAlt(pItem1, nil, vItems)

	if vNumItems == 0 then
		-- Shouldn't ever get here

		Outfitter:DebugMessage("Outfitter.ItemList_ItemsAreSame: Item not found")
		Outfitter:DebugTable(pItem1, "Item")

		return false
	elseif vNumItems == 1
	or pItem1.InvType == "INVTYPE_AMMO"
	or pItem2.InvType == "INVTYPE_AMMO" then
		-- If there's only one of that item then the enchant code
		-- is disregarded so just make sure it's the same

		-- Also don't bother comparing enchants on ammo or on items that
		-- were found as alternate codes for the desired item (ie, Argent vs. Alliance/Horde Lance)

		return true
	else
		local vResult = Outfitter.cItemAliases[pItem1.Code] -- Aliasable item, don't compare sub-codes
		   or (pItem1.EnchantCode == pItem2.EnchantCode
		   and pItem1.JewelCode1 == pItem2.JewelCode1
		   and pItem1.JewelCode2 == pItem2.JewelCode2
		   and pItem1.JewelCode3 == pItem2.JewelCode3
		   and pItem1.JewelCode4 == pItem2.JewelCode4
		   and pItem1.UniqueID == pItem2.UniqueID
		   and pItem1.UpgradeTypeID == pItem2.UpgradeTypeID
		   and pItem1.InstanceDifficultyID == pItem2.InstanceDifficultyID
		   and pItem1.BonusIDs == pItem2.BonusIDs
		   and pItem1.UpgradeID == pItem2.UpgradeID
		   and Outfitter.AzeriteCodesMatch(pItem1.AzeriteCodes, pItem2.AzeriteCodes))

		if Outfitter.Debug.TemporaryItems
		and not vResult then
			Outfitter:DebugMessage("ItemsAreSame(%s, %s): false", tostring(pItem1.Name), tostring(pItem2.Name))
		end

		return vResult
	end
end

function Outfitter._InventoryCache:InventorySlotContainsItem(inventorySlot, outfitItem)
	-- Nil items are supposed to be ignored, so never claim the slot contains them
	if outfitItem == nil then
--		Outfitter:DebugMessage("InventorySlotContainsItem: OutfitItem is nil")
		return false, nil
	end

	-- If the item specifies an empty slot check to see if the slot is actually empty

	if outfitItem.Code == 0 then
		return self.InventoryItems[inventorySlot] == nil
	end

	local items = {}
	local numItems = self:FindAllItemsOrAlt(outfitItem, nil, items)

	if inventorySlot == "HeadSlot" then
		Outfitter:DebugTable(items, "items")
	end

	if numItems == 0 then
--		Outfitter:DebugMessage("InventorySlotContainsItem: OutfitItem not found")
--		Outfitter:DebugTable(outfitItem, "InventorySlotContainsItem: OutfitItem")

		return false
	elseif numItems == 1 then
		-- If there's only one of that item then the enchant code
		-- is disregarded so just make sure it's in the slot

		local match = items[1].Location.SlotName == inventorySlot

--		if not match then
--			Outfitter:DebugMessage("InventorySlotContainsItem: Slots don't match %s", tostring(inventorySlot))
--			Outfitter:DebugTable(items[1], "InventorySlotContainsItem: Item")
--		end

		return match, items[1]
	else
		-- See if one of the items is in the slot

		for _, item in ipairs(items) do
			if item.Location.SlotName == inventorySlot then
				-- Must match the enchant and jewel codes if there are multiple items
				-- in order to be considered a perfect match

					-- note SubCode mismatch is not checked for; shouldn't it be?
				local codesMatch = item.InvType == "INVTYPE_AMMO"
				                or (item.EnchantCode == outfitItem.EnchantCode
				                and item.JewelCode1 == outfitItem.JewelCode1
				                and item.JewelCode2 == outfitItem.JewelCode2
				                and item.JewelCode3 == outfitItem.JewelCode3
				                and item.JewelCode4 == outfitItem.JewelCode4
				                and item.UniqueID == outfitItem.UniqueID
				                and item.UpgradeTypeID == outfitItem.UpgradeTypeID
				                and item.InstanceDifficultyID == outfitItem.InstanceDifficultyID
				                and item.BonusIDs == outfitItem.BonusIDs
				                and item.UpgradeID == outfitItem.UpgradeID
				                and Outfitter.AzeriteCodesMatch(item.AzeriteCodes, outfitItem.AzeriteCodes))

--				if not codesMatch then
--					Outfitter:DebugMessage("InventorySlotContainsItem: Items don't match")
--					Outfitter:DebugTable(outfitItem, "InventorySlotContainsItem: OutfitItem")
--					Outfitter:DebugTable(item, "InventorySlotContainsItem: Item")
--				end

				return codesMatch, item
			end
		end

		-- No items in the slot

--		Outfitter:DebugMessage("InventorySlotContainsItem: Items don't match -- no item")
--		Outfitter:DebugTable(outfitItem, "InventorySlotContainsItem: OutfitItem")

		return false, nil
	end
end