HelloGuild.lua

local ADDON_NAME = ...
local frame = CreateFrame("Frame")
local L = HelloGuild_L

local DEFAULTS = {
    enabled = true,
    greetEnabled = true,
    achievementEnabled = true,
    minimapButton = true,
    minimapAngle = 220,
    cooldown = 8,
    greetingDelayMin = 3,
    greetingDelayMax = 8,
    achievementDelayMin = 2,
    achievementDelayMax = 6,
    messageLanguage = HelloGuild_ClientMessageLanguage,
    messageStyle = "fantasy",
    greetingLibraryVersion = 3,
    congratulationsLibraryVersion = 3,
    greetingsByLanguage = HelloGuild_DefaultGreetingsByLanguage,
    congratulationsByLanguage = HelloGuild_DefaultCongratulationsByLanguage,
    simpleGreetingsByLanguage = HelloGuild_DefaultSimpleGreetingsByLanguage,
    simpleCongratulationsByLanguage = HelloGuild_DefaultSimpleCongratulationsByLanguage,
}

local online = {}
local rosterReady = false
local queue = {}
local sending = false
local pendingGreetings = {}
local activeGuild
local sendGeneration = 0
local achievementGeneration = 0
local retryScheduled = false
local inFlight

local QUEUE_LIMIT = 50
local QUEUE_MAX_AGE = 7200
local SEND_CONFIRM_TIMEOUT = 6

local function RandomDelay(minimum, maximum)
    minimum = math.max(0, math.floor(tonumber(minimum) or 0))
    maximum = math.max(minimum, math.floor(tonumber(maximum) or minimum))
    return math.random(minimum, maximum)
end

local function Print(message)
    DEFAULT_CHAT_FRAME:AddMessage("|cff33ff99HelloGuild:|r " .. message)
end

local function CopyDefaults(source, target)
    for key, value in pairs(source) do
        if type(value) == "table" then
            if type(target[key]) ~= "table" then
                target[key] = {}
                CopyDefaults(value, target[key])
            elseif #value == 0 then
                -- Verschachtelte Optionsgruppen weiter ergänzen, bestehende
                -- Nachrichtenlisten jedoch niemals mit Defaults auffüllen.
                CopyDefaults(value, target[key])
            end
        elseif target[key] == nil then
            target[key] = value
        end
    end
end

