TradeSkillMaster/Core/UI/Elements/AuctionScrollingTable.lua

-- ------------------------------------------------------------------------------ --
--                                TradeSkillMaster                                --
--                          https://tradeskillmaster.com                          --
--    All Rights Reserved - Detailed license information included with addon.     --
-- ------------------------------------------------------------------------------ --

--- AuctionScrollingTable UI Element Class.
-- An auction scrolling table displays a scrollable list of auctions with a fixed set of columns. It operations on
-- auction records returned by the scanning code. It is a subclass of the @{ScrollingTable} class.
-- @classmod AuctionScrollingTable

local _, TSM = ...
local L = TSM.Include("Locale").GetTable()
local Math = TSM.Include("Util.Math")
local Money = TSM.Include("Util.Money")
local String = TSM.Include("Util.String")
local TempTable = TSM.Include("Util.TempTable")
local Theme = TSM.Include("Util.Theme")
local ScriptWrapper = TSM.Include("Util.ScriptWrapper")
local ItemInfo = TSM.Include("Service.ItemInfo")
local PlayerInfo = TSM.Include("Service.PlayerInfo")
local AuctionScrollingTable = TSM.Include("LibTSMClass").DefineClass("AuctionScrollingTable", TSM.UI.ScrollingTable)
local UIElements = TSM.Include("UI.UIElements")
UIElements.Register(AuctionScrollingTable)
TSM.UI.AuctionScrollingTable = AuctionScrollingTable
local private = {
	sortContext = {
		rowSortValue = {},
		baseSortValue = {},
		sortValue = {},
		self = nil,
	},
	subRowsTemp = {},
}
local ICON_SIZE = 12



-- ============================================================================
-- Public Class Methods
-- ============================================================================

function AuctionScrollingTable.__init(self)
	self.__super:__init()
	self._auctionScan = nil
	self._marketValueFunc = nil
	self._sortCol = nil
	self._sortAscending = nil
	self._expanded = {}
	self._firstSubRowByItem = {}
	self._rowByItem = {}
	self._browseResultsVisible = false
	self._firstUnscannedItem = nil
	self._selectionBaseItemString = nil
	self._selectionBaseSortValue = nil
	self._selectionSubRowIndex = nil
	self._currentSearchItem = nil
	self._onResultsUpdated = function()
		self:UpdateData(true)
	end
	self._getNextSearchItem = function()
		if self._selectionBaseItemString and not self._firstSubRowByItem[self._selectionBaseItemString] then
			-- the selected row has priority
			return self._selectionBaseItemString
		end
		return self._firstUnscannedItem
	end
	self._currentSearchChanged = function(_, baseItemString)
		if not baseItemString then
			-- the search was paused or unpaused, so just update the current item
			baseItemString = self._currentSearchItem
		end
		self._currentSearchItem = baseItemString
		-- layout the new row to update it's action icon state
		for _, row in ipairs(self._rows) do
			local data = row:GetData()
			if data and not data:IsSubRow() and data:GetBaseItemString() == baseItemString then
				row:_LayoutDataRow()
			end
		end
	end
end

