Core.lua

local ADDON_NAME, ns = ...

local Core = CreateFrame("Frame")
ns.Core = Core
Core.addonName = ADDON_NAME

local ADDON_PLAIN_NAME = "BluePosts"
local ADDON_DISPLAY_NAME = "|cffffc757Blue|r|cff00b4ffPosts|r"

ns.ADDON_PLAIN_NAME = ADDON_PLAIN_NAME
ns.ADDON_DISPLAY_NAME = ADDON_DISPLAY_NAME

local GUILD_SHARE_POPUP = "BLUEPOSTS_CONFIRM_GUILD_SHARE"

local DEFAULT_DB = {
    read = {},
    minimap = {
        hide = false,
        showInCompartment = true,
    },
    window = {
        point = "CENTER",
        relativePoint = "CENTER",
        x = 0,
        y = 0,
        width = 980,
        height = 650,
        maximized = false,
    },
    filters = {
        category = "ALL",
        region = "ALL",
    },
    showToasts = true,
    toastSound = true,
    toastDuration = 12,
    toastPosition = "TOPCENTER",
    toastOffsetX = 0,
    toastOffsetY = 30,
    autoMarkRead = true,
    confirmGuildShare = true,
    readerFontSize = 13,
    resumeLastPost = true,
    dateFormat = "MDY_SLASH",
    showClassicPosts = false,
}

local RESETTABLE_SETTING_KEYS = {
    "minimap",
    "showToasts",
    "toastSound",
    "toastDuration",
    "toastPosition",
    "toastOffsetX",
    "toastOffsetY",
    "autoMarkRead",
    "confirmGuildShare",
    "readerFontSize",
    "resumeLastPost",
    "dateFormat",
    "showClassicPosts",
}

local DATE_FORMATS = {
    MDY_SLASH = "%m/%d/%Y %H:%M",
    DMY_SLASH = "%d/%m/%Y %H:%M",
    YMD_DASH = "%Y-%m-%d %H:%M",
    YMD_SLASH = "%Y/%m/%d %H:%M",
    DMY_DOT = "%d.%m.%Y %H:%M",
}

ns.THEME = {
    bg = { 0.10, 0.10, 0.10, 0.85 },
    panel = { 0.07, 0.07, 0.08, 0.88 },
    rail = { 0.055, 0.055, 0.065, 0.92 },
    void = { 0.28, 0.08, 0.45, 0.95 },
    voidSoft = { 0.18, 0.06, 0.30, 0.55 },
    gold = { 1.00, 0.78, 0.34, 1.00 },
    blue = { 0.00, 0.70, 1.00, 1.00 },
    text = { 0.88, 0.88, 0.86, 1.00 },
    muted = { 0.62, 0.62, 0.64, 1.00 },
    danger = { 1.00, 0.26, 0.26, 1.00 },
}

ns.CATEGORY_META = {
    ALL = {
        label = "All",
        icon = "Interface\\Icons\\INV_Misc_Book_09",
    },
    NEWS = {
        label = "News",
        icon = "Interface\\Icons\\INV_Letter_15",
    },
    PTR = {
        label = "PTR",
        icon = "Interface\\Icons\\INV_Misc_Gear_01",
    },
    FIXES = {
        label = "Fixes",
        icon = "Interface\\Icons\\Trade_Engineering",
    },
    CLASS = {
        label = "Classes",
        icon = "Interface\\Icons\\INV_Misc_Book_11",
    },
    BLOG = {
        label = "Blog",
        icon = "Interface\\Icons\\INV_Misc_Note_01",
    },
}

local CLASS_NAMES = {
    ["DEATH KNIGHT"] = true,
    ["DEMON HUNTER"] = true,
    ["DRUID"] = true,
    ["DRACTHYR"] = true,
    ["EVOKER"] = true,
    ["HUNTER"] = true,
    ["MAGE"] = true,
    ["MONK"] = true,
    ["PALADIN"] = true,
    ["PRIEST"] = true,
    ["ROGUE"] = true,
    ["SHAMAN"] = true,
    ["WARLOCK"] = true,
    ["WARRIOR"] = true,
}

ns.CLASS_NAMES = CLASS_NAMES

