UI.lua

local addonName, ns = ...

local OUTER_WIDTH = 520
local OUTER_PADDING = 12
local SEARCH_HEIGHT = 48
local DROPDOWN_GAP = 8
local ROW_HEIGHT = 52
local ROW_SPACING = 2
local CONTENT_PADDING = 6
local FAVORITE_BUTTON_SIZE = 18
local FAVORITE_BUTTON_GAP = 12
local RIGHT_ROW_PADDING = 14
local TEXT_VERTICAL_OFFSET = -3
local SECURE_TYPE_SUFFIX = WOW_PROJECT_ID == WOW_PROJECT_MAINLINE and "release" or ""

local function applyBackdrop(frame, bgR, bgG, bgB, bgA, borderR, borderG, borderB, borderA)
    frame:SetBackdrop({
        bgFile = "Interface/Buttons/WHITE8X8",
        edgeFile = "Interface/Buttons/WHITE8X8",
        edgeSize = 1,
    })
    frame:SetBackdropColor(bgR, bgG, bgB, bgA)
    frame:SetBackdropBorderColor(borderR, borderG, borderB, borderA)
end

local function createText(parent, layer, fontObject, r, g, b)
    local text = parent:CreateFontString(nil, layer, fontObject)
    text:SetJustifyH("LEFT")
    text:SetJustifyV("MIDDLE")
    if r and g and b then
        text:SetTextColor(r, g, b)
    end
    return text
end

local function getPlayerClassColor()
    local classFilename = select(2, UnitClass("player"))
    local classColors = CUSTOM_CLASS_COLORS or RAID_CLASS_COLORS
    local classColor = classFilename and classColors and classColors[classFilename]

    if classColor then
        return classColor.r, classColor.g, classColor.b
    end

    return 0.28, 0.56, 0.86
end

local function getSecureResultBinding(result)
    if not result then
        return nil
    end

    if result.macroText and result.macroText ~= "" then
        return {
            type = "macro",
            macroText = result.macroText,
        }
    end

    return nil
end

local function updateFavoriteButtonState(button, isSelected)
    if not button.favoriteButton then
        return
    end

    local atlas = button.isFavorite and "auctionhouse-icon-favorite" or "auctionhouse-icon-favorite-off"
    button.favoriteButton.icon:SetAtlas(atlas)

    local alpha
    if button.isFavorite then
        alpha = button.favoriteButton.isHovered and 1 or (isSelected and 0.95 or 0.80)
    else
        alpha = button.favoriteButton.isHovered and 0.75 or (isSelected and 0.50 or 0.28)
    end

    if button.isDisabled then
        alpha = alpha * 0.75
    end

    button.favoriteButton.icon:SetAlpha(alpha)
end

local function setButtonState(button, isSelected)
    if isSelected then
        local r, g, b = getPlayerClassColor()
        button:SetBackdropColor(r, g, b, 0.15)
        button:SetBackdropBorderColor(r, g, b, 0.40)
        if button.isDisabled then
            button.title:SetTextColor(0.52, 0.56, 0.62)
            button.subtitle:SetTextColor(0.43, 0.46, 0.50)
        else
            button.title:SetTextColor(0.96, 0.97, 0.99)
            button.subtitle:SetTextColor(0.73, 0.77, 0.83)
        end
    else
        button:SetBackdropColor(1.00, 1.00, 1.00, 0.00)
        button:SetBackdropBorderColor(1.00, 1.00, 1.00, 0.00)
        if button.isDisabled then
            button.title:SetTextColor(0.42, 0.45, 0.50)
            button.subtitle:SetTextColor(0.34, 0.37, 0.41)
        else
            button.title:SetTextColor(0.88, 0.89, 0.92)
            button.subtitle:SetTextColor(0.57, 0.60, 0.66)
        end
    end

    if button.icon.SetDesaturated then
        button.icon:SetDesaturated(button.isDisabled)
    end

    button.icon:SetAlpha(button.isDisabled and 0.45 or 1)
    updateFavoriteButtonState(button, isSelected)
end