function AuctionScrollingTable.Acquire(self)
	self.__super:Acquire()
	-- temporarily set a context table so we can create the table columns (should be overridden later)
	self:GetScrollingTableInfo()
		:NewColumn("item")
			:SetHeaderIndent("8")
			:SetTitle(L["Item"])
			:SetFont("ITEM_BODY3")
			:SetJustifyH("LEFT")
			:SetIconSize(ICON_SIZE)
			:SetTextFunction(private.GetItemCellText)
			:SetIconFunction(private.GetItemCellIcon)
			:SetTooltipFunction(private.GetItemCellTooltip)
			:SetExpanderStateFunction(private.GetExpanderState)
			:SetBadgeStateFunction(private.GetBadgeState)
			:SetActionIconInfo(1, 12, private.GetPendingIcon)
			:SetActionIconClickHandler(private.OnPendingIconClick)
			:DisableHiding()
			:Commit()
		:NewColumn("ilvl")
			:SetTitle(L["ilvl"])
			:SetFont("TABLE_TABLE1")
			:SetJustifyH("RIGHT")
			:SetTextFunction(private.GetItemLevelCellText)
			:Commit()
	if not TSM.IsWowClassic() then
		self:GetScrollingTableInfo()
			:NewColumn("qty")
				:SetTitle(L["Qty"])
				:SetFont("TABLE_TABLE1")
				:SetJustifyH("RIGHT")
				:SetTextFunction(private.GetAuctionsQuantityText)
				:Commit()
	else
		self:GetScrollingTableInfo()
			:NewColumn("posts")
				:SetTitle(L["Posts"])
				:SetFont("TABLE_TABLE1")
				:SetJustifyH("RIGHT")
				:SetTextFunction(private.GetAuctionsPostsText)
				:Commit()
			:NewColumn("stack")
				:SetTitle(L["Stack"])
				:SetFont("TABLE_TABLE1")
				:SetJustifyH("RIGHT")
				:SetTextFunction(private.GetAuctionsStackText)
				:Commit()
	end
	self:GetScrollingTableInfo()
		:NewColumn("timeLeft")
			:SetTitleIcon("iconPack.14x14/Clock")
			:SetFont("TABLE_TABLE1")
			:SetJustifyH("CENTER")
			:SetTextFunction(private.GetTimeLeftCellText)
			:Commit()
		:NewColumn("seller")
			:SetTitle(L["Seller"])
			:SetFont("ITEM_BODY3")
			:SetJustifyH("LEFT")
			:SetTextFunction(private.GetSellerCellText)
			:Commit()
		:NewColumn("itemBid")
			:SetTitle(L["Bid (item)"])
			:SetFont("TABLE_TABLE1")
			:SetJustifyH("RIGHT")
			:SetTextFunction(private.GetItemBidCellText)
			:Commit()
		:NewColumn("bid")
			:SetTitle(TSM.IsWowClassic() and L["Bid (stack)"] or L["Bid (total)"])
			:SetFont("TABLE_TABLE1")
			:SetJustifyH("RIGHT")
			:SetTextFunction(private.GetBidCellText)
			:Commit()
		:NewColumn("itemBuyout")
			:SetTitle(L["Buyout (item)"])
			:SetFont("TABLE_TABLE1")
			:SetJustifyH("RIGHT")
			:SetTextFunction(private.GetItemBuyoutCellText)
			:Commit()
		:NewColumn("buyout")
			:SetTitle(TSM.IsWowClassic() and L["Buyout (stack)"] or L["Buyout (total)"])
			:SetFont("TABLE_TABLE1")
			:SetJustifyH("RIGHT")
			:SetTextFunction(private.GetBuyoutCellText)
			:Commit()
		:NewColumn("bidPct")
			:SetTitle(BID.." %")
			:SetFont("TABLE_TABLE1")
			:SetJustifyH("RIGHT")
			:SetTextFunction(private.GetBidPercentCellText)
			:Commit()
		:NewColumn("pct")
			:SetTitle("%")
			:SetFont("TABLE_TABLE1")
			:SetJustifyH("RIGHT")
			:SetTextFunction(private.GetPercentCellText)
			:Commit()
		:Commit()
	self._sortCol = "pct"
	self._sortAscending = true
end

function AuctionScrollingTable.Release(self)
	if self._auctionScan then
		self._auctionScan:RemoveResultsUpdateCallback(self._onResultsUpdated)
		self._auctionScan:SetNextSearchItemFunction(nil)
		self._auctionScan:SetScript("OnCurrentSearchChanged", nil)
	end
	self._auctionScan = nil
	self._sortCol = nil
	self._sortAscending = nil
	self._marketValueFunc = nil
	self._browseResultsVisible = false
	self._firstUnscannedItem = nil
	wipe(self._expanded)
	wipe(self._firstSubRowByItem)
	wipe(self._rowByItem)
	for _, row in ipairs(self._rows) do
		ScriptWrapper.Clear(row._frame, "OnDoubleClick")
		for _, tooltipFrame in pairs(row._buttons) do
			ScriptWrapper.Clear(tooltipFrame, "OnDoubleClick")
		end
	end
	self._selectionBaseItemString = nil
	self._selectionBaseSortValue = nil
	self._selectionSubRowIndex = nil
	self._currentSearchItem = nil
	self.__super:Release()
end

--- Sets the @{DatabaseQuery} source for this table.
-- This query is used to populate the entries in the auction scrolling table.
-- @tparam AuctionScrollingTable self The auction scrolling table object
-- @tparam AuctionScanManager auctionScan The auction scan object
-- @tparam[opt=false] bool redraw Whether or not to redraw the scrolling table
-- @treturn AuctionScrollingTable The auction scrolling table object
function AuctionScrollingTable.SetAuctionScan(self, auctionScan, redraw)
	if auctionScan == self._auctionScan and not redraw then
		return self
	end
	if self._auctionScan then
		self._auctionScan:RemoveResultsUpdateCallback(self._onResultsUpdated)
		self._auctionScan:SetNextSearchItemFunction(nil)
		self._auctionScan:SetScript("OnCurrentSearchChanged", nil)
	end
	self._auctionScan = auctionScan
	self._auctionScan:AddResultsUpdateCallback(self._onResultsUpdated)
	self._auctionScan:SetNextSearchItemFunction(self._getNextSearchItem)
	self._auctionScan:SetScript("OnCurrentSearchChanged", self._currentSearchChanged)
	wipe(self._expanded)
	self:UpdateData(redraw)
	return self