local CATEGORY_FILTER_KEYS = {
    ALL = true,
    NEWS = true,
    PTR = true,
    FIXES = true,
    CLASS = true,
}

local CATEGORY_KEYS = {
    NEWS = true,
    PTR = true,
    FIXES = true,
    CLASS = true,
}

local REGION_FILTER_KEYS = {
    ALL = true,
    EU = true,
    US = true,
}

local function NormalizeRegionFilter(region)
    region = tostring(region or ""):upper()
    if region == "NA" then
        region = "US"
    end

    return REGION_FILTER_KEYS[region] and region or nil
end

local function NormalizeCategoryFilter(category)
    category = tostring(category or ""):upper()
    if category == "BLOG" then
        category = "NEWS"
    end

    return CATEGORY_FILTER_KEYS[category] and category or nil
end

local function NormalizeCategoryKey(category)
    category = tostring(category or ""):upper()
    if category == "BLOG" then
        category = "NEWS"
    end

    return CATEGORY_KEYS[category] and category or nil
end

local function DetectClientRegion()
    local regionID = GetCurrentRegion and GetCurrentRegion()
    if regionID == 3 or (_G.LE_REGION_EU and regionID == _G.LE_REGION_EU) then
        return "EU"
    end

    if regionID == 1
        or (_G.LE_REGION_AMERICAS and regionID == _G.LE_REGION_AMERICAS)
        or (_G.LE_REGION_US and regionID == _G.LE_REGION_US) then
        return "US"
    end

    local portal
    if C_CVar and C_CVar.GetCVar then
        portal = C_CVar.GetCVar("portal")
    elseif GetCVar then
        portal = GetCVar("portal")
    end

    return NormalizeRegionFilter(portal)
end

local function CopyDefaults(src, dst)
    for key, value in pairs(src) do
        if type(value) == "table" then
            if type(dst[key]) ~= "table" then
                dst[key] = {}
            end
            CopyDefaults(value, dst[key])
        elseif dst[key] == nil then
            dst[key] = value
        end
    end
end

local function CopyValue(value)
    if type(value) ~= "table" then
        return value
    end

    local copy = {}
    for key, child in pairs(value) do
        copy[key] = CopyValue(child)
    end
    return copy
end

local function ResetValue(defaultValue, targetValue)
    if type(defaultValue) == "table" and type(targetValue) == "table" then
        wipe(targetValue)
        for key, child in pairs(defaultValue) do
            targetValue[key] = CopyValue(child)
        end
        return targetValue
    end

    return CopyValue(defaultValue)
end

local function Trim(value)
    if value == nil then
        return ""
    end
    return tostring(value):match("^%s*(.-)%s*$") or ""
end

local function Contains(haystack, needle)
    return haystack:find(needle, 1, true) ~= nil
end

local function NormalizeText(value)
    return Trim(value):upper()
end

local function NormalizeDateFormat(formatKey)
    formatKey = tostring(formatKey or ""):upper()
    return DATE_FORMATS[formatKey] and formatKey or "MDY_SLASH"
end

local function IsClassicPost(post)
    if type(post) ~= "table" then
        return false
    end

    local haystack = NormalizeText((post.title or "") .. " " .. (post.category or ""))
    return Contains(haystack, "CLASSIC")
        or Contains(haystack, "SEASON OF DISCOVERY")
        or Contains(haystack, "HARDCORE")
end

local function GetCategoryKey(post)
    local title = (post.title or ""):lower()
    local category = (post.category or ""):lower()
    local haystack = category .. " " .. title

    if Contains(haystack, "hotfix") or Contains(haystack, "fixes") then
        return "FIXES"
    end

    if Contains(haystack, "ptr") or Contains(haystack, "public test") then
        return "PTR"
    end

    if Contains(haystack, "death knight") or Contains(haystack, "demon hunter") or Contains(haystack, "evoker") or Contains(haystack, "class") then
        return "CLASS"
    end

    if Contains(category, "blog") or Contains(category, "blogs") then
        return "NEWS"
    end

    return "NEWS"
end

local function GetPostRegion(post)
    local category = post and (post.category or "") or ""
    local title = post and (post.title or "") or ""
    local haystack = category .. " " .. title

    if haystack:find("%(EU%)") then
        return "EU"
    end

    if haystack:find("%(US%)") then
        return "US"
    end

    return "OTHER"
