core.lua

local AddOnName = ...;
---@class XIVBar : AceAddon-3.0, AceConsole-3.0, AceEvent-3.0
local XIVBar = select(2, ...);
local _G = _G;
local pairs, select = pairs, select
local AceAddon = _G.LibStub('AceAddon-3.0')

AceAddon:NewAddon(XIVBar, AddOnName, "AceConsole-3.0", "AceEvent-3.0");
local L = LibStub("AceLocale-3.0"):GetLocale(AddOnName, true);
LibStub:GetLibrary("LibDataBroker-1.1"):NewDataObject(AddOnName, {
    type = "launcher",
    icon = "Interface\\Icons\\Spell_Nature_StormReach",
    OnClick = function() XIVBar:ToggleConfig() end
})

XIVBar.Changelog = {}

XIVBar.L = L ---@type XIV_DatabarLocale

_G.XIV_Databar_Continued_OnAddonCompartmentClick = function()
    XIVBar:ToggleConfig()
end

XIVBar.constants = {
    mediaPath = "Interface\\AddOns\\" .. AddOnName .. "\\media\\",
    playerName = UnitName("player"),
    playerClass = select(2, UnitClass("player")),
    playerLevel = UnitLevel("player"),
    playerFactionLocal = select(2, UnitFactionGroup("player")),
    playerRealm = GetRealmName(),
    popupPadding = 10
}

XIVBar.LSM = LibStub('LibSharedMedia-3.0');

function XIVBar:OnInitialize()
    -- Capture before AceDB creates a profile for a brand-new install.
    local sv = _G.XIVBarDB
    self._hadPriorInstall = type(sv) == "table"
        and type(sv.profiles) == "table"
        and next(sv.profiles) ~= nil

    -- Omit default profile so new characters get a per-character "Name - Realm" profile.
    -- Existing profileKeys (e.g. "Default") are preserved by AceDB.
    self.db = LibStub("AceDB-3.0"):New("XIVBarDB", self.defaults)
    self.LSM:Register(self.LSM.MediaType.FONT, 'Homizio Bold',
                      self.constants.mediaPath .. "homizio_bold.ttf")
    self.frames = {}

    self.fontFlags = {'', 'OUTLINE', 'THICKOUTLINE', 'MONOCHROME'}

    self:SetupOptions()
    -- Module defaults are appended in SetupOptions; re-register so AceDB copies them
    -- into already-initialized sections and strips them correctly on logout.
    self.db:RegisterDefaults(self.defaults)

    self.timerRefresh = false

    self:RegisterChatCommand('xivc', 'ToggleConfig')
    self:RegisterChatCommand('xivbar', 'ToggleConfig')
    self:RegisterChatCommand('xbc', 'ToggleConfig')

    -- Defer so the chat frame is ready (OnInitialize is too early for reliable chat).
    local function printStartupChatMessages()
        if self.PrintLoadMessage then
            self:PrintLoadMessage()
        end
        if self.MaybeAnnounceAddonUpdate then
            self:MaybeAnnounceAddonUpdate()
        end
    end
    if C_Timer and C_Timer.After then
        C_Timer.After(2, printStartupChatMessages)
    else
        printStartupChatMessages()
    end
end

local function AddChatMessage(message)
    if DEFAULT_CHAT_FRAME and DEFAULT_CHAT_FRAME.AddMessage then
        DEFAULT_CHAT_FRAME:AddMessage(message)
    else
        print(message)
    end
end

function XIVBar:GetChatPrefix()
    return "|cffffd100XIV Databar|r |cffb0b0b0Continued|r"
end

function XIVBar.ColorizeCommands(_, text)
    if type(text) ~= "string" then return text end
    local out = {}
    local index = 1
    while true do
        local startPos, endPos, cmd = text:find("(/%w+)", index)
        if not startPos then
            table.insert(out, text:sub(index))
            break
        end
        table.insert(out, text:sub(index, startPos - 1))
        table.insert(out, "|cffffd100" .. cmd .. "|r")
        index = endPos + 1
    end
    return table.concat(out)
end

function XIVBar:PrintLoadMessage()
    if not (self.db and self.db.profile and self.db.profile.general) then return end
    if self.db.profile.general.disableLoginMessage then return end

    local prefix = self:GetChatPrefix()
    local body = self:ColorizeCommands(
        L["ADDON_LOADED_MSG"] or "loaded, type /xivc to open settings."
    )
    AddChatMessage(prefix .. " " .. body)
end

function XIVBar:OpenChangelogCategory()
    local settings = _G["Settings"]
    local openLegacyCategory = _G["InterfaceOptionsFrame_OpenToCategory"]
    local category = self.changelogCategory or self.optionsCategory or "XIV Databar Continued"

    if settings and settings.OpenToCategory then
        settings.OpenToCategory(category)
    elseif openLegacyCategory then
        openLegacyCategory(category)
    end