end

--- Sets whether or not browse results are visible.
-- @tparam AuctionScrollingTable self The auction scrolling table object
-- @tparam boolean visible Whether or not browse results should be visible
-- @treturn AuctionScrollingTable The auction scrolling table object
function AuctionScrollingTable.SetBrowseResultsVisible(self, visible)
	self._browseResultsVisible = visible
	return self
end

--- Sets the market value function.
-- @tparam AuctionScrollingTable self The auction scrolling table object
-- @tparam function func The function to call with the item DB record to get the market value
-- @treturn AuctionScrollingTable The auction scrolling table object
function AuctionScrollingTable.SetMarketValueFunction(self, func)
	if self._marketValueFunc ~= func then
		self._marketValueFunc = func
		self:UpdateData(false)
	end
	return self
end

--- Gets the selected result row.
-- @tparam AuctionScrollingTable self The auction scrolling table object
-- @return The selected result row or nil if there's no selection
function AuctionScrollingTable.GetSelection(self)
	local selection = self.__super:GetSelection()
	if not selection then
		return nil
	end
	local baseItemString = selection:GetBaseItemString()
	if not selection:IsSubRow() then
		selection = self._firstSubRowByItem[baseItemString] or selection
	end
	return selection
end

--- Sets the selected result row.
-- @tparam AuctionScrollingTable self The auction scrolling table object
-- @param selection The selected result row or nil to clear the selection
-- @treturn AuctionScrollingTable The auction scrolling table object
function AuctionScrollingTable.SetSelection(self, selection)
	if not selection then
		self._selectionBaseItemString = nil
		self._selectionBaseSortValue = nil
		self._selectionSubRowIndex = nil
		return self.__super:SetSelection(selection)
	end
	local baseItemString = selection:GetBaseItemString()
	if selection == self._firstSubRowByItem[baseItemString] then
		selection = self._rowByItem[baseItemString]
		assert(selection)
	end
	self._selectionBaseItemString = baseItemString
	self._selectionBaseSortValue = self:_GetSortValue(selection, self._sortCol, self._sortAscending)
	local firstIndex = nil
	for i, data in ipairs(self._data) do
		if not firstIndex and data:GetBaseItemString() == baseItemString then
			firstIndex = i
		end
		if data == selection then
			self._selectionSubRowIndex = i - firstIndex + 1
			break
		end
	end
	assert(self._selectionSubRowIndex)
	return self.__super:SetSelection(selection)
end

--- Expands a single auction result.
-- If there is a single top-level auction result, this will cause it to be expanded. Otherwise, this does nothing.
-- @tparam AuctionScrollingTable self The auction scrolling table object
-- @treturn AuctionScrollingTable The auction scrolling table object
function AuctionScrollingTable.ExpandSingleResult(self)
	-- if only one result, expand it
	local singleResult = nil
	for baseItemString in pairs(self._firstSubRowByItem) do
		if not singleResult then
			singleResult = baseItemString
		elseif singleResult then
			singleResult = nil
			break
		end
	end
	if singleResult then
		self._expanded[singleResult] = true
		self:UpdateData(true)
	end
end

--- Sets the % column header tooltip.
-- @tparam AuctionScrollingTable self The auction scrolling table object
-- @param tooltip The tooltip
-- @treturn AuctionScrollingTable The auction scrolling table object
function AuctionScrollingTable.SetPctTooltip(self, tooltip)
	self._tableInfo:GetColById("pct"):SetHeaderTooltip(tooltip)
	return self
end

function AuctionScrollingTable.Draw(self)
	self.__super:Draw()
	self._header:SetSort(self._sortCol, self._sortAscending)
end



-- ============================================================================
-- Private Class Methods
-- ============================================================================

