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

local _, TSM = ...
local Auctioning = TSM.UI.AuctionUI:NewPackage("Auctioning")
local L = TSM.Include("Locale").GetTable()
local FSM = TSM.Include("Util.FSM")
local Event = TSM.Include("Util.Event")
local Table = TSM.Include("Util.Table")
local Sound = TSM.Include("Util.Sound")
local Money = TSM.Include("Util.Money")
local Log = TSM.Include("Util.Log")
local Theme = TSM.Include("Util.Theme")
local ItemString = TSM.Include("Util.ItemString")
local Threading = TSM.Include("Service.Threading")
local ItemInfo = TSM.Include("Service.ItemInfo")
local CustomPrice = TSM.Include("Service.CustomPrice")
local BagTracking = TSM.Include("Service.BagTracking")
local AuctionTracking = TSM.Include("Service.AuctionTracking")
local AuctionScan = TSM.Include("Service.AuctionScan")
local Settings = TSM.Include("Service.Settings")
local UIElements = TSM.Include("UI.UIElements")
local private = {
	settings = nil,
	contentPath = "selection",
	hasLastScan = false,
	fsm = nil,
	scanContext = {},
	auctionScan = nil,
	groupSearch = "",
	selectionFrame = nil,
	logQuery = nil,
	perItem = true,
	canStartNewScan = false,
}
local SECONDS_PER_MIN = 60
local SECONDS_PER_HOUR = 60 * SECONDS_PER_MIN
local SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR



-- ============================================================================
-- Module Functions
-- ============================================================================

function Auctioning.OnInitialize()
	private.settings = Settings.NewView()
		:AddKey("global", "auctionUIContext", "auctioningSelectionDividedContainer")
		:AddKey("global", "auctionUIContext", "auctioningSelectionVerticalDividedContainer")
		:AddKey("global", "auctionUIContext", "auctioningBagScrollingTable")
		:AddKey("global", "auctionUIContext", "auctioningLogScrollingTable")
		:AddKey("global", "auctionUIContext", "auctioningAuctionScrollingTable")
		:AddKey("global", "auctionUIContext", "auctioningTabGroup")
		:AddKey("char", "auctionUIContext", "auctioningGroupTree")
		:AddKey("global", "auctioningOptions", "scanCompleteSound")
		:AddKey("global", "auctioningOptions", "confirmCompleteSound")
	TSM.UI.AuctionUI.RegisterTopLevelPage(L["Auctioning"], private.GetAuctioningFrame, private.OnItemLinked)
	private.FSMCreate()
end



-- ============================================================================
-- Auctioning UI
-- ============================================================================

function private.GetAuctioningFrame()
	TSM.UI.AnalyticsRecordPathChange("auction", "auctioning")
	if not private.hasLastScan then
		private.contentPath = "selection"
	end
	return UIElements.New("ViewContainer", "auctioning")
		:SetNavCallback(private.GetAuctioningContentFrame)
		:AddPath("selection")
		:AddPath("scan")
		:SetPath(private.contentPath)
end

function private.GetAuctioningContentFrame(_, path)
	private.contentPath = path
	if path == "selection" then
		return private.GetAuctioningSelectionFrame()
	elseif path == "scan" then
		return private.GetAuctioningScanFrame()
	else
		error("Unexpected path: "..tostring(path))
	end
end

function private.GetAuctioningSelectionFrame()
	TSM.UI.AnalyticsRecordPathChange("auction", "auctioning", "selection")
	local frame = UIElements.New("DividedContainer", "selection")
		:SetSettingsContext(private.settings, "auctioningSelectionDividedContainer")
		:SetMinWidth(220, 250)
		:SetBackgroundColor("PRIMARY_BG")
		:SetLeftChild(UIElements.New("Frame", "groupSelection")
			:SetLayout("VERTICAL")
			:SetPadding(0, 0, 8, 0)
			:AddChild(UIElements.New("Frame", "title")
				:SetLayout("HORIZONTAL")
				:SetMargin(0, 0, 0, 8)
				:SetHeight(24)
				:AddChild(UIElements.New("Input", "search")
					:SetMargin(8, 8, 0, 0)
					:SetIconTexture("iconPack.18x18/Search")
					:SetClearButtonEnabled(true)
					:AllowItemInsert(true)
					:SetHintText(L["Search Groups"])
					:SetValue(private.groupSearch)
					:SetScript("OnValueChanged", private.GroupSearchOnValueChanged)
				)
				:AddChild(UIElements.New("Button", "expandAllBtn")
					:SetSize(24, 24)
					:SetMargin(0, 4, 0, 0)
					:SetBackground("iconPack.18x18/Expand All")
					:SetScript("OnClick", private.ExpandAllGroupsOnClick)
					:SetTooltip(L["Expand / Collapse All Groups"])
				)
				:AddChild(UIElements.New("Button", "selectAllBtn")
					:SetSize(24, 24)
					:SetMargin(0, 8, 0, 0)
					:SetBackground("iconPack.18x18/Select All")
					:SetScript("OnClick", private.SelectAllGroupsOnClick)
					:SetTooltip(L["Select / Deselect All Groups"])
				)
			)
			:AddChild(UIElements.New("Texture", "line")
				:SetHeight(2)
				:SetTexture("ACTIVE_BG")
			)
			:AddChild(UIElements.New("ApplicationGroupTree", "groupTree")
				:SetSettingsContext(private.settings, "auctioningGroupTree")
				:SetQuery(TSM.Groups.CreateQuery(), "Auctioning")
				:SetSearchString(private.groupSearch)
				:SetScript("OnGroupSelectionChanged", private.GroupTreeOnGroupSelectionChanged)
			)
			:AddChild(UIElements.New("Frame", "bottom")
				:SetLayout("VERTICAL")
				:SetHeight(74)
				:SetBackgroundColor("PRIMARY_BG_ALT")
				:AddChild(UIElements.New("Texture", "line")
					:SetHeight(2)
					:SetTexture("ACTIVE_BG")
				)
				:AddChild(UIElements.New("ActionButton", "postScanBtn")
					:SetHeight(24)
					:SetMargin(8)
					:SetText(L["Run Post Scan"])
					:SetScript("OnClick", private.RunPostButtonOnclick)
				)
				:AddChild(UIElements.New("ActionButton", "cancelScanBtn")
					:SetHeight(24)
					:SetMargin(8, 8, 0, 8)
					:SetText(L["Run Cancel Scan"])
					:SetScript("OnClick", private.RunCancelButtonOnclick)
				)
			)
		)
		:SetRightChild(UIElements.New("DividedContainer", "content")
			:SetVertical()
			:SetMargin(0, 0, 6, 0)
			:SetSettingsContext(private.settings, "auctioningSelectionVerticalDividedContainer")
			:SetMinWidth(50, 100)
			:SetBackgroundColor("PRIMARY_BG")
			:SetTopChild(UIElements.New("Frame", "content")
				:SetLayout("VERTICAL")
				:AddChild(UIElements.New("TabGroup", "buttons")
					:SetNavCallback(private.GetScansElement)
					:SetSettingsContext(private.settings, "auctioningTabGroup")
					:AddPath(L["Recent Scans"])
					:AddPath(L["Favorite Scans"])
				)
			)
			:SetBottomChild(UIElements.New("Frame", "content")
				:SetLayout("VERTICAL")
				:AddChild(UIElements.New("Frame", "bottom")
					:SetLayout("VERTICAL")
					:SetHeight(37)
					:SetBackgroundColor("PRIMARY_BG_ALT")
					:AddChild(UIElements.New("Text", "label")
						:SetHeight(24)
						:SetMargin(4, 0, 6, 6)
						:SetFont("BODY_BODY1_BOLD")
						:SetText(L["Post Items from Bags"])
					)
				)
				:AddChild(UIElements.New("SelectionScrollingTable", "bagScrollingTable")
					:SetSettingsContext(private.settings, "auctioningBagScrollingTable")
					:GetScrollingTableInfo()
						:NewColumn("item")
							:SetTitle(L["Item"])
							:SetHeaderIndent(18)
							:SetFont("ITEM_BODY3")
							:SetJustifyH("LEFT")
							:SetIconSize(12)
							:SetTextInfo("autoBaseItemString", TSM.UI.GetColoredItemName)
							:SetIconInfo("itemTexture")
							:SetTooltipInfo("autoBaseItemString")
							:SetSortInfo("name")
							:DisableHiding()
							:Commit()
						:NewColumn("operation")
							:SetTitle(L["Auctioning Operation"])
							:SetFont("BODY_BODY3_MEDIUM")
							:SetJustifyH("LEFT")
							:SetTextInfo("firstOperation", private.BagGetOperationText)
							:SetSortInfo("firstOperation")
							:Commit()
						:Commit()
					:SetQuery(TSM.Auctioning.PostScan.CreateBagsQuery())
					:SetAutoReleaseQuery(true)
					:SetSelectionValidator(private.BagScrollingTableIsSelectionEnabled)
					:SetScript("OnSelectionChanged", private.BagOnSelectionChanged)
				)
				:AddChild(UIElements.New("Texture", "line")
					:SetHeight(2)
					:SetTexture("ACTIVE_BG")
				)
				:AddChild(UIElements.New("Frame", "button")
					:SetLayout("HORIZONTAL")
					:SetHeight(40)
					:SetPadding(8)
					:SetBackgroundColor("PRIMARY_BG_ALT")
					:AddChild(UIElements.New("ActionButton", "postSelected")
						:SetHeight(24)
						:SetMargin(0, 8, 0, 0)
						:SetDisabled(true)
						:SetText(L["Post Selected"])
						:SetScript("OnClick", private.RunPostBagsButtonOnClick)
					)
					:AddChild(UIElements.New("Button", "selectAll")
						:SetSize("AUTO", 20)
						:SetMargin(0, 8, 0, 0)
						:SetFont("BODY_BODY3_MEDIUM")
						:SetText(L["Select All"])
						:SetScript("OnClick", private.SelectAllOnClick)
					)
					:AddChild(UIElements.New("Texture", "line")
						:SetSize(2, 20)
						:SetMargin(0, 8, 0, 0)
						:SetTexture("ACTIVE_BG")
					)
					:AddChild(UIElements.New("Button", "clearAll")
						:SetSize("AUTO", 20)
						:SetFont("BODY_BODY3_MEDIUM")
						:SetText(L["Clear All"])
						:SetDisabled(true)
						:SetScript("OnClick", private.ClearAllOnClick)
					)
				)
			)
		)
		:SetScript("OnHide", private.SelectionOnHide)
	local noGroupSelected = frame:GetElement("groupSelection.groupTree"):IsSelectionCleared(true)
	frame:GetElement("groupSelection.bottom.postScanBtn"):SetDisabled(noGroupSelected)
	frame:GetElement("groupSelection.bottom.cancelScanBtn"):SetDisabled(noGroupSelected)
	private.selectionFrame = frame
	return frame
