-- read namespace from global env
local _G = _G
local Grichelde = _G.Grichelde

local nilOrEmpty, pairs, tSize, unpack, find, join, toString, toNumber
    = Grichelde.functions.nilOrEmpty, Grichelde.functions.pairs, Grichelde.functions.tSize, Grichelde.functions.unpack, Grichelde.functions.find, Grichelde.functions.join, Grichelde.functions.toString, Grichelde.functions.toNumber

function Grichelde:CreateOptionsUI()
    return {
        name = self:Format(self.L.Options_Title, self.L.AddonName),
        type = "group",
        childGroups = "tab",
        set = function(info, val) self:SyncToDatabase(info, val) end,
        get = function(info) return self:ReadFromDatabase(info) end,
        hidden = false,
        disabled = function(info) return self:IsDisabled(info) end,
        args = {
            enabled = {
                order = 0,
                type = "toggle",
                name = self.L.Options_Enabled_Name,
                desc = self:Format(self.L.Options_Enabled_Desc, self.L.AddonName),
                disabled = false,
            },

            channels = {
                order = 2,
                type = "group",
                name = self.L.Options_Channels_Group_Name,
                desc = self:Format(self.L.Options_Channels_Group_Desc, self.L.AddonName),
                args = {
                    say = {
                        order = 0,
                        type = "toggle",
                        name = self.L.Options_Channels_ChannelSay_Name,
                        desc = self:Format(self.L.Options_Channels_ChannelSay_Desc, self.L.AddonName),
                    },
                    emote = {
                        order = 1,
                        type = "toggle",
                        name = self.L.Options_Channels_ChannelEmote_Name,
                        desc = self:Format(self.L.Options_Channels_ChannelEmote_Desc, self.L.AddonName),
                    },
                    yell = {
                        order = 2,
                        type = "toggle",
                        name = self.L.Options_Channels_ChannelYell_Name,
                        desc = self:Format(self.L.Options_Channels_ChannelYell_Desc, self.L.AddonName),
                    },
                    party = {
                        order = 3,
                        type = "toggle",
                        name = self.L.Options_Channels_ChannelParty_Name,
                        desc = self:Format(self.L.Options_Channels_ChannelParty_Desc, self.L.AddonName),
                    },
                    guild = {
                        order = 4,
                        type = "toggle",
                        name = self.L.Options_Channels_ChannelGuild_Name,
                        desc = self:Format(self.L.Options_Channels_ChannelGuild_Desc, self.L.AddonName),
                    },
                    officer = {
                        order = 5,
                        type = "toggle",
                        name = self.L.Options_Channels_ChannelOfficer_Name,
                        desc = self:Format(self.L.Options_Channels_ChannelOfficer_Desc, self.L.AddonName),
                    },
                    raid = {
                        order = 6,
                        type = "toggle",
                        name = self.L.Options_Channels_ChannelRaid_Name,
                        desc = self:Format(self.L.Options_Channels_ChannelRaid_Desc, self.L.AddonName),
                    },
                    raidWarning = {
                        order = 7,
                        type = "toggle",
                        name = self.L.Options_Channels_ChannelRaidWarning_Name,
                        desc = self:Format(self.L.Options_Channels_ChannelRaidWarning_Desc, self.L.AddonName),
                    },
                    instance = {
                        order = 8,
                        type = "toggle",
                        name = self.L.Options_Channels_ChannelInstance_Name,
                        desc = self:Format(self.L.Options_Channels_ChannelInstance_Desc, self.L.AddonName),
                    },
                    battleground = {
                        order = 9,
                        type = "toggle",
                        name = self.L.Options_Channels_ChannelBattleground_Name,
                        desc = self:Format(self.L.Options_Channels_ChannelBattleground_Desc, self.L.AddonName),
                    },
                    whisper = {
                        order = 10,
                        type = "toggle",
                        name = self.L.Options_Channels_ChannelWhisper_Name,
                        desc = self:Format(self.L.Options_Channels_ChannelWhisper_Desc, self.L.AddonName),
                    },
                }
            },

            replacements = {
                order = 3,
                type = "group",
                name = self.L.Options_Replacements_Group_Name,
                desc = self.L.Options_Replacements_Group_Desc,
                args = {
                    add = {
                        order = 0,
                        type = "execute",
                        confirm = false,
                        name = self.L.Options_Replacements_Add_Name,
                        desc = self.L.Options_Replacements_Add_Desc,
                        func = function(info) self:AddReplacement(info) end
                    },
                    deleteAll = {
                        order = 1,
                        type = "execute",
                        confirm = true,
                        confirmText = self.L.Options_Replacements_DeleteAll_ConfirmText,
                        name = self.L.Options_Replacements_DeleteAll_Name,
                        desc = self.L.Options_Replacements_DeleteAll_Desc,
                        func = function(info) self:DeleteAllReplacements(info) end
                    }
                }
            }
        }
    }