local function getLineView(result)
    local lineView = result.lineView or {}
    local subtitle = lineView.subtitle

    if subtitle == "" then
        subtitle = nil
    end

    return {
        icon = lineView.icon or result.icon or 134400,
        title = lineView.title or result.title or "",
        subtitle = subtitle,
        disabled = lineView.disabled or false,
    }
end

local function applyLineView(button, result)
    local lineView = getLineView(result)

    button.isDisabled = lineView.disabled
    button.icon:SetTexture(lineView.icon)
    button.title:SetText(lineView.title)

    button.title:ClearAllPoints()
    button.subtitle:ClearAllPoints()

    if lineView.subtitle then
        button.title:SetPoint("BOTTOMLEFT", button.textContainer, "LEFT", 0, 1 + TEXT_VERTICAL_OFFSET)
        button.title:SetPoint("BOTTOMRIGHT", button.textContainer, "RIGHT", 0, 1 + TEXT_VERTICAL_OFFSET)
        button.subtitle:SetPoint("TOPLEFT", button.textContainer, "LEFT", 0, -1 + TEXT_VERTICAL_OFFSET)
        button.subtitle:SetPoint("TOPRIGHT", button.textContainer, "RIGHT", 0, -1 + TEXT_VERTICAL_OFFSET)
        button.subtitle:SetText(lineView.subtitle)
        button.subtitle:Show()
    else
        button.title:SetPoint("LEFT", button.textContainer, "LEFT", 0, TEXT_VERTICAL_OFFSET)
        button.title:SetPoint("RIGHT", button.textContainer, "RIGHT", 0, TEXT_VERTICAL_OFFSET)
        button.subtitle:SetText("")
        button.subtitle:Hide()
    end
end