end

function XIVBar:ScheduleOpenChangelogAfterCombat()
    if self._changelogOpenAfterCombat then return end
    self._changelogOpenAfterCombat = true

    local frame = self._changelogCombatFrame
    if not frame then
        frame = CreateFrame("Frame")
        self._changelogCombatFrame = frame
    end

    frame:RegisterEvent("PLAYER_REGEN_ENABLED")
    frame:SetScript("OnEvent", function(eventFrame, event)
        if event ~= "PLAYER_REGEN_ENABLED" then return end
        eventFrame:UnregisterEvent("PLAYER_REGEN_ENABLED")
        eventFrame:SetScript("OnEvent", nil)
        self._changelogOpenAfterCombat = nil
        if self.OpenChangelogCategory then
            self:OpenChangelogCategory()
        end
    end)
end

function XIVBar:HandleChangelogChatLink()
    if InCombatLockdown() then
        AddChatMessage(self:GetChatPrefix() .. ": " ..
            (L["CHANGELOG_AFTER_COMBAT"] or "Changelog will open after combat ends"))
        self:ScheduleOpenChangelogAfterCombat()
        return
    end

    self:OpenChangelogCategory()
end

function XIVBar:MaybeAnnounceAddonUpdate()
    if not (self.db and self.db.profile and self.db.profile.general) then return end

    local currentVersion = C_AddOns.GetAddOnMetadata(AddOnName, "Version") or ""
    -- Hotfix tags (e.g. 5.6.1-fix1): seed silently, no [Open Changelog] announce.
    if currentVersion:lower():find("fix", 1, true) then
        self.db.profile.general.lastChangelogAnnounce = currentVersion
        return
    end

    local lastAnnounce = self.db.profile.general.lastChangelogAnnounce or ""

    if lastAnnounce == "" then
        -- Brand-new install: seed silently. Existing profiles: fall through and announce.
        if not self._hadPriorInstall then
            self.db.profile.general.lastChangelogAnnounce = currentVersion
            return
        end
    elseif lastAnnounce == currentVersion then
        return
    end

    local versionText = "|cffffd100" .. currentVersion .. "|r"
    local linkText = "|cffdb6233[" .. (L["OPEN_CHANGELOG"] or "Open Changelog") .. "]|r"
    local link = "|Hxivcchangelog:1|h" .. linkText .. "|h"
    local body = (L["UPDATE_ANNOUNCE"] or "got updated to %s,"):format(versionText)
    AddChatMessage(self:GetChatPrefix() .. " " .. body .. " " .. link)
    self.db.profile.general.lastChangelogAnnounce = currentVersion
end

if not XIVBar._XIVC_ChangelogChatLinkHooked then
    XIVBar._XIVC_ChangelogChatLinkHooked = true
    hooksecurefunc("SetItemRef", function(link)
        if type(link) ~= "string" then return end
        local linkType = strsplit(":", link, 2)
        if linkType ~= "xivcchangelog" then return end

        if XIVBar and XIVBar.HandleChangelogChatLink then
            XIVBar:HandleChangelogChatLink()
        end
    end)
end

-- Bump when the setup prompt must be shown again (e.g. after changing who gets it).
local PROFILE_SETUP_VERSION = 4

function XIVBar:GetCharacterProfileKey()
    return self.constants.playerName .. " - " .. self.constants.playerRealm
end

function XIVBar:HasCompletedProfileSetup()
    return (self.db.char.profileSetupVersion or 0) >= PROFILE_SETUP_VERSION
end

function XIVBar:MarkProfileSetupDone()
    self.db.char.profileSetupVersion = PROFILE_SETUP_VERSION
    -- Clear the early boolean flag that could silently suppress the Default prompt.
    self.db.char.profileSetupDone = nil
    self.profileSetupPending = nil
end

function XIVBar:HasDefaultProfile()
    return self.db.profiles and rawget(self.db.profiles, "Default") ~= nil
end

function XIVBar:GetSharedProfileForCopy()
    local pending = self.profileSetupPending
    local charKey = (pending and pending.charKey) or self:GetCharacterProfileKey()
    local candidate = pending and pending.preferred
    if candidate and candidate ~= charKey then
        return candidate
    end
    if self:HasDefaultProfile() then
        return "Default"
    end
    return nil
end

