Gladdy.lua

local setmetatable = setmetatable
local type = type
local tostring = tostring
local select = select
local pairs = pairs
local ipairs = ipairs
local tinsert = table.insert
local tsort = table.sort
local str_lower = string.lower
local GetTime = GetTime
local GetPhysicalScreenSize = GetPhysicalScreenSize
local InCombatLockdown = InCombatLockdown
local CreateFrame = CreateFrame
local DEFAULT_CHAT_FRAME = DEFAULT_CHAT_FRAME
local IsAddOnLoaded = IsAddOnLoaded
local GetBattlefieldStatus = GetBattlefieldStatus
local IsInInstance = IsInInstance
local GetNumArenaOpponents = GetNumArenaOpponents
local EventRegistry = EventRegistry
local RELEASE_TYPES = { alpha = "Alpha", beta = "Beta", release = "Release"}
local PREFIX = "Gladdy v"
local VERSION_REGEX = PREFIX .. "(%d+%.%d+)%-(%a)"
local LibStub = LibStub

---------------------------

-- CORE

---------------------------

local MAJOR, MINOR = "Gladdy", 18
local Gladdy = LibStub:NewLibrary(MAJOR, MINOR)
local L
Gladdy.version_major_num = 2
Gladdy.version_minor_num = 0.43
Gladdy.version_num = Gladdy.version_major_num + Gladdy.version_minor_num
Gladdy.version_releaseType = RELEASE_TYPES.release
Gladdy.version = PREFIX .. string.format("%.2f", Gladdy.version_num) .. "-" .. Gladdy.version_releaseType
Gladdy.VERSION_REGEX = VERSION_REGEX

local GLADDY_COLORED = "|cff0384fcGladdy|r:"

Gladdy.debug = false

LibStub("AceTimer-3.0"):Embed(Gladdy)
LibStub("AceComm-3.0"):Embed(Gladdy)
Gladdy.modules = {}
Gladdy.indexedModules = {}
setmetatable(Gladdy, {
    __tostring = function()
        return MAJOR
    end
})

function Gladdy:Print(...)
    local text = GLADDY_COLORED
    local val
    for i = 1, select("#", ...) do
        val = select(i, ...)
        if (type(val) == 'boolean') then val = val and "true" or false end
        text = text .. " " .. tostring(val)
    end
    DEFAULT_CHAT_FRAME:AddMessage(text)
end

Gladdy.INFO = "[INFO]" --Gladdy:SetRGBTextColor("[INFO]", 35, 167, 204)
Gladdy.WARN = "[WARN]"--Gladdy:SetRGBTextColor("[WARN]", 204, 145, 35)
Gladdy.ERROR = "[ERROR]"--Gladdy:SetRGBTextColor("[ERROR]", 196, 52, 29)
function Gladdy:Debug(lvl, ...)
    if Gladdy.debug then
        if lvl == "INFO" then
            self:Print(self.INFO, ...)
            EventRegistry:TriggerEvent(GLADDY_COLORED, self.INFO, ...)
        elseif lvl == "WARN" then
            self:Print(self.WARN, ...)
            EventRegistry:TriggerEvent(GLADDY_COLORED, self.WARN, ...)
        elseif lvl == "ERROR" then
            self:Print(self.ERROR, ...)
            EventRegistry:TriggerEvent(GLADDY_COLORED, self.ERROR, ...)
        end
    end
end

Gladdy.events = CreateFrame("Frame")
Gladdy.events.registered = {}
Gladdy.events:RegisterEvent("PLAYER_LOGIN")
Gladdy.events:RegisterEvent("PLAYER_LOGOUT")
Gladdy.events:RegisterEvent("CVAR_UPDATE")
hooksecurefunc(SettingsPanel, "Commit", function()
    Gladdy:PixelPerfectScale(true)
end)
hooksecurefunc(SettingsPanel, "RevertSettings", function()
    Gladdy:PixelPerfectScale(true)
end)
hooksecurefunc(SettingsPanel, "SetAllSettingsToDefaults", function()
    Gladdy:PixelPerfectScale(true)
end)