local function AppendUniqueDefaults(target, defaults, firstIndex)
    local known = {}
    for _, text in ipairs(target) do
        known[text] = true
    end
    for index = firstIndex, #defaults do
        local text = defaults[index]
        if not known[text] then
            target[#target + 1] = text
            known[text] = true
        end
    end
end

local function NormalizeDelayRange(minimumKey, maximumKey)
    local minimum = math.max(
        0,
        math.min(60, math.floor(tonumber(HelloGuildDB[minimumKey]) or 0))
    )
    local maximum = math.max(
        0,
        math.min(60, math.floor(tonumber(HelloGuildDB[maximumKey]) or minimum))
    )
    if minimum > maximum then
        minimum, maximum = maximum, minimum
    end
    HelloGuildDB[minimumKey] = minimum
    HelloGuildDB[maximumKey] = maximum
end

local function ShortName(name)
    if not name then return nil end
    return Ambiguate(name, "short")
end

local function PlayerIsSelf(name)
    local playerName = UnitName("player")
    return ShortName(name) == playerName
end

local function Render(template, name)
    return template:gsub("{name}", ShortName(name) or L.UNKNOWN)
end

local function CurrentGuild()
    if not IsInGuild() then return nil end
    local guildName = GetGuildInfo("player")
    if guildName then
        activeGuild = guildName
    end
    return guildName
end

local function RemoveQueuedKind(kind)
    local removedInFlight = inFlight and inFlight.entry.kind == kind
    for index = #queue, 1, -1 do
        if queue[index].kind == kind then
            table.remove(queue, index)
        end
    end
    if removedInFlight then
        sendGeneration = sendGeneration + 1
        inFlight = nil
        sending = false
    end
end

local function EntryCanStillSend(entry, guildName, now)
    if now - entry.createdAt > QUEUE_MAX_AGE then return false end
    if entry.guildName and entry.guildName ~= guildName then return false end
    if entry.kind == "greeting" and not HelloGuildDB.greetEnabled then return false end
    if entry.kind == "achievement" and not HelloGuildDB.achievementEnabled then return false end
    return true
end

local SendNext

local function ChallengeModeIsActive()
    return C_ChallengeMode
        and C_ChallengeMode.IsChallengeModeActive
        and C_ChallengeMode.IsChallengeModeActive()
end

local function SendingIsRestricted()
    if InCombatLockdown() or UnitAffectingCombat("player") then
        return true, 2
    end
    if IsEncounterInProgress and IsEncounterInProgress() then
        return true, 2
    end
    if ChallengeModeIsActive() then
        return true, 15
    end
    return false, nil
end

local function ScheduleQueueRetry(delay)
    if retryScheduled or #queue == 0 or not HelloGuildDB.enabled then return end
    retryScheduled = true
    local generation = sendGeneration
    C_Timer.After(delay or 2, function()
        retryScheduled = false
        if generation ~= sendGeneration or #queue == 0 or sending then return end
        SendNext()
    end)
end

SendNext = function()
    if sending or inFlight then return end
    if #queue == 0 then
        sending = false
        return
    end

    if not HelloGuildDB.enabled then
        wipe(queue)
        sending = false
        return
    end

    -- Gildenchat kann im Kampf, während Encountern und in aktiven
    -- Herausforderungsmodi geschützt sein. Die Nachricht bleibt vorne in der
    -- Queue und wird erst nach Ende des geschützten Zustands versucht.
    local restricted, retryDelay = SendingIsRestricted()
    if restricted then
        sending = false
        ScheduleQueueRetry(retryDelay)
        return
    end

    -- Die Gilden-API kann bei Lade- und Zonenwechseln kurzzeitig keine Daten
    -- liefern. In diesem Fall bleibt die Queue erhalten und wird durch das
    -- nächste passende Ereignis erneut angestoßen.
    local guildName = CurrentGuild()
    if not guildName then
        sending = false
        ScheduleQueueRetry(2)
        return
    end

    local now = GetTime()
    while queue[1] and not EntryCanStillSend(queue[1], guildName, now) do
        table.remove(queue, 1)
    end
    if #queue == 0 then
        sending = false
        return
    end

    local entry = queue[1]
    sending = true
    inFlight = {
        entry = entry,
        generation = sendGeneration,
    }
    local sent = pcall(C_ChatInfo.SendChatMessage, entry.message, "GUILD")
    if not sent then
        inFlight = nil
        sending = false
        ScheduleQueueRetry(2)
        return
    end

    local flight = inFlight
    C_Timer.After(SEND_CONFIRM_TIMEOUT, function()
        if inFlight == flight and flight.generation == sendGeneration then
            -- Kein eigenes Gildenchat-Echo: WoW hat den Aufruf möglicherweise
            -- still blockiert. Der Eintrag bleibt für einen späteren Versuch
            -- in der Queue.
            inFlight = nil
            sending = false
            ScheduleQueueRetry(5)
        end
    end)
end

local function ConfirmSentMessage(message, sender)
    local flight = inFlight
    if not flight
        or flight.generation ~= sendGeneration
        or not PlayerIsSelf(sender)
        or message ~= flight.entry.message
    then
        return false
    end

    if queue[1] == flight.entry then
        table.remove(queue, 1)
    end
    inFlight = nil

    local generation = sendGeneration
    C_Timer.After(math.max(3, HelloGuildDB.cooldown or 8), function()
        if generation == sendGeneration then
            sending = false
            SendNext()
        end
    end)
    return true
end

local function Enqueue(message, kind, guildName)
    if not message or message == "" then return end
    guildName = guildName or activeGuild
    if not guildName then return end
    if #queue >= QUEUE_LIMIT then return end
    queue[#queue + 1] = {
        message = message,
        kind = kind,
        guildName = guildName,
        createdAt = GetTime(),
    }
    if not sending then
        SendNext()
    end
end

local function RandomMessage(list, name)
    if not list or #list == 0 then return nil end
    return Render(list[math.random(#list)], name)
end

local function MessageList(kind)
    local language = HelloGuildDB.messageLanguage
    if language ~= "de" and language ~= "en" then
        language = HelloGuild_ClientMessageLanguage
    end
    local simple = HelloGuildDB.messageStyle == "simple"
    local lists
    if kind == "greetings" then
        lists = simple
            and HelloGuildDB.simpleGreetingsByLanguage
            or HelloGuildDB.greetingsByLanguage
    else
        lists = simple
            and HelloGuildDB.simpleCongratulationsByLanguage
            or HelloGuildDB.congratulationsByLanguage
    end
    return lists[language]
end

function HelloGuild_GetMessageList(kind)
    return MessageList(kind)
end

function HelloGuild_SetMessageLanguage(language)
    if language ~= "de" and language ~= "en" then return false end
    if HelloGuildDB.messageLanguage ~= language then
        RemoveQueuedKind("greeting")
        RemoveQueuedKind("achievement")
    end
    HelloGuildDB.messageLanguage = language
    return true
end

function HelloGuild_SetMessageStyle(style)
    if style ~= "fantasy" and style ~= "simple" then return false end
    if HelloGuildDB.messageStyle ~= style then
        RemoveQueuedKind("greeting")
        RemoveQueuedKind("achievement")
    end
    HelloGuildDB.messageStyle = style
    return true
end

local function ScheduleGreeting(name)
    if pendingGreetings[name] then return end
    local guildName = CurrentGuild() or activeGuild
    local token = {}
    pendingGreetings[name] = token

    local delay = RandomDelay(
        HelloGuildDB.greetingDelayMin,
        HelloGuildDB.greetingDelayMax
    )
    C_Timer.After(delay, function()
        if pendingGreetings[name] ~= token then return end
        pendingGreetings[name] = nil
        if HelloGuildDB.enabled
            and HelloGuildDB.greetEnabled
            -- false bedeutet ausdrücklich wieder offline. nil kann dagegen
            -- ein vorübergehend unvollständiger Roster-Snapshot sein.
            and online[name] ~= false
            and not PlayerIsSelf(name)
        then
            Enqueue(
                RandomMessage(MessageList("greetings"), name),
                "greeting",
                guildName
            )
        end
    end)
end

local function ScheduleAchievement(name)
    local guildName = CurrentGuild() or activeGuild
    local generation = achievementGeneration
    local delay = RandomDelay(
        HelloGuildDB.achievementDelayMin,
        HelloGuildDB.achievementDelayMax
    )
    C_Timer.After(delay, function()
        if generation ~= achievementGeneration then return end
        if HelloGuildDB.enabled
            and HelloGuildDB.achievementEnabled
            and not PlayerIsSelf(name)
        then
            Enqueue(
                RandomMessage(MessageList("congratulations"), name),
                "achievement",
                guildName
            )
        end
    end)
end

local function UpdateGuildRoster()
    if not IsInGuild() then
        wipe(online)
        rosterReady = false
        activeGuild = nil
        return
    end

    local guildName = CurrentGuild()
    if not guildName then return end

    local current = {}
    for index = 1, GetNumGuildMembers() do
        local name, _, _, _, _, _, _, _, isOnline = GetGuildRosterInfo(index)
        if name then
            current[name] = isOnline and true or false

            if rosterReady
                and HelloGuildDB.enabled
                and HelloGuildDB.greetEnabled
                and isOnline
                and online[name] == false
                and not PlayerIsSelf(name)
            then
                ScheduleGreeting(name)
            end
        end
    end

    online = current
    rosterReady = true
end

local function ApplyToggleState(key, enabled)
    HelloGuildDB[key] = enabled and true or false
    if HelloGuildDB[key] then return end

    if key == "enabled" then
        wipe(queue)
        wipe(pendingGreetings)
        achievementGeneration = achievementGeneration + 1
        sendGeneration = sendGeneration + 1
        inFlight = nil
        sending = false
    elseif key == "greetEnabled" then
        wipe(pendingGreetings)
        RemoveQueuedKind("greeting")
    elseif key == "achievementEnabled" then
        achievementGeneration = achievementGeneration + 1
        RemoveQueuedKind("achievement")
    end
end

function HelloGuild_SetEnabledOption(key, enabled)
    ApplyToggleState(key, enabled)
end

function HelloGuild_ResetToDefaults()
    wipe(HelloGuildDB)
    CopyDefaults(DEFAULTS, HelloGuildDB)
    NormalizeDelayRange("greetingDelayMin", "greetingDelayMax")
    NormalizeDelayRange("achievementDelayMin", "achievementDelayMax")

    wipe(queue)
    wipe(pendingGreetings)
    achievementGeneration = achievementGeneration + 1
    sendGeneration = sendGeneration + 1
    inFlight = nil
    sending = false

    if HelloGuild_ResetMinimapButtonPosition then
        HelloGuild_ResetMinimapButtonPosition()
    end
    if HelloGuild_SetMinimapButtonShown then
        HelloGuild_SetMinimapButtonShown(HelloGuildDB.minimapButton)
    end
end

local function SetToggle(key, value, label)
    if value == "an" or value == "on" then
        ApplyToggleState(key, true)
    elseif value == "aus" or value == "off" then
        ApplyToggleState(key, false)
    else
        Print(L.STATUS:format(label, HelloGuildDB[key] and L.ON or L.OFF))
        return
    end
    Print(L.CHANGED:format(label, HelloGuildDB[key] and L.ENABLED or L.DISABLED))
end

local function ListMessages(kind, list)
    Print(kind .. ":")
    for index, text in ipairs(list) do
        Print(index .. ". " .. text)
    end
end

local function AddMessage(list, text, kind)
    if text == "" then
        Print(L.TEXT_REQUIRED)
        return
    end
    list[#list + 1] = text
    Print(L.TEXT_ADDED:format(kind, text))
end

local function DeleteMessage(list, indexText, kind)
    local index = tonumber(indexText)
    if not index or not list[index] then
        Print(L.INVALID_NUMBER)
        return
    end
    local removed = table.remove(list, index)
    Print(L.TEXT_REMOVED:format(kind, removed))
end

local function ShowHelp()
    Print(L.COMMANDS)
    for _, line in ipairs(L.HELP_LINES) do
        Print(line)
    end
end

local function IsGreeting(value)
    return value == "begruessung" or value == "greeting" or value == "greetings"
end

local function IsAchievement(value)
    return value == "erfolg" or value == "achievement" or value == "achievements"
end

local function SlashCommand(input)
    local command, rest = input:match("^%s*(%S*)%s*(.-)%s*$")
    command = command:lower()

    if command == "an" or command == "aus" or command == "on" or command == "off" then
        SetToggle("enabled", command, L.ADDON)
    elseif IsGreeting(command) then
        SetToggle("greetEnabled", rest:lower(), L.GREETINGS)
    elseif IsAchievement(command) then
        SetToggle("achievementEnabled", rest:lower(), L.CONGRATULATIONS)
    elseif command == "add" then
        local kind, text = rest:match("^(%S+)%s+(.+)$")
        kind = kind and kind:lower()
        if IsGreeting(kind) then
            AddMessage(MessageList("greetings"), text or "", L.GREETING)
        elseif IsAchievement(kind) then
            AddMessage(MessageList("congratulations"), text or "", L.CONGRATULATION)
        else
            Print(L.ADD_USAGE)
        end
    elseif command == "del" or command == "delete" then
        local kind, index = rest:match("^(%S+)%s+(%S+)$")
        kind = kind and kind:lower()
        if IsGreeting(kind) then
            DeleteMessage(MessageList("greetings"), index, L.GREETING)
        elseif IsAchievement(kind) then
            DeleteMessage(MessageList("congratulations"), index, L.CONGRATULATION)
        else
            Print(L.DELETE_USAGE)
        end
    elseif command == "liste" or command == "list" then
        ListMessages(L.GREETINGS, MessageList("greetings"))
        ListMessages(L.CONGRATULATIONS, MessageList("congratulations"))
    elseif command == "optionen" or command == "options" then
        if HelloGuild_OpenOptions then
            HelloGuild_OpenOptions()
        else
            Print(L.OPTIONS_NOT_LOADED)
        end
    elseif command == "minimap" then
        local value = rest:lower()
        if value == "an" or value == "on" then
            HelloGuildDB.minimapButton = true
        elseif value == "aus" or value == "off" then
            HelloGuildDB.minimapButton = false
        else
            Print(L.MINIMAP_STATUS:format(HelloGuildDB.minimapButton and L.ON or L.OFF))
            return
        end
        if HelloGuild_SetMinimapButtonShown then
            HelloGuild_SetMinimapButtonShown(HelloGuildDB.minimapButton)
        end
        Print(L.MINIMAP_CHANGED:format(HelloGuildDB.minimapButton and L.SHOWN or L.HIDDEN))
    elseif command == "test" then
        if IsGreeting(rest:lower()) then
            Enqueue(
                RandomMessage(MessageList("greetings"), UnitName("player")),
                "greeting",
                CurrentGuild() or activeGuild
            )
        elseif IsAchievement(rest:lower()) then
            Enqueue(
                RandomMessage(MessageList("congratulations"), UnitName("player")),
                "achievement",
                CurrentGuild() or activeGuild
            )
        else
            Print(L.TEST_USAGE)
        end
    elseif command == "cooldown" then
        local seconds = tonumber(rest)
        if seconds and seconds >= 3 and seconds <= 120 then
            HelloGuildDB.cooldown = seconds
            Print(L.COOLDOWN_SET:format(seconds))
        else
            Print(L.COOLDOWN_INVALID)
        end
    else
        ShowHelp()
    end
end

frame:RegisterEvent("ADDON_LOADED")
frame:RegisterEvent("PLAYER_LOGIN")
frame:RegisterEvent("PLAYER_GUILD_UPDATE")
frame:RegisterEvent("PLAYER_ENTERING_WORLD")
frame:RegisterEvent("PLAYER_REGEN_ENABLED")
frame:RegisterEvent("ENCOUNTER_END")
frame:RegisterEvent("CHALLENGE_MODE_COMPLETED")
frame:RegisterEvent("CHALLENGE_MODE_RESET")
frame:RegisterEvent("GUILD_ROSTER_UPDATE")
frame:RegisterEvent("CHAT_MSG_GUILD")
frame:RegisterEvent("CHAT_MSG_GUILD_ACHIEVEMENT")

frame:SetScript("OnEvent", function(_, event, ...)
    if event == "ADDON_LOADED" then
        local addon = ...
        if addon ~= ADDON_NAME then return end
        HelloGuildDB = HelloGuildDB or {}
        local greetingLibraryVersion = tonumber(HelloGuildDB.greetingLibraryVersion) or 1
        local congratulationsLibraryVersion = tonumber(
            HelloGuildDB.congratulationsLibraryVersion
        ) or 1
        local legacyLanguage = HelloGuildDB.messageLanguage
        if legacyLanguage ~= "de" and legacyLanguage ~= "en" then
            legacyLanguage = HelloGuild_ClientMessageLanguage
        end
        if type(HelloGuildDB.greetingsByLanguage) ~= "table" then
            HelloGuildDB.greetingsByLanguage = {}
        end
        if type(HelloGuildDB.congratulationsByLanguage) ~= "table" then
            HelloGuildDB.congratulationsByLanguage = {}
        end
        if type(HelloGuildDB.greetings) == "table"
            and HelloGuildDB.greetingsByLanguage[legacyLanguage] == nil
        then
            HelloGuildDB.greetingsByLanguage[legacyLanguage] = HelloGuildDB.greetings
        end
        if type(HelloGuildDB.congratulations) == "table"
            and HelloGuildDB.congratulationsByLanguage[legacyLanguage] == nil
        then
            HelloGuildDB.congratulationsByLanguage[legacyLanguage] = HelloGuildDB.congratulations
        end
        HelloGuildDB.greetings = nil
        HelloGuildDB.congratulations = nil
        HelloGuildDB.messageLanguage = legacyLanguage
        -- Der frühere Einzelwert bleibt bei bestehenden Installationen als
        -- fester Bereich erhalten. Neue Installationen erhalten die Defaults.
        if HelloGuildDB.greetingDelay ~= nil
            and HelloGuildDB.greetingDelayMin == nil
            and HelloGuildDB.greetingDelayMax == nil
        then
            local oldDelay = math.max(
                0,
                math.min(60, math.floor(tonumber(HelloGuildDB.greetingDelay) or 5))
            )
            HelloGuildDB.greetingDelayMin = oldDelay
            HelloGuildDB.greetingDelayMax = oldDelay
            HelloGuildDB.greetingDelay = nil
        end
        CopyDefaults(DEFAULTS, HelloGuildDB)
        if HelloGuildDB.messageStyle ~= "fantasy"
            and HelloGuildDB.messageStyle ~= "simple"
        then
            HelloGuildDB.messageStyle = "fantasy"
        end
        if greetingLibraryVersion < 2 then
            for _, language in ipairs({ "de", "en" }) do
                AppendUniqueDefaults(
                    HelloGuildDB.greetingsByLanguage[language],
                    HelloGuild_DefaultGreetingsByLanguage[language],
                    17
                )
            end
        elseif greetingLibraryVersion < 3 then
            for _, language in ipairs({ "de", "en" }) do
                AppendUniqueDefaults(
                    HelloGuildDB.greetingsByLanguage[language],
                    HelloGuild_DefaultGreetingsByLanguage[language],
                    61
                )
            end
        end
        HelloGuildDB.greetingLibraryVersion = 3
        if congratulationsLibraryVersion < 2 then
            for _, language in ipairs({ "de", "en" }) do
                AppendUniqueDefaults(
                    HelloGuildDB.congratulationsByLanguage[language],
                    HelloGuild_DefaultCongratulationsByLanguage[language],
                    5
                )
            end
        elseif congratulationsLibraryVersion < 3 then
            for _, language in ipairs({ "de", "en" }) do
                AppendUniqueDefaults(
                    HelloGuildDB.congratulationsByLanguage[language],
                    HelloGuild_DefaultCongratulationsByLanguage[language],
                    61
                )
            end
        end
        HelloGuildDB.congratulationsLibraryVersion = 3
        NormalizeDelayRange("greetingDelayMin", "greetingDelayMax")
        NormalizeDelayRange("achievementDelayMin", "achievementDelayMax")
        SLASH_HELLOGUILD1 = "/hg"
        SLASH_HELLOGUILD2 = "/helloguild"
        SLASH_HELLOGUILD3 = "/gb"
        SLASH_HELLOGUILD4 = "/gildenbegruesser"
        SlashCmdList.HELLOGUILD = SlashCommand
    elseif event == "PLAYER_LOGIN" then
        CurrentGuild()
        rosterReady = false
        wipe(online)
        if IsInGuild() then
            C_GuildInfo.GuildRoster()
        end
    elseif event == "PLAYER_GUILD_UPDATE" then
        local previousGuild = activeGuild
        local guildName = CurrentGuild()
        if previousGuild and guildName and previousGuild ~= guildName then
            wipe(queue)
            wipe(pendingGreetings)
            achievementGeneration = achievementGeneration + 1
            sendGeneration = sendGeneration + 1
            inFlight = nil
            sending = false
            rosterReady = false
            wipe(online)
        elseif not IsInGuild() then
            activeGuild = nil
            rosterReady = false
            wipe(online)
        end
        if IsInGuild() then
            C_GuildInfo.GuildRoster()
        end
        if #queue > 0 and not sending then
            SendNext()
        end
    elseif event == "PLAYER_ENTERING_WORLD" then
        if IsInGuild() then
            C_GuildInfo.GuildRoster()
        end
        if #queue > 0 and not sending then
            SendNext()
        end
    elseif event == "GUILD_ROSTER_UPDATE" then
        UpdateGuildRoster()
        if #queue > 0 and not sending then
            SendNext()
        end
    elseif event == "PLAYER_REGEN_ENABLED"
        or event == "ENCOUNTER_END"
        or event == "CHALLENGE_MODE_COMPLETED"
        or event == "CHALLENGE_MODE_RESET"
    then
        if #queue > 0 and not sending then
            -- Einen Moment nach dem Event warten, damit Combat Lockdown und
            -- Gildeninformationen garantiert ihren neuen Zustand haben.
            ScheduleQueueRetry(0.5)
        end
    elseif event == "CHAT_MSG_GUILD" then
        local message, sender = ...
        ConfirmSentMessage(message, sender)
    elseif event == "CHAT_MSG_GUILD_ACHIEVEMENT" then
        local _, sender = ...
        if HelloGuildDB.enabled
            and HelloGuildDB.achievementEnabled
            and sender
            and not PlayerIsSelf(sender)
        then
            ScheduleAchievement(sender)
        end
    end
end)