end

function private.GetScansElement(_, button)
	if button == L["Recent Scans"] then
		return UIElements.New("SearchList", "list")
			:SetQuery(TSM.Auctioning.SavedSearches.CreateRecentSearchesQuery())
			:SetEditButtonHidden(true)
			:SetScript("OnFavoriteChanged", private.SearchListOnFavoriteChanged)
			:SetScript("OnDelete", private.SearchListOnDelete)
			:SetScript("OnRowClick", private.SearchListOnRowClick)
	elseif button == L["Favorite Scans"] then
		return UIElements.New("SearchList", "list")
			:SetQuery(TSM.Auctioning.SavedSearches.CreateFavoriteSearchesQuery())
			:SetScript("OnFavoriteChanged", private.SearchListOnFavoriteChanged)
			:SetScript("OnEditClick", private.SearchListOnEditClick)
			:SetScript("OnDelete", private.SearchListOnDelete)
			:SetScript("OnRowClick", private.SearchListOnRowClick)
	else
		error("Unexpected button: "..tostring(button))
	end
end

function private.GetAuctioningScanFrame()
	TSM.UI.AnalyticsRecordPathChange("auction", "auctioning", "scan")
	return UIElements.New("Frame", "scan")
		:SetLayout("VERTICAL")
		:SetBackgroundColor("PRIMARY_BG")
		:AddChild(UIElements.New("Frame", "header")
			:SetLayout("HORIZONTAL")
			:SetPadding(8)
			:SetHeight(92)
			:AddChild(UIElements.New("Frame", "back")
				:SetLayout("VERTICAL")
				:SetWidth(54)
				:SetHeight(76)
				:SetMargin(0, 8, 0, 0)
				:SetPadding(0, 0, 4, 0)
				:SetBackgroundColor("PRIMARY_BG_ALT", true)
				:AddChild(UIElements.New("Button", "backBtn")
					:SetMargin(0, 0, 2, 0)
					:SetSize(28, 28)
					:SetBackground("iconPack.24x24/Close/Default")
					:SetScript("OnEnter", private.ExitScanButtonOnEnter)
					:SetScript("OnLeave", private.ExitScanButtonOnLeave)
					:SetScript("OnClick", private.ExitScanButtonOnClick)
				)
				:AddChild(UIElements.New("Text", "text")
					:SetHeight(18)
					:SetFont("BODY_BODY3_MEDIUM")
					:SetJustifyH("CENTER")
					:SetText(L["Exit"])
				)
				:AddChild(UIElements.New("Text", "text")
					:SetHeight(18)
					:SetFont("BODY_BODY3_MEDIUM")
					:SetJustifyH("CENTER")
					:SetText(L["Scan"])
				)
				:SetScript("OnEnter", private.ExitScanFrameOnEnter)
				:SetScript("OnLeave", private.ExitScanFrameOnLeave)
				:SetScript("OnMouseUp", private.ExitScanButtonOnClick)
			)
			:AddChild(UIElements.New("Frame", "content")
				:SetLayout("HORIZONTAL")
				:SetPadding(8, 8, 4, 4)
				:SetBackgroundColor("PRIMARY_BG_ALT", true)
				:AddChild(UIElements.New("Frame", "item")
					:SetLayout("VERTICAL")
					:AddChild(UIElements.New("Frame", "content")
						:SetLayout("HORIZONTAL")
						:SetHeight(24)
						:SetMargin(0, 0, 0, 4)
						:AddChild(UIElements.New("Button", "icon")
							:SetSize(18, 18)
						)
						:AddChild(UIElements.New("Button", "text")
							:SetMargin(4, 0, 0, 0)
							:SetFont("ITEM_BODY1")
							:SetJustifyH("LEFT")
						)
					)
					:AddChild(UIElements.New("Frame", "cost")
						:SetLayout("HORIZONTAL")
						:SetHeight(20)
						:AddChild(UIElements.New("Text", "desc")
							:SetWidth("AUTO")
							:SetFont("BODY_BODY3_MEDIUM")
							:SetText(L["Deposit Cost"]..":")
						)
						:AddChild(UIElements.New("Text", "text")
							:SetMargin(4, 0, 0, 0)
							:SetFont("TABLE_TABLE1")
						)
					)
					:AddChild(UIElements.New("Frame", "operation")
						:SetLayout("HORIZONTAL")
						:SetHeight(20)
						:AddChild(UIElements.New("Text", "desc")
							:SetWidth("AUTO")
							:SetFont("BODY_BODY3_MEDIUM")
							:SetText(L["Operation"]..":")
						)
						:AddChild(UIElements.New("Text", "text")
							:SetMargin(4, 0, 0, 0)
							:SetFont("BODY_BODY3_MEDIUM")
						)
					)
				)
				:AddChild(UIElements.New("Frame", "details")
					:SetLayout("VERTICAL")
					:SetWidth(371)
					:SetMargin(16, 0, 0, 0)
					:AddChild(UIElements.New("Frame", "header")
						:SetLayout("HORIZONTAL")
						:SetHeight(24)
						:AddChild(UIElements.New("Text", "text")
							:SetMargin(0, 10, 0, 0)
							:SetSize("AUTO", 16)
							:SetFont("BODY_BODY1")
							:SetText(L["Auctioning Details"])
						)
						:AddChild(UIElements.New("ActionButton", "editBtn")
							:SetHeight(16)
							:SetFont("BODY_BODY3_MEDIUM")
							:SetText(L["Edit Post"])
							:SetScript("OnClick", private.EditButtonOnClick)
						)
					)
					:AddChild(UIElements.New("Frame", "details")
						:SetLayout("HORIZONTAL")
						:SetMargin(0, 0, 4, 0)
						:AddChild(UIElements.New("Frame", "details1")
							:SetLayout("VERTICAL")
							:SetWidth(200)
							:SetMargin(0, 8, 0, 0)
							:AddChild(UIElements.New("Frame", "bid")
								:SetLayout("HORIZONTAL")
								:SetHeight(20)
								:AddChild(UIElements.New("Text", "desc")
									:SetWidth("AUTO")
									:SetFont("BODY_BODY3_MEDIUM")
									:SetText(L["Bid Price"]..":")
								)
								:AddChild(UIElements.New("Text", "text")
									:SetMargin(4, 0, 0, 0)
									:SetFont("TABLE_TABLE1")
								)
							)
							:AddChild(UIElements.New("Frame", "buyout")
								:SetLayout("HORIZONTAL")
								:SetHeight(20)
								:AddChild(UIElements.New("Text", "desc")
									:SetWidth("AUTO")
									:SetFont("BODY_BODY3_MEDIUM")
									:SetText(L["Buyout Price"]..":")
								)
								:AddChild(UIElements.New("Text", "text")
									:SetMargin(4, 0, 0, 0)
									:SetFont("TABLE_TABLE1")
								)
							)
						)
						:AddChild(UIElements.New("Frame", "details2")
							:SetLayout("VERTICAL")
							:AddChild(UIElements.New("Frame", "quantity")
								:SetLayout("HORIZONTAL")
								:SetHeight(20)
								:AddChild(UIElements.New("Text", "desc")
									:SetWidth("AUTO")
									:SetFont("BODY_BODY3_MEDIUM")
									:SetText((TSM.IsWowClassic() and L["Stack / Quantity"] or L["Quantity"])..":")
								)
								:AddChild(UIElements.New("Text", "text")
									:SetMargin(4, 0, 0, 0)
									:SetFont("TABLE_TABLE1")
								)
							)
							:AddChild(UIElements.New("Frame", "duration")
								:SetLayout("HORIZONTAL")
								:SetHeight(20)
								:AddChild(UIElements.New("Text", "desc")
									:SetWidth("AUTO")
									:SetFont("BODY_BODY3_MEDIUM")
									:SetText(L["Duration"]..":")
								)
								:AddChild(UIElements.New("Text", "text")
									:SetMargin(4, 0, 0, 0)
									:SetFont("TABLE_TABLE1")
								)
							)
						)
					)
				)
			)
		)
		:AddChild(UIElements.New("SimpleTabGroup", "tabs")
			:SetNavCallback(private.ScanNavCallback)
			:AddPath(L["Auctioning Log"], true)
			:AddPath(L["All Auctions"])
		)
		:AddChild(UIElements.New("Texture", "line")
			:SetHeight(2)
			:SetTexture("ACTIVE_BG")
		)
		:AddChild(UIElements.New("Frame", "bottom")
			:SetLayout("HORIZONTAL")
			:SetHeight(40)
			:SetPadding(8)
			:SetBackgroundColor("PRIMARY_BG_ALT")
			:AddChild(UIElements.New("ActionButton", "pauseResumeBtn")
				:SetSize(24, 24)
				:SetMargin(0, 8, 0, 0)
				:SetIcon("iconPack.18x18/PlayPause")
				:SetScript("OnClick", private.PauseResumeBtnOnClick)
			)
			:AddChild(UIElements.New("ProgressBar", "progressBar")
				:SetHeight(24)
				:SetMargin(0, 8, 0, 0)
				:SetProgress(0)
				:SetProgressIconHidden(false)
				:SetText(L["Starting Scan..."])
			)
			:AddChild(UIElements.NewNamed("ActionButton", "processBtn", "TSMAuctioningBtn")
				:SetSize(160, 24)
				:SetMargin(0, 8, 0, 0)
				:SetText(L["Post"])
				:SetDisabled(true)
				:DisableClickCooldown(true)
				:SetScript("OnClick", private.ProcessButtonOnClick)
			)
			:AddChild(UIElements.New("ActionButton", "skipBtn")
				:SetSize(160, 24)
				:SetText(L["Skip"])
				:SetDisabled(true)
				:DisableClickCooldown(true)
				:SetScript("OnClick", private.SkipButtonOnClick)
			)
		)
		:SetScript("OnUpdate", private.ScanFrameOnUpdate)
		:SetScript("OnHide", private.ScanFrameOnHide)