-- copyShared: nil/false = blank personal profile; true = personal profile copied from shared/Default.
function XIVBar:CreatePersonalProfileFromSetup(copyShared)
    local pending = self.profileSetupPending
    local charKey = (pending and pending.charKey) or self:GetCharacterProfileKey()
    local baseProfile = copyShared and self:GetSharedProfileForCopy() or nil

    self:MarkProfileSetupDone()

    if self.db:GetCurrentProfile() ~= charKey then
        self.db:SetProfile(charKey)
    end

    if copyShared and baseProfile and baseProfile ~= charKey then
        self.db:CopyProfile(baseProfile, true)
    else
        self.db:ResetProfile()
    end
end

function XIVBar:UseSharedDefaultFromSetup()
    self:MarkProfileSetupDone()
    if self.db:GetCurrentProfile() ~= "Default" then
        self.db:SetProfile("Default")
    end
end

function XIVBar:MaybeShowProfileSetupPrompt()
    if not self.db or self:HasCompletedProfileSetup() then
        return
    end

    local charKey = self:GetCharacterProfileKey()
    local current = self.db:GetCurrentProfile()

    if current == "Default" then
        -- Legacy shared profile: full migration dialog.
        self.profileSetupPending = {
            mode = "migrate",
            preferred = "Default",
            sourceProfile = current,
            charKey = charKey,
            isLegacyDefault = true,
        }
        self:ShowProfileSetupDialog("migrate")
        return
    end

    if current == charKey and self:HasDefaultProfile() then
        -- New character on a blank personal profile: offer shared Default or stay fresh.
        self.profileSetupPending = {
            mode = "newchar",
            preferred = "Default",
            sourceProfile = current,
            charKey = charKey,
        }
        self:ShowProfileSetupDialog("newchar")
        return
    end

    -- Custom profile, or first character with no Default yet.
    self:MarkProfileSetupDone()
end

