Core.lua

local addonName, ns = ...

_G.SimpleSearch = ns
_G.BINDING_NAME_SIMPLESEARCH_TOGGLE = "Toggle Simple Search"

ns.API_VERSION = 1
ns.modules = {}
ns.modulePrefixes = {}
ns.maxResults = 8
ns.currentQuery = ""
ns.favoriteWarmupPending = false
ns.isReady = false
ns.initializedModules = {}

local eventFrame = CreateFrame("Frame")

local function trim(text)
    if not text then
        return ""
    end

    return (text:gsub("^%s+", ""):gsub("%s+$", ""))
end

local function printMessage(message)
    print("|cFF9CDF95Simple|rSearch: " .. message)
end

local function getAddonVersion()
    local version

    if C_AddOns and C_AddOns.GetAddOnMetadata then
        version = C_AddOns.GetAddOnMetadata(addonName, "Version")
    elseif GetAddOnMetadata then
        version = GetAddOnMetadata(addonName, "Version")
    end

    if type(version) == "string" and version ~= "" then
        return version
    end

    return "unknown"
end

local function failRegistration(message)
    printMessage(message)
    return false, message
end

local function normalizePrefixes(api, prefixes)
    local normalizedPrefixes = {}
    local seenPrefixes = {}

    for _, prefix in ipairs(prefixes or {}) do
        local normalizedPrefix = api:NormalizeText(prefix)
        if normalizedPrefix ~= "" and not seenPrefixes[normalizedPrefix] then
            normalizedPrefixes[#normalizedPrefixes + 1] = normalizedPrefix
            seenPrefixes[normalizedPrefix] = true
        end
    end

    return normalizedPrefixes
end

function ns:InitializeModule(module)
    if not module or not module.id or self.initializedModules[module.id] then
        return
    end

    if module.OnInitialize then
        module:OnInitialize()
    end

    self.initializedModules[module.id] = true
end

function ns:RegisterModule(module)
    if type(module) ~= "table" then
        return failRegistration("Module registration requires a table.")
    end

    if type(module.id) ~= "string" or module.id == "" then
        return failRegistration("Module registration requires a non-empty string id.")
    end

    if type(module.label) ~= "string" or module.label == "" then
        return failRegistration(string.format("Module '%s' is missing a label.", module.id))
    end

    if type(module.Search) ~= "function" then
        return failRegistration(string.format("Module '%s' is missing a Search(query, limit) function.", module.id))
    end

    local existingModule = self.modules[module.id]
    if existingModule and existingModule ~= module then
        return failRegistration(string.format("Module id '%s' is already registered.", module.id))
    elseif existingModule == module then
        if self.isReady then
            self:InitializeModule(module)
        end
        return true
    end

    local normalizedPrefixes = normalizePrefixes(self, module.prefixes)
    for _, normalizedPrefix in ipairs(normalizedPrefixes) do
        local existingPrefixModule = self.modulePrefixes[normalizedPrefix]
        if existingPrefixModule and existingPrefixModule ~= module then
            return failRegistration(string.format(
                "Prefix '%s:' for module '%s' is already registered by module '%s'.",
                normalizedPrefix,
                module.id,
                existingPrefixModule.id or "unknown"
            ))
        end
    end

    self.modules[module.id] = module
    module._simpleSearchNormalizedPrefixes = normalizedPrefixes

    for _, normalizedPrefix in ipairs(normalizedPrefixes) do
        self.modulePrefixes[normalizedPrefix] = module
    end

    if self.isReady then
        self:InitializeModule(module)
        self:RefreshActiveSearch()
    end

    return true
end

function ns:NormalizeText(text)
    text = trim(text)
    if text == "" then
        return ""
    end

    text = text:lower()
    text = text:gsub("[%c%p]+", " ")
    text = text:gsub("%s+", " ")

    return trim(text)
end

function ns:SplitTerms(text)
    local terms = {}

    for term in self:NormalizeText(text):gmatch("%S+") do
        terms[#terms + 1] = term
    end

    return terms
end

function ns:ScoreQuery(query, primaryText, secondaryText, tertiaryText)
    query = self:NormalizeText(query)
    if query == "" then
        return 1
    end

    local primary = self:NormalizeText(primaryText)
    if primary == "" then
        return nil
    end

    local blob = primary

    for _, extra in ipairs({ secondaryText, tertiaryText }) do
        local normalized = self:NormalizeText(extra)
        if normalized ~= "" then
            blob = blob .. " " .. normalized
        end
    end

    local score = 0
    local exactInPrimary = primary:find(query, 1, true)
    if exactInPrimary then
        score = score + 500 - exactInPrimary
    end

    local exactInBlob = blob:find(query, 1, true)
    if exactInBlob then
        score = score + 250 - exactInBlob
    end

    for _, term in ipairs(self:SplitTerms(query)) do
        local primaryPosition = primary:find(term, 1, true)
        local blobPosition = blob:find(term, 1, true)

        if primaryPosition then
            score = score + 80 - primaryPosition
        elseif blobPosition then
            score = score + 30 - blobPosition
        else
            return nil
        end
    end

    if primary == query then
        score = score + 1000
    elseif primary:sub(1, #query) == query then
        score = score + 200
    end

    return score
end

function ns:ExtractPrefix(rawQuery)
    local prefix, remainder = rawQuery:match("^%s*([%a][%w_]*)%s*:%s*(.-)%s*$")
    if not prefix then
        return nil, rawQuery
    end

    local module = self.modulePrefixes[self:NormalizeText(prefix)]
    if not module then
        return nil, rawQuery
    end

    return module, remainder or ""
end

function ns:GetSearchModules(prefixModule)
    if prefixModule then
        return { prefixModule }
    end

    local modules = {}
    for _, module in pairs(self.modules) do
        modules[#modules + 1] = module
    end

    table.sort(modules, function(left, right)
        return left.label < right.label
    end)

    return modules
end

function ns:GetModulePrefixHint()
    local prefixes = {}

    for _, module in pairs(self.modules) do
        local prefix = module.prefixes and module.prefixes[1]
        if prefix then
            prefixes[#prefixes + 1] = self:NormalizeText(prefix) .. ":"
        end
    end

    table.sort(prefixes)
    return table.concat(prefixes, "  ")
end

function ns:ExtractImplicitModule(rawQuery)
    rawQuery = trim(rawQuery)

    for _, module in pairs(self.modules) do
        if module.GetImplicitQuery then
            local query = module:GetImplicitQuery(rawQuery)
            if query ~= nil then
                return module, trim(query)
            end
        end
    end

    return nil, rawQuery
end

function ns:TryExecuteInput(rawQuery)
    rawQuery = trim(rawQuery)
    if rawQuery == "" then
        return false
    end

    for _, module in pairs(self.modules) do
        if module.TryExecuteInput and module:TryExecuteInput(rawQuery) then
            return true
        end
    end

    return false
end

function ns:RunSearch(rawQuery)
    rawQuery = rawQuery or ""

    local prefixModule, query = self:ExtractPrefix(rawQuery)
    if not prefixModule then
        prefixModule, query = self:ExtractImplicitModule(rawQuery)
    end
    query = trim(query)

    if trim(rawQuery) == "" then
        local favoriteResults = self:GetFavoriteResults(self.maxResults)
        return favoriteResults, nil, query, #favoriteResults > 0
    end

    local results = {}

    for _, module in ipairs(self:GetSearchModules(prefixModule)) do
        local moduleResults = module:Search(query, self.maxResults) or {}
        for _, result in ipairs(moduleResults) do
            result.moduleID = result.moduleID or module.id
            result.moduleLabel = result.moduleLabel or module.label
            if self:IsFavorite(result.id) then
                result.score = (result.score or 0) + 100
            end
            results[#results + 1] = result
        end
    end

    table.sort(results, function(left, right)
        if left.score ~= right.score then
            return left.score > right.score
        end

        return (left.sortText or left.title or "") < (right.sortText or right.title or "")
    end)

    while #results > self.maxResults do
        table.remove(results)
    end

    return results, prefixModule, query, false
end

function ns:RefreshActiveSearch()
    if self.ui and self.ui:IsShown() then
        self.ui:RefreshResults()
    end
end

function ns:EnsureDatabase()
    SimpleSearchDB = SimpleSearchDB or {}
    self.db = SimpleSearchDB
    self.db.favorites = self.db.favorites or {}
    self.db.favoriteSequence = self.db.favoriteSequence or 0
end

function ns:MaybePrintLoginHelp()
    self:EnsureDatabase()

    local version = getAddonVersion()
    if self.db.lastLoginHelpVersion == version then
        return
    end

    self.db.lastLoginHelpVersion = version
    printMessage("Type '|cFF9CDF95/ss|r' to open Simple Search.")
    printMessage("Default keybind: |cFF9CDF95CTRL + Space|r. If you use character-specific keybindings, you may need to set '|cFF9CDF95Toggle Simple Search|r' yourself in the native Keybindings menu.")
end

function ns:IsFavorite(resultID)
    self:EnsureDatabase()
    return resultID and self.db.favorites[resultID] ~= nil or false
end

function ns:GetFavoriteOrder(resultID)
    self:EnsureDatabase()
    return resultID and self.db.favorites[resultID] or nil
end

function ns:GetFavoriteModules()
    self:EnsureDatabase()

    if not next(self.db.favorites) then
        return {}
    end

    local modules = {}

    for _, module in ipairs(self:GetSearchModules(nil)) do
        local prefixes = module.favoriteIDPrefixes or {}
        local matchedModule = false

        for resultID in pairs(self.db.favorites) do
            for _, prefix in ipairs(prefixes) do
                if resultID:sub(1, #prefix) == prefix then
                    matchedModule = true
                    break
                end
            end

            if matchedModule then
                break
            end
        end

        if matchedModule then
            modules[#modules + 1] = module
        end
    end

    return modules
end

function ns:SetFavorite(resultID, isFavorite)
    self:EnsureDatabase()

    if not resultID or resultID == "" then
        return false
    end

    if isFavorite then
        if not self.db.favorites[resultID] then
            self.db.favoriteSequence = self.db.favoriteSequence + 1
            self.db.favorites[resultID] = self.db.favoriteSequence
        end
    else
        self.db.favorites[resultID] = nil
    end

    self:RefreshActiveSearch()
    return self.db.favorites[resultID] ~= nil
end

function ns:ToggleFavorite(resultID)
    return self:SetFavorite(resultID, not self:IsFavorite(resultID))
end

function ns:GetFavoriteResults(limit)
    self:EnsureDatabase()

    if not next(self.db.favorites) then
        return {}
    end

    local results = {}
    local seenResults = {}

    for _, module in ipairs(self:GetFavoriteModules()) do
        local moduleResults = module.Search and module:Search("", math.huge) or {}
        for _, result in ipairs(moduleResults) do
            if result.id and self.db.favorites[result.id] and not seenResults[result.id] then
                result.moduleID = result.moduleID or module.id
                result.moduleLabel = result.moduleLabel or module.label
                results[#results + 1] = result
                seenResults[result.id] = true
            end
        end
    end

    table.sort(results, function(left, right)
        local leftOrder = self.db.favorites[left.id] or 0
        local rightOrder = self.db.favorites[right.id] or 0

        if leftOrder ~= rightOrder then
            return leftOrder > rightOrder
        end

        return (left.sortText or left.title or "") < (right.sortText or right.title or "")
    end)

    while #results > limit do
        table.remove(results)
    end

    return results
end

function ns:WarmFavoriteModules()
    self:EnsureDatabase()

    if self.favoriteWarmupPending or not C_Timer or not next(self.db.favorites) then
        return
    end

    local modules = self:GetFavoriteModules()
    if #modules == 0 then
        return
    end

    self.favoriteWarmupPending = true

    local index = 1
    local function warmNextModule()
        local module = modules[index]
        if not module then
            self.favoriteWarmupPending = false
            return
        end

        if module.RefreshCache then
            module:RefreshCache()
        elseif module.Search then
            module:Search("", 1)
        end

        index = index + 1
        C_Timer.After(0.15, warmNextModule)
    end

    C_Timer.After(1.0, warmNextModule)
end

function ns:EnsureDefaultBinding()
    self:EnsureDatabase()

    if self.db.defaultBindingInitialized then
        return
    end

    local action = "SIMPLESEARCH_TOGGLE"
    local desiredKey = "CTRL-SPACE"
    local bindingContext = C_KeyBindings and C_KeyBindings.GetBindingContextForAction and C_KeyBindings.GetBindingContextForAction(action) or nil
    local key1, key2 = GetBindingKey(action, nil, bindingContext)

    if key1 == desiredKey or key2 == desiredKey then
        self.db.defaultBindingInitialized = true
        self.db.defaultBindingApplied = true
        return
    end

    local existingAction = GetBindingAction(desiredKey, nil, bindingContext)
    if existingAction ~= "" and existingAction ~= action then
        self.db.defaultBindingInitialized = true
        self.db.defaultBindingApplied = false
        printMessage("|cFF9CDF95CTRL + Space|r is already bound. Use Keybindings to assign '|cFF9CDF95Toggle Simple Search|r' if you want a shortcut.")
        return
    end

    if SetBinding(desiredKey, action, bindingContext) then
        SaveBindings(GetCurrentBindingSet() or Enum.BindingSet.Account)
        self.db.defaultBindingApplied = true
    else
        self.db.defaultBindingApplied = false
    end

    self.db.defaultBindingInitialized = true
end

function ns:Toggle()
    self:CreateUI()
    self.ui:Toggle()
end

function ns:IsReady()
    return self.isReady
end

function ns:Close()
    if self.ui then
        self.ui:HideSpotlight()
    end
end

function ns:PLAYER_LOGIN()
    self:EnsureDatabase()
    self:CreateUI()
    self:EnsureDefaultBinding()
    self:MaybePrintLoginHelp()
    self.isReady = true

    for _, module in pairs(self.modules) do
        self:InitializeModule(module)
    end

    self:WarmFavoriteModules()
end

SLASH_SIMPLESEARCH1 = "/simplesearch"
SLASH_SIMPLESEARCH2 = "/ss"
SLASH_SIMPLESEARCH3 = "/spotlight"
SLASH_SIMPLESEARCH4 = "/ws"
SlashCmdList.SIMPLESEARCH = function(message)
    message = trim(message)

    ns:Toggle()
    if message ~= "" and ns.ui then
        ns.ui:SetQuery(message)
    end
end

eventFrame:RegisterEvent("PLAYER_LOGIN")
eventFrame:SetScript("OnEvent", function(_, event, ...)
    if ns[event] then
        ns[event](ns, ...)
    end
end)