function AuctionScrollingTable._UpdateData(self)
	if not self._auctionScan then
		return
	end
	local sortKey = self._sortCol
	wipe(self._data)
	wipe(self._firstSubRowByItem)
	wipe(self._rowByItem)
	self._firstUnscannedItem = nil
	private.sortContext.self = self

	local rows = TempTable.Acquire()
	local subRows = TempTable.Acquire()
	local subRowsStart = TempTable.Acquire()
	local subRowsEnd = TempTable.Acquire()
	local sortAscending = self._sortAscending
	for _, query in self._auctionScan:QueryIterator() do
		for baseItemString, row in query:BrowseResultsIterator() do
			if not self._rowByItem[baseItemString] and row:HasItemInfo() then
				assert(not next(private.subRowsTemp))
				local hasSubRows = false
				for _, subRow in row:SubRowIterator() do
					hasSubRows = true
					local sortValue = self:_GetSortValue(subRow, sortKey, sortAscending)
					private.sortContext.sortValue[subRow] = sortValue
					tinsert(private.subRowsTemp, subRow)
				end
				if hasSubRows then
					-- sort all the subRows
					sort(private.subRowsTemp, sortAscending and private.SortSubRowAscendingHelper or private.SortSubRowDescendingHelper)
					-- grab the first subRow which is shown when this item is collapsed
					assert(not self._firstSubRowByItem[baseItemString])
					local firstSubRow = private.subRowsTemp[1]
					self._firstSubRowByItem[baseItemString] = firstSubRow
					private.sortContext.baseSortValue[baseItemString] = private.sortContext.sortValue[firstSubRow]
					private.sortContext.rowSortValue[row] = private.sortContext.baseSortValue[baseItemString]
					-- add all the subRows if this item is expanded
					if self._expanded[baseItemString] and #private.subRowsTemp > 1 then
						subRowsStart[baseItemString] = #subRows + 1
						for i = 2, #private.subRowsTemp do
							tinsert(subRows, private.subRowsTemp[i])
						end
						subRowsEnd[baseItemString] = #subRows
					end
				elseif self._browseResultsVisible then
					private.sortContext.baseSortValue[baseItemString] = self:_GetSortValue(row, sortKey, sortAscending)
					private.sortContext.rowSortValue[row] = private.sortContext.baseSortValue[baseItemString]
				end

				-- insert this row
				if hasSubRows or self._browseResultsVisible then
					self._rowByItem[baseItemString] = row
					tinsert(rows, row)
				else
					self._rowByItem[baseItemString] = private.subRowsTemp[1]
				end
				wipe(private.subRowsTemp)
			end
		end
	end

	-- sort the rows
	sort(rows, sortAscending and private.SortRowAscendingHelper or private.SortRowDescendingHelper)

	-- insert all the data
	local hasPrevSelection, nextIndexSelection = false, nil
	for _, row in ipairs(rows) do
		local baseItemString = row:GetBaseItemString()
		if not self._firstSubRowByItem[baseItemString] and not self._firstUnscannedItem then
			self._firstUnscannedItem = baseItemString
		end
		tinsert(self._data, row)
		hasPrevSelection = hasPrevSelection or self._selection == row
		local startIndex = subRowsStart[baseItemString]
		if startIndex then
			for i = startIndex, subRowsEnd[baseItemString] do
				local subRow = subRows[i]
				tinsert(self._data, subRow)
				hasPrevSelection = hasPrevSelection or self._selection == subRow
			end
			if not hasPrevSelection and not nextIndexSelection then
				if self._selectionBaseItemString == baseItemString and self._selectionSubRowIndex then
					-- check if we can find the new selection based on the sub row index (subtract 2 because subRows start from index 2)
					local index = startIndex + self._selectionSubRowIndex - 2
					if index <= subRowsEnd[baseItemString] then
						nextIndexSelection = subRows[index]
					end
				end
			end
		end
	end
	TempTable.Release(rows)
	TempTable.Release(subRows)
	TempTable.Release(subRowsStart)
	TempTable.Release(subRowsEnd)

	if self._selection and not hasPrevSelection then
		-- the previous selection doesn't exist anymore
		local firstSubRow = self._firstSubRowByItem[self._selectionBaseItemString]
		if nextIndexSelection then
			-- we can select the next subRow for the same item
			self:SetSelection(nextIndexSelection)
		elseif firstSubRow then
			-- select the first row of the same item
			self:SetSelection(firstSubRow)
		elseif self._selectionBaseSortValue then
			-- select the next row by sort value (if it exists)
			local bestSortValue, bestNewSelection = nil, nil
			for _, row in ipairs(self._data) do
				local baseItemString = row:GetBaseItemString()
				local sortValue = private.sortContext.baseSortValue[baseItemString]
				if sortValue and (row == self._firstSubRowByItem[baseItemString] or row == self._rowByItem[baseItemString]) then
					local isBetterSortValue = nil
					if self._sortAscending then
						isBetterSortValue = (not bestSortValue or sortValue < bestSortValue) and (sortValue > self._selectionBaseSortValue or (sortValue == self._selectionBaseSortValue and baseItemString > self._selectionBaseItemString))
					else
						isBetterSortValue = (not bestSortValue or sortValue > bestSortValue) and (sortValue < self._selectionBaseSortValue or (sortValue == self._selectionBaseSortValue and baseItemString < self._selectionBaseItemString))
					end
					if isBetterSortValue then
						bestSortValue = sortValue
						bestNewSelection = row
					end
				end
			end
			self:SetSelection(bestNewSelection)
		else
			self:SetSelection(nil)
		end
	elseif self._selection then
		self._selectionBaseSortValue = private.sortContext.baseSortValue[self._selection:GetBaseItemString()]
	end

	wipe(private.sortContext.sortValue)
	wipe(private.sortContext.rowSortValue)
	wipe(private.sortContext.baseSortValue)
	private.sortContext.self = nil