function XIVBar:CreateMainBar()
    if self.frames.bar == nil then
        local bar = CreateFrame("FRAME", "XIV_Databar", UIParent)
        self:RegisterFrame('bar', bar)
        self.frames.bgTexture = self.frames.bgTexture or bar:CreateTexture(nil, "BACKGROUND")

        -- Create guide lines
        local guides = CreateFrame("FRAME", nil, UIParent)
        guides:SetAllPoints()
        guides:Hide()

        -- Vertical center line
        local centerLine = guides:CreateTexture(nil, "OVERLAY")
        centerLine:SetColorTexture(1, 1, 1, 0.3)
        centerLine:SetWidth(2)
        centerLine:SetPoint("TOP", UIParent, "TOP", 0, 0)
        centerLine:SetPoint("BOTTOM", UIParent, "BOTTOM", 0, 0)

        -- Horizontal center line
        local hCenterLine = guides:CreateTexture(nil, "OVERLAY")
        hCenterLine:SetColorTexture(1, 1, 1, 0.3)
        hCenterLine:SetHeight(2)
        hCenterLine:SetPoint("LEFT", UIParent, "LEFT", 0, 0)
        hCenterLine:SetPoint("RIGHT", UIParent, "RIGHT", 0, 0)

        -- Edge markers
        local edgeMarkerSize = 40
        local edgeMarkerThickness = 2

        -- Top edge markers
        local topLeft = guides:CreateTexture(nil, "OVERLAY")
        topLeft:SetColorTexture(1, 1, 1, 0.3)
        topLeft:SetSize(edgeMarkerSize, edgeMarkerThickness)
        topLeft:SetPoint("TOPLEFT", UIParent, "TOPLEFT", 0, 0)

        local topRight = guides:CreateTexture(nil, "OVERLAY")
        topRight:SetColorTexture(1, 1, 1, 0.3)
        topRight:SetSize(edgeMarkerSize, edgeMarkerThickness)
        topRight:SetPoint("TOPRIGHT", UIParent, "TOPRIGHT", 0, 0)

        -- Bottom edge markers
        local bottomLeft = guides:CreateTexture(nil, "OVERLAY")
        bottomLeft:SetColorTexture(1, 1, 1, 0.3)
        bottomLeft:SetSize(edgeMarkerSize, edgeMarkerThickness)
        bottomLeft:SetPoint("BOTTOMLEFT", UIParent, "BOTTOMLEFT", 0, 0)

        local bottomRight = guides:CreateTexture(nil, "OVERLAY")
        bottomRight:SetColorTexture(1, 1, 1, 0.3)
        bottomRight:SetSize(edgeMarkerSize, edgeMarkerThickness)
        bottomRight:SetPoint("BOTTOMRIGHT", UIParent, "BOTTOMRIGHT", 0, 0)

        -- Vertical edge markers
        local leftTop = guides:CreateTexture(nil, "OVERLAY")
        leftTop:SetColorTexture(1, 1, 1, 0.3)
        leftTop:SetSize(edgeMarkerThickness, edgeMarkerSize)
        leftTop:SetPoint("TOPLEFT", UIParent, "TOPLEFT", 0, 0)

        local leftBottom = guides:CreateTexture(nil, "OVERLAY")
        leftBottom:SetColorTexture(1, 1, 1, 0.3)
        leftBottom:SetSize(edgeMarkerThickness, edgeMarkerSize)
        leftBottom:SetPoint("BOTTOMLEFT", UIParent, "BOTTOMLEFT", 0, 0)

        local rightTop = guides:CreateTexture(nil, "OVERLAY")
        rightTop:SetColorTexture(1, 1, 1, 0.3)
        rightTop:SetSize(edgeMarkerThickness, edgeMarkerSize)
        rightTop:SetPoint("TOPRIGHT", UIParent, "TOPRIGHT", 0, 0)

        local rightBottom = guides:CreateTexture(nil, "OVERLAY")
        rightBottom:SetColorTexture(1, 1, 1, 0.3)
        rightBottom:SetSize(edgeMarkerThickness, edgeMarkerSize)
        rightBottom:SetPoint("BOTTOMRIGHT", UIParent, "BOTTOMRIGHT", 0, 0)

        self.frames.guides = guides

        -- Set initial frame level instead of strata
        bar:SetFrameLevel(1)

        -- Make the bar movable
        bar:SetMovable(true)
        bar:EnableMouse(true)
        bar:RegisterForDrag("LeftButton")

        -- Snap threshold in pixels
        local SNAP_THRESHOLD = 20

        -- Helper function to check if a value is within the snap threshold
        local function IsWithinThreshold(value, target, threshold)
            return math.abs(value - target) <= threshold
        end

        -- Helper function to get the center coordinates of the bar
        local function GetBarCenter(frame)
            local width, height = frame:GetSize()
            local x, y = frame:GetCenter()
            return x, y, width, height
        end

        -- Helper function to snap to nearest point if within threshold
        local function GetSnappedPosition(frame)
            local screenWidth, screenHeight = UIParent:GetWidth(), UIParent:GetHeight()
            local centerX, centerY, barWidth = GetBarCenter(frame)
            local point
            local xOffset
            local yOffset
            local snapped = false

            -- Check horizontal position
            if IsWithinThreshold(centerX, screenWidth/2, SNAP_THRESHOLD) then
                point = "CENTER"
                xOffset = 0
                snapped = true
            elseif IsWithinThreshold(centerX - barWidth/2, 0, SNAP_THRESHOLD) then
                point = "LEFT"
                xOffset = 0
                snapped = true
            elseif IsWithinThreshold(centerX + barWidth/2, screenWidth, SNAP_THRESHOLD) then
                point = "RIGHT"
                xOffset = 0
                snapped = true
            else
                point = "CENTER"
                xOffset = centerX - screenWidth/2
            end

            -- Check vertical position
            if IsWithinThreshold(centerY, 0, SNAP_THRESHOLD) then
                yOffset = 0
                point = "BOTTOM" .. (point ~= "CENTER" and point or "")
                snapped = true
            elseif IsWithinThreshold(centerY, screenHeight, SNAP_THRESHOLD) then
                yOffset = 0
                point = "TOP" .. (point ~= "CENTER" and point or "")
                snapped = true
            else
                yOffset = centerY - screenHeight/2
            end

            return point, point, xOffset, yOffset, snapped
        end

        bar:SetScript("OnDragStart", function(frame)
            if not XIVBar.db.profile.general.locked and not XIVBar.db.profile.general.barFullscreen then
                frame:StartMoving()
                XIVBar.frames.guides:Show()
            end
        end)

        bar:SetScript("OnDragStop", function(frame)
            if not XIVBar.db.profile.general.barFullscreen then
                frame:StopMovingOrSizing()
                XIVBar.frames.guides:Hide()

                -- Get final position with snapping
                local point, relativePoint, xOffset, yOffset = GetSnappedPosition(frame)

                -- Save position
                XIVBar.db.profile.general.point = point
                XIVBar.db.profile.general.relativePoint = relativePoint
                XIVBar.db.profile.general.xOffset = xOffset
                XIVBar.db.profile.general.yOffset = yOffset

                -- Apply position
                frame:ClearAllPoints()
                frame:SetPoint(point, UIParent, relativePoint, xOffset, yOffset)

                XIVBar:Refresh()
            end
        end)
    end
end

function XIVBar:ResetUI()
    if UIParent_UpdateTopFramePositions then
        UIParent_UpdateTopFramePositions()
    end
end