end

function private.ScanNavCallback(_, path)
	if path == L["Auctioning Log"] then
		TSM.UI.AnalyticsRecordPathChange("auction", "auctioning", "scan", "log")
		private.logQuery = private.logQuery or TSM.Auctioning.Log.CreateQuery()
		return UIElements.New("Frame", "logFrame")
			:SetLayout("VERTICAL")
			:AddChild(UIElements.New("QueryScrollingTable", "log")
				:SetSettingsContext(private.settings, "auctioningLogScrollingTable")
				:GetScrollingTableInfo()
					:NewColumn("index")
						:SetTitleIcon("iconPack.14x14/Attention")
						:SetIconSize(12)
						:SetFont("ITEM_BODY3")
						:SetJustifyH("CENTER")
						:SetIconInfo(nil, private.LogGetIndexIcon)
						:SetSortInfo("index")
						:Commit()
					:NewColumn("item")
						:SetTitle(L["Item"])
						:SetFont("ITEM_BODY3")
						:SetJustifyH("LEFT")
						:SetIconSize(12)
						:SetTextInfo("itemString", TSM.UI.GetColoredItemName)
						:SetIconInfo("itemString", ItemInfo.GetTexture)
						:SetTooltipInfo("itemString")
						:SetSortInfo("name")
						:Commit()
					:NewColumn("buyout")
						:SetTitle(L["Your Buyout"])
						:SetFont("TABLE_TABLE1")
						:SetJustifyH("RIGHT")
						:SetTextInfo("buyout", private.LogGetBuyoutText)
						:SetSortInfo("buyout")
						:Commit()
					:NewColumn("operation")
						:SetTitle(L["Operation"])
						:SetFont("TABLE_TABLE1")
						:SetJustifyH("LEFT")
						:SetTextInfo("operation")
						:SetSortInfo("operation")
						:Commit()
					:NewColumn("seller")
						:SetTitle(L["Seller"])
						:SetFont("TABLE_TABLE1")
						:SetJustifyH("LEFT")
						:SetTextInfo("seller")
						:SetSortInfo("seller")
						:Commit()
					:NewColumn("info")
						:SetTitle(INFO)
						:SetFont("TABLE_TABLE1")
						:SetJustifyH("LEFT")
						:SetTextInfo(nil, TSM.Auctioning.Log.GetInfoStr)
						:SetSortInfo("reasonStr")
						:Commit()
					:Commit()
				:SetQuery(private.logQuery)
				:SetSelectionDisabled(true)
			)
	elseif path == L["All Auctions"] then
		TSM.UI.AnalyticsRecordPathChange("auction", "auctioning", "scan", "auctions")
		return UIElements.New("Frame", "auctionsFrame")
			:SetLayout("VERTICAL")
			:AddChild(UIElements.New("AuctionScrollingTable", "auctions")
				:SetSettingsContext(private.settings, "auctioningAuctionScrollingTable")
				:SetBrowseResultsVisible(true)
				:SetMarketValueFunction(private.MarketValueFunction)
				:SetAuctionScan(private.auctionScan)
			)
	else
		error("Unexpected path: "..tostring(path))
	end
end



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

function private.OnItemLinked(_, itemLink)
	if private.selectionFrame then
		if not TSM.UI.AuctionUI.StartingScan(L["Auctioning"]) then
			return false
		end
		wipe(private.scanContext)
		private.scanContext.isItems = true
		tinsert(private.scanContext, TSM.Groups.TranslateItemString(ItemString.Get(itemLink)))
		private.selectionFrame:GetParentElement():SetPath("scan", true)
		private.fsm:ProcessEvent("EV_START_SCAN", "POST", private.scanContext)
		return true
	else
		if not private.canStartNewScan then
			return false
		end
		wipe(private.scanContext)
		private.scanContext.isItems = true
		tinsert(private.scanContext, TSM.Groups.TranslateItemString(ItemString.Get(itemLink)))
		private.fsm:ProcessEvent("EV_START_SCAN", "POST", private.scanContext)
		return true
	end
end

function private.SelectionOnHide(frame)
	assert(frame == private.selectionFrame)
	private.selectionFrame = nil
end

function private.GroupSearchOnValueChanged(input)
	private.groupSearch = strlower(input:GetValue())
	input:GetElement("__parent.__parent.groupTree")
		:SetSearchString(private.groupSearch)
		:Draw()
end

function private.ExpandAllGroupsOnClick(button)
	button:GetElement("__parent.__parent.groupTree")
		:ToggleExpandAll()
end

function private.SelectAllGroupsOnClick(button)
	button:GetElement("__parent.__parent.groupTree")
		:ToggleSelectAll()
end

function private.GroupTreeOnGroupSelectionChanged(groupTree)
	local postScanBtn = groupTree:GetElement("__parent.bottom.postScanBtn")
	postScanBtn:SetDisabled(groupTree:IsSelectionCleared())
	postScanBtn:Draw()
	local cancelScanBtn = groupTree:GetElement("__parent.bottom.cancelScanBtn")
	cancelScanBtn:SetDisabled(groupTree:IsSelectionCleared())
	cancelScanBtn:Draw()
end

function private.RunPostButtonOnclick(button)
	if not TSM.UI.AuctionUI.StartingScan(L["Auctioning"]) then
		return
	end
	wipe(private.scanContext)
	for _, groupPath in button:GetElement("__parent.__parent.groupTree"):SelectedGroupsIterator() do
		tinsert(private.scanContext, groupPath)
	end
	button:GetElement("__parent.__parent.__parent.__parent"):SetPath("scan", true)
	private.fsm:ProcessEvent("EV_START_SCAN", "POST", private.scanContext)
end

function private.RunCancelButtonOnclick(button)
	if not TSM.UI.AuctionUI.StartingScan(L["Auctioning"]) then
		return
	end
	wipe(private.scanContext)
	for _, groupPath in button:GetElement("__parent.__parent.groupTree"):SelectedGroupsIterator() do
		tinsert(private.scanContext, groupPath)
	end
	button:GetElement("__parent.__parent.__parent.__parent"):SetPath("scan", true)
	private.fsm:ProcessEvent("EV_START_SCAN", "CANCEL", private.scanContext)
end

function private.SearchListOnFavoriteChanged(_, dbRow, isFavorite)
	TSM.Auctioning.SavedSearches.SetSearchIsFavorite(dbRow, isFavorite)
end