end

function Grichelde:CreateReplacement(offset)
    return {
        order = offset or 9999,
        type = "group",
        name = function(info) return self:MappingName(info) end,
        desc = self.L.Options_Replacement_Group_Desc,
        childGroups = "tree",
        args = {
            searchText = {
                order = 0,
                type = "input",
                name = self.L.Options_Replacement_SearchText_Name,
                desc = self.L.Options_Replacement_SearchText_Desc,
            },
            replaceText = {
                order = 1,
                type = "input",
                name = self.L.Options_Replacement_ReplaceText_Name,
                desc = self.L.Options_Replacement_ReplaceText_Desc,
            },
            caseSensitive = {
                order = 2,
                type = "toggle",
                name = self.L.Options_Replacement_CaseSensitive_Name,
                desc = self.L.Options_Replacement_CaseSensitive_Desc,
            },
            consolidate = {
                order = 3,
                type = "toggle",
                name = self.L.Options_Replacement_Consolidate_Name,
                desc = self.L.Options_Replacement_Consolidate_Desc,
                width = 2
            },
            delete = {
                order = 4,
                type = "execute",
                confirm = true,
                confirmText = self.L.Options_Replacements_Delete_ConfirmText,
                name = self.L.Options_Replacement_Delete_Name,
                desc = self.L.Options_Replacement_Delete_Desc,
                func = function(info) self:DeleteReplacement(info) end
            },
        }
    }
end

function Grichelde:SetupOptions()
    -- add DB-backed profiles to UI options
    local options = self:CreateOptionsUI()
    options.args.profiles = LibStub("AceDBOptions-3.0"):GetOptionsTable(self.db)
    options.args.profiles.disabled = false

    -- Adding options to blizzard frame
    LibStub("AceConfig-3.0"):RegisterOptionsTable(self.name, options)
    local dialog = LibStub("AceConfigDialog-3.0")
    dialog:AddToBlizOptions(self.name, self.L.AddonName)

    return options, dialog
end

function Grichelde:IsDisabled(info)
    if info.option.type == "group" then
        return false
    end
    return not self.db.profile.enabled
end