Gladdy.events:SetScript("OnEvent", function(self, event, ...)
    if (event == "PLAYER_LOGIN") then
        Gladdy:OnInitialize()
        Gladdy:OnEnable()
    elseif (event == "CVAR_UPDATE") then
        if (str_lower(select(1, ...)) == "uiscale") then
            Gladdy:PixelPerfectScale(true)
        end
    elseif (event == "PLAYER_LOGOUT") then
        Gladdy:DeleteUnknownOptions(Gladdy.db, Gladdy.defaults.profile)
    else
        local func = self.registered[event]

        if (type(Gladdy[func]) == "function") then
            Gladdy[func](Gladdy, event, ...)
        end
    end
end)

function Gladdy:RegisterEvent(event, func)
    self.events.registered[event] = func or event
    self.events:RegisterEvent(event)
end
function Gladdy:UnregisterEvent(event)
    self.events.registered[event] = nil
    self.events:UnregisterEvent(event)
end
function Gladdy:UnregisterAllEvents()
    self.events.registered = {}
    self.events:UnregisterAllEvents()
end

---------------------------

-- MODULE FUNCTIONS

---------------------------

function Gladdy:Call(module, func, ...)
    if (type(module) == "string") then
        module = self.modules[module]
    end

    if (type(module[func]) == "function") then
        module[func](module, ...)
    end
end
function Gladdy:SendMessage(message, ...)
    Gladdy:Debug("INFO", "Gladdy:SendMessage", message, ...)
    for _, module in ipairs(self.indexedModules) do
        self:Call(module, module.messages[message], ...)
    end
end

function Gladdy:NewModule(name, priority, defaults)
    local module = CreateFrame("Frame")
    module.name = name
    module.priority = priority or 0
    module.defaults = defaults or {}
    module.messages = {}

    module.RegisterMessages = function(self, ...)
        for _,message in pairs({...}) do
            self.messages[message] = message
        end
    end

    module.RegisterMessage = function(self, message, func)
        self.messages[message] = func or message
    end

    module.UnregisterMessage = function(self, message)
        self.messages[message] = nil
    end

    module.UnregisterMessages = function(self, ...)
        for _,message in pairs({...}) do
            self.messages[message] = nil
        end
    end

    module.UnregisterAllMessages = function(self)
        for msg,_ in pairs(self.messages) do
            self.messages[msg] = nil
        end
    end

    module.GetOptions = function()
        return nil
    end

    for k, v in pairs(module.defaults) do
        self.defaults.profile[k] = v
    end

    self.modules[name] = module

    tinsert(self.indexedModules, module)
    tsort(self.indexedModules, function(x, y)
        return x.priority > y.priority
    end)

    return module
end

---------------------------

-- INIT

---------------------------

local ignoredOptions = {
    ["auraListDefault"] = {
        ["enabled"] = true,
        ["track"] = "string",
        ["priority"] = 1,
        ["spellIDs"] = { 1 },
        ["texture"] = 1234,
        ["textureSpell"] = 1234,
    },
    ["trackedDebuffs"] = {
        id = { 1 },
        class = "str",
        active = true,
    },
    ["trackedBuffs"] = { -- ["trackedBuffs"]["123123"] =
        id = { 1 },
        class = "str",
        active = true,
    }
}

function Gladdy:CleanupIgnoredOptions(tbl, refTbl, str, refOptionStruct)
    if type(tbl) == "table" then
        for k,v in pairs(tbl) do
            if type(tbl[k]) ~= type(refOptionStruct) then -- not even same type: reset or delete
                if refTbl[k] then
                    self:Debug("INFO", "SavedVariable reset:", str .. "." .. k, " - invalid Format \"" .. type(tbl[k]) .. "\" - setting default \"" .. type(refOptionStruct) .. "\"")
                    tbl[k] = refTbl[k]
                else
                    self:Debug("INFO", "SavedVariable deleted:", str .. "." .. k, " - invalid Format \"" .. type(tbl[k]) .. "\" - deleting")
                    tbl[k] = nil
                end
            elseif type(tbl[k]) == "table" then--is table, go over items
                if not refTbl[k] then -- all options must be present because not default option
                    for refKey, refValue in pairs(refOptionStruct) do
                        if tbl[k][refKey] == nil or type(tbl[k][refKey]) ~= type(refValue) then -- should have this option .. delete tbl[k]
                            self:Debug("INFO", "SavedVariable deleted:", str .. "." .. k, " - should have the option", refKey)
                            tbl[k] = nil
                        end
                    end
                end
                if tbl[k] then
                    for sk,sv in pairs(tbl[k]) do
                        if refOptionStruct[sk] == nil then --option key does not exist
                            self:Debug("INFO", "SavedVariable deleted:", str .. "." .. k .. "." .. sk, " - does not exist")
                            tbl[k][sk] = nil
                        elseif type(tbl[k][sk]) ~= type(refOptionStruct[sk]) then --wrong type
                            if refTbl[k] and refTbl[k][sk] then
                                self:Debug("INFO", "SavedVariable reset:", str .. "." .. k .. "." .. sk, " - invalid Format \"" .. type(tbl[k][sk]) .. "\" - setting default \"" .. type(refOptionStruct[sk]) .. "\"")
                                tbl[k][sk] = refTbl[k][sk]
                            else
                                self:Debug("INFO", "SavedVariable deleted:", str .. "." .. k .. "." .. sk, " - invalid Format \"" .. type(tbl[k][sk]) .. "\" - deleting does not exist in ref table")
                                tbl[k][sk] = nil
                            end
                        end
                    end
                end
            end
        end
    else
        self:Debug("INFO", "SavedVariable deleted:", str, " - not a table - deleting")
        tbl = nil
    end