function private.SearchListOnEditClick(searchList, dbRow)
	local dialog = UIElements.New("Frame", "frame")
		:SetLayout("VERTICAL")
		:SetSize(600, 187)
		:AddAnchor("CENTER")
		:SetBackgroundColor("FRAME_BG")
		:SetBorderColor("ACTIVE_BG")
		:AddChild(UIElements.New("Text", "title")
			:SetHeight(44)
			:SetMargin(16, 16, 24, 16)
			:SetFont("BODY_BODY1_BOLD")
			:SetJustifyH("CENTER")
			:SetText(L["Rename Search"])
		)
		:AddChild(UIElements.New("Input", "nameInput")
			:SetHeight(26)
			:SetMargin(16, 16, 0, 25)
			:SetBackgroundColor("PRIMARY_BG_ALT")
			:AllowItemInsert(true)
			:SetContext(dbRow)
			:SetValue(dbRow:GetField("name"))
			:SetScript("OnEnterPressed", private.RenameInputOnEnterPressed)
		)
		:AddChild(UIElements.New("Frame", "buttons")
			:SetLayout("HORIZONTAL")
			:SetMargin(16, 16, 0, 16)
			:AddChild(UIElements.New("Spacer", "spacer"))
			:AddChild(UIElements.New("ActionButton", "closeBtn")
				:SetSize(126, 26)
				:SetText(CLOSE)
				:SetScript("OnClick", private.DialogCloseBtnOnClick)
			)
		)
	searchList:GetBaseElement():ShowDialogFrame(dialog)
	dialog:GetElement("nameInput"):SetFocused(true)
end

function private.RenameInputOnEnterPressed(input)
	local name = input:GetValue()
	if name == "" then
		return
	end
	local dbRow = input:GetContext()
	local baseElement = input:GetBaseElement()
	baseElement:HideDialog()
	TSM.Auctioning.SavedSearches.RenameSearch(dbRow, name)
end

function private.DialogCloseBtnOnClick(button)
	button:GetBaseElement():HideDialog()
end

function private.SearchListOnDelete(_, dbRow)
	TSM.Auctioning.SavedSearches.DeleteSearch(dbRow)
end

function private.SearchListOnRowClick(searchList, dbRow)
	if not TSM.UI.AuctionUI.StartingScan(L["Auctioning"]) then
		return
	end
	local scanType = dbRow:GetField("searchType")
	wipe(private.scanContext)
	private.scanContext.isItems = scanType == "postItems" or nil
	TSM.Auctioning.SavedSearches.FiltersToTable(dbRow, private.scanContext)
	searchList:GetParentElement():GetParentElement():GetParentElement():GetParentElement():GetParentElement():SetPath("scan", true)
	private.fsm:ProcessEvent("EV_START_SCAN", scanType == "cancelGroups" and "CANCEL" or "POST", private.scanContext)
end

function private.PauseResumeBtnOnClick(button)
	private.fsm:ProcessEvent("EV_PAUSE_RESUME_CLICKED")
end

function private.ProcessButtonOnClick(button)
	private.fsm:ProcessEvent("EV_PROCESS_CLICKED")
end

function private.SkipButtonOnClick(button)
	private.fsm:ProcessEvent("EV_SKIP_CLICKED")
end

function private.ScanFrameOnUpdate(frame)
	frame:SetScript("OnUpdate", nil)
	private.fsm:ProcessEvent("EV_SCAN_FRAME_SHOWN", frame)
end

function private.ScanFrameOnHide(frame)
	private.fsm:ProcessEvent("EV_SCAN_FRAME_HIDDEN")
end

function private.BagOnSelectionChanged(scrollingTable)
	local selectionCleared = scrollingTable:IsSelectionCleared()
	scrollingTable:GetElement("__parent.button.postSelected"):SetDisabled(selectionCleared)
		:Draw()
	scrollingTable:GetElement("__parent.button.selectAll"):SetDisabled(scrollingTable:IsAllSelected())
		:Draw()
	scrollingTable:GetElement("__parent.button.clearAll"):SetDisabled(selectionCleared)
		:Draw()
end

function private.SelectAllOnClick(button)
	button:GetElement("__parent.__parent.bagScrollingTable"):SelectAll()
end

function private.ClearAllOnClick(button)
	button:GetElement("__parent.__parent.bagScrollingTable"):ClearSelection()
end

function private.RunPostBagsButtonOnClick(button)
	if not TSM.UI.AuctionUI.StartingScan(L["Auctioning"]) then
		return
	end
	wipe(private.scanContext)
	private.scanContext.isItems = true
	for _, row in button:GetElement("__parent.__parent.bagScrollingTable"):SelectionIterator() do
		local autoBaseItemString, operation = row:GetFields("autoBaseItemString", "firstOperation")
		if operation then
			tinsert(private.scanContext, autoBaseItemString)
		end
	end
	button:GetParentElement():GetParentElement():GetParentElement():GetParentElement():GetParentElement():SetPath("scan", true)
	private.fsm:ProcessEvent("EV_START_SCAN", "POST", private.scanContext)
end

function private.ExitScanButtonOnEnter(button)
	private.ExitScanFrameOnEnter(button:GetParentElement())
end

function private.ExitScanButtonOnLeave(button)
	private.ExitScanFrameOnLeave(button:GetParentElement())
end

function private.ExitScanFrameOnEnter(frame)
	frame:SetBackgroundColor("PRIMARY_BG_ALT+HOVER", true)
		:Draw()
end

function private.ExitScanFrameOnLeave(frame)
	frame:SetBackgroundColor("PRIMARY_BG_ALT", true)
		:Draw()
end

function private.ExitScanButtonOnClick()
	if TSM.IsWowClassic() then
		ClearCursor()
		ClickAuctionSellItemButton(AuctionsItemButton, "LeftButton")
		ClearCursor()
	end
	private.fsm:ProcessEvent("EV_BACK_BUTTON_CLICKED")
end

function private.EditButtonOnClick(button)
	private.fsm:ProcessEvent("EV_EDIT_BUTTON_CLICKED")
end



-- ============================================================================
-- FSM
-- ============================================================================