function XIVBar:OnEnable()
    self:CreateMainBar()
    self:Refresh()

    self.db.RegisterCallback(self, 'OnProfileCopied', 'Refresh')
    self.db.RegisterCallback(self, 'OnProfileChanged', 'Refresh')
    self.db.RegisterCallback(self, 'OnProfileReset', 'Refresh')

    C_Timer.After(1, function()
        if XIVBar and XIVBar.db then
            XIVBar:MaybeShowProfileSetupPrompt()
        end
    end)

    if not self.timerRefresh then
        C_Timer.After(5, function()
            self:Refresh()
            self.timerRefresh = true
        end)
    end
end

function XIVBar:ToggleConfig()
    local settings = _G["Settings"]
    local openLegacyCategory = _G["InterfaceOptionsFrame_OpenToCategory"]

    if settings and settings.OpenToCategory then
        if self.optionsCategory then
            settings.OpenToCategory(self.optionsCategory)
        else
            settings.OpenToCategory("XIV Bar Continued")
        end
    elseif openLegacyCategory then
        local category = self.optionsCategory or "XIV Bar Continued"
        openLegacyCategory(category)
    else
        self:Print("Impossible d'ouvrir les options sur cette version du client.")
    end
end

function XIVBar:SetColor(name, r, g, b, a)
    self.db.profile.color[name].r = r
    self.db.profile.color[name].g = g
    self.db.profile.color[name].b = b
    self.db.profile.color[name].a = a

    self:Refresh()
end

function XIVBar:GetColor(name)
    local profile = self.db.profile.color
    local r, g, b, a = profile[name].r, profile[name].g, profile[name].b, profile[name].a

    if name == 'normal' and profile.useTextCC then
        r, g, b = self:GetClassColors()
    elseif name == 'barColor' and profile.useCC then
        r, g, b = self:GetClassColors()
    elseif name == 'hover' and profile.useHoverCC then
        r, g, b = self:GetClassColors()
    end

    return r, g, b, a or 1
end

-- Pass nil year for SHORTDATENOYEAR (calendar/lockout dates without year).
function XIVBar:FormatLocalizedDate(day, month, year)
    day, month = tonumber(day), tonumber(month)
    if not (day and month) then
        return nil
    end
    if year ~= nil then
        year = tonumber(year)
        if not year then
            return nil
        end
        return FormatShortDate(day, month, year)
    end
    return FormatShortDate(day, month)
end

-- Accept YYYY-MM-DD or YYYY/MM/DD
function XIVBar:FormatLocalizedDateString(dateString)
    if type(dateString) ~= "string" then
        return dateString
    end
    local y, m, d = dateString:match("^(%d%d%d%d)[%-%/](%d%d)[%-%/](%d%d)$")
    if not y then
        return dateString
    end
    return self:FormatLocalizedDate(d, m, y) or dateString
end

function XIVBar:HoverColors()
    local colors
    local profile = self.db.profile.color
    local hoverAlpha = profile.hover.a or 1
    -- use self-picked color for hover color
    if not profile.useHoverCC then
        colors = {
            profile.hover.r, profile.hover.g, profile.hover.b, hoverAlpha
        }
        -- use class color for hover color
    else
        local r, g, b = self:GetClassColors()
        colors = {r, g, b, hoverAlpha}
    end
    return colors
end

function XIVBar:RegisterFrame(name, frame)
    frame:SetScript('OnHide',
                    function() self:SendMessage('XIVBar_FrameHide', name) end)
    frame:SetScript('OnShow',
                    function() self:SendMessage('XIVBar_FrameShow', name) end)
    self.frames[name] = frame
end

function XIVBar:RegisterMouseoverHoldFrame(frame, keepVisibleWhileShown)
    if not frame then
        return
    end
    self.mouseoverHoldFrames = self.mouseoverHoldFrames or {}
    self.mouseoverHoldFrames[frame] = true
    frame._xivKeepVisibleWhileShown = (keepVisibleWhileShown ~= false)
end

function XIVBar:GetPopupDismissLayer()
    if self.popupDismissLayer then
        return self.popupDismissLayer
    end

    local layer = CreateFrame("BUTTON", nil, UIParent)
    layer:SetAllPoints(UIParent)
    layer:Hide()
    layer:EnableMouse(true)
    layer:RegisterForClicks("AnyUp", "AnyDown")
    layer:SetFrameStrata("TOOLTIP")
    layer:SetFrameLevel(1)
    layer:SetScript("OnClick", function()
        XIVBar:HideActivePopup()
    end)

    self.popupDismissLayer = layer
    return layer
end