end

function Gladdy:DeleteUnknownOptions(tbl, refTbl, str)
    if str == nil then
        str = "Gladdy.db"
    end
    for k,v in pairs(tbl) do
        if refTbl[k] == nil then
            self:Debug("INFO", "SavedVariable deleted:", str .. "." .. k, "not found!")
            tbl[k] = nil
        else
            if type(v) ~= type(refTbl[k]) then
                self:Debug("INFO", "SavedVariable reset:", str .. "." .. k, "type error!", "Expected", type(refTbl[k]), "but found", type(v))
                tbl[k] = refTbl[k]
            elseif ignoredOptions[k] then --iterate to keep options in default format
                self:Debug("INFO", "Ignored Saved variables:", str .. "." .. k, "evaluating")
                self:CleanupIgnoredOptions(v, refTbl[k], str .. "." .. k, ignoredOptions[k])
            elseif type(v) == "table" and (not ignoredOptions[k] or self.db.version and self.db.version < 2.23) then
                self:DeleteUnknownOptions(v, refTbl[k], str .. "." .. k)
            end
        end
    end
end

function Gladdy:PixelPerfectScale(update)
    local physicalWidth, physicalHeight = GetPhysicalScreenSize()
    local perfectUIScale = 768.0/physicalHeight--768/select(2, strsplit("x",({ GetScreenResolutions()})[GetCurrentResolution()]))
    if self.db and self.db.pixelPerfect and self.frame then
        self.frame:SetIgnoreParentScale(true)
        self.frame:SetScale(perfectUIScale)
        --local adaptiveScale = (GetCVar("useUiScale") == "1" and 1.0 + perfectUIScale - GetCVar("UIScale") or perfectUIScale)
        --self.frame:SetScale(adaptiveScale)
        if update then
            self:UpdateFrame()
        end
    elseif self.frame then
        self.frame:SetScale(self.db.frameScale)
        self.frame:SetIgnoreParentScale(false)
    end
end