function private.FSMCreate()
	local fsmContext = {
		itemString = nil,
		scanFrame = nil,
		scanThreadId = nil,
		scanType = nil,
		auctionScan = nil,
		pausePending = nil,
		isScanning = false,
		pendingFuture = nil,
	}
	Event.Register("AUCTION_HOUSE_CLOSED", function()
		private.fsm:ProcessEvent("EV_AUCTION_HOUSE_CLOSED")
	end)
	if TSM.IsWowClassic() then
		Event.Register("CHAT_MSG_SYSTEM", function(_, msg)
			if msg == ERR_AUCTION_STARTED then
				private.fsm:SetLoggingEnabled(false)
				private.fsm:ProcessEvent("EV_AUCTION_POST_CONFIRM", true)
				private.fsm:SetLoggingEnabled(true)
			elseif msg == ERR_AUCTION_REMOVED then
				private.fsm:SetLoggingEnabled(false)
				private.fsm:ProcessEvent("EV_AUCTION_CANCEL_CONFIRM", true)
				private.fsm:SetLoggingEnabled(true)
			end
		end)
		local POST_ERR_MSGS = {
			-- errors where we can retry
			[ERR_ITEM_NOT_FOUND] = true,
			[ERR_AUCTION_DATABASE_ERROR] = true,
			-- errors where we can't retry
			[ERR_AUCTION_REPAIR_ITEM] = false,
			[ERR_AUCTION_LIMITED_DURATION_ITEM] = false,
			[ERR_AUCTION_USED_CHARGES] = false,
			[ERR_AUCTION_WRAPPED_ITEM] = false,
			[ERR_AUCTION_BAG] = false,
			[ERR_NOT_ENOUGH_MONEY] = false,
		}
		Event.Register("UI_ERROR_MESSAGE", function(_, _, msg)
			if POST_ERR_MSGS[msg] ~= nil then
				private.fsm:ProcessEvent("EV_AUCTION_POST_CONFIRM", false, POST_ERR_MSGS[msg])
			end
			if msg == ERR_ITEM_NOT_FOUND then
				private.fsm:ProcessEvent("EV_AUCTION_CANCEL_CONFIRM", false, true)
			end
		end)
	end
	local fsmPrivate = {}
	function fsmPrivate.UpdateDepositCost(context)
		if context.scanType ~= "POST" then
			return
		end

		local header = context.scanFrame:GetElement("header")
		local detailsHeader1 = header:GetElement("content.details.details.details1")

		local currentRow = TSM.Auctioning.PostScan.GetCurrentRow()
		if not currentRow then
			return
		end

		local itemString = currentRow:GetField("itemString")
		local postBag, postSlot = BagTracking.CreateQueryBagsAuctionable()
			:OrderBy("slotId", true)
			:Select("bag", "slot")
			:Equal("baseItemString", ItemString.GetBaseFast(itemString))
			:VirtualField("autoBaseItemString", "string", TSM.Groups.TranslateItemString, "itemString")
			:Equal("autoBaseItemString", itemString)
			:GetFirstResultAndRelease()
		local postTime = currentRow:GetField("postTime")
		local stackSize = tonumber(currentRow:GetField("stackSize"))
		local depositCost = 0
		if postBag and postSlot then
			if TSM.IsWowClassic() then
				ClearCursor()
				PickupContainerItem(postBag, postSlot)
				ClickAuctionSellItemButton(AuctionsItemButton, "LeftButton")
				ClearCursor()
				local bid = Money.FromString(detailsHeader1:GetElement("bid.text"):GetText())
				local buyout = Money.FromString(detailsHeader1:GetElement("buyout.text"):GetText())
				depositCost = GetAuctionDeposit(postTime, bid, buyout, stackSize, 1)
				ClearCursor()
				ClickAuctionSellItemButton(AuctionsItemButton, "LeftButton")
				ClearCursor()
			else
				local isCommodity = ItemInfo.IsCommodity(itemString)
				depositCost = max(floor(0.15 * (ItemInfo.GetVendorSell(itemString) or 0) * (isCommodity and stackSize or 1) * (postTime == 3 and 4 or postTime)), 100) * (isCommodity and 1 or stackSize)
			end
		end

		header:GetElement("content.item.cost.text"):SetText(Money.ToString(depositCost))
			:Draw()
	end
	function fsmPrivate.UpdateScanFrame(context)
		if not context.scanFrame then
			return
		end

		local header = context.scanFrame:GetElement("header")
		local currentRow, numProcessed, numConfirmed, _, totalNum = nil, nil, nil, nil, nil
		if context.scanType == "POST" then
			currentRow = TSM.Auctioning.PostScan.GetCurrentRow()
			numProcessed, numConfirmed, _, totalNum = TSM.Auctioning.PostScan.GetStatus()
			header:GetElement("content.item.cost")
				:Show()
				:Draw()
		elseif context.scanType == "CANCEL" then
			currentRow = TSM.Auctioning.CancelScan.GetCurrentRow()
			numProcessed, numConfirmed, _, totalNum = TSM.Auctioning.CancelScan.GetStatus()
			header:GetElement("content.item.cost")
				:Hide()
				:Draw()
		else
			error("Invalid scan type: "..tostring(context.scanType))
		end
		local itemContent = header:GetElement("content.item.content")
		local detailsHeader1 = header:GetElement("content.details.details.details1")
		local detailsHeader2 = header:GetElement("content.details.details.details2")
		if currentRow then
			local selectedRow = nil
			for _, row in private.logQuery:Iterator() do
				if currentRow:GetField("auctionId") == row:GetField("index") then
					selectedRow = row
				end
			end
			if selectedRow and context.scanFrame:GetElement("tabs"):GetPath() == L["Auctioning Log"] then
				context.scanFrame:GetElement("tabs.logFrame.log")
					:SetSelection(selectedRow:GetUUID())
					:Draw()
			end

			local itemString = currentRow:GetField("itemString")
			local rowStacksRemaining = currentRow:GetField("numStacks") - currentRow:GetField("numProcessed")
			itemContent:GetElement("icon")
				:SetBackground(ItemInfo.GetTexture(itemString))
				:SetTooltip(itemString)
				:Draw()
			itemContent:GetElement("text")
				:SetText(TSM.UI.GetColoredItemName(itemString))
				:SetTooltip(itemString)
				:Draw()
			header:GetElement("content.item.operation.text")
				:SetText(currentRow:GetField("operationName"))
				:Draw()
			detailsHeader1:GetElement("bid.text")
				:SetText(Money.ToString(currentRow:GetField(ItemInfo.IsCommodity(itemString) and "itemBuyout" or "bid"), nil, "OPT_83_NO_COPPER"))
				:Draw()
			detailsHeader1:GetElement("buyout.text")
				:SetText(Money.ToString(currentRow:GetField(ItemInfo.IsCommodity(itemString) and "itemBuyout" or "buyout"), nil, "OPT_83_NO_COPPER"))
				:Draw()
			detailsHeader2:GetElement("quantity.text")
				:SetText(TSM.IsWowClassic() and format(L["%d of %d"], rowStacksRemaining, currentRow:GetField("stackSize")) or currentRow:GetField("stackSize"))
				:Draw()
			local duration = nil
			if context.scanType == "POST" then
				duration = TSM.CONST.AUCTION_DURATIONS[currentRow:GetField("postTime")]
			elseif context.scanType == "CANCEL" then
				if TSM.IsWowClassic() then
					duration = _G["AUCTION_TIME_LEFT"..currentRow:GetField("duration")]
				else
					duration = currentRow:GetField("duration") - time()
					if duration < SECONDS_PER_MIN then
						duration = duration.."s"
					elseif duration < SECONDS_PER_HOUR then
						duration = floor(duration / SECONDS_PER_MIN).."m"
					elseif duration < SECONDS_PER_DAY then
						duration = floor(duration / SECONDS_PER_HOUR).."h"
					else
						duration = floor(duration / SECONDS_PER_DAY).."d"
					end
				end
			else
				error("Invalid scanType: "..tostring(context.scanType))
			end
			detailsHeader2:GetElement("duration.text")
				:SetText(duration)
				:Draw()
			if context.scanType == "POST" and context.itemString ~= itemString then
				fsmPrivate.UpdateDepositCost(context)
				context.itemString = itemString
			end
			header:GetElement("content.details.header.editBtn")
				:SetDisabled(context.scanType ~= "POST")
				:Draw()
		else
			itemContent:GetElement("icon")
				:SetBackground(nil)
				:SetTooltip(nil)
				:Draw()
			itemContent:GetElement("text")
				:SetText("-")
				:SetTooltip(nil)
				:Draw()
			header:GetElement("content.item.cost.text")
				:SetText("-")
				:Draw()
			header:GetElement("content.item.operation.text")
				:SetText("-")
				:Draw()
			detailsHeader1:GetElement("bid.text")
				:SetText("-")
				:Draw()
			detailsHeader1:GetElement("buyout.text")
				:SetText("-")
				:Draw()
			detailsHeader2:GetElement("quantity.text")
				:SetText("-")
				:Draw()
			detailsHeader2:GetElement("duration.text")
				:SetText("-")
				:Draw()
			if context.scanFrame:GetElement("tabs"):GetPath() == L["Auctioning Log"] then
				context.scanFrame:GetElement("tabs.logFrame.log")
					:SetSelection(nil)
					:Draw()
			end
			header:GetElement("content.details.header.editBtn")
				:SetDisabled(true)
				:Draw()
		end

		local processText = nil
		if context.scanType == "POST" then
			processText = L["Post"]
		elseif context.scanType == "CANCEL" then
			processText = CANCEL
		else
			error("Invalid scan type: "..tostring(context.scanType))
		end
		local bottom = context.scanFrame:GetElement("bottom")
		bottom:GetElement("processBtn")
			:SetText(processText)
		local progress, isPaused = context.auctionScan:GetProgress()
		local scanDone = progress == 1 and not context.isScanning
		local isPausePending = context.pausePending ~= nil
		if not isPausePending and (scanDone or isPaused) then
			-- we're done (or paused) scanning so start Posting/Canceling
			local doneStr, progressFmtStr = nil, nil
			if context.scanType == "POST" then
				doneStr = L["Done Posting"]
				progressFmtStr = (isPaused and (L["Scan Paused"].." | ") or "")..L["Posting %d / %d"]
			elseif context.scanType == "CANCEL" then
				doneStr = L["Done Canceling"]
				progressFmtStr = (isPaused and (L["Scan Paused"].." | ") or "")..L["Canceling %d / %d"]
			else
				error("Invalid scan type: "..tostring(context.scanType))
			end
			local progressText, iconHidden = nil, false
			if numConfirmed == totalNum then
				progressText = doneStr
				iconHidden = true
			elseif numProcessed == totalNum then
				progressText = format(L["Confirming %d / %d"], numConfirmed + 1, totalNum)
			elseif numProcessed == numConfirmed then
				progressText = format(progressFmtStr, numProcessed + 1, totalNum)
				iconHidden = true
			else
				progressText = format(progressFmtStr.." ("..L["Confirming %d / %d"]..")", numProcessed + 1, totalNum, numConfirmed + 1, totalNum)
			end
			bottom:GetElement("progressBar")
				:SetProgress(totalNum > 0 and (numProcessed / totalNum) or 1)
				:SetProgressIconHidden(iconHidden)
				:SetText(progressText)
			local deposit = context.scanType == "POST" and Money.FromString(header:GetElement("content.item.cost.text"):GetText())
			bottom:GetElement("processBtn"):SetDisabled(numProcessed == totalNum or (deposit and deposit > GetMoney()) or (not TSM.IsWowClassic() and context.pendingFuture))
			bottom:GetElement("skipBtn"):SetDisabled(numProcessed == totalNum)
			bottom:GetElement("pauseResumeBtn")
				:SetDisabled(numProcessed ~= numConfirmed or scanDone)
				:SetHighlightLocked(false)
		else
			-- we're scanning or pausing
			local text = nil
			if isPausePending then
				text = isPaused and L["Resuming Scan..."] or L["Pausing Scan..."]
			else
				local numItems = context.auctionScan:GetNumItems()
				text = numItems and format(L["Scanning (%d Items)"], numItems) or L["Scanning"]
			end
			bottom:GetElement("progressBar")
				:SetProgress(progress)
				:SetProgressIconHidden(false)
				:SetText(text)
			bottom:GetElement("processBtn"):SetDisabled(true)
			bottom:GetElement("skipBtn"):SetDisabled(true)
			bottom:GetElement("pauseResumeBtn")
				:SetDisabled(isPausePending or numProcessed == totalNum)
				:SetHighlightLocked(isPausePending)
		end
		bottom:Draw()
	end
	function fsmPrivate.ShowEditDialog(context)
		if context.scanType ~= "POST" then
			return
		end
		local currentRow = TSM.Auctioning.PostScan.GetCurrentRow()
		local itemString = currentRow:GetField("itemString")
		local isCommodity = ItemInfo.IsCommodity(itemString)
		local bid = currentRow:GetField(isCommodity and "itemBuyout" or "bid")
		local buyout = currentRow:GetField(isCommodity and "itemBuyout" or "buyout")

		private.perItem = true

		context.scanFrame:GetBaseElement():ShowDialogFrame(UIElements.New("Frame", "frame")
			:SetLayout("VERTICAL")
			:SetSize(328, 328)
			:SetPadding(12)
			:AddAnchor("CENTER")
			:SetBackgroundColor("FRAME_BG", true)
			:SetMouseEnabled(true)
			:AddChild(UIElements.New("Frame", "header")
				:SetLayout("HORIZONTAL")
				:SetHeight(24)
				:SetMargin(0, 0, -4, 10)
				:AddChild(UIElements.New("Spacer", "spacer")
					:SetWidth(24)
				)
				:AddChild(UIElements.New("Text", "title")
					:SetFont("BODY_BODY2_MEDIUM")
					:SetJustifyH("CENTER")
					:SetText(L["Edit Post"])
				)
				:AddChild(UIElements.New("Button", "closeBtn")
					:SetMargin(0, -4, 0, 0)
					:SetBackgroundAndSize("iconPack.24x24/Close/Default")
					:SetScript("OnClick", private.EditDialogCloseBtnOnClick)
				)
			)
			:AddChild(UIElements.New("Frame", "item")
				:SetLayout("HORIZONTAL")
				:SetPadding(6)
				:SetMargin(0, 0, 0, 16)
				:SetBackgroundColor("PRIMARY_BG_ALT", true)
				:AddChild(UIElements.New("Button", "icon")
					:SetSize(36, 36)
					:SetMargin(0, 8, 0, 0)
					:SetBackground(ItemInfo.GetTexture(itemString))
					:SetTooltip(itemString)
				)
				:AddChild(UIElements.New("Text", "name")
					:SetHeight(36)
					:SetFont("ITEM_BODY1")
					:SetText(TSM.UI.GetColoredItemName(itemString))
				)
			)
			-- TODO: implement editing stack sizes
			:AddChild(UIElements.New("Frame", "stacksFrame")
				:SetLayout("HORIZONTAL")
				:SetHeight(20)
				:SetMargin(0, 0, 0, 16)
				:AddChild(UIElements.New("Text", "stacksText")
					:SetWidth("AUTO")
					:SetMargin(0, 8, 0, 0)
					:SetFont("BODY_BODY2")
					:SetText(L["Stack(s)"]..":")
				)
				:AddChild(UIElements.New("Input", "stacksInput")
					:SetSize(62, 24)
					:SetMargin(0, 16, 0, 0)
					:SetBackgroundColor("PRIMARY_BG_ALT")
					:SetValidateFunc("NUMBER", "1:5000")
					:SetDisabled(true)
					:SetValue(currentRow:GetField("numStacks"))
				)
				:AddChild(UIElements.New("Text", "quantityText")
					:SetWidth("AUTO")
					:SetMargin(0, 8, 0, 0)
					:SetFont("BODY_BODY2")
					:SetText(L["Quantity"]..":")
				)
				:AddChild(UIElements.New("Input", "quantityInput")
					:SetSize(62, 24)
					:SetBackgroundColor("PRIMARY_BG_ALT")
					:SetValidateFunc("NUMBER", "1:5000")
					:SetDisabled(true)
					:SetValue(currentRow:GetField("stackSize"))
				)
			)
			:AddChild(UIElements.New("Frame", "duration")
				:SetLayout("HORIZONTAL")
				:SetHeight(24)
				:SetMargin(0, 0, 0, 24)
				:AddChild(UIElements.New("Text", "desc")
					:SetWidth("AUTO")
					:SetFont("BODY_BODY2")
					:SetText(L["Duration"]..":")
				)
				:AddChild(UIElements.New("Toggle", "toggle")
					:SetMargin(0, 48, 0, 0)
					:AddOption(TSM.CONST.AUCTION_DURATIONS[1])
					:AddOption(TSM.CONST.AUCTION_DURATIONS[2])
					:AddOption(TSM.CONST.AUCTION_DURATIONS[3])
					:SetOption(TSM.CONST.AUCTION_DURATIONS[currentRow:GetField("postTime")])
				)
			)
			:AddChild(UIElements.New("Frame", "per")
				:SetLayout("HORIZONTAL")
				:SetHeight(20)
				:SetMargin(0, 0, 0, 8)
				:AddChild(UIElements.New("Spacer", "spacer"))
				:AddChild(UIElements.New("Button", "item")
					:SetWidth("AUTO")
					:SetMargin(0, 8, 0, 0)
					:SetFont("BODY_BODY2_MEDIUM")
					:SetJustifyH("RIGHT")
					:SetTextColor("INDICATOR")
					:SetText(L["Per Item"])
					:SetScript("OnClick", TSM.IsWowClassic() and private.PerItemOnClick)
				)
				:AddChildIf(TSM.IsWowClassic(), UIElements.New("Button", "stack")
					:SetWidth("AUTO")
					:SetTextColor("TEXT")
					:SetFont("BODY_BODY2_MEDIUM")
					:SetJustifyH("RIGHT")
					:SetTextColor("INDICATOR")
					:SetText(L["Per Stack"])
					:SetScript("OnClick", TSM.IsWowClassic() and private.PerStackOnClick)
				)
			)
			:AddChild(UIElements.New("Frame", "bid")
				:SetLayout("HORIZONTAL")
				:SetHeight(24)
				:SetMargin(0, 0, 0, 10)
				:AddChild(UIElements.New("Text", "desc")
					:SetWidth("AUTO")
					:SetFont("BODY_BODY2")
					:SetText(L["Bid Price"]..":")
				)
				:AddChild(UIElements.New("Spacer", "spacer"))
				:AddChild(UIElements.New("Input", "input")
					:SetWidth(132)
					:SetBackgroundColor("PRIMARY_BG_ALT")
					:SetFont("TABLE_TABLE1")
					:SetValidateFunc(private.BidBuyoutValidateFunc)
					:SetJustifyH("RIGHT")
					:SetDisabled(isCommodity)
					:SetTabPaths("__parent.__parent.buyout.input", "__parent.__parent.buyout.input")
					:SetContext("bid")
					:SetValue(Money.ToString(bid, nil, "OPT_83_NO_COPPER"))
					:SetScript("OnValidationChanged", private.BidBuyoutOnValidationChanged)
					:SetScript("OnValueChanged", private.BidBuyoutInputOnValueChanged)
					:SetScript("OnEnterPressed", private.BidBuyoutInputOnEnterPressed)
				)
			)
			:AddChild(UIElements.New("Frame", "buyout")
				:SetLayout("HORIZONTAL")
				:SetHeight(24)
				:SetMargin(0, 0, 0, 16)
				:AddChild(UIElements.New("Text", "desc")
					:SetWidth("AUTO")
					:SetFont("BODY_BODY2")
					:SetText(L["Buyout Price"]..":")
				)
				:AddChild(UIElements.New("Spacer", "spacer"))
				:AddChild(UIElements.New("Input", "input")
					:SetWidth(132)
					:SetBackgroundColor("PRIMARY_BG_ALT")
					:SetFont("TABLE_TABLE1")
					:SetValidateFunc(private.BidBuyoutValidateFunc)
					:SetJustifyH("RIGHT")
					:SetContext(isCommodity and "itemBuyout" or "buyout")
					:SetTabPaths("__parent.__parent.bid.input", "__parent.__parent.bid.input")
					:SetValue(Money.ToString(buyout, nil, "OPT_83_NO_COPPER"))
					:SetScript("OnValidationChanged", private.BidBuyoutOnValidationChanged)
					:SetScript("OnValueChanged", private.BidBuyoutInputOnValueChanged)
					:SetScript("OnEnterPressed", private.BidBuyoutInputOnEnterPressed)
				)
			)
			:AddChild(UIElements.New("ActionButton", "saveBtn")
				:SetHeight(24)
				:SetText(SAVE)
				:SetContext(context)
				:SetScript("OnClick", fsmPrivate.EditPostingDetailsSaveOnClick)
			)
		)
	end
	function fsmPrivate.EditPostingDetailsSaveOnClick(button)
		local context = button:GetContext()
		assert(context.scanType == "POST")
		local currentRow = TSM.Auctioning.PostScan.GetCurrentRow()

		local buyout = private.ParseBidBuyout(button:GetElement("__parent.buyout.input"):GetValue())
		local bid = min(private.ParseBidBuyout(button:GetElement("__parent.bid.input"):GetValue()), buyout)
		if not TSM.IsWowClassic() and ItemInfo.IsCommodity(context.itemString) and bid ~= buyout then
			Log.PrintUser(L["Did not change prices due to an invalid bid or buyout value."])
		else
			local duration = Table.KeyByValue(TSM.CONST.AUCTION_DURATIONS, button:GetElement("__parent.duration.toggle"):GetValue())
			if duration ~= currentRow:GetField("postTime") then
				TSM.Auctioning.PostScan.ChangePostDetail("postTime", duration)
			end

			-- update buyout first since doing so may change the bid
			if buyout ~= currentRow:GetField("buyout") then
				TSM.Auctioning.PostScan.ChangePostDetail("buyout", private.perItem and buyout or buyout / currentRow:GetField("stackSize"))
			end

			if not ItemInfo.IsCommodity(context.itemString) and bid ~= currentRow:GetField("bid") then
				TSM.Auctioning.PostScan.ChangePostDetail("bid", private.perItem and bid or bid / currentRow:GetField("stackSize"))
			end
		end

		fsmPrivate.UpdateDepositCost(context)
		fsmPrivate.UpdateScanFrame(context)
		button:GetBaseElement():HideDialog()
	end
	private.fsm = FSM.New("AUCTIONING")
		:AddState(FSM.NewState("ST_INIT")
			:SetOnEnter(function(context, scanType, scanContext)
				private.hasLastScan = false
				TSM.Auctioning.Log.Truncate()
				TSM.Auctioning.PostScan.Reset()
				TSM.Auctioning.CancelScan.Reset()

				if context.scanThreadId then
					Threading.Kill(context.scanThreadId)
					context.scanThreadId = nil
				end
				context.pausePending = nil
				context.itemString = nil
				context.isScanning = false
				if context.auctionScan then
					context.auctionScan:Release()
					context.auctionScan = nil
					private.auctionScan = context.auctionScan
				end
				if context.pendingFuture then
					context.pendingFuture:Cancel()
					context.pendingFuture = nil
				end

				if scanType then
					return "ST_STARTING_SCAN", scanType, scanContext
				elseif context.scanFrame then
					context.scanFrame:GetParentElement():SetPath("selection", true)
					context.scanFrame = nil
				end
				TSM.UI.AuctionUI.EndedScan(L["Auctioning"])
			end)
			:AddTransition("ST_INIT")
			:AddTransition("ST_STARTING_SCAN")
		)
		:AddState(FSM.NewState("ST_STARTING_SCAN")
			:SetOnEnter(function(context, scanType, scanContext)
				private.hasLastScan = true
				context.scanType = scanType
				if context.scanType == "POST" then
					context.scanThreadId = TSM.Auctioning.PostScan.Prepare()
					private.logQuery:ResetOrderBy()
					private.logQuery:OrderBy("index", true)
				elseif context.scanType == "CANCEL" then
					context.scanThreadId = TSM.Auctioning.CancelScan.Prepare()
					private.logQuery:ResetOrderBy()
					private.logQuery:OrderBy("index", false)
				else
					error("Invalid scan type: "..tostring(context.scanType))
				end
				context.auctionScan = AuctionScan.GetManager()
					:SetResolveSellers(true)
					:SetScript("OnProgressUpdate", private.FSMAuctionScanOnProgressUpdate)
				private.auctionScan = context.auctionScan
				fsmPrivate.UpdateScanFrame(context)
				Threading.SetCallback(context.scanThreadId, private.FSMScanCallback)
				Threading.Start(context.scanThreadId, context.auctionScan, scanContext)
				return "ST_SCANNING"
			end)
			:AddTransition("ST_SCANNING")
		)
		:AddState(FSM.NewState("ST_SCANNING")
			:SetOnEnter(function(context)
				context.isScanning = true
				fsmPrivate.UpdateScanFrame(context)
			end)
			:SetOnExit(function(context)
				context.isScanning = false
			end)
			:AddTransition("ST_RESULTS")
			:AddTransition("ST_INIT")
			:AddEvent("EV_SCAN_PROGRESS_UPDATE", function(context)
				local _, isPaused = context.auctionScan:GetProgress()
				if context.pausePending == isPaused then
					context.pausePending = nil
				end
				if isPaused and context.pausePending == nil then
					return "ST_RESULTS"
				else
					fsmPrivate.UpdateScanFrame(context)
				end
			end)
			:AddEvent("EV_SCAN_COMPLETE", function(context)
				Sound.PlaySound(private.settings.scanCompleteSound)
				return "ST_RESULTS"
			end)
			:AddEvent("EV_PAUSE_RESUME_CLICKED", function(context)
				assert(context.pausePending == nil)
				context.pausePending = true
				context.auctionScan:SetPaused(true)
				fsmPrivate.UpdateScanFrame(context)
			end)
			:AddEvent("EV_EDIT_BUTTON_CLICKED", function(context)
				fsmPrivate.ShowEditDialog(context)
			end)
		)
		:AddState(FSM.NewState("ST_HANDLING_CONFIRM")
			:SetOnEnter(function(context, success, canRetry)
				local isDone = false
				if context.scanType == "POST" then
					TSM.Auctioning.PostScan.HandleConfirm(success, canRetry)
					local _, numConfirmed, numFailed, totalNum = TSM.Auctioning.PostScan.GetStatus()
					if numConfirmed == totalNum then
						if numFailed > 0 then
							-- TODO: need to wait for the player's bags to settle
							Log.PrintfUser(L["Retrying %d auction(s) which failed."], numFailed)
							TSM.Auctioning.PostScan.PrepareFailedPosts()
						else
							isDone = true
						end
					end
				elseif context.scanType == "CANCEL" then
					TSM.Auctioning.CancelScan.HandleConfirm(success, canRetry)
					local _, numConfirmed, numFailed, totalNum = TSM.Auctioning.CancelScan.GetStatus()
					if numConfirmed == totalNum then
						if numFailed > 0 then
							-- TODO: need to wait for the player's auctions to settle
							Log.PrintfUser(L["Retrying %d auction(s) which failed."], numFailed)
							TSM.Auctioning.CancelScan.PrepareFailedCancels()
						else
							isDone = true
						end
					end
				else
					error("Invalid scan type: "..tostring(context.scanType))
				end
				local _, isPaused = context.auctionScan:GetProgress()
				if not isDone then
					return "ST_RESULTS"
				elseif isPaused then
					-- unpause the scan now that we're done
					assert(context.pausePending == nil)
					context.pausePending = false
					context.auctionScan:SetPaused(false)
					return "ST_SCANNING"
				else
					return "ST_DONE"
				end
			end)
			:AddTransition("ST_SCANNING")
			:AddTransition("ST_RESULTS")
			:AddTransition("ST_DONE")
		)
		:AddState(FSM.NewState("ST_RESULTS")
			:SetOnEnter(function(context)
				local _, isPaused = context.auctionScan:GetProgress()
				if not isPaused then
					TSM.UI.AuctionUI.EndedScan(L["Auctioning"])
					Threading.Kill(context.scanThreadId)
				end
				fsmPrivate.UpdateScanFrame(context)
			end)
			:AddTransition("ST_INIT")
			:AddTransition("ST_HANDLING_CONFIRM")
			:AddTransition("ST_SCANNING")
			:AddTransition("ST_DONE")
			:AddEvent("EV_PROCESS_CLICKED", function(context)
				context.scanFrame:GetBaseElement():HideDialog()
				local result, noRetry = nil, nil
				if context.scanType == "POST" then
					result, noRetry = TSM.Auctioning.PostScan.DoProcess()
				elseif context.scanType == "CANCEL" then
					result, noRetry = TSM.Auctioning.CancelScan.DoProcess()
				else
					error("Invalid scan type: "..tostring(context.scanType))
				end
				if not result then
					-- we failed to post / cancel
					return "ST_HANDLING_CONFIRM", false, not noRetry
				elseif not TSM.IsWowClassic() then
					context.pendingFuture = result
					context.pendingFuture:SetScript("OnDone", private.FSMPendingFutureOneDone)
				end
				fsmPrivate.UpdateScanFrame(context)
			end)
			:AddEvent("EV_SKIP_CLICKED", function(context)
				local isDone = nil
				if context.scanType == "POST" then
					TSM.Auctioning.PostScan.DoSkip()
					local _, numConfirmed, numFailed, totalNum = TSM.Auctioning.PostScan.GetStatus()
					isDone = numConfirmed == totalNum and numFailed == 0
				elseif context.scanType == "CANCEL" then
					TSM.Auctioning.CancelScan.DoSkip()
					local _, numConfirmed, numFailed, totalNum = TSM.Auctioning.CancelScan.GetStatus()
					isDone = numConfirmed == totalNum and numFailed == 0
				else
					error("Invalid scan type: "..tostring(context.scanType))
				end
				fsmPrivate.UpdateScanFrame(context)
				local _, isPaused = context.auctionScan:GetProgress()
				if isDone and isPaused then
					-- unpause the scan now that we're done
					assert(context.pausePending == nil)
					context.pausePending = false
					context.auctionScan:SetPaused(false)
					return "ST_SCANNING"
				elseif isDone then
					return "ST_DONE"
				end
			end)
			:AddEvent("EV_PENDING_FUTURE_DONE", function(context)
				assert(context.pendingFuture:IsDone())
				local value = context.pendingFuture:GetValue()
				context.pendingFuture = nil
				if value == true then
					return "ST_HANDLING_CONFIRM", true, false
				elseif value == false then
					return "ST_HANDLING_CONFIRM", false, true
				elseif value == nil then
					return "ST_HANDLING_CONFIRM", false, false
				else
					error("Invalid value: "..tostring(value))
				end
			end)
			:AddEvent("EV_AUCTION_POST_CONFIRM", function(context, success, canRetry)
				if context.scanType == "POST" then
					return "ST_HANDLING_CONFIRM", success, canRetry
				end
			end)
			:AddEvent("EV_AUCTION_CANCEL_CONFIRM", function(context, success, canRetry)
				if context.scanType == "CANCEL" then
					return "ST_HANDLING_CONFIRM", success, canRetry
				end
			end)
			:AddEvent("EV_PAUSE_RESUME_CLICKED", function(context)
				assert(context.pausePending == nil)
				context.pausePending = false
				context.auctionScan:SetPaused(false)
				return "ST_SCANNING"
			end)
			:AddEvent("EV_EDIT_BUTTON_CLICKED", function(context)
				fsmPrivate.ShowEditDialog(context)
			end)
		)
		:AddState(FSM.NewState("ST_DONE")
			:SetOnEnter(function(context)
				private.canStartNewScan = true
				AuctionTracking.QueryOwnedAuctions()
				Sound.PlaySound(private.settings.confirmCompleteSound)
				fsmPrivate.UpdateScanFrame(context)
			end)
			:SetOnExit(function(context)
				private.canStartNewScan = false
			end)
			:AddTransition("ST_INIT")
		)
		:AddDefaultEvent("EV_START_SCAN", function(context, scanType, scanContext)
			return "ST_INIT", scanType, scanContext
		end)
		:AddDefaultEvent("EV_SCAN_FRAME_SHOWN", function(context, scanFrame)
			context.scanFrame = scanFrame
			fsmPrivate.UpdateScanFrame(context)
		end)
		:AddDefaultEvent("EV_SCAN_FRAME_HIDDEN", function(context)
			context.scanFrame = nil
			context.itemString = nil
		end)
		:AddDefaultEventTransition("EV_BACK_BUTTON_CLICKED", "ST_INIT")
		:AddDefaultEventTransition("EV_AUCTION_HOUSE_CLOSED", "ST_INIT")
		:AddDefaultEvent("EV_PENDING_FUTURE_DONE", function(context)
			error("Unexpected pending future done event")
		end)
		:Init("ST_INIT", fsmContext)