function XIVBar:ShowPopup(popup)
    if not popup then
        return
    end

    local layer = self:GetPopupDismissLayer()
    if self.activePopup and self.activePopup ~= popup and self.activePopup.Hide then
        self.activePopup:Hide()
    end

    self.activePopup = popup

    if not popup._xivPopupAutoCloseHooked then
        popup._xivPopupAutoCloseHooked = true
        popup:HookScript("OnHide", function(frame)
            if XIVBar.activePopup == frame then
                XIVBar.activePopup = nil
                if XIVBar.popupDismissLayer then
                    XIVBar.popupDismissLayer:Hide()
                end
            end
        end)
    end

    layer:ClearAllPoints()
    layer:SetAllPoints(UIParent)
    layer:SetFrameStrata(popup:GetFrameStrata() or "TOOLTIP")
    local popupLevel = popup:GetFrameLevel() or 1
    layer:SetFrameLevel(math.max(1, popupLevel - 1))
    layer:Show()
    popup:Show()
end

function XIVBar:HidePopup(popup)
    if not popup then
        return
    end
    popup:Hide()
    if self.activePopup == popup then
        self.activePopup = nil
        if self.popupDismissLayer then
            self.popupDismissLayer:Hide()
        end
    end
end

function XIVBar:HideActivePopup()
    if self.activePopup and self.activePopup.Hide then
        self.activePopup:Hide()
        return
    end
    if self.popupDismissLayer then
        self.popupDismissLayer:Hide()
    end
end

--- Get the frame with the specified name
---@param name string name of the frame as supplied to RegisterFrame
---@return Frame
function XIVBar:GetFrame(name) return self.frames[name] end

function XIVBar:HideBarEvent()
    local bar = self:GetFrame("bar")
    local vehiculeIsFlight = false;

    bar:UnregisterAllEvents()
    bar.OnEvent = nil
    bar:RegisterEvent("PET_BATTLE_OPENING_START")
    bar:RegisterEvent("PET_BATTLE_CLOSE")
    bar:RegisterEvent("TAXIMAP_CLOSED")
    bar:RegisterEvent("VEHICLE_POWER_SHOW")
    bar:RegisterEvent("PLAYER_ENTERING_WORLD")
    bar:RegisterEvent("ZONE_CHANGED_NEW_AREA")

    bar:SetScript("OnEvent", function(_, event)
        local barFrame = XIVBar:GetFrame("bar")

        -- Handle zone changes and instance transitions
        if event == "PLAYER_ENTERING_WORLD" or event == "ZONE_CHANGED_NEW_AREA" then
            C_Timer.After(0.5, function()
                if not barFrame:IsVisible() then
                    barFrame:Show()
                end
                -- Full refresh of the bar and modules
                XIVBar:Refresh()
                -- Force update module positions
                XIVBar:ResetUI()
            end)
            return
        end

        if self.db.profile.general.barFlightHide then
            if event == "VEHICLE_POWER_SHOW" then
                if not barFrame:IsVisible() then barFrame:Show() end
                if vehiculeIsFlight and barFrame:IsVisible() then
                    barFrame:Hide()
                end
            end

            if event == "TAXIMAP_CLOSED" then
                vehiculeIsFlight = true
                C_Timer.After(1, function()
                    vehiculeIsFlight = false
                end)
            end
        end

        if event == "PET_BATTLE_OPENING_START" and barFrame:IsVisible() then
            barFrame:Hide()
        end
        if event == "PET_BATTLE_CLOSE" and not barFrame:IsVisible() then
            barFrame:Show()
        end
    end)

    if self.db.profile.general.barCombatHide then
        bar:RegisterEvent("PLAYER_REGEN_ENABLED")
        bar:RegisterEvent("PLAYER_REGEN_DISABLED")

        bar:HookScript("OnEvent", function(_, event)
            local barFrame = XIVBar:GetFrame("bar")
            if event == "PLAYER_REGEN_DISABLED" and barFrame:IsVisible() then
                barFrame:Hide()
            end
            if event == "PLAYER_REGEN_ENABLED" and not barFrame:IsVisible() then
                barFrame:Show()
                -- Refresh modules when showing after combat
                XIVBar:Refresh()
            end
        end)
    else
        if bar:IsEventRegistered("PLAYER_REGEN_ENABLED") then
            bar:UnregisterEvent("PLAYER_REGEN_ENABLED")
        elseif bar:IsEventRegistered("PLAYER_REGEN_DISABLED") then
            bar:UnregisterEvent("PLAYER_REGEN_DISABLED")
        end
    end
end

function XIVBar:GetHeight()
    return (self.db.profile.text.fontSize * 2) +
               self.db.profile.general.barPadding
end

function XIVBar:ApplySavedBarOffset()
    if self.frames.bar == nil then return end
    if self.db.profile.general.barFullscreen then return end
    if InCombatLockdown() then return end

    local point = self.db.profile.general.point
    if not point then return end

    self.frames.bar:ClearAllPoints()
    self.frames.bar:SetPoint(
        point,
        UIParent,
        self.db.profile.general.relativePoint,
        self.db.profile.general.xOffset,
        self.db.profile.general.yOffset
    )