end

local function PostMatchesRegionFilter(post, regionFilter)
    regionFilter = NormalizeRegionFilter(regionFilter) or "ALL"
    if regionFilter == "ALL" then
        return true
    end

    local postRegion = NormalizeRegionFilter(post and post.region) or GetPostRegion(post)
    return postRegion == regionFilter
end

local function FormatDate(timestamp, formatKey)
    timestamp = tonumber(timestamp) or 0
    if timestamp <= 0 then
        return ""
    end
    return date(DATE_FORMATS[NormalizeDateFormat(formatKey)], timestamp)
end

ns.FormatDate = FormatDate
ns.IsClassicPost = IsClassicPost
ns.NormalizeText = NormalizeText
ns.GetCategoryKey = GetCategoryKey
ns.GetPostRegion = GetPostRegion
ns.NormalizeCategoryFilter = NormalizeCategoryFilter
ns.NormalizeRegionFilter = NormalizeRegionFilter

function Core:Print(message)
    DEFAULT_CHAT_FRAME:AddMessage(ADDON_DISPLAY_NAME .. " " .. tostring(message))
end

function Core:GetDefaultRegionFilter()
    return self.detectedRegion or "ALL"
end

function Core:GetDateFormat()
    return NormalizeDateFormat(self.db and self.db.dateFormat)
end

function Core:FormatDate(timestamp)
    return FormatDate(timestamp, self:GetDateFormat())
end

function Core:IsClassicPost(post)
    return IsClassicPost(post)
end

function Core:IsPostVisible(post)
    if not post then
        return false
    end

    return not self.db or self.db.showClassicPosts == true or not IsClassicPost(post)
end

function Core:GetVisiblePostCount()
    local count = 0
    for _, post in ipairs(self.posts or {}) do
        if self:IsPostVisible(post) then
            count = count + 1
        end
    end
    return count
end

function Core:RefreshFormattedDates()
    for _, post in ipairs(self.posts or {}) do
        post.dateText = self:FormatDate(post.timestamp)
    end
end

function Core:SetDateFormat(formatKey)
    if not self.db then
        return
    end

    self.db.dateFormat = NormalizeDateFormat(formatKey)
    self:RefreshFormattedDates()
    if ns.UI and ns.UI.RefreshDateDisplays then
        ns.UI:RefreshDateDisplays()
    end
end

function Core:SetShowClassicPosts(enabled)
    if not self.db then
        return
    end

    self.db.showClassicPosts = enabled ~= false
    if ns.UI and ns.UI.ApplyPostVisibilityPreferences then
        ns.UI:ApplyPostVisibilityPreferences()
    end
end

function Core:GetRegionFilter()
    local filters = self.db and self.db.filters
    return NormalizeRegionFilter(filters and filters.region) or self:GetDefaultRegionFilter()
end

function Core:SetRegionFilter(region, automatic)
    if not self.db then
        return
    end

    self.db.filters = self.db.filters or {}
    region = NormalizeRegionFilter(region) or self:GetDefaultRegionFilter()
    self.db.filters.region = region
    self.db.regionFilterAutoRegion = automatic and region ~= "ALL" and region or nil
end

function Core:PostMatchesRegionFilter(post, regionFilter)
    return PostMatchesRegionFilter(post, regionFilter)
end