end

function private.FSMAuctionScanOnProgressUpdate(auctionScan)
	-- this even is very spammy while we scan, so silence the FSM logging
	private.fsm:SetLoggingEnabled(false)
	private.fsm:ProcessEvent("EV_SCAN_PROGRESS_UPDATE")
	private.fsm:SetLoggingEnabled(true)
end

function private.FSMScanCallback()
	private.fsm:ProcessEvent("EV_SCAN_COMPLETE")
end

function private.FSMPendingFutureOneDone(value)
	private.fsm:ProcessEvent("EV_PENDING_FUTURE_DONE")
end



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

function private.BagScrollingTableIsSelectionEnabled(_, record)
	return record:GetField("firstOperation") and true or false
end

function private.BagGetOperationText(firstOperation)
	return firstOperation or Theme.GetFeedbackColor("RED"):ColorText(L["Skipped: No assigned operation"])
end

function private.LogGetBuyoutText(buyout)
	return buyout == 0 and "-" or Money.ToString(buyout, nil, "OPT_83_NO_COPPER")
end

function private.LogGetIndexIcon(row)
	if row:GetField("state") == "PENDING" then
		-- color the circle icon to match the color of the text
		return TSM.UI.TexturePacks.GetColoredKey("iconPack.12x12/Circle", TSM.Auctioning.Log.GetColorFromReasonKey(row:GetField("reasonKey")))
	else
		return "iconPack.12x12/Checkmark/Default"
	end