function ns:CreateUI()
    if self.ui then
        return self.ui
    end

    local frame = CreateFrame("Frame", "SimpleSearchFrame", UIParent, "BackdropTemplate")
    frame:SetSize(OUTER_WIDTH, OUTER_PADDING * 2 + SEARCH_HEIGHT)
    frame:SetPoint("CENTER", 0, 90)
    frame:SetFrameStrata("DIALOG")
    frame:SetToplevel(true)
    frame:SetClampedToScreen(true)
    frame:Hide()
    applyBackdrop(frame, 0.00, 0.00, 0.00, 0.80, 1.00, 1.00, 1.00, 0.08)

    local glow = frame:CreateTexture(nil, "BACKGROUND")
    glow:SetPoint("TOPLEFT", 1, -1)
    glow:SetPoint("TOPRIGHT", -1, -1)
    glow:SetHeight(56)
    glow:SetColorTexture(0.22, 0.26, 0.34, 0.12)

    local searchShell = CreateFrame("Frame", nil, frame, "BackdropTemplate")
    searchShell:SetPoint("TOPLEFT", OUTER_PADDING, -OUTER_PADDING)
    searchShell:SetPoint("TOPRIGHT", -OUTER_PADDING, -OUTER_PADDING)
    searchShell:SetHeight(SEARCH_HEIGHT)
    applyBackdrop(searchShell, 0.00, 0.00, 0.00, 0.40, 1.00, 1.00, 1.00, 0.04)

    local searchBox = CreateFrame("EditBox", "$parentSearchBox", searchShell)
    searchBox:SetHeight(34)
    searchBox:SetAutoFocus(false)
    searchBox:SetTextInsets(10, 10, 4, 4)
    searchBox:SetFont(STANDARD_TEXT_FONT, 22, "")
    searchBox:SetTextColor(0.95, 0.96, 0.98)
    searchBox:SetJustifyH("LEFT")
    searchBox:SetAltArrowKeyMode(false)
    searchBox:SetMaxLetters(128)

    local placeholder = createText(searchBox, "OVERLAY", "GameFontHighlightLarge", 0.46, 0.50, 0.56)
    placeholder:SetPoint("LEFT", 18, 0)
    placeholder:SetText("Search")

    local prefixHint = createText(searchShell, "OVERLAY", "GameFontHighlightSmall", 0.38, 0.42, 0.48)
    prefixHint:SetPoint("RIGHT", -18, 0)
    prefixHint:SetText(ns:GetModulePrefixHint())

    searchBox:SetPoint("LEFT", searchShell, "LEFT", 8, 0)
    searchBox:SetPoint("RIGHT", prefixHint, "LEFT", -12, 0)

    local resultsPane = CreateFrame("Frame", nil, frame)
    resultsPane:SetPoint("TOPLEFT", searchShell, "BOTTOMLEFT", 0, -DROPDOWN_GAP)
    resultsPane:SetPoint("TOPRIGHT", searchShell, "BOTTOMRIGHT", 0, -DROPDOWN_GAP)
    resultsPane:SetHeight(0)
    resultsPane:SetFrameStrata(frame:GetFrameStrata())
    resultsPane:SetFrameLevel(searchShell:GetFrameLevel() + 1)
    resultsPane:Hide()

    local buttons = {}
    local results = {}
    local selectedIndex
    local lastQueryKey = ""
    local suppressInitialWhitespace = false
    local isNormalizingSearchText = false

    local executeButton = CreateFrame("Button", "SimpleSearchExecuteButton", frame, "InsecureActionButtonTemplate")
    executeButton:RegisterForClicks("AnyDown", "AnyUp")
    executeButton:SetAttribute("pressAndHoldAction", "1")
    executeButton:SetAttribute("type", "macro")
    executeButton:SetAttribute("macrotext", "")
    if WOW_PROJECT_ID == WOW_PROJECT_MAINLINE then
        executeButton:SetAttribute("typerelease", "macro")
    end
    executeButton:Hide()

    local function getSelectedResult()
        return results[selectedIndex or 1]
    end

    local function hasSelectedSecureBinding()
        return getSecureResultBinding(getSelectedResult()) ~= nil
    end

    local function applyButtonSecureBinding(button, binding)
        local typeAttribute = "type" .. SECURE_TYPE_SUFFIX .. "1"

        button:SetAttribute("type1", nil)
        button:SetAttribute("typerelease1", nil)
        button:SetAttribute(typeAttribute, nil)
        button:SetAttribute("macrotext", "")

        if not binding then
            return
        end

        if binding.type == "macro" then
            button:SetAttribute(typeAttribute, "macro")
            button:SetAttribute("macrotext", binding.macroText or "")
        end
    end

    local function applyExecuteButtonSecureBinding(binding)
        executeButton:SetAttribute("type", "macro")
        executeButton:SetAttribute("macrotext", "")

        if WOW_PROJECT_ID == WOW_PROJECT_MAINLINE then
            executeButton:SetAttribute("typerelease", "macro")
        end

        if not binding then
            return
        end

        if binding.type == "macro" then
            executeButton:SetAttribute("type", "macro")
            executeButton:SetAttribute("macrotext", binding.macroText or "")
            if WOW_PROJECT_ID == WOW_PROJECT_MAINLINE then
                executeButton:SetAttribute("typerelease", "macro")
            end
        end
    end

    local function updateSecureExecutionBinding()
        ClearOverrideBindings(executeButton)

        local binding = getSecureResultBinding(getSelectedResult())
        applyExecuteButtonSecureBinding(binding)

        if binding then
            SetOverrideBindingClick(executeButton, true, "ENTER", executeButton:GetName())
            SetOverrideBindingClick(executeButton, true, "NUMPADENTER", executeButton:GetName())
        end
    end

    executeButton:HookScript("OnClick", function()
        frame:HideSpotlight()
    end)

    local function findResultIndexByID(resultList, resultID)
        if not resultID then
            return nil
        end

        for index, result in ipairs(resultList) do
            if result.id == resultID then
                return index
            end
        end

        return nil
    end

    local function updatePromptState()
        local text = searchBox:GetText() or ""
        local hasText = text:match("%S") ~= nil
        prefixHint:SetText(ns:GetModulePrefixHint())
        placeholder:SetShown(not hasText)
        prefixHint:SetShown(not hasText and prefixHint:GetText() ~= "")
    end

    local function clearTransientSearchState()
        selectedIndex = nil
        lastQueryKey = ""
        suppressInitialWhitespace = false
        ns.currentQuery = ""
    end

    local function normalizeInitialWhitespace()
        if isNormalizingSearchText or not suppressInitialWhitespace then
            return false
        end

        local text = searchBox:GetText() or ""
        if text == "" then
            return false
        end

        suppressInitialWhitespace = false

        local normalizedText = text:gsub("^%s+", "")
        if normalizedText == text then
            return false
        end

        isNormalizingSearchText = true
        searchBox:SetText(normalizedText)
        searchBox:SetCursorPosition(normalizedText:len())
        isNormalizingSearchText = false

        return true
    end

    local function setSearchShellHighlighted(isHighlighted)
        if isHighlighted then
            local r, g, b = getPlayerClassColor()
            searchShell:SetBackdropBorderColor(r, g, b, 0.40)
        else
            searchShell:SetBackdropBorderColor(1.00, 1.00, 1.00, 0.04)
        end
    end

    local function refreshButtonSelection()
        for index, button in ipairs(buttons) do
            setButtonState(button, button:IsShown() and index == selectedIndex)
        end
    end

    local function setSelection(index)
        if #results == 0 then
            selectedIndex = nil
        else
            selectedIndex = math.max(1, math.min(index, #results))
        end

        refreshButtonSelection()
        updateSecureExecutionBinding()
    end

    local function activateSelection()
        local result = getSelectedResult()
        if not result or getSecureResultBinding(result) or not result.action then
            return
        end

        result.action(result)
    end

    local function handleEnterKey()
        if ns:TryExecuteInput(searchBox:GetText() or "") then
            return "handled"
        end

        if hasSelectedSecureBinding() then
            return "propagate"
        end

        activateSelection()
        return "handled"
    end

    local function doesBindingMatchKey(binding, key)
        if not binding or binding == "" then
            return false
        end

        local bindingKey = binding:match("([^%-]+)$")
        if not bindingKey or bindingKey ~= key then
            return false
        end

        local requiresAlt = binding:find("ALT%-", 1, true) ~= nil
        local requiresCtrl = binding:find("CTRL%-", 1, true) ~= nil
        local requiresShift = binding:find("SHIFT%-", 1, true) ~= nil

        return requiresAlt == IsAltKeyDown()
            and requiresCtrl == IsControlKeyDown()
            and requiresShift == IsShiftKeyDown()
    end

    local function isToggleBindingPressed(key)
        key = (key or ""):upper()
        if key == "" or key == "ALT" or key == "CTRL" or key == "SHIFT" then
            return false
        end

        local key1, key2 = GetBindingKey("SIMPLESEARCH_TOGGLE")
        return doesBindingMatchKey(key1, key) or doesBindingMatchKey(key2, key)
    end

    for index = 1, ns.maxResults do
        local button = CreateFrame("Button", nil, resultsPane, "InsecureActionButtonTemplate,BackdropTemplate")
        button:SetPoint("TOPLEFT", resultsPane, "TOPLEFT", 0, -(CONTENT_PADDING + ((index - 1) * (ROW_HEIGHT + ROW_SPACING))))
        button:SetPoint("TOPRIGHT", resultsPane, "TOPRIGHT", 0, -(CONTENT_PADDING + ((index - 1) * (ROW_HEIGHT + ROW_SPACING))))
        button:SetHeight(ROW_HEIGHT)
        button:SetFrameStrata(resultsPane:GetFrameStrata())
        button:SetFrameLevel(resultsPane:GetFrameLevel() + 1)
        button:RegisterForClicks("LeftButtonUp")
        button:SetAttribute("pressAndHoldAction", "1")
        applyButtonSecureBinding(button, nil)
        applyBackdrop(button, 0.00, 0.00, 0.00, 0.00, 1.00, 1.00, 1.00, 0.00)

        button.icon = button:CreateTexture(nil, "ARTWORK")
        button.icon:SetSize(30, 30)
        button.icon:SetPoint("LEFT", 12, 0)

        button.favoriteButton = CreateFrame("Button", nil, button)
        button.favoriteButton:SetSize(FAVORITE_BUTTON_SIZE, FAVORITE_BUTTON_SIZE)
        button.favoriteButton:SetPoint("RIGHT", -RIGHT_ROW_PADDING, 0)
        button.favoriteButton:RegisterForClicks("LeftButtonUp")
        button.favoriteButton.icon = button.favoriteButton:CreateTexture(nil, "OVERLAY")
        button.favoriteButton.icon:SetAllPoints()

        button.textContainer = CreateFrame("Frame", nil, button)
        button.textContainer:SetPoint("TOPLEFT", button, "TOPLEFT", 56, 0)
        button.textContainer:SetPoint("BOTTOMRIGHT", button, "BOTTOMRIGHT", -(RIGHT_ROW_PADDING + FAVORITE_BUTTON_SIZE + FAVORITE_BUTTON_GAP), 0)

        button.title = createText(button.textContainer, "OVERLAY", "GameFontNormal")
        button.title:SetFont(STANDARD_TEXT_FONT, 18, "")
        button.title:SetWordWrap(false)

        button.subtitle = createText(button.textContainer, "OVERLAY", "GameFontHighlightSmall")
        button.subtitle:SetFont(STANDARD_TEXT_FONT, 12, "")
        button.subtitle:SetWordWrap(false)

        button.resultIndex = index

        button:SetScript("OnEnter", function(self)
            setSelection(self.resultIndex)
        end)

        button:HookScript("OnClick", function(self)
            setSelection(self.resultIndex)

            local result = results[self.resultIndex]
            if getSecureResultBinding(result) then
                frame:HideSpotlight()
                return
            end

            activateSelection()
        end)

        button.favoriteButton:SetScript("OnEnter", function(self)
            local owner = self:GetParent()
            self.isHovered = true
            setSelection(owner.resultIndex)
            updateFavoriteButtonState(owner, owner.resultIndex == selectedIndex)

            local result = results[owner.resultIndex]
            if result and result.id then
                GameTooltip:SetOwner(self, "ANCHOR_RIGHT")
                GameTooltip:SetText(ns:IsFavorite(result.id) and "Remove favorite" or "Add to favorites")
                GameTooltip:Show()
            end
        end)

        button.favoriteButton:SetScript("OnLeave", function(self)
            self.isHovered = false
            updateFavoriteButtonState(self:GetParent(), self:GetParent().resultIndex == selectedIndex)
            GameTooltip:Hide()
        end)

        button.favoriteButton:SetScript("OnClick", function(self)
            local owner = self:GetParent()
            local result = results[owner.resultIndex]
            if not result or not result.id then
                return
            end

            setSelection(owner.resultIndex)
            ns:ToggleFavorite(result.id)
            searchBox:SetFocus()
        end)

        setButtonState(button, false)
        button:Hide()
        buttons[index] = button
    end

    local function getDropdownHeight(resultCount)
        if resultCount <= 0 then
            return 0
        end

        return CONTENT_PADDING * 2 + (resultCount * ROW_HEIGHT) + ((resultCount - 1) * ROW_SPACING)
    end

    function frame:UpdateLayout(resultCount)
        local dropdownHeight = getDropdownHeight(resultCount)

        if dropdownHeight > 0 then
            resultsPane:SetHeight(dropdownHeight)
            resultsPane:Show()
            self:SetHeight((OUTER_PADDING * 2) + SEARCH_HEIGHT + DROPDOWN_GAP + dropdownHeight)
        else
            resultsPane:SetHeight(0)
            resultsPane:Hide()
            self:SetHeight((OUTER_PADDING * 2) + SEARCH_HEIGHT)
        end
    end

    function frame:SetResults(newResults, prefixModule, query, showWithoutQuery)
        local normalizedQuery = ns:NormalizeText(query)
        local hasQuery = showWithoutQuery or prefixModule ~= nil or normalizedQuery ~= ""
        local previousSelectedID = results[selectedIndex or 1] and results[selectedIndex or 1].id
        local queryKey = (prefixModule and prefixModule.id or "") .. ":" .. normalizedQuery

        results = hasQuery and (newResults or {}) or {}

        if #results > 0 then
            if queryKey == lastQueryKey then
                selectedIndex = findResultIndexByID(results, previousSelectedID) or math.min(selectedIndex or 1, #results)
            else
                selectedIndex = 1
            end
        else
            selectedIndex = nil
        end

        lastQueryKey = hasQuery and queryKey or ""

        for index, button in ipairs(buttons) do
            local result = results[index]
            if result then
                button.isFavorite = ns:IsFavorite(result.id)
                applyLineView(button, result)
                applyButtonSecureBinding(button, getSecureResultBinding(result))
                button:Show()
            else
                button.isDisabled = false
                button.isFavorite = false
                applyButtonSecureBinding(button, nil)
                button:Hide()
            end
        end

        self:UpdateLayout(#results)
        refreshButtonSelection()
        updateSecureExecutionBinding()
    end

    function frame:RefreshResults()
        local query = searchBox:GetText() or ""
        ns.currentQuery = query
        updatePromptState()

        local searchResults, prefixModule, trimmedQuery, showWithoutQuery = ns:RunSearch(query)
        self:SetResults(searchResults, prefixModule, trimmedQuery, showWithoutQuery)
    end

    function frame:MoveSelection(direction)
        if #results == 0 then
            return
        end

        setSelection((selectedIndex or 1) + direction)
    end

    function frame:HideSpotlight()
        clearTransientSearchState()
        self:Hide()
    end

    function frame:ShowSpotlight()
        if not self:IsShown() then
            searchBox:SetText("")
            searchBox:SetCursorPosition(0)
            suppressInitialWhitespace = true
            updatePromptState()
        end

        self:Show()
        searchBox:SetFocus()
        searchBox:SetCursorPosition((searchBox:GetText() or ""):len())
        self:RefreshResults()
    end

    function frame:Toggle()
        if self:IsShown() then
            self:HideSpotlight()
        else
            self:ShowSpotlight()
        end
    end

    function frame:SetQuery(query)
        query = query or ""
        self:ShowSpotlight()
        suppressInitialWhitespace = false
        searchBox:SetText(query)
        searchBox:SetCursorPosition(query:len())
    end

    searchShell:EnableMouse(true)
    searchShell:SetScript("OnMouseDown", function()
        searchBox:SetFocus()
    end)

    frame:SetScript("OnHide", function()
        clearTransientSearchState()
        ClearOverrideBindings(executeButton)
        applyExecuteButtonSecureBinding(nil)
        if searchBox.SetPropagateKeyboardInput then
            searchBox:SetPropagateKeyboardInput(false)
        end
        searchBox:ClearFocus()
        searchBox:SetText("")
        updatePromptState()
        frame:SetResults({}, nil, "", false)
    end)

    searchBox:SetScript("OnEscapePressed", function()
        frame:HideSpotlight()
    end)

    searchBox:SetScript("OnEnterPressed", function()
        if searchBox.SetPropagateKeyboardInput then
            return
        end

        handleEnterKey()
    end)

    searchBox:SetScript("OnEditFocusGained", function()
        setSearchShellHighlighted(true)
    end)

    searchBox:SetScript("OnEditFocusLost", function()
        setSearchShellHighlighted(false)
    end)

    searchBox:SetScript("OnTextChanged", function()
        if normalizeInitialWhitespace() then
            return
        end

        frame:RefreshResults()
    end)

    searchBox:SetScript("OnKeyDown", function(self, key)
        if isToggleBindingPressed(key) then
            if self.SetPropagateKeyboardInput then
                self:SetPropagateKeyboardInput(false)
            end

            return
        end

        if key == "ENTER" or key == "NUMPADENTER" then
            local result = handleEnterKey()
            if self.SetPropagateKeyboardInput then
                self:SetPropagateKeyboardInput(result == "propagate")
            end
            return
        end

        if self.SetPropagateKeyboardInput then
            self:SetPropagateKeyboardInput(false)
        end
    end)

    searchBox:SetScript("OnArrowPressed", function(_, key)
        if key == "UP" then
            frame:MoveSelection(-1)
        elseif key == "DOWN" then
            frame:MoveSelection(1)
        end
    end)

    updatePromptState()
    setSearchShellHighlighted(false)
    if searchBox.SetPropagateKeyboardInput then
        searchBox:SetPropagateKeyboardInput(false)
    end
    table.insert(UISpecialFrames, frame:GetName())

    self.ui = frame
    return frame
end