function Core:InitializeDB()
    local hadRegionFilter = BluePostsDB
        and BluePostsDB.filters
        and BluePostsDB.filters.region ~= nil

    BluePostsDB = BluePostsDB or {}
    self.detectedRegion = DetectClientRegion()
    CopyDefaults(DEFAULT_DB, BluePostsDB)
    self.db = BluePostsDB
    if BluePostsDB.filters then
        BluePostsDB.filters.unreadOnly = nil
    end

    BluePostsDB.filters = BluePostsDB.filters or {}
    BluePostsDB.filters.category = NormalizeCategoryFilter(BluePostsDB.filters.category) or "ALL"
    BluePostsDB.dateFormat = NormalizeDateFormat(BluePostsDB.dateFormat)
    BluePostsDB.showClassicPosts = BluePostsDB.showClassicPosts == true
    local defaultRegion = self:GetDefaultRegionFilter()
    local savedRegion = NormalizeRegionFilter(BluePostsDB.filters.region)
    local autoRegion = NormalizeRegionFilter(BluePostsDB.regionFilterAutoRegion)

    if not hadRegionFilter then
        self:SetRegionFilter(defaultRegion, defaultRegion ~= "ALL")
    elseif autoRegion and savedRegion == autoRegion then
        if defaultRegion ~= "ALL" and defaultRegion ~= autoRegion then
            self:SetRegionFilter(defaultRegion, true)
        else
            BluePostsDB.filters.region = savedRegion
        end
    elseif savedRegion then
        BluePostsDB.filters.region = savedRegion
        BluePostsDB.regionFilterAutoRegion = nil
    else
        self:SetRegionFilter(defaultRegion, defaultRegion ~= "ALL")
    end
end