end

function private.MarketValueFunction(row)
	return CustomPrice.GetValue("dbmarket", row:GetItemString() or row:GetBaseItemString())
end

function private.EditDialogCloseBtnOnClick(button)
	button:GetBaseElement():HideDialog()
end

function private.PerItemOnClick(button)
	if private.perItem then
		return
	end

	private.perItem = true
	button:GetElement("__parent.stack")
		:SetTextColor("TEXT")
		:Draw()
	button:SetTextColor("INDICATOR")
		:Draw()

	local row = TSM.Auctioning.PostScan.GetCurrentRow()
	local bidInput = button:GetElement("__parent.__parent.bid.input")
	local buyoutInput = button:GetElement("__parent.__parent.buyout.input")
	buyoutInput:SetFocused(false)
		:SetValue(row:GetField("buyout"))
		:Draw()
	bidInput:SetFocused(false)
		:SetValue(row:GetField("bid"))
		:Draw()
end

function private.PerStackOnClick(button)
	if not private.perItem then
		return
	end

	private.perItem = false
	button:GetElement("__parent.item")
		:SetTextColor("TEXT")
		:Draw()
	button:SetTextColor("INDICATOR")
		:Draw()

	local row = TSM.Auctioning.PostScan.GetCurrentRow()
	local stackSize = row:GetField("stackSize")
	local bidInput = button:GetElement("__parent.__parent.bid.input")
	local buyoutInput = button:GetElement("__parent.__parent.buyout.input")
	buyoutInput:SetFocused(false)
		:SetValue(row:GetField("buyout") * stackSize)
		:Draw()
	bidInput:SetFocused(false)
		:SetValue(row:GetField("bid") * stackSize)
		:Draw()