end

function XIVBar:Refresh()
    if self.frames.bar == nil then return; end

    self:HideBarEvent()
    self.miniTextPosition = "TOP"
    if self.db.profile.general.barPosition == 'TOP' then
        self.miniTextPosition = 'BOTTOM'
    else
        self:ResetUI();
    end

    if not InCombatLockdown() then
        self.frames.bar:ClearAllPoints()
    end

    -- Use saved position if not in fullscreen mode
    if not self.db.profile.general.barFullscreen then
        -- If we have a saved custom position, use it
        if self.db.profile.general.point then
            self:ApplySavedBarOffset()
        else
            -- Initial position based on barHoriz and barPosition
            self.frames.bar:SetPoint(self.db.profile.general.barPosition, UIParent, self.db.profile.general.barPosition)
            if self.db.profile.general.barHoriz == 'LEFT' then
                self.frames.bar:SetPoint("LEFT", UIParent, "LEFT", self.db.profile.general.barMargin, 0)
            elseif self.db.profile.general.barHoriz == 'RIGHT' then
                self.frames.bar:SetPoint("RIGHT", UIParent, "RIGHT", -self.db.profile.general.barMargin, 0)
            else -- CENTER
                self.frames.bar:SetPoint(self.db.profile.general.barHoriz, UIParent, self.db.profile.general.barHoriz, 0, 0)
            end
        end
        self.frames.bar:SetWidth(self.db.profile.general.barWidth)
    else
        if not InCombatLockdown() then
            self.frames.bar:SetPoint(self.db.profile.general.barPosition)
            self.frames.bar:SetPoint("LEFT", self.db.profile.general.barMargin, 0)
            self.frames.bar:SetPoint("RIGHT", -self.db.profile.general.barMargin, 0)
        end
    end

    if not InCombatLockdown() then
        self.frames.bar:SetHeight(self:GetHeight())
        self.frames.bgTexture:SetColorTexture(self:GetColor('barColor'))
        self.frames.bgTexture:SetAllPoints()
    end

    for _, module in self:IterateModules() do
        if module['Refresh'] == nil then return; end
        module:Refresh()
    end

    self:UpdateMouseoverScripts()
end

function XIVBar:GetFont(size)
    return self.LSM:Fetch(self.LSM.MediaType.FONT, self.db.profile.text.font),
           size, self.fontFlags[self.db.profile.text.flags]
end

function XIVBar:GetClassColors()
    return RAID_CLASS_COLORS[self.constants.playerClass].r,
           RAID_CLASS_COLORS[self.constants.playerClass].g,
           RAID_CLASS_COLORS[self.constants.playerClass].b,
           self.db.profile.color.barColor.a
end