function Core:NormalizeData()
    self.posts = {}
    self.postsByID = {}
    self.categories = {}
    self.regions = {}

    local raw = BluePosts_Data or {}
    local source = raw.posts or raw
    self.packageTimestamp = tonumber(raw.package_timestamp or raw.generated_at) or 0
    self.packageNewPostIDs = {}
    self.packageNewPostLookup = {}

    for _, postID in ipairs(raw.new_post_ids or {}) do
        postID = Trim(postID)
        if postID ~= "" then
            self.packageNewPostIDs[#self.packageNewPostIDs + 1] = postID
            self.packageNewPostLookup[postID] = true
        end
    end

    for key, post in pairs(source) do
        if type(post) == "table" and post.title then
            local id = tostring(post.id or key)
            local normalized = {}

            for postKey, value in pairs(post) do
                normalized[postKey] = value
            end

            normalized.id = id
            normalized.post_key = normalized.post_key or normalized.postKey or id
            normalized.title = Trim(normalized.title)
            normalized.category = Trim(normalized.category)
            normalized.url = Trim(normalized.url or normalized.source_url)
            normalized.timestamp = tonumber(normalized.timestamp) or 0
            normalized.dateText = self:FormatDate(normalized.timestamp)
            normalized.categoryKey = NormalizeCategoryKey(normalized.categoryKey) or GetCategoryKey(normalized)
            normalized.region = normalized.region or GetPostRegion(normalized)
            normalized.content = type(normalized.content) == "table" and normalized.content or {}
            normalized.isPackagedNew = self.packageNewPostLookup[id] == true

            table.insert(self.posts, normalized)
            self.postsByID[id] = normalized
            self.categories[normalized.categoryKey] = (self.categories[normalized.categoryKey] or 0) + 1
            self.regions[normalized.region] = (self.regions[normalized.region] or 0) + 1
        end
    end

    table.sort(self.posts, function(left, right)
        if left.timestamp == right.timestamp then
            return (left.title or "") < (right.title or "")
        end
        return (left.timestamp or 0) > (right.timestamp or 0)
    end)
end

function Core:GetPost(id)
    return self.postsByID and self.postsByID[id]
end

function Core:IsRead(post)
    if not post then
        return false
    end
    return self.db and self.db.read and self.db.read[post.id] == true
end

function Core:SetRead(post, read)
    if not post or not self.db then
        return
    end
    self.db.read[post.id] = read and true or nil
    if ns.UI then
        ns.UI:RefreshPostList()
        ns.UI:UpdateToolbar()
        ns.UI:RefreshSettingsPanel()
    end
end

function Core:SetAllRead(read)
    if not self.db or not self.db.read then
        return
    end

    if read then
        for _, post in ipairs(self.posts or {}) do
            if self:IsPostVisible(post) then
                self.db.read[post.id] = true
            end
        end
    else
        for _, post in ipairs(self.posts or {}) do
            if self:IsPostVisible(post) then
                self.db.read[post.id] = nil
            end
        end
    end

    if ns.UI then
        ns.UI:RefreshPostList()
        ns.UI:UpdateToolbar()
        ns.UI:RefreshSettingsPanel()
    end
end

function Core:ResetSettingsToDefaults()
    if not self.db then
        return
    end

    for _, key in ipairs(RESETTABLE_SETTING_KEYS) do
        self.db[key] = ResetValue(DEFAULT_DB[key], self.db[key])
    end

    self.db.dateFormat = NormalizeDateFormat(self.db.dateFormat)
    self:RefreshFormattedDates()
    self:UpdateMinimapVisibility()

    if ns.UI then
        if ns.UI.ApplyPostVisibilityPreferences then
            ns.UI:ApplyPostVisibilityPreferences()
        end
        if ns.UI.RefreshDateDisplays then
            ns.UI:RefreshDateDisplays()
        end
        if ns.UI.ApplyToastPosition then
            ns.UI:ApplyToastPosition()
        end
        if ns.UI.RefreshSettingsPanel then
            ns.UI:RefreshSettingsPanel()
        end
    end

    self:Print("Settings reset to defaults.")
end

function Core:GetUnreadCount()
    local count = 0
    for _, post in ipairs(self.posts or {}) do
        if self:IsPostVisible(post) and not self:IsRead(post) then
            count = count + 1
        end
    end
    return count
end

function Core:IsPackagedNewPost(post)
    if type(post) == "table" then
        if post.isPackagedNew ~= nil then
            return post.isPackagedNew == true
        end

        post = post.id
    end

    post = Trim(post)
    return post ~= "" and self.packageNewPostLookup and self.packageNewPostLookup[post] == true or false
end

function Core:GetNewestUnreadPost(regionFilter)
    for _, post in ipairs(self.posts or {}) do
        if self:IsPostVisible(post) and PostMatchesRegionFilter(post, regionFilter) and not self:IsRead(post) then
            return post
        end
    end

    return nil
end

function Core:GetNewestRecentPost(regionFilter)
    local now = time()

    for _, post in ipairs(self.posts or {}) do
        if self:IsPostVisible(post)
            and PostMatchesRegionFilter(post, regionFilter)
            and post.timestamp
            and post.timestamp > 0
            and (now - post.timestamp) <= 86400 then
            return post
        end
    end

    return nil
end

function Core:GetNewestPackagedUnreadPost(regionFilter)
    if not next(self.packageNewPostLookup or {}) then
        return nil
    end

    for _, post in ipairs(self.posts or {}) do
        if self:IsPostVisible(post)
            and self:IsPackagedNewPost(post)
            and PostMatchesRegionFilter(post, regionFilter)
            and not self:IsRead(post) then
            return post
        end
    end

    return nil
end

function Core:GetToastPreviewPost()
    if ns.UI and ns.UI.selectedPost and self:IsPostVisible(ns.UI.selectedPost) then
        return ns.UI.selectedPost
    end

    local regionFilter = self:GetRegionFilter()
    return self:GetNewestPackagedUnreadPost(regionFilter)
        or self:GetNewestUnreadPost(regionFilter)
        or self:GetNewestRecentPost(regionFilter)
        or (function()
            for _, post in ipairs(self.posts or {}) do
                if self:IsPostVisible(post) then
                    return post
                end
            end
        end)()
end

function Core:ShowToast(post, rememberToastID)
    if not post or not self:IsPostVisible(post) or not ns.UI or not ns.UI.ShowToast then
        return false
    end

    local shown = ns.UI:ShowToast(post)
    if shown and rememberToastID ~= false and self.db then
        self.db.lastToastID = post.id
    end

    return shown and true or false
end

function Core:Show(postID)
    if ns.UI then
        ns.UI:Show()
        if postID then
            ns.UI:SelectPost(postID)
        end
    end
end

function Core:Hide()
    if ns.UI then
        ns.UI:Hide()
    end
end

function Core:Toggle()
    if ns.UI and ns.UI.frame and ns.UI.frame:IsShown() then
        self:Hide()
    else
        self:Show()
    end
end

function Core:RegisterGuildSharePopup()
    if not StaticPopupDialogs or StaticPopupDialogs[GUILD_SHARE_POPUP] then
        return
    end

    StaticPopupDialogs[GUILD_SHARE_POPUP] = {
        text = "Share this Blue Post with your guild?\n\n%s",
        button1 = "Share",
        button2 = "Cancel",
        OnAccept = function(_, post)
            Core:AnnounceGuild(post)
        end,
        timeout = 0,
        whileDead = true,
        hideOnEscape = true,
        preferredIndex = 3,
    }
end

function Core:ConfirmAnnounceGuild(post)
    if not post then
        return
    end

    if not IsInGuild() then
        self:Print("You are not in a guild.")
        return
    end

    if self.db and self.db.confirmGuildShare == false then
        self:AnnounceGuild(post)
        return
    end

    if StaticPopup_Show then
        StaticPopup_Show(GUILD_SHARE_POPUP, post.title or "Blue Post", nil, post)
        return
    end

    self:AnnounceGuild(post)
end

function Core:AnnounceGuild(post)
    if not post then
        return
    end

    if not IsInGuild() then
        self:Print("You are not in a guild.")
        return
    end

    local title = post.title or "Blue post"
    if #title > 120 then
        title = title:sub(1, 117) .. "..."
    end

    local message = ("%s: %s - %s"):format(ADDON_PLAIN_NAME, title, post.url or "")
    if #message > 255 then
        message = message:sub(1, 252) .. "..."
    end

    SendChatMessage(message, "GUILD")
    self:Print("Shared with guild.")
end

function Core:InitializeBroker()
    local dataBroker
    local dbIcon

    if LibStub then
        dataBroker = LibStub("LibDataBroker-1.1", true)
        dbIcon = LibStub("LibDBIcon-1.0", true)
    end

    if dataBroker then
        self.ldb = dataBroker:NewDataObject("BluePosts", {
            type = "launcher",
            icon = "Interface\\Icons\\INV_Letter_15",
            label = ADDON_DISPLAY_NAME,
            text = ADDON_DISPLAY_NAME,
            OnClick = function(_, button)
                if button == "LeftButton" then
                    self:Toggle()
                end
            end,
            OnTooltipShow = function(tooltip)
                tooltip:AddLine(ADDON_DISPLAY_NAME)
                tooltip:AddLine("Left click: open", 0.8, 0.8, 0.8)
                tooltip:AddLine(("Unread: %d"):format(self:GetUnreadCount()), 0.0, 0.7, 1.0)
            end,
        })
    end

    if self.ldb and dbIcon then
        self.dbIcon = dbIcon
        self.db.minimap.showInCompartment = true
        dbIcon:Register("BluePosts", self.ldb, self.db.minimap)
        if dbIcon.AddButtonToCompartment then
            dbIcon:AddButtonToCompartment("BluePosts")
        end
        if self.db.minimap.hide then
            dbIcon:Hide("BluePosts")
        end
        return
    end

    self:CreateFallbackMinimapButton()
end

function Core:CreateFallbackMinimapButton()
    if self.db.minimap.hide or not Minimap then
        return
    end

    local button = CreateFrame("Button", "BluePosts_MinimapButton", Minimap, "BackdropTemplate")
    button:SetSize(32, 32)
    button:SetPoint("TOPLEFT", Minimap, "TOPLEFT", -2, -2)
    button:SetFrameStrata("MEDIUM")
    button:RegisterForClicks("LeftButtonUp")

    button.icon = button:CreateTexture(nil, "ARTWORK")
    button.icon:SetAllPoints(button)
    button.icon:SetTexture("Interface\\Icons\\INV_Letter_15")
    button.icon:SetTexCoord(0.08, 0.92, 0.08, 0.92)

    button:SetHighlightTexture("Interface\\Minimap\\UI-Minimap-ZoomButton-Highlight")

    button:SetScript("OnClick", function()
        self:Toggle()
    end)

    button:SetScript("OnEnter", function()
        GameTooltip:SetOwner(button, "ANCHOR_LEFT")
        GameTooltip:AddLine(ADDON_DISPLAY_NAME)
        GameTooltip:AddLine("Left click: open", 0.8, 0.8, 0.8)
        GameTooltip:Show()
    end)

    button:SetScript("OnLeave", GameTooltip_Hide)
    self.fallbackMinimapButton = button
end

function Core:ApplyMBBMinimapVisibility(button, hidden)
    if not button or not button.oshow or not button.ohide then
        return false
    end

    -- MBB wraps Show/Hide and keeps the originals on oshow/ohide.
    local name = button:GetName()
    local excluded = MBB_IsInArray and MBB_Exclude and MBB_IsInArray(MBB_Exclude, name)
    button.isvisible = not hidden

    if hidden then
        button.ohide(button)
    elseif excluded or MBB_IsShown == 1 then
        button.oshow(button)
    else
        button.ohide(button)
    end

    if MBB_SetPositions then
        MBB_SetPositions()
    end

    return true
end

function Core:UpdateMinimapVisibility()
    local hidden = self.db and self.db.minimap and self.db.minimap.hide == true

    if self.dbIcon then
        local minimapButton = self.dbIcon.GetMinimapButton and self.dbIcon:GetMinimapButton("BluePosts")
        local handledByMBB = self:ApplyMBBMinimapVisibility(minimapButton, hidden)

        if hidden then
            self.dbIcon:Hide("BluePosts")
        else
            self.dbIcon:Show("BluePosts")
        end

        if self.dbIcon.Refresh then
            self.dbIcon:Refresh("BluePosts", self.db.minimap)
        end

        if minimapButton and not handledByMBB then
            if hidden then
                minimapButton:Hide()
            else
                minimapButton:Show()
            end
        end
    elseif self.fallbackMinimapButton then
        self.fallbackMinimapButton:SetShown(not hidden)
    elseif not hidden then
        self:CreateFallbackMinimapButton()
    end

    if ns.UI and ns.UI.RefreshSettingsPanel then
        ns.UI:RefreshSettingsPanel()
    end
end

function Core:HandleSlash(message)
    local command = Trim(message):lower()

    if command == "reset" then
        if ns.UI then
            ns.UI:ResetPosition()
        end
        return
    end

    if command == "minimap" then
        self.db.minimap.hide = not self.db.minimap.hide
        self:UpdateMinimapVisibility()
        self:Print(self.db.minimap.hide and "Minimap button hidden." or "Minimap button visible.")
        return
    end

    if command == "toasts" then
        self.db.showToasts = not self.db.showToasts
        if ns.UI and ns.UI.RefreshSettingsPanel then
            ns.UI:RefreshSettingsPanel()
        end
        self:Print(self.db.showToasts and "Toasts enabled." or "Toasts disabled.")
        return
    end

    if command == "toasttest" then
        local post = self:GetToastPreviewPost()
        if not post then
            self:Print("No post available for toast preview.")
            return
        end

        if not self:ShowToast(post, false) then
            self:Print("Toast preview failed.")
        end
        return
    end

    if command == "settings" or command == "options" then
        self:Show()
        if ns.UI and ns.UI.ShowSettings then
            ns.UI:ShowSettings()
        end
        return
    end

    self:Toggle()
end

function Core:RegisterSlashCommands()
    SLASH_BLUEPOSTS1 = "/blueposts"
    SLASH_BLUEPOSTS2 = "/bp"
    SlashCmdList.BLUEPOSTS = function(message)
        self:HandleSlash(message)
    end
end

function Core:MaybeShowLoginToast()
    if not self.db or self.db.showToasts == false then
        return
    end

    local regionFilter = self:GetRegionFilter()
    local post = self:GetNewestPackagedUnreadPost(regionFilter)
    if not post or self.db.lastToastID == post.id then
        return
    end

    C_Timer.After(2.0, function()
        if self:IsPostVisible(post) and not self:IsRead(post) and PostMatchesRegionFilter(post, self:GetRegionFilter()) then
            self:ShowToast(post)
        end
    end)
end

function Core:OnAddonLoaded(addonName)
    if addonName ~= ADDON_NAME then
        return
    end

    self:InitializeDB()
    self:RegisterGuildSharePopup()
    self:NormalizeData()

    if ns.UI then
        ns.UI:Initialize(self)
    end

    self:RegisterSlashCommands()
    self:InitializeBroker()
    self:RegisterEvent("PLAYER_LOGIN")
end

function Core:OnEvent(event, ...)
    if event == "ADDON_LOADED" then
        self:OnAddonLoaded(...)
    elseif event == "PLAYER_LOGIN" then
        self:MaybeShowLoginToast()
    end
end

Core:SetScript("OnEvent", Core.OnEvent)
Core:RegisterEvent("ADDON_LOADED")