end

function AuctionScrollingTable._GetSortValue(self, row, id, isAscending)
	if id == "item" then
		local baseItemString = row:GetBaseItemString()
		return ItemInfo.GetName(baseItemString)
	elseif id == "ilvl" then
		return ItemInfo.GetItemLevel(row:GetItemString() or row:GetBaseItemString())
	elseif id == "posts" then
		local _, numAuctions = row:GetQuantities()
		return numAuctions or (isAscending and math.huge or -math.huge)
	elseif id == "stack" then
		local quantity = row:GetQuantities()
		return quantity or (isAscending and math.huge or -math.huge)
	elseif id == "qty" then
		local quantity, numAuctions = row:GetQuantities()
		if not quantity or not numAuctions then
			return isAscending and math.huge or -math.huge
		end
		return quantity * numAuctions
	elseif id == "timeLeft" then
		if not row:IsSubRow() then
			return isAscending and math.huge or -math.huge
		end
		local timeLeft = row:GetListingInfo()
		return timeLeft
	elseif id == "seller" then
		if not row:IsSubRow() then
			return ""
		end
		local ownerStr = row:GetOwnerInfo()
		return ownerStr
	elseif id == "itemBid" then
		if not row:IsSubRow() then
			return isAscending and math.huge or -math.huge
		end
		local _, itemDisplayedBid = row:GetDisplayedBids()
		return itemDisplayedBid
	elseif id == "bid" then
		if not row:IsSubRow() then
			return isAscending and math.huge or -math.huge
		end
		local displayedBid = row:GetDisplayedBids()
		return displayedBid
	elseif id == "itemBuyout" then
		local _, itemBuyout, minItemBuyout = row:GetBuyouts()
		itemBuyout = itemBuyout or minItemBuyout or 0
		return itemBuyout == 0 and (isAscending and math.huge or -math.huge) or itemBuyout
	elseif id == "buyout" then
		local buyout = row:GetBuyouts() or 0
		return buyout == 0 and (isAscending and math.huge or -math.huge) or buyout
	elseif id == "bidPct" then
		local _, pct = self:_GetMarketValuePct(row)
		return pct or (isAscending and math.huge or -math.huge)
	elseif id == "pct" then
		local pct = self:_GetMarketValuePct(row)
		return pct or (isAscending and math.huge or -math.huge)
	else
		error("Invalid sort col id: "..tostring(id))
	end
end

function AuctionScrollingTable._GetTableRow(self, isHeader)
	local row = self.__super:_GetTableRow(isHeader)
	if not isHeader then
		for _, tooltipFrame in pairs(row._buttons) do
			ScriptWrapper.SetPropagate(tooltipFrame, "OnDoubleClick")
		end
		ScriptWrapper.Set(row._frame, "OnDoubleClick", private.RowOnDoubleClick, row)
	end
	return row
end

function AuctionScrollingTable._GetMarketValuePct(self, row)
	if not self._marketValueFunc then
		-- no market value function was set
		return nil, nil
	end
	local marketValue = self._marketValueFunc(row) or 0
	if marketValue == 0 then
		-- this item doesn't have a market value
		return nil, nil
	end
	local _, itemBuyout, minItemBuyout = row:GetBuyouts()
	itemBuyout = itemBuyout or minItemBuyout or 0
	local bidPct = nil
	if row:IsSubRow() then
		local _, itemDisplayedBid = row:GetDisplayedBids()
		bidPct = itemDisplayedBid / marketValue
	end
	return itemBuyout > 0 and itemBuyout / marketValue or nil, bidPct