end

function private.UpdateSaveButtonState(frame)
	local bidInput = frame:GetElement("bid.input")
	local buyoutInput = frame:GetElement("buyout.input")
	local bid = private.ParseBidBuyout(bidInput:GetValue())
	local buyout = private.ParseBidBuyout(buyoutInput:GetValue())
	frame:GetElement("saveBtn")
		:SetDisabled(bid > buyout or not bidInput:IsValid() or not buyoutInput:IsValid())
		:Draw()
end

function private.BidBuyoutOnValidationChanged(input)
	private.UpdateSaveButtonState(input:GetElement("__parent.__parent"))
end

function private.BidBuyoutInputOnValueChanged(input)
	local frame = input:GetElement("__parent.__parent")
	local context = frame:GetElement("saveBtn"):GetContext()
	local bidInput = frame:GetElement("bid.input")
	local buyoutInput = frame:GetElement("buyout.input")
	local bid = private.ParseBidBuyout(bidInput:GetValue())
	local buyout = private.ParseBidBuyout(buyoutInput:GetValue())
	if input == buyoutInput and not TSM.IsWowClassic() and ItemInfo.IsCommodity(context.itemString) then
		-- update the bid to match
		bidInput:SetValue(Money.ToString(buyout, nil, "OPT_83_NO_COPPER", "OPT_DISABLE"))
			:Draw()
	elseif input == bidInput and private.ParseBidBuyout(input:GetValue()) > private.ParseBidBuyout(buyoutInput:GetValue()) then
		-- update the buyout to match
		buyoutInput:SetValue(Money.ToString(bid, nil, "OPT_83_NO_COPPER"))
			:Draw()
	end
	private.UpdateSaveButtonState(frame)
end

function private.BidBuyoutInputOnEnterPressed(input)
	local frame = input:GetElement("__parent.__parent")
	local bidInput = frame:GetElement("bid.input")
	local buyoutInput = frame:GetElement("buyout.input")
	local value = private.ParseBidBuyout(input:GetValue())
	input:SetValue(Money.ToString(value, nil, "OPT_83_NO_COPPER"))
	input:Draw()
	if input == buyoutInput and private.ParseBidBuyout(buyoutInput:GetValue()) < private.ParseBidBuyout(bidInput:GetValue()) then
		-- update the bid to match
		bidInput:SetValue(Money.ToString(value, nil, "OPT_83_NO_COPPER"))
			:Draw()
	end
	private.UpdateSaveButtonState(frame)
end

function private.ParseBidBuyout(value)
	value = Money.FromString(value) or tonumber(value)
	if not value then
		return nil
	end
	if not TSM.IsWowClassic() and value % COPPER_PER_SILVER ~= 0 then
		return nil
	end
	return (value or 0) > 0 and value <= MAXIMUM_BID_PRICE and value or nil
end

function private.BidBuyoutValidateFunc(input, value)
	value = private.ParseBidBuyout(value)
	if not value then
		return false, L["Invalid price."]
	end
	return true
end