function Gladdy:OnInitialize()
    self.dbi = LibStub("AceDB-3.0"):New("GladdyXZ", self.defaults)
    self.dbi.RegisterCallback(self, "OnProfileChanged", "OnProfileChanged")
    self.dbi.RegisterCallback(self, "OnProfileCopied", "OnProfileChanged")
    self.dbi.RegisterCallback(self, "OnProfileReset", "OnProfileReset")
    self.db = self.dbi.profile
    self:DeleteUnknownOptions(self.db, self.defaults.profile)

    self.LSM = LibStub("LibSharedMedia-3.0")
    self.LSM:Register("statusbar", "Gloss", "Interface\\AddOns\\Gladdy\\Images\\Gloss")
    self.LSM:Register("statusbar", "Smooth", "Interface\\AddOns\\Gladdy\\Images\\Smooth")
    self.LSM:Register("statusbar", "Minimalist", "Interface\\AddOns\\Gladdy\\Images\\Minimalist")
    self.LSM:Register("statusbar", "LiteStep", "Interface\\AddOns\\Gladdy\\Images\\LiteStep.tga")
    self.LSM:Register("statusbar", "Gradient", "Interface\\AddOns\\Gladdy\\Images\\Gradient2")
    self.LSM:Register("statusbar", "Flat", "Interface\\AddOns\\Gladdy\\Images\\UI-StatusBar")
    self.LSM:Register("border", "Gladdy Tooltip round", "Interface\\AddOns\\Gladdy\\Images\\UI-Tooltip-Border_round_selfmade")
    self.LSM:Register("border", "Gladdy Tooltip squared", "Interface\\AddOns\\Gladdy\\Images\\UI-Tooltip-Border_square_selfmade")
    self.LSM:Register("border", "Square Full White", "Interface\\AddOns\\Gladdy\\Images\\Square_FullWhite.tga")
    self.LSM:Register("font", "DorisPP", "Interface\\AddOns\\Gladdy\\Fonts\\DorisPP.TTF")
    --self.LSM:Register("font", "NotoSans Black", "Interface\\AddOns\\Gladdy\\Fonts\\NotoSansCJK-Black.ttf")
    --self.LSM:Register("font", "NotoSans Bold", "Interface\\AddOns\\Gladdy\\Fonts\\NotoSansCJK-Bold.ttf")
    --self.LSM:Register("font", "NotoSans Medium", "Interface\\AddOns\\Gladdy\\Fonts\\NotoSansCJK-Medium.ttf")
    --self.LSM:Register("font", "NotoSans Regular", "Interface\\AddOns\\Gladdy\\Fonts\\NotoSansCJK-Regular.ttf")

    L = self.L

    self.testData = {
        ["arena1"] = { name = "Swift", raceLoc = L["NightElf"], classLoc = L["Druid"], class = "DRUID", health = 67, healthMax = 100, power = 76, powerMax = 100, powerType = 1, testSpec = L["Restoration"], race = "NightElf" },
        ["arena2"] = { name = "Vilden", raceLoc = L["Undead"], classLoc = L["Mage"], class = "MAGE", health = 99, healthMax = 100, power = 7833, powerMax = 10460, powerType = 0, testSpec = L["Frost"], race = "Scourge" },
        ["arena3"] = { name = "Krymu", raceLoc = L["Human"], classLoc = L["Rogue"], class = "ROGUE", health = 10, healthMax = 100, power = 45, powerMax = 110, powerType = 3, testSpec = L["Subtlety"], race = "Human" },
        ["arena4"] = { name = "Talmon", raceLoc = L["Human"], classLoc = L["Warlock"], class = "WARLOCK", health = 40, healthMax = 100, power = 9855, powerMax = 9855, powerType = 0, testSpec = L["Demonology"], race = "Human" },
        ["arena5"] = { name = "Hydra", raceLoc = L["Undead"], classLoc = L["Priest"], class = "PRIEST", health = 70, healthMax = 100, power = 2515, powerMax = 10240, powerType = 0, testSpec = L["Discipline"], race = "Human" },
    }

    self.cooldownSpellIds = {}
    self.spellTextures = {}
    self.specSpells = self:GetSpecSpells()
    self.buttons = {}
    self.guids = {}
    self.curBracket = nil
    self.curUnit = 1

    self:SetupOptions()

    for _, module in ipairs(self.indexedModules) do
        self:Call(module, "Initialize")
    end
    if self.db.hideBlizzard == "always" then
        self:BlizzArenaSetAlpha(0)
    end
    if not self.db.newLayout then
        self:ToggleFrame(3)
        self:HideFrame()
    end
end

function Gladdy:OnProfileReset()
    self.db = self.dbi.profile
    self:Debug("INFO", "OnProfileReset")
    self:HideFrame()
    self:ToggleFrame(3)
    self.options.args.lock.name = self.db.locked and L["Unlock frame"] or L["Lock frame"]
    self.options.args.showMover.name = self.db.showMover and L["Hide Mover"] or L["Show Mover"]
    LibStub("AceConfigRegistry-3.0"):NotifyChange("Gladdy")
end

function Gladdy:OnProfileChanged()
    self.db = self.dbi.profile
    self:HideFrame()
    self:ToggleFrame(3)
    self.options.args.lock.name = self.db.locked and L["Unlock frame"] or L["Lock frame"]
    self.options.args.showMover.name = self.db.showMover and L["Hide Mover"] or L["Show Mover"]
    LibStub("AceConfigRegistry-3.0"):NotifyChange("Gladdy")
end