end

function AuctionScrollingTable._ToggleSort(self, id)
	if not self._sortCol or not self._auctionScan then
		-- sorting disabled so ignore
		return
	end

	local sortCol = nil
	for _, col in ipairs(self._tableInfo:_GetCols()) do
		if col:_GetId() == id then
			sortCol = col:_GetId()
		end
	end
	assert(sortCol)
	if sortCol == self._sortCol then
		self._sortAscending = not self._sortAscending
	else
		self._sortCol = sortCol
		self._sortAscending = true
	end
	if self._selection then
		self._selectionBaseSortValue = self:_GetSortValue(self._selection, self._sortCol, self._sortAscending)
	end
	self:UpdateData(true)
end

function AuctionScrollingTable._SetRowData(self, row, data)
	local ownerStr = private.GetSellerCellText(self, data)
	local isPlayer = false
	if ownerStr ~= "" then
		for owner in String.SplitIterator(ownerStr, ",") do
			if PlayerInfo.IsPlayer(owner, true, true, true) then
				isPlayer = true
				break
			end
		end
	end
	if isPlayer then
		row._texts.seller:SetTextColor(0.3, 0.6, 1, 1)
	else
		row._texts.seller:SetTextColor(1, 1, 1, 1)
	end
	self.__super:_SetRowData(row, data)
end



-- ============================================================================
-- Local Script Handlers
-- ============================================================================

function private.RowOnDoubleClick(row, mouseButton)
	if mouseButton ~= "LeftButton" then
		return
	end
	local self = row._scrollingTable
	local subRow = row:GetData()
	local baseItemString = subRow:GetBaseItemString()
	self._expanded[baseItemString] = not self._expanded[baseItemString]
	self:UpdateData(true)
end



-- ============================================================================
-- Private Helper Functions
-- ============================================================================

function private.SortRowAscendingHelper(a, b)
	local sortContext = private.sortContext
	local aSortValue = sortContext.rowSortValue[a]
	local bSortValue = sortContext.rowSortValue[b]
	if aSortValue == bSortValue then
		return a:GetBaseItemString() < b:GetBaseItemString()
	end
	return aSortValue < bSortValue
end

function private.SortRowDescendingHelper(a, b)
	local sortContext = private.sortContext
	local aSortValue = sortContext.rowSortValue[a]
	local bSortValue = sortContext.rowSortValue[b]
	if aSortValue == bSortValue then
		return a:GetBaseItemString() > b:GetBaseItemString()
	end
	return aSortValue > bSortValue
end

function private.SortSubRowAscendingHelper(a, b)
	local sortContext = private.sortContext
	local aBaseItemString = a:GetBaseItemString()
	local bBaseItemString = b:GetBaseItemString()
	if aBaseItemString == bBaseItemString then
		local aSortValue = sortContext.sortValue[a]
		local bSortValue = sortContext.sortValue[b]
		if aSortValue == bSortValue then
			-- always show base records first
			local self = sortContext.self
			if self._firstSubRowByItem[aBaseItemString] == a then
				return true
			elseif self._firstSubRowByItem[bBaseItemString] == b then
				return false
			else
				-- order by buyout
				local _, aItemBuyout = a:GetBuyouts()
				local _, bItemBuyout = b:GetBuyouts()
				if aItemBuyout ~= bItemBuyout then
					return aItemBuyout < bItemBuyout
				end
				-- show the higher auctionId first
				local _, aAuctionId, aBrowseId = a:GetListingInfo()
				local _, bAuctionId, bBrowseId = b:GetListingInfo()
				if aAuctionId ~= bAuctionId then
					return aAuctionId > bAuctionId
				else
					return aBrowseId > bBrowseId
				end
			end
		end
		return aSortValue < bSortValue
	else
		-- we're sorting different items
		local aSortValue = sortContext.baseSortValue[aBaseItemString]
		local bSortValue = sortContext.baseSortValue[bBaseItemString]
		if aSortValue == bSortValue then
			return aBaseItemString < bBaseItemString
		end
		return aSortValue < bSortValue
	end
end