function XIVBar:UpdateMouseoverScripts()
    local bar = XIVBar.frames and XIVBar.frames.bar
    if not bar then return end

    local function IsMouseOverBar()
        if bar:IsMouseOver() then
            return true
        end

        if XIVBar.mouseoverHoldFrames then
            for frame in pairs(XIVBar.mouseoverHoldFrames) do
                if frame then
                    local isShown = frame.IsShown and frame:IsShown()
                    local isVisible = frame.IsVisible and frame:IsVisible()
                    if isShown and isVisible then
                        if frame:IsMouseOver() or frame._xivKeepVisibleWhileShown then
                            return true
                        end
                    end
                end
            end
        end

        return false
    end

    local function IsBarChild(frame)
        local parent = frame and frame:GetParent()
        while parent do
            if parent == bar then
                return true
            end
            parent = parent:GetParent()
        end
        return false
    end

    local function EnsureMouseoverAnimations()
        if bar._xivFadeInGroup and bar._xivFadeOutGroup then
            return
        end

        bar._xivFadeInGroup = bar:CreateAnimationGroup()
        bar._xivFadeIn = bar._xivFadeInGroup:CreateAnimation("Alpha")
        bar._xivFadeIn:SetOrder(1)
        bar._xivFadeIn:SetDuration(0.15)
        bar._xivFadeInGroup:SetScript("OnFinished", function()
            bar:SetAlpha(1)
        end)

        bar._xivFadeOutGroup = bar:CreateAnimationGroup()
        bar._xivFadeOut = bar._xivFadeOutGroup:CreateAnimation("Alpha")
        bar._xivFadeOut:SetOrder(1)
        bar._xivFadeOut:SetDuration(0.15)
        bar._xivFadeOutGroup:SetScript("OnFinished", function()
            bar:SetAlpha(0)
        end)
    end

    local function PlayAlpha(group, anim, fromAlpha, toAlpha)
        if group:IsPlaying() then
            group:Stop()
        end
        anim:SetFromAlpha(fromAlpha)
        anim:SetToAlpha(toAlpha)
        group:Play()
    end

    local showBar
    local hideBarIfOut

    local function HookMouseoverFrame(frame)
        if not (frame and frame.EnableMouse) then
            return
        end
        if frame._xivMouseoverHooksInstalled then
            return
        end

        frame:EnableMouse(true)

        if frame._xivKeepVisibleWhileShown then
            frame._xivMouseoverHooksInstalled = true
            return
        end

        if not frame.HookScript then
            return
        end

        frame._xivMouseoverHooksInstalled = true
        frame:HookScript('OnEnter', showBar)
        frame:HookScript('OnLeave', hideBarIfOut)
    end

    showBar = function()
        bar._xivHidePending = false
        if not bar._xivMouseoverEnabled then
            return
        end
        if bar._xivMouseoverVisible then
            return
        end

        EnsureMouseoverAnimations()
        if bar._xivFadeOutGroup and bar._xivFadeOutGroup:IsPlaying() then
            bar._xivFadeOutGroup:Stop()
        end

        bar._xivMouseoverVisible = true
        PlayAlpha(bar._xivFadeInGroup, bar._xivFadeIn, bar:GetAlpha(), 1)
    end

    hideBarIfOut = function()
        -- Petit délai pour laisser le curseur passer d'un enfant à l'autre sans clignoter
        if bar._xivHidePending then return end
        bar._xivHidePending = true
        bar._xivHideToken = (bar._xivHideToken or 0) + 1
        local token = bar._xivHideToken
        C_Timer.After(0.12, function()
            bar._xivHidePending = false
            if token ~= bar._xivHideToken then
                return
            end
            if not bar._xivMouseoverEnabled then
                return
            end
            if not IsMouseOverBar() then
                EnsureMouseoverAnimations()
                if bar._xivFadeInGroup and bar._xivFadeInGroup:IsPlaying() then
                    bar._xivFadeInGroup:Stop()
                end

                bar._xivMouseoverVisible = false
                PlayAlpha(bar._xivFadeOutGroup, bar._xivFadeOut, bar:GetAlpha(), 0)
            end
        end)
    end

    if XIVBar.db and XIVBar.db.profile and XIVBar.db.profile.general.showOnMouseover then
        bar._xivMouseoverEnabled = true
        bar._xivMouseoverVisible = false
        bar._xivHidePending = false
        bar:SetAlpha(0)
        bar:SetScript('OnEnter', showBar)
        bar:SetScript('OnLeave', hideBarIfOut)
        bar:SetScript('OnUpdate', function(frame, elapsed)
            frame._xivMouseoverElapsed = (frame._xivMouseoverElapsed or 0) + elapsed
            if frame._xivMouseoverElapsed < 0.05 then return end
            frame._xivMouseoverElapsed = 0
            if not bar._xivMouseoverEnabled then
                return
            end
            if IsMouseOverBar() then
                showBar()
            else
                hideBarIfOut()
            end
        end)
        -- Apply the same handlers to all registered module frames so the bar stays visible when hovering them
        if XIVBar.frames then
            for _, frame in pairs(XIVBar.frames) do
                if frame and frame ~= bar and frame.EnableMouse and frame.HookScript and IsBarChild(frame) then
                    HookMouseoverFrame(frame)
                end
            end
        end
        if XIVBar.mouseoverHoldFrames then
            for frame in pairs(XIVBar.mouseoverHoldFrames) do
                if frame and frame ~= bar then
                    HookMouseoverFrame(frame)
                end
            end
        end
    else
        bar._xivMouseoverEnabled = false
        bar._xivHideToken = (bar._xivHideToken or 0) + 1
        if bar._xivFadeInGroup and bar._xivFadeInGroup:IsPlaying() then
            bar._xivFadeInGroup:Stop()
        end
        if bar._xivFadeOutGroup and bar._xivFadeOutGroup:IsPlaying() then
            bar._xivFadeOutGroup:Stop()
        end
        bar._xivHidePending = false
        bar:SetAlpha(1)
        bar:SetScript('OnEnter', nil)
        bar:SetScript('OnLeave', nil)
        bar:SetScript('OnUpdate', nil)
        bar._xivMouseoverElapsed = nil
        bar._xivMouseoverVisible = nil
        bar._xivHidePending = nil
    end
end

function XIVBar:ShouldShowTooltip()
    if self.db.profile.general.disableTooltipsInCombat and InCombatLockdown() then
        return false
    end
    return true
end