function Gladdy:OnEnable()
    self:RegisterEvent("UPDATE_BATTLEFIELD_STATUS")
    self:RegisterEvent("PLAYER_ENTERING_WORLD")
    self:RegisterEvent("PLAYER_REGEN_ENABLED")

    if (IsAddOnLoaded("Clique")) then
        for i = 1, 5 do
            self:CreateButton(i)
        end

        ClickCastFrames = ClickCastFrames or {}
        ClickCastFrames[self.buttons.arena1.secure] = true
        ClickCastFrames[self.buttons.arena2.secure] = true
        ClickCastFrames[self.buttons.arena3.secure] = true
        ClickCastFrames[self.buttons.arena4.secure] = true
        ClickCastFrames[self.buttons.arena5.secure] = true
    end

    if (not self.db.locked and self.db.x == 0 and self.db.y == 0) then
        self:Print(L["Welcome to Gladdy!"])
        self:Print(L["First run has been detected, displaying test frame."])
        self:Print(L["Valid slash commands are:"])
        self:Print(L["/gladdy ui"])
        self:Print(L["/gladdy test2-5"])
        self:Print(L["/gladdy hide"])
        self:Print(L["/gladdy reset"])
        self:Print(L["If this is not your first run please lock or move the frame to prevent this from happening."])

        self:HideFrame()
        self:ToggleFrame(3)
        self.showConfig = true
    end
end

function Gladdy:GetIconStyles()
    return
    {
        ["Interface\\AddOns\\Gladdy\\Images\\Border_rounded_blp"] = L["Gladdy Tooltip round"],
        ["Interface\\AddOns\\Gladdy\\Images\\Border_squared_blp"] = L["Gladdy Tooltip squared"],
        ["Interface\\AddOns\\Gladdy\\Images\\Border_Gloss"] = L["Gloss (black border)"],
        ["Interface\\AddOns\\Gladdy\\Images\\HabBorder1"] = L["Habborder"],
    }
end

---------------------------

-- TEST

---------------------------

function Gladdy:Test()
    self.frame.testing = true
    if self.curBracket then
        for i = 1, self.curBracket do
            local unit = "arena" .. i
            if (not self.buttons[unit]) then
                self:CreateButton(i)
            end
            local button = self.buttons[unit]

            for k, v in pairs(self.testData[unit]) do
                button[k] = v
            end

            for _, module in ipairs(self.indexedModules) do
                self:Call(module, "Test", unit)
            end

            button:SetAlpha(1)
        end
        for _, module in ipairs(self.indexedModules) do
            self:Call(module, "TestOnce")
        end
    end
end

---------------------------

-- EVENT HANDLING

---------------------------

function Gladdy:PLAYER_ENTERING_WORLD()
    if self.showConfig then
        LibStub("AceConfigDialog-3.0"):Open("Gladdy", nil, LibStub("AceConfigDialog-3.0"):SelectGroup("Gladdy", "XiconProfiles"))
        self.showConfig = nil
    end
    if (self.frame and self.frame:IsVisible()) then
        self:Reset()
        self:HideFrame()
    end
end

function Gladdy:UPDATE_BATTLEFIELD_STATUS(_, index)
    local status, mapName, instanceID, levelRangeMin, levelRangeMax, teamSize, isRankedArena, suspendedQueue, bool, queueType = GetBattlefieldStatus(index)
    local instanceType = select(2, IsInInstance())
    self:Debug("INFO", "UPDATE_BATTLEFIELD_STATUS", instanceType, status, teamSize)
    if ((instanceType == "arena" or GetNumArenaOpponents() > 0) and status == "active" and teamSize > 0) then
        self.curBracket = teamSize
        self:JoinedArena()
    elseif status == "active" then
        if self.db.hideBlizzard == "always" then
            self:BlizzArenaSetAlpha(0)
        else
            self:BlizzArenaSetAlpha(1)
        end
    end
end

function Gladdy:PLAYER_REGEN_ENABLED()
    if self.showFrame then
        self:InitFrames()
    end
    if self.hideFrame then
        self:Reset()
        self.frame:Hide()
        self.hideFrame = nil
    end
end

---------------------------

-- RESET FUNCTIONS (ARENA LEAVE)

---------------------------

function Gladdy:Reset()
    if type(self.guids) == "table" then
        for k,_ in pairs(self.guids) do
            self.guids[k] = nil
        end
    end
    self.guids = {}
    self.curBracket = nil
    self.curUnit = 1

    for _, module in ipairs(self.indexedModules) do
        self:Call(module, "Reset")
    end

    for unit in pairs(self.buttons) do
        self:ResetUnit(unit)
    end
    if self.db.hideBlizzard == "never" or self.db.hideBlizzard == "arena" then
        self:BlizzArenaSetAlpha(1)
    end