function Grichelde:MappingName(info)
    local option = self.db.profile
    local path = 1
    while (path <= #info) do
        option = option[info[path]]
        path = path + 1
    end

    if nilOrEmpty(option.searchText) and nilOrEmpty(option.replaceText) then
        return self.L.Options_Replacement_EmptyMapping
    else
        return self:Format(self.L.Options_Replacement_Group_Name, option.searchText or "", option.replaceText or "")
    end
end

function Grichelde:RefreshOptions(event)
    self:DebugPrint("RefreshOptions : event:", event)
    if event == "OnNewProfile" then
        self:PrefixedPrint(self.L.Profiles_Created, self.COLOR_CODES.GREEN .. self.db:GetCurrentProfile() .. self.COLOR_CODES.CLOSE)
    elseif event == "OnProfileChanged" then
        self:PrefixedPrint(self.L.Profiles_Loaded, self.COLOR_CODES.GREEN .. self.db:GetCurrentProfile() .. self.COLOR_CODES.CLOSE)
    elseif event == "OnProfileDeleted" then
        self:PrefixedPrint(self.L.Profiles_Deleted, self.COLOR_CODES.GREEN .. self.db:GetCurrentProfile() .. self.COLOR_CODES.CLOSE)
    elseif event == "OnProfileCopied" then
        self:PrefixedPrint(self.L.Profiles_Copied, self.COLOR_CODES.GREEN .. self.db:GetCurrentProfile() .. self.COLOR_CODES.CLOSE)
    elseif event == "OnProfileReset" then
        self:PrefixedPrint(self.L.Profiles_Reset, self.COLOR_CODES.GREEN .. self.db:GetCurrentProfile() .. self.COLOR_CODES.CLOSE)
    else
        self:DebugPrint("Refreshing Profile %s on options change: %s", self.db:GetCurrentProfile(), event)
    end

    self:RefreshReplacements(self:ReorderReplacements(self.db.profile.replacements))
end

--- Create UI options for rhe given replacement table (from DB).
--- Usually called with with self.db.profile.replacements
-- @param replacementsTable
function Grichelde:RefreshReplacements(replacementsTable)
    --self:DebugPrint("RefreshReplacements : DB table:")
    --self:DebugPrint(replacementsTable)

    -- remove all previous replacements from options (not DB), except header and buttons
    local replacements = self.options.args.replacements.args or {}
    for k, _ in pairs(replacements) do
        if k and find(k, "^replacement_") then
            replacements[k] = nil
        end
    end

    for replName, _ in pairs(replacementsTable or {}) do
        local _, replNumber = self:SplitOnFirstMatch(replName, "_")
        replacements[replName] = self:CreateReplacement(toNumber(replNumber))
    end

    --self:DebugPrint("RefreshReplacements : UI options:")
    --self:DebugPrint(replacements)

    self.dialog:ConfigTableChanged(nil, self.name)
end

function Grichelde:AddReplacement()
    local replacements = self.db.profile.replacements
    local maxRepl = tSize(replacements)
    local newMapping = "replacement_" .. maxRepl
    self:DebugPrint("AddReplacement : new replacement key:", newMapping)

    -- setting replacements[newMapping] = {} will deactivate defaults
    replacements[newMapping].order = maxRepl
    --self:DebugPrint("AddReplacements : all DB entries:")
    --self:DebugPrint(replacements)

    --self.db.profile.replacements = replacements
    self:RefreshOptions("AddReplacement " .. newMapping)
    self.dialog:SelectGroup(self.name, "replacements", newMapping)
end

function Grichelde:DeleteReplacement(info)
    self:DebugPrint("DeleteReplacement")
    local option = self.db.profile
    local path = 1
    while (path < #info - 1) do
        option = option[info[path]]
        --self:DebugPrint(option)
        path = path + 1
    end
    local optionPath = join(".", unpack(info, 1, #info))
    self:DebugPrint("delete option \"%s\": %s", optionPath, toString(option[info[path]]))
    option[info[path]] = nil

    self:RefreshOptions("DeleteReplacement " .. info[path])

    local _, replNumber = self:SplitOnFirstMatch(info[path], "_")
    local newMapping = "replacement_" .. toNumber(replNumber - 1)
    self.dialog:SelectGroup(self.name, "replacements", newMapping)
end

function Grichelde:DeleteAllReplacements()
    self:DebugPrint("DeleteAllReplacements : ")

    --self.db.profile.replacements = {}
    for replName, _ in pairs(self.db.profile.replacements or {}) do
        self.db.profile.replacements[replName] = nil
    end
    self:AddReplacement()

    self:RefreshOptions("DeleteAllReplacements")
end