function private.SortSubRowDescendingHelper(a, b)
	local sortContext = private.sortContext
	local aBaseItemString = a:GetBaseItemString()
	local bBaseItemString = b:GetBaseItemString()
	if aBaseItemString == bBaseItemString then
		local aSortValue = sortContext.sortValue[a]
		local bSortValue = sortContext.sortValue[b]
		if aSortValue == bSortValue then
			-- always show base records first
			local self = sortContext.self
			if self._firstSubRowByItem[aBaseItemString] == a then
				return true
			elseif self._firstSubRowByItem[bBaseItemString] == b then
				return false
			else
				-- order by buyout
				local _, aItemBuyout = a:GetBuyouts()
				local _, bItemBuyout = b:GetBuyouts()
				if aItemBuyout ~= bItemBuyout then
					return aItemBuyout < bItemBuyout
				end
				-- show the higher auctionId first
				local _, aAuctionId, aBrowseId = a:GetListingInfo()
				local _, bAuctionId, bBrowseId = b:GetListingInfo()
				if aAuctionId ~= bAuctionId then
					return aAuctionId > bAuctionId
				else
					return aBrowseId > bBrowseId
				end
			end
		end
		return aSortValue > bSortValue
	else
		-- we're sorting different items
		local aSortValue = sortContext.baseSortValue[aBaseItemString]
		local bSortValue = sortContext.baseSortValue[bBaseItemString]
		if aSortValue == bSortValue then
			return aBaseItemString > bBaseItemString
		end
		return aSortValue > bSortValue
	end
end

function private.GetItemCellText(self, subRow)
	local isIndented = subRow:IsSubRow()
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		local itemString = subRow:GetItemString()
		subRow = self._firstSubRowByItem[baseItemString]
		if not subRow then
			return TSM.UI.GetColoredItemName(itemString or baseItemString, 0)
		end
	end
	local itemLink = subRow:GetLinks()
	-- TODO: use theme constant for indented tint pct
	return TSM.UI.GetColoredItemName(itemLink, isIndented and -20 or 0)
end

function private.GetItemLevelCellText(self, subRow)
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		local itemString = subRow:GetItemString()
		subRow = self._firstSubRowByItem[baseItemString]
		if not subRow then
			return ItemInfo.GetItemLevel(itemString or baseItemString)
		end
	end
	local itemLink = subRow:GetLinks()
	return ItemInfo.GetItemLevel(itemLink)
end

function private.GetAuctionsQuantityText(self, subRow)
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		subRow = self._firstSubRowByItem[baseItemString] or subRow
	end
	local quantity, numAuctions = subRow:GetQuantities()
	if not quantity or not numAuctions then
		return ""
	end
	return quantity * numAuctions
end

function private.GetAuctionsPostsText(self, subRow)
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		subRow = self._firstSubRowByItem[baseItemString] or subRow
	end
	local _, numAuctions = subRow:GetQuantities()
	return numAuctions
end

function private.GetAuctionsStackText(self, subRow)
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		subRow = self._firstSubRowByItem[baseItemString] or subRow
	end
	local quantity = subRow:GetQuantities()
	return quantity
end

function private.GetTimeLeftCellText(self, subRow)
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		subRow = self._firstSubRowByItem[baseItemString]
		if not subRow then
			return ""
		end
	end
	local timeLeft = subRow:GetListingInfo()
	return TSM.UI.GetTimeLeftString(timeLeft)
end

function private.GetSellerCellText(self, subRow)
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		subRow = self._firstSubRowByItem[baseItemString]
		if not subRow then
			return ""
		end
	end
	local ownerStr = subRow:GetOwnerInfo()
	return ownerStr
end

function private.GetItemBidCellText(self, subRow)
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		subRow = self._firstSubRowByItem[baseItemString]
		if not subRow then
			return ""
		end
	end
	local _, itemDisplayedBid = subRow:GetDisplayedBids()
	local _, _, _, isHighBidder = subRow:GetBidInfo()
	return Money.ToString(itemDisplayedBid, isHighBidder and Theme.GetFeedbackColor("GREEN"):GetTextColorPrefix() or nil, "OPT_83_NO_COPPER")
end

function private.GetBidCellText(self, subRow)
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		subRow = self._firstSubRowByItem[baseItemString]
		if not subRow then
			return ""
		end
	end
	local displayedBid = subRow:GetDisplayedBids()
	local _, _, _, isHighBidder = subRow:GetBidInfo()
	return Money.ToString(displayedBid, isHighBidder and Theme.GetFeedbackColor("GREEN"):GetTextColorPrefix() or nil, "OPT_83_NO_COPPER")
end