end

function Gladdy:ResetUnit(unit)
    local button = self.buttons[unit]
    if (not button) then
        return
    end

    button:SetAlpha(0)
    self:ResetButton(unit)

    for _, module in ipairs(self.indexedModules) do
        self:Call(module, "ResetUnit", unit)
    end
end

function Gladdy:ResetButton(unit)
    local button = self.buttons[unit]
    if (not button) then
        return
    end
    for k1, v1 in pairs(self.BUTTON_DEFAULTS) do
        if (type(v1) == "string") then
            button[k1] = nil
        elseif (type(v1) == "number") then
            button[k1] = 0
        elseif (type(v1) == "table") then
            button[k1] = {}
        elseif (type(v1) == "boolean") then
            button[k1] = false
        end
    end
end

---------------------------

-- ARENA JOINED

---------------------------

function Gladdy:JoinedArena()
    if InCombatLockdown() then
        self:Print("Gladdy frames show as soon as you leave combat")
        self.showFrame = true
    else
        self:InitFrames()
    end
end

function Gladdy:InitFrames()
    self.showFrame = nil
    if not self.curBracket then
        self.curBracket = 2
    end

    for i = 1, self.curBracket do
        if (not self.buttons["arena" .. i]) then
            self:CreateButton(i)
        end
    end

    self:UpdateFrame()
    if self.startTest then
        self:Test()
        self.startTest = nil
    end
    self.frame:Show()
    self:SendMessage("JOINED_ARENA") -- /run LibStub("Gladdy"):SendMessage("JOINED_ARENA")

    for i=1, self.curBracket do
        self.buttons["arena" .. i]:SetAlpha(1)
    end
    if self.db.hideBlizzard == "arena" or self.db.hideBlizzard == "always" then
        self:BlizzArenaSetAlpha(0)
    else
        self:BlizzArenaSetAlpha(1)
    end
end

---------------------------

-- BLIZZARD FRAMES

---------------------------

function Gladdy:BlizzArenaSetAlpha(alpha)
    if IsAddOnLoaded("Blizzard_ArenaUI") then
        if (ArenaEnemyFrames) then
            ArenaEnemyFrames:SetAlpha(alpha)
        end
        if ArenaEnemyFrame1 then
            ArenaEnemyFrame1:SetAlpha(alpha)
        end
        if ArenaEnemyFrame1PetFrame then
            ArenaEnemyFrame1PetFrame:SetAlpha(alpha)
        end
        if ArenaEnemyFrame2 then
            ArenaEnemyFrame2:SetAlpha(alpha)
        end
        if ArenaEnemyFrame2PetFrame then
            ArenaEnemyFrame2PetFrame:SetAlpha(alpha)
        end
        if ArenaEnemyFrame3 then
            ArenaEnemyFrame3:SetAlpha(alpha)
        end
        if ArenaEnemyFrame3PetFrame then
            ArenaEnemyFrame3PetFrame:SetAlpha(alpha)
        end
        if ArenaEnemyFrame4 then
            ArenaEnemyFrame4:SetAlpha(alpha)
        end
        if ArenaEnemyFrame4PetFrame then
            ArenaEnemyFrame4PetFrame:SetAlpha(alpha)
        end
        if ArenaEnemyFrame5 then
            ArenaEnemyFrame5:SetAlpha(alpha)
        end
        if ArenaEnemyFrame5PetFrame then
            ArenaEnemyFrame5PetFrame:SetAlpha(alpha)
        end
    end
end

---------------------------

-- FONT/STATUSBAR/BORDER

---------------------------

local defaults = {["statusbar"] = "Smooth", ["border"] = "Gladdy Tooltip round", ["font"] = "DorisPP"}

local lastWarning = {}
function Gladdy:SMFetch(lsmType, key)
    local smMediaType = self.LSM:Fetch(lsmType, Gladdy.db[key])
    if (smMediaType == nil and Gladdy.db[key] ~= "None") then
        if not lastWarning[key] or GetTime() - lastWarning[key] > 120 then
            lastWarning[key] = GetTime()
            Gladdy:Debug("WARN", "Could not find", "\"" .. lsmType .. "\" \"", Gladdy.db[key], " \" for", "\"" .. key .. "\"", "- setting it to", "\"" .. defaults[lsmType] .. "\"")
        end
        return self.LSM:Fetch(lsmType, defaults[lsmType])
    end
    return smMediaType
end