function private.GetItemBuyoutCellText(self, subRow)
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		subRow = self._firstSubRowByItem[baseItemString] or subRow
	end
	local _, itemBuyout, minItemBuyout = subRow:GetBuyouts()
	local value = itemBuyout or minItemBuyout
	if not value then
		return ""
	end
	return Money.ToString(value, nil, "OPT_83_NO_COPPER")
end

function private.GetBuyoutCellText(self, subRow)
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		subRow = self._firstSubRowByItem[baseItemString] or subRow
	end
	local buyout = subRow:GetBuyouts()
	if not buyout then
		return ""
	end
	return Money.ToString(buyout, nil, "OPT_83_NO_COPPER")
end

function private.GetBidPercentCellText(self, subRow)
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		subRow = self._firstSubRowByItem[baseItemString] or subRow
	end
	local _, pct = self:_GetMarketValuePct(subRow)
	pct = pct and Math.Round(pct * 100) or nil
	if not pct then
		return "---"
	end
	local pctColor = Theme.GetAuctionPercentColor(pct)
	if pct > 999 then
		pct = ">999"
	end
	return pctColor:ColorText(pct.."%")
end

function private.GetPercentCellText(self, subRow)
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		subRow = self._firstSubRowByItem[baseItemString] or subRow
	end
	local pct, bidPct = self:_GetMarketValuePct(subRow)
	pct = pct and Math.Round(pct * 100) or nil
	bidPct = bidPct and Math.Round(bidPct * 100) or nil
	if pct then
		local pctColor = Theme.GetAuctionPercentColor(pct)
		if pct > 999 then
			pct = ">999"
		end
		return pctColor:ColorText(pct.."%")
	elseif bidPct then
		local pctColor = Theme.GetAuctionPercentColor("BID")
		if bidPct > 999 then
			bidPct = ">999"
		end
		return pctColor:ColorText(bidPct.."%")
	else
		return "---"
	end
end

function private.GetItemCellIcon(self, subRow)
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		subRow = self._firstSubRowByItem[baseItemString]
		if not subRow then
			return ItemInfo.GetTexture(baseItemString)
		end
	end
	local itemLink = subRow:GetLinks()
	return ItemInfo.GetTexture(itemLink)
end

function private.GetItemCellTooltip(self, subRow)
	local baseItemString = subRow:GetBaseItemString()
	local itemString = subRow:GetItemString()
	if not subRow:IsSubRow() then
		subRow = self._firstSubRowByItem[baseItemString] or subRow
		baseItemString = subRow:GetBaseItemString()
		itemString = subRow:GetItemString()
	end
	if subRow:IsSubRow() then
		local _, rawLink = subRow:GetLinks()
		return rawLink or itemString or baseItemString
	else
		return itemString or baseItemString
	end
end

function private.GetExpanderState(self, subRow)
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		subRow = self._firstSubRowByItem[baseItemString]
		if not subRow then
			return false, false, 0
		end
	end
	local baseItemString = subRow:GetBaseItemString()
	local isExpanded = self._expanded[baseItemString]
	local isIndented = isExpanded and subRow ~= self._firstSubRowByItem[baseItemString]
	local numSubRows = subRow:GetResultRow():GetNumSubRows()
	local expanderVisible = not isIndented and numSubRows > 1
	return expanderVisible, expanderVisible and isExpanded, isIndented and 1 or 0
end

function private.GetBadgeState(self, subRow)
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		subRow = self._firstSubRowByItem[baseItemString]
		if not subRow then
			return false
		end
	end
	local baseItemString = subRow:GetBaseItemString()
	local numSubRows = subRow:GetResultRow():GetNumSubRows()
	local isVisible = not self._expanded[baseItemString] and numSubRows > 1
	return isVisible, numSubRows > 999 and "(999+)" or ("("..numSubRows..")")
end

function private.GetPendingIcon(self, subRow, iconIndex)
	assert(iconIndex == 1)
	if not subRow:IsSubRow() then
		local baseItemString = subRow:GetBaseItemString()
		subRow = self._firstSubRowByItem[baseItemString]
		if not subRow then
			local texture, shouldRotate = nil, nil
			if baseItemString == self._currentSearchItem then
				local _, isPaused = self._auctionScan:GetProgress()
				texture = "iconPack.12x12/Running"
				shouldRotate = not isPaused
			else
				texture = TSM.UI.TexturePacks.GetColoredKey("iconPack.12x12/Running", "ACTIVE_BG_ALT")
				shouldRotate = false
			end
			return true, texture, true, nil, shouldRotate
		end
	end
	return false
end

function private.OnPendingIconClick(self, data)
	self:SetSelection(data)
end