GUI.lua

-- NSRTEnhancer / GUI
-- Custom dark-themed tabbed config window. Everything (frame chrome, toggles,
-- sliders, dropdowns, color swatches, buttons, section cards) is built from
-- scratch so we can match a modern flat UI language instead of inheriting
-- the dated Blizzard templates.

local ADDON_NAME, NSE = ...
local M = {}
NSE.GUI = M

-- ---------------------------------------------------------------------------
-- Palette
-- ---------------------------------------------------------------------------

-- LibSharedMedia: NSRT ships LSM-3.0; we use it to populate the font picker.
local LSM = LibStub and LibStub:GetLibrary("LibSharedMedia-3.0", true)

local function BuildFontOptions()
    local opts = {}
    if LSM then
        local list = LSM:List("font")
        for _, name in ipairs(list) do
            local path = LSM:Fetch("font", name)
            table.insert(opts, { text = name, value = path, preview = path })
        end
    end
    -- Fallbacks / always-available entries
    if #opts == 0 then
        opts = {
            { text = "Friz Quadrata", value = "Fonts\\FRIZQT__.TTF", preview = "Fonts\\FRIZQT__.TTF" },
            { text = "Arial Narrow",  value = "Fonts\\ARIALN.TTF",   preview = "Fonts\\ARIALN.TTF"   },
            { text = "Morpheus",      value = "Fonts\\MORPHEUS.TTF", preview = "Fonts\\MORPHEUS.TTF" },
            { text = "Skurri",        value = "Fonts\\SKURRI.TTF",   preview = "Fonts\\SKURRI.TTF"   },
        }
    end
    return opts
end

-- Given a font path, return a friendly name (LSM name, or the filename).
local function FontPathToName(path)
    if not path then return "Default" end
    if LSM then
        for _, name in ipairs(LSM:List("font")) do
            if LSM:Fetch("font", name) == path then return name end
        end
    end
    return path:match("[^\\/]+$") or path
end

local C = {
    bg           = {0.07, 0.08, 0.13, 0.98},
    panel        = {0.11, 0.12, 0.19, 1},
    panelHover   = {0.14, 0.16, 0.24, 1},
    divider      = {0.20, 0.22, 0.30, 0.7},
    borderSubtle = {0.22, 0.24, 0.32, 1},
    accent       = {0.40, 0.85, 0.92, 1},   -- cyan
    accentDim    = {0.25, 0.55, 0.65, 1},
    title        = {1.00, 0.40, 0.65, 1},   -- magenta
    toggleOn     = {0.30, 0.80, 0.65, 1},   -- teal
    toggleOff    = {0.32, 0.32, 0.40, 1},
    thumb        = {0.98, 0.98, 1.00, 1},
    textPrim     = {0.94, 0.94, 0.98, 1},
    textSec      = {0.60, 0.62, 0.70, 1},
    textMuted    = {0.45, 0.47, 0.55, 1},
    button       = {0.15, 0.17, 0.24, 1},
    buttonHover  = {0.22, 0.26, 0.36, 1},
}

local function c(color, a)
    return color[1], color[2], color[3], a or color[4] or 1
end

-- ---------------------------------------------------------------------------
-- Typography
-- ---------------------------------------------------------------------------
-- Poppins family, served via SharedMedia_MyMedia (direct file paths; if the
-- media addon isn't installed WoW silently falls back to a default font).
-- Black for headers, Regular for body. Color-coding between headers and
-- body is handled by the palette above (title/section use accent colors,
-- body uses textPrim/textSec).
local FONT_HEADER = "Interface\\AddOns\\NSRTEnhancer\\Media\\Fonts\\Poppins-Black.ttf"
local FONT_BODY   = "Interface\\AddOns\\NSRTEnhancer\\Media\\Fonts\\Poppins-Regular.ttf"

-- ---------------------------------------------------------------------------
-- Scroll frame styling
-- ---------------------------------------------------------------------------
-- Replace the default UIPanelScrollFrameTemplate's beige/grey Blizzard
-- chrome with a thin dark track + accent-colored thumb so our scroll frames
-- visually match the rest of the GUI instead of standing out.
local function StyleScrollFrame(scroll)
    local sb = scroll.ScrollBar
    if not sb then return end

    -- The thumb is also one of sb's regions; we must NOT null it or we'll
    -- zero its vertex alpha and it becomes invisible no matter what
    -- SetColorTexture we apply afterwards.
    local thumb = sb:GetThumbTexture()

    for _, region in ipairs({ sb:GetRegions() }) do
        if region ~= thumb and region.GetObjectType and region:GetObjectType() == "Texture" then
            region:SetTexture(nil)
            region:SetVertexColor(1, 1, 1, 0)
        end
    end

    -- Hide up/down arrow buttons if they exist on this template.
    for _, btnName in ipairs({ "ScrollUpButton", "ScrollDownButton", "Back", "Forward" }) do
        local btn = sb[btnName]
        if btn then
            btn:SetAlpha(0)
            btn:EnableMouse(false)
            btn:SetSize(0.001, 0.001)  -- effectively collapsed
        end
    end

    -- Narrow bar + dark track drawn as our own texture.
    sb:SetWidth(8)
    if not sb._nseTrack then
        sb._nseTrack = sb:CreateTexture(nil, "BACKGROUND")
        sb._nseTrack:SetPoint("TOP", 0, 0)
        sb._nseTrack:SetPoint("BOTTOM", 0, 0)
        sb._nseTrack:SetWidth(4)
        sb._nseTrack:SetColorTexture(C.panel[1], C.panel[2], C.panel[3], 0.9)
    end

    -- Accent-colored thumb. Reset vertex color in case something already
    -- wiped it; let Blizzard auto-size based on scroll content.
    if thumb then
        thumb:SetColorTexture(C.accent[1], C.accent[2], C.accent[3], 0.85)
        thumb:SetVertexColor(1, 1, 1, 1)
        thumb:SetWidth(6)
    end
end

-- ---------------------------------------------------------------------------
-- Primitive helpers
-- ---------------------------------------------------------------------------

local function SetBG(frame, color, layer)
    if not frame._bg then
        frame._bg = frame:CreateTexture(nil, layer or "BACKGROUND")
        frame._bg:SetAllPoints()
    end
    frame._bg:SetColorTexture(c(color))
end

-- Four thin-edge fake border (WoW doesn't give us borders on plain frames).
local function SetBorder(frame, color, size)
    size = size or 1
    color = color or C.borderSubtle
    if not frame._borders then
        frame._borders = {}
        for _, side in ipairs({"TOP", "BOTTOM", "LEFT", "RIGHT"}) do
            local t = frame:CreateTexture(nil, "BORDER")
            if side == "TOP" then
                t:SetPoint("TOPLEFT"); t:SetPoint("TOPRIGHT"); t:SetHeight(size)
            elseif side == "BOTTOM" then
                t:SetPoint("BOTTOMLEFT"); t:SetPoint("BOTTOMRIGHT"); t:SetHeight(size)
            elseif side == "LEFT" then
                t:SetPoint("TOPLEFT"); t:SetPoint("BOTTOMLEFT"); t:SetWidth(size)
            elseif side == "RIGHT" then
                t:SetPoint("TOPRIGHT"); t:SetPoint("BOTTOMRIGHT"); t:SetWidth(size)
            end
            frame._borders[side] = t
        end
    end
    for _, t in pairs(frame._borders) do
        t:SetColorTexture(c(color))
    end
end

local function MakeLabel(parent, text, style)
    local fs = parent:CreateFontString(nil, "OVERLAY", "GameFontNormal")
    fs:SetText(text)
    if style == "title" then
        fs:SetFont(FONT_HEADER, 20, "")
        fs:SetTextColor(c(C.title))
    elseif style == "version" then
        fs:SetFont(FONT_BODY, 11, "")
        fs:SetTextColor(c(C.textMuted))
    elseif style == "section" then
        fs:SetFont(FONT_HEADER, 12, "")   -- Black weight for section headers
        fs:SetTextColor(c(C.accent))
    elseif style == "secondary" then
        fs:SetFont(FONT_BODY, 11, "")
        fs:SetTextColor(c(C.textSec))
    elseif style == "primary" then
        fs:SetFont(FONT_BODY, 12, "")
        fs:SetTextColor(c(C.textPrim))
    else
        fs:SetFont(FONT_BODY, 12, "")
        fs:SetTextColor(c(C.textPrim))
    end
    return fs
end

-- ---------------------------------------------------------------------------
-- Toggle switch (pill + sliding thumb)
-- ---------------------------------------------------------------------------

local function CreateToggle(parent, getter, setter, onChange)
    local btn = CreateFrame("Button", nil, parent)
    btn:SetSize(42, 20)

    btn.track = btn:CreateTexture(nil, "BACKGROUND")
    btn.track:SetAllPoints()

    -- Subtle inner shadow/edge for depth
    btn.edge = btn:CreateTexture(nil, "BORDER")
    btn.edge:SetPoint("TOPLEFT", -1, 1)
    btn.edge:SetPoint("BOTTOMRIGHT", 1, -1)
    btn.edge:SetColorTexture(0, 0, 0, 0.35)

    btn.thumb = btn:CreateTexture(nil, "ARTWORK")
    btn.thumb:SetSize(16, 16)
    btn.thumb:SetColorTexture(c(C.thumb))

    btn.thumbShadow = btn:CreateTexture(nil, "ARTWORK", nil, -1)
    btn.thumbShadow:SetPoint("TOPLEFT", btn.thumb, "TOPLEFT", -1, -1)
    btn.thumbShadow:SetPoint("BOTTOMRIGHT", btn.thumb, "BOTTOMRIGHT", 1, 1)
    btn.thumbShadow:SetColorTexture(0, 0, 0, 0.45)

    function btn:Refresh()
        local on = getter() and true or false
        if on then
            btn.track:SetColorTexture(c(C.toggleOn))
            btn.thumb:ClearAllPoints()
            btn.thumb:SetPoint("RIGHT", btn, "RIGHT", -2, 0)
        else
            btn.track:SetColorTexture(c(C.toggleOff))
            btn.thumb:ClearAllPoints()
            btn.thumb:SetPoint("LEFT", btn, "LEFT", 2, 0)
        end
    end
    btn:Refresh()

    btn:SetScript("OnClick", function()
        setter(not getter())
        btn:Refresh()
        if onChange then onChange() end
    end)
    return btn
end

-- ---------------------------------------------------------------------------
-- Slider (dark track, cyan thumb)
-- ---------------------------------------------------------------------------

local function CreateSlider(parent, min, max, step, getter, setter, fmt, onChange)
    fmt = fmt or "%.2f"
    local s = CreateFrame("Slider", nil, parent)
    s:SetOrientation("HORIZONTAL")
    s:SetSize(160, 16)
    s:SetMinMaxValues(min, max)
    s:SetValueStep(step)
    s:SetObeyStepOnDrag(true)
    s:SetValue(getter())

    s.trackBG = s:CreateTexture(nil, "BACKGROUND")
    s.trackBG:SetColorTexture(c(C.panel))
    s.trackBG:SetHeight(4)
    s.trackBG:SetPoint("LEFT", 0, 0)
    s.trackBG:SetPoint("RIGHT", 0, 0)

    -- Active fill: from left edge of track to the thumb
    s.trackFill = s:CreateTexture(nil, "BORDER")
    s.trackFill:SetColorTexture(c(C.accentDim))
    s.trackFill:SetHeight(4)
    s.trackFill:SetPoint("LEFT", s.trackBG, "LEFT")

    local thumb = s:CreateTexture(nil, "OVERLAY")
    thumb:SetColorTexture(c(C.accent))
    thumb:SetSize(6, 16)
    s:SetThumbTexture(thumb)

    -- Editable value input sitting to the right of the slider.
    local eb = CreateFrame("EditBox", nil, s)
    eb:SetSize(60, 18)
    eb:SetPoint("LEFT", s, "RIGHT", 10, 0)
    eb:SetAutoFocus(false)
    eb:SetJustifyH("CENTER")
    eb:SetMaxLetters(10)
    eb:SetFont(FONT_BODY, 11, "")
    eb:SetTextColor(c(C.textPrim))
    eb:SetTextInsets(4, 4, 0, 0)
    SetBG(eb, C.button)
    SetBorder(eb, C.borderSubtle, 1)
    eb:SetText(string.format(fmt, getter()))
    s.valueInput = eb
    s.valueLabel = eb  -- alias so AddRow's offset detection still works

    local function unitFor(f)
        -- Extract any trailing unit from the format (e.g. " px", " s", " icons")
        return (f:match("%%[^%s]*(.*)$")) or ""
    end
    local unitSuffix = unitFor(fmt)

    local function parseInput(text)
        if not text or text == "" then return nil end
        -- Strip common unit suffixes and anything non-numeric trailing.
        local numStr = text:match("^%s*(%-?[%d%.]+)")
        return tonumber(numStr)
    end

    local function updateFill(value)
        local lo, hi = s:GetMinMaxValues()
        local pct = (value - lo) / math.max(hi - lo, 0.0001)
        local w = math.max(0.01, pct * s:GetWidth())
        s.trackFill:SetWidth(w)
    end
    updateFill(getter())

    s:SetScript("OnValueChanged", function(self, value)
        if step and step > 0 then
            value = math.floor((value / step) + 0.5) * step
        end
        setter(value)
        -- Only refresh the EditBox text when it's not being edited, to avoid
        -- fighting the user's keystrokes.
        if not eb:HasFocus() then
            eb:SetText(string.format(fmt, value))
        end
        updateFill(value)
        if onChange then onChange(value) end
    end)

    eb:SetScript("OnEscapePressed", function(self)
        self:SetText(string.format(fmt, s:GetValue()))
        self:ClearFocus()
    end)
    eb:SetScript("OnEnterPressed", function(self)
        local v = parseInput(self:GetText())
        if v then
            local lo, hi = s:GetMinMaxValues()
            v = math.max(lo, math.min(hi, v))
            s:SetValue(v)
        end
        self:ClearFocus()
    end)
    eb:SetScript("OnEditFocusLost", function(self)
        local v = parseInput(self:GetText())
        if v then
            local lo, hi = s:GetMinMaxValues()
            v = math.max(lo, math.min(hi, v))
            s:SetValue(v)
        end
        self:SetText(string.format(fmt, s:GetValue()))
    end)
    -- Derive a "numeric-only" format spec from the display `fmt` so we
    -- show the editable value without the unit suffix AND without Lua's
    -- default full float precision. E.g. "%.2fx" -> "%.2f", "%d icons" -> "%d".
    local editFmt = fmt:match("(%%[%-%+]?%d*%.?%d*[dfgeEGiouxX])") or "%g"

    eb:SetScript("OnEditFocusGained", function(self)
        self:SetText(string.format(editFmt, s:GetValue()))
        self:HighlightText()
    end)
    return s
end

-- ---------------------------------------------------------------------------
-- Dropdown (custom popup)
-- ---------------------------------------------------------------------------

-- Track open popups so clicking another dropdown closes any prior one.
local _openPopup

local function CreateDropdown(parent, options, getter, setter, onChange, width, maxPopupHeight)
    width = width or 160
    maxPopupHeight = maxPopupHeight or 320

    local dd = CreateFrame("Button", nil, parent)
    dd:SetSize(width, 24)
    SetBG(dd, C.button)
    SetBorder(dd, C.borderSubtle, 1)

    dd.text = dd:CreateFontString(nil, "OVERLAY", "GameFontNormal")
    dd.text:SetFont(FONT_BODY, 12, "")
    dd.text:SetPoint("LEFT", 8, 0)
    dd.text:SetPoint("RIGHT", -20, 0)
    dd.text:SetJustifyH("LEFT")
    dd.text:SetTextColor(c(C.textPrim))

    -- Down-arrow indicator. A real texture, not a Unicode glyph (WoW's UI
    -- fonts don't carry the "down triangle" codepoint and render it as a
    -- missing-glyph square).
    dd.arrow = dd:CreateTexture(nil, "OVERLAY")
    dd.arrow:SetSize(10, 10)
    dd.arrow:SetPoint("RIGHT", -8, 0)
    dd.arrow:SetTexture("Interface\\ChatFrame\\ChatFrameExpandArrow")
    dd.arrow:SetRotation(-math.pi / 2)  -- rotate right-arrow to point down
    dd.arrow:SetVertexColor(c(C.textSec))

    -- Measure the longest option text so the popup can auto-size to fit
    -- long names (e.g. "Microsoft David Desktop - English (United States)")
    -- instead of clipping them. The dropdown BUTTON keeps its original
    -- narrow width; only the popup expands.
    local measurer = UIParent:CreateFontString(nil, "BACKGROUND")
    measurer:SetFont(FONT_BODY, 12, "")
    local maxTextWidth = 0
    for _, opt in ipairs(options) do
        measurer:SetText(opt.text or "")
        local w = measurer:GetStringWidth() or 0
        if w > maxTextWidth then maxTextWidth = w end
    end
    measurer:Hide()
    -- +30 accounts for left padding (8) + scroll-bar reservation (~16) + comfort.
    local popupWidth = math.max(width, maxTextWidth + 30)
    popupWidth = math.min(popupWidth, 480)  -- hard cap

    -- Popup (scrollable when there are more options than fit in maxPopupHeight)
    local itemH = 22
    local fullHeight = #options * itemH + 4
    local needScroll = fullHeight > maxPopupHeight
    local popupHeight = needScroll and maxPopupHeight or fullHeight

    local popup = CreateFrame("Frame", nil, UIParent)
    popup:SetFrameStrata("FULLSCREEN_DIALOG")
    popup:SetSize(popupWidth, popupHeight)
    popup:Hide()
    SetBG(popup, C.panel)
    SetBorder(popup, C.borderSubtle, 1)

    local itemParent = popup
    if needScroll then
        local sf = CreateFrame("ScrollFrame", nil, popup, "UIPanelScrollFrameTemplate")
        sf:SetPoint("TOPLEFT", 2, -2)
        sf:SetPoint("BOTTOMRIGHT", -12, 2)
        StyleScrollFrame(sf)
        local sc = CreateFrame("Frame", nil, sf)
        sc:SetSize(popupWidth - 16, fullHeight - 4)
        sf:SetScrollChild(sc)
        itemParent = sc
    end

    for i, opt in ipairs(options) do
        local item = CreateFrame("Button", nil, itemParent)
        item:SetSize(popupWidth - (needScroll and 18 or 4), itemH - 0)
        if needScroll then
            item:SetPoint("TOPLEFT", 0, -(i - 1) * itemH)
        else
            item:SetPoint("TOPLEFT", 2, -(i - 1) * itemH - 2)
        end

        item.hl = item:CreateTexture(nil, "BACKGROUND")
        item.hl:SetAllPoints()
        item.hl:SetColorTexture(c(C.panelHover))
        item.hl:Hide()

        item.text = item:CreateFontString(nil, "OVERLAY", "GameFontNormal")
        item.text:SetFont(FONT_BODY, 12, "")
        item.text:SetPoint("LEFT", 8, 0)
        item.text:SetText(opt.text)
        item.text:SetTextColor(c(C.textPrim))

        -- If the option carries a font path, preview it in the item label
        -- (overrides the Poppins body font for this specific item).
        if opt.preview then
            item.text:SetFont(opt.preview, 12, "")
        end

        item:SetScript("OnEnter", function() item.hl:Show() end)
        item:SetScript("OnLeave", function() item.hl:Hide() end)
        item:SetScript("OnClick", function()
            setter(opt.value)
            dd.text:SetText(opt.text)
            popup:Hide()
            _openPopup = nil
            if onChange then onChange(opt.value) end
        end)
    end

    local function refresh()
        local val = getter()
        for _, opt in ipairs(options) do
            if opt.value == val then
                dd.text:SetText(opt.text)
                return
            end
        end
        if options[1] then dd.text:SetText(options[1].text) end
    end
    refresh()

    dd:SetScript("OnClick", function()
        if popup:IsShown() then
            popup:Hide()
            _openPopup = nil
        else
            if _openPopup and _openPopup ~= popup then _openPopup:Hide() end
            popup:ClearAllPoints()
            popup:SetPoint("TOPLEFT", dd, "BOTTOMLEFT", 0, -4)
            popup:Show()
            -- Clamp inside the config window: if the popup extends past
            -- the main frame's right edge, re-anchor it to open from the
            -- dropdown's RIGHT edge instead (expanding leftward).
            if mainFrame and mainFrame:IsShown() then
                local mainRight = mainFrame:GetRight()
                local popRight  = popup:GetRight()
                if mainRight and popRight and popRight > mainRight - 10 then
                    popup:ClearAllPoints()
                    popup:SetPoint("TOPRIGHT", dd, "BOTTOMRIGHT", 0, -4)
                end
            end
            _openPopup = popup
        end
    end)

    -- Close popup when main config window hides
    dd.popup = popup
    dd.Refresh = refresh
    return dd
end

-- ---------------------------------------------------------------------------
-- Button
-- ---------------------------------------------------------------------------

local function CreateButton(parent, text, onClick, width)
    local b = CreateFrame("Button", nil, parent)
    b:SetSize(width or 110, 24)
    SetBG(b, C.button)
    SetBorder(b, C.borderSubtle, 1)

    b.text = b:CreateFontString(nil, "OVERLAY", "GameFontNormal")
    b.text:SetFont(FONT_BODY, 12, "")
    b.text:SetPoint("CENTER")
    b.text:SetText(text)
    b.text:SetTextColor(c(C.textPrim))

    b:SetScript("OnEnter", function() b._bg:SetColorTexture(c(C.buttonHover)) end)
    b:SetScript("OnLeave", function() b._bg:SetColorTexture(c(C.button)) end)
    b:SetScript("OnClick", onClick)
    return b
end

-- ---------------------------------------------------------------------------
-- Single-line text input (matches the slider value-input styling)
-- ---------------------------------------------------------------------------

local function CreateTextInput(parent, getter, setter, maxLetters, width)
    local eb = CreateFrame("EditBox", nil, parent)
    eb:SetSize(width or 220, 22)
    eb:SetAutoFocus(false)
    eb:SetMaxLetters(maxLetters or 64)
    eb:SetFont(FONT_BODY, 12, "")
    eb:SetTextColor(c(C.textPrim))
    eb:SetTextInsets(6, 6, 0, 0)
    SetBG(eb, C.button)
    SetBorder(eb, C.borderSubtle, 1)
    eb:SetText(getter() or "")

    local function commit()
        local v = eb:GetText() or ""
        setter(v)
    end

    eb:SetScript("OnEnterPressed",    function(self) commit(); self:ClearFocus() end)
    eb:SetScript("OnEscapePressed",   function(self) self:SetText(getter() or ""); self:ClearFocus() end)
    eb:SetScript("OnEditFocusLost",   function(self) commit() end)
    eb:SetScript("OnEditFocusGained", function(self) self:HighlightText() end)
    return eb
end

-- ---------------------------------------------------------------------------
-- Color swatch
-- ---------------------------------------------------------------------------

local function CreateColorSwatch(parent, getter, setter, onChange)
    local btn = CreateFrame("Button", nil, parent)
    btn:SetSize(24, 24)

    btn.border = btn:CreateTexture(nil, "BORDER")
    btn.border:SetAllPoints()
    btn.border:SetColorTexture(c(C.borderSubtle))

    btn.tex = btn:CreateTexture(nil, "ARTWORK")
    btn.tex:SetPoint("TOPLEFT", 1, -1)
    btn.tex:SetPoint("BOTTOMRIGHT", -1, 1)

    local function update()
        local col = getter()
        btn.tex:SetColorTexture(col[1], col[2], col[3], col[4] or 1)
    end
    update()

    local function apply(r, g, b, a)
        setter({r, g, b, a})
        update()
        if onChange then onChange() end
    end

    btn:SetScript("OnClick", function()
        local cur = getter()
        local info = {
            swatchFunc = function()
                local r, g, bl = ColorPickerFrame:GetColorRGB()
                local a = 1
                if ColorPickerFrame.GetColorAlpha then
                    a = ColorPickerFrame:GetColorAlpha()
                elseif OpacitySliderFrame then
                    a = 1 - OpacitySliderFrame:GetValue()
                end
                apply(r, g, bl, a)
            end,
            opacityFunc = function()
                local r, g, bl = ColorPickerFrame:GetColorRGB()
                local a = 1
                if ColorPickerFrame.GetColorAlpha then
                    a = ColorPickerFrame:GetColorAlpha()
                elseif OpacitySliderFrame then
                    a = 1 - OpacitySliderFrame:GetValue()
                end
                apply(r, g, bl, a)
            end,
            cancelFunc = function(prev)
                apply(prev.r, prev.g, prev.b, prev.opacity or 1)
            end,
            hasOpacity = true,
            opacity = cur[4] or 1,
            r = cur[1], g = cur[2], b = cur[3],
        }
        if ColorPickerFrame.SetupColorPickerAndShow then
            ColorPickerFrame:SetupColorPickerAndShow(info)
        else
            ColorPickerFrame.func        = info.swatchFunc
            ColorPickerFrame.opacityFunc = info.opacityFunc
            ColorPickerFrame.cancelFunc  = info.cancelFunc
            ColorPickerFrame.hasOpacity  = info.hasOpacity
            ColorPickerFrame.opacity     = info.opacity
            ColorPickerFrame:SetColorRGB(info.r, info.g, info.b)
            ColorPickerFrame:Hide()
            ColorPickerFrame:Show()
        end
    end)
    btn.Refresh = update
    return btn
end

-- ---------------------------------------------------------------------------
-- Section card (grouped settings with accent bar + title)
-- ---------------------------------------------------------------------------

local function CreateSection(parent, titleText)
    local section = CreateFrame("Frame", nil, parent)
    SetBG(section, C.panel)

    section.accent = section:CreateTexture(nil, "ARTWORK")
    section.accent:SetColorTexture(c(C.accent))
    section.accent:SetWidth(3)
    section.accent:SetPoint("TOPLEFT", 0, -8)
    section.accent:SetPoint("BOTTOMLEFT", 0, 8)

    section.title = MakeLabel(section, string.upper(titleText), "section")
    section.title:SetPoint("TOPLEFT", 14, -10)

    section.divider = section:CreateTexture(nil, "ARTWORK")
    section.divider:SetColorTexture(c(C.divider))
    section.divider:SetHeight(1)
    section.divider:SetPoint("TOPLEFT", 14, -28)
    section.divider:SetPoint("TOPRIGHT", -14, -28)

    section.content = CreateFrame("Frame", nil, section)
    section.content:SetPoint("TOPLEFT", 14, -36)
    section.content:SetPoint("BOTTOMRIGHT", -14, 12)

    section._cursorY = 0

    return section
end

-- A row inside a section: label on the left, widget on the right.
-- description is optional and appears in small grey text below the label.
--
-- Layout:
--   Without description: label and widget are both vertically centered on
--   the row's midline. Label text is left-justified and never wraps, so
--   every row in every section reads on a clean horizontal line regardless
--   of label length or widget height (dropdowns 24 px, sliders 16 px,
--   toggles 20 px all line up on the same center).
--
--   With description: label at the top, description right below the label,
--   widget also top-anchored. The description is word-wrapped within the
--   space left of the widget.
local function AddRow(section, labelText, widget, description)
    local content = section.content
    local y = section._cursorY

    local row = CreateFrame("Frame", nil, content)
    row:SetPoint("TOPLEFT", 0, -y)
    row:SetPoint("TOPRIGHT", 0, -y)

    -- Compute the row height BEFORE placing widgets, since the center
    -- anchor depends on the final row height.
    local rowH = 22
    if widget then
        rowH = math.max(rowH, widget:GetHeight() + 6)
    end
    if description then
        rowH = math.max(48, rowH + 22)
    end
    row:SetHeight(rowH)

    -- ---- Widget --------------------------------------------------------
    local rightOffset = 0
    if widget then
        widget:SetParent(row)
        widget:ClearAllPoints()
        -- Sliders carry a `.valueInput` EditBox that sticks out to the right;
        -- reserve that space so the editbox stays inside the row.
        if widget.valueInput then
            rightOffset = -(widget.valueInput:GetWidth() + 16)
        end
        if description then
            -- Multi-line row: widget top-aligned with label.
            widget:SetPoint("TOPRIGHT", rightOffset, -2)
        else
            -- Single-line row: widget vertically centered on the row.
            widget:SetPoint("RIGHT", rightOffset, 0)
        end
    end

    -- ---- Label ---------------------------------------------------------
    local labelFS = MakeLabel(row, labelText, "primary")
    labelFS:SetJustifyH("LEFT")
    labelFS:SetWordWrap(false)
    if description then
        labelFS:SetPoint("TOPLEFT", 0, -2)
    else
        labelFS:SetPoint("LEFT", 0, 0)
    end
    if widget then
        labelFS:SetPoint("RIGHT", widget, "LEFT", -8, 0)
    else
        labelFS:SetPoint("RIGHT", -4, 0)
    end

    -- ---- Optional description -----------------------------------------
    if description then
        local desc = MakeLabel(row, description, "secondary")
        desc:SetJustifyH("LEFT")
        desc:SetWordWrap(true)
        desc:SetPoint("TOPLEFT", 0, -20)
        if widget then
            desc:SetPoint("RIGHT", widget, "LEFT", -16, 0)
        else
            desc:SetPoint("RIGHT", -10, 0)
        end
    end

    section._cursorY = y + rowH + 10
end

-- Finalize section height based on its cursor.
local function FinalizeSection(section)
    section:SetHeight(section._cursorY + 48)
end

-- ---------------------------------------------------------------------------
-- Main frame + tabs
-- ---------------------------------------------------------------------------

local mainFrame
local tabButtons, tabPanels = {}, {}
local activeTabIndex = 1

local function SelectTab(index)
    -- Close any dropdown popup left open by the tab we're leaving. The
    -- popups are parented to UIParent (not the tab panel) so they don't
    -- hide automatically when the tab panel hides.
    if _openPopup then _openPopup:Hide(); _openPopup = nil end
    activeTabIndex = index
    for i, panel in ipairs(tabPanels) do panel:SetShown(i == index) end
    for i, btn in ipairs(tabButtons) do
        btn:SetActive(i == index)
    end
end

local function CreateTabButton(parent, label, onClick)
    local b = CreateFrame("Button", nil, parent)
    b:SetSize(140, 32)

    b.text = MakeLabel(b, label, "primary")
    b.text:SetPoint("CENTER", 0, 2)

    b.underline = b:CreateTexture(nil, "OVERLAY")
    b.underline:SetColorTexture(c(C.accent))
    b.underline:SetHeight(2)
    b.underline:SetPoint("BOTTOMLEFT", 6, 0)
    b.underline:SetPoint("BOTTOMRIGHT", -6, 0)
    b.underline:Hide()

    function b:SetActive(active)
        if active then
            b.text:SetTextColor(c(C.accent))
            b.underline:Show()
        else
            b.text:SetTextColor(c(C.textSec))
            b.underline:Hide()
        end
    end
    b:SetActive(false)

    b:SetScript("OnEnter", function() if not b.underline:IsShown() then b.text:SetTextColor(c(C.textPrim)) end end)
    b:SetScript("OnLeave", function() if not b.underline:IsShown() then b.text:SetTextColor(c(C.textSec)) end end)
    b:SetScript("OnClick", onClick)
    return b
end

local function BuildMain()
    if mainFrame then return mainFrame end

    local f = CreateFrame("Frame", "NSRTEnhancerConfigFrame", UIParent)
    f:SetSize(680, 640)
    f:SetPoint("CENTER")
    f:SetFrameStrata("HIGH")
    f:SetToplevel(true)
    f:SetClampedToScreen(true)  -- prevent dragging fully off-screen
    f:Hide()

    -- Drag from anywhere on the frame. Interactive children (buttons,
    -- sliders, dropdowns, checkboxes, editboxes) have their own mouse, so
    -- they absorb clicks before the main frame sees them and dragging only
    -- starts on empty space -- which is the "drag from anywhere" UX the
    -- user asked for.
    f:SetMovable(true)
    f:EnableMouse(true)
    f:RegisterForDrag("LeftButton")
    f:SetScript("OnDragStart", function(self) self:StartMoving() end)
    f:SetScript("OnDragStop",  function(self) self:StopMovingOrSizing() end)

    -- Background + subtle border
    SetBG(f, C.bg)
    SetBorder(f, C.borderSubtle, 1)

    -- Title
    f.title = MakeLabel(f, "NSRT Enhancer", "title")
    f.title:SetPoint("TOPLEFT", 20, -16)

    f.version = MakeLabel(f, "v2.0", "version")
    f.version:SetPoint("LEFT", f.title, "RIGHT", 8, -2)

    -- Close button (custom X)
    f.close = CreateFrame("Button", nil, f)
    f.close:SetSize(28, 28)
    f.close:SetPoint("TOPRIGHT", -10, -10)
    f.close.text = f.close:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge")
    f.close.text:SetPoint("CENTER", 0, 1)
    f.close.text:SetText("×")
    f.close.text:SetFont(FONT_HEADER, 22, "")
    f.close.text:SetTextColor(c(C.textSec))
    f.close:SetScript("OnEnter", function() f.close.text:SetTextColor(1, 1, 1) end)
    f.close:SetScript("OnLeave", function() f.close.text:SetTextColor(c(C.textSec)) end)
    f.close:SetScript("OnClick", function() f:Hide() end)

    -- Divider under title
    f.topDivider = f:CreateTexture(nil, "ARTWORK")
    f.topDivider:SetColorTexture(c(C.divider))
    f.topDivider:SetHeight(1)
    f.topDivider:SetPoint("TOPLEFT", 0, -48)
    f.topDivider:SetPoint("TOPRIGHT", 0, -48)

    -- Tabs
    local tabNames = { "Past Reminders", "On Deck", "Voice", "On You" }
    for i, name in ipairs(tabNames) do
        local tab = CreateTabButton(f, name, function() SelectTab(i) end)
        if i == 1 then
            tab:SetPoint("TOPLEFT", 16, -52)
        else
            tab:SetPoint("LEFT", tabButtons[i - 1], "RIGHT", 8, 0)
        end
        tabButtons[i] = tab

        local panel = CreateFrame("Frame", nil, f)
        panel:SetPoint("TOPLEFT", 0, -92)
        panel:SetPoint("BOTTOMRIGHT", 0, 0)
        panel:Hide()
        tabPanels[i] = panel
    end

    -- Tab-bar bottom divider
    f.tabsDivider = f:CreateTexture(nil, "ARTWORK")
    f.tabsDivider:SetColorTexture(c(C.divider))
    f.tabsDivider:SetHeight(1)
    f.tabsDivider:SetPoint("TOPLEFT", 0, -88)
    f.tabsDivider:SetPoint("TOPRIGHT", 0, -88)

    -- Close open dropdown popups on hide
    f:SetScript("OnHide", function()
        if _openPopup then _openPopup:Hide(); _openPopup = nil end
    end)

    mainFrame = f
    return f
end

-- ---------------------------------------------------------------------------
-- Module master-enable header (shared by all tabs)
-- ---------------------------------------------------------------------------
--
-- Renders a "Enable <Module>" toggle + thin divider across the top of a tab
-- and returns a content Frame anchored BELOW it. A click-blocking / dimming
-- mask overlay is installed over the content; flipping the toggle off shows
-- the mask (greyed + inert) and flipping it on hides it.
--
-- Usage: `local content = BuildTabMaster(panel, "Past Reminders", getter, setter)`
-- Then parent all your sections / scroll frames to `content` instead of
-- `panel` directly.

local function BuildTabMaster(panel, moduleLabel, getter, setter)
    -- Top bar holding the master toggle
    local bar = CreateFrame("Frame", nil, panel)
    bar:SetPoint("TOPLEFT", 16, -12)
    bar:SetPoint("TOPRIGHT", -16, -12)
    bar:SetHeight(28)

    local labelFS = MakeLabel(bar, "Enable " .. moduleLabel, "primary")
    labelFS:SetPoint("LEFT", 0, 0)

    -- State text ("ON" / "OFF") on the right for extra clarity
    local stateFS = MakeLabel(bar, "", "secondary")
    stateFS:SetPoint("RIGHT", 0, 0)

    -- Thin divider beneath the bar
    local sep = panel:CreateTexture(nil, "ARTWORK")
    sep:SetColorTexture(c(C.divider))
    sep:SetHeight(1)
    sep:SetPoint("TOPLEFT", 16, -46)
    sep:SetPoint("TOPRIGHT", -16, -46)

    -- Content area below the bar
    local content = CreateFrame("Frame", nil, panel)
    content:SetPoint("TOPLEFT", 0, -52)
    content:SetPoint("BOTTOMRIGHT", 0, 0)

    -- Disabled mask: click-blocking dark overlay with centered hint text.
    -- Parented to the panel (not content) so it sits above the content's
    -- descendants and intercepts every click in the area.
    local mask = CreateFrame("Frame", nil, panel)
    mask:SetAllPoints(content)
    mask:SetFrameLevel(content:GetFrameLevel() + 50)  -- above all descendants of `content`
    mask:EnableMouse(true)
    mask:EnableMouseWheel(true)
    mask.tex = mask:CreateTexture(nil, "OVERLAY")
    mask.tex:SetAllPoints()
    mask.tex:SetColorTexture(c(C.bg, 0.65))
    mask.hint = MakeLabel(mask, "Module disabled", "section")
    mask.hint:SetPoint("CENTER", 0, 20)
    mask.hint:SetTextColor(c(C.textMuted))
    mask.sub = MakeLabel(mask, "Toggle above to enable and configure", "secondary")
    mask.sub:SetPoint("TOP", mask.hint, "BOTTOM", 0, -6)
    mask.sub:SetTextColor(c(C.textMuted))
    mask:Hide()

    local function refresh(enabled)
        if enabled then
            mask:Hide()
            content:SetAlpha(1)
            stateFS:SetText("ON")
            stateFS:SetTextColor(c(C.toggleOn))
        else
            mask:Show()
            -- Keep content semi-visible (helps user see the settings) but
            -- dimmed so the disabled state is obvious.
            content:SetAlpha(0.5)
            stateFS:SetText("OFF")
            stateFS:SetTextColor(c(C.textMuted))
        end
    end

    -- Toggle is placed AFTER the state label so drag-like click flows feel
    -- natural. It wraps the user's setter so we refresh the UI in lockstep.
    local toggle = CreateToggle(bar, getter, function(v)
        setter(v)
        refresh(getter())
    end)
    toggle:SetPoint("LEFT", labelFS, "RIGHT", 12, 0)

    -- Initial sync.
    refresh(getter())

    -- Expose the refresh hook so external mutations (e.g. `/nse mute`)
    -- can request a visual resync.
    panel._refreshMaster = refresh

    return content
end

-- ---------------------------------------------------------------------------
-- Tab 1: Past Reminders
-- ---------------------------------------------------------------------------

local function BuildPastRemindersTab(panel)
    local content = BuildTabMaster(panel, "Past Reminders",
        function() return NSE.db.pastReminders.enabled end,
        function(v) NSE.PastReminders:SetEnabled(v) end)

    local inner = CreateFrame("Frame", nil, content)
    inner:SetPoint("TOPLEFT", 20, -20)
    inner:SetPoint("BOTTOMRIGHT", -20, 20)

    local section = CreateSection(inner, "About")
    section:SetPoint("TOPLEFT")
    section:SetPoint("TOPRIGHT")

    local desc = section.content:CreateFontString(nil, "OVERLAY", "GameFontHighlight")
    desc:SetFont(FONT_BODY, 12, "")
    desc:SetPoint("TOPLEFT", 0, -2)
    desc:SetPoint("TOPRIGHT", -4, -2)
    desc:SetJustifyH("LEFT")
    desc:SetWordWrap(true)
    desc:SetTextColor(c(C.textSec))
    desc:SetText("Keeps past-due lines on the NSRT personal reminder note visible and greyed, instead of deleting them. Highlights the first upcoming line's timer in yellow. Works during encounters and Timeline > Play Preview.")
    desc:SetHeight(56)
    section._cursorY = 60

    FinalizeSection(section)
end

-- ---------------------------------------------------------------------------
-- Tab 2: On Deck (scrollable, many sections)
-- ---------------------------------------------------------------------------

local function BuildOnDeckTab(panel)
    local tabContent = BuildTabMaster(panel, "On Deck",
        function() return NSE.db.onDeck.enabled end,
        function(v) NSE.OnDeck:SetEnabled(v); NSE.OnDeck:Refresh() end)

    local scroll = CreateFrame("ScrollFrame", nil, tabContent, "UIPanelScrollFrameTemplate")
    scroll:SetPoint("TOPLEFT", 16, -16)
    scroll:SetPoint("BOTTOMRIGHT", -18, 16)
    StyleScrollFrame(scroll)

    local content = CreateFrame("Frame", nil, scroll)
    content:SetSize(616, 10)
    scroll:SetScrollChild(content)

    local cfg     = function() return NSE.db.onDeck end
    local refresh = function() NSE.OnDeck:Refresh() end
    local y = 0

    local function placeSection(section)
        section:SetPoint("TOPLEFT", 0, -y)
        section:SetPoint("TOPRIGHT", 0, -y)
        FinalizeSection(section)
        y = y + section:GetHeight() + 14
    end

    -- X/Y sliders captured here so we can re-sync them when the tab is
    -- shown (the user may have dragged the frame since the GUI was last
    -- opened, which updates cfg().position.x/y directly).
    local xSlider, ySlider

    -- ------ General ------
    do
        local s = CreateSection(content, "General")
        AddRow(s, "Unlock (drag to move)",
            CreateToggle(s.content,
                function() return not cfg().locked end,
                function(v) NSE.OnDeck:SetLocked(not v) end),
            "When on, the icon row gets a blue backdrop and can be dragged anywhere on screen.")

        AddRow(s, "Hide NSRT icon/bar displays",
            CreateToggle(s.content,
                function() return cfg().suppressNSRT end,
                function(v) cfg().suppressNSRT = v; NSE.OnDeck:ApplyNSRTSuppression() end),
            "Hide NSRT's own reminder icons, bars, and text displays (its vertical icon column). Use this when you want NSE's On Deck panel to be the only cooldown UI on screen. NSRT's TTS and sounds are unaffected.")

        xSlider = CreateSlider(s.content, -2000, 2000, 1,
            function() return cfg().position.x or 0 end,
            function(v)
                cfg().position.x = v
                cfg().position.point, cfg().position.relPoint = "CENTER", "CENTER"
                NSE.OnDeck:ApplyLayout()
            end,
            "%d px")
        AddRow(s, "X position", xSlider,
            "Horizontal offset from the screen's center. Negative = left, positive = right.")

        ySlider = CreateSlider(s.content, -2000, 2000, 1,
            function() return cfg().position.y or 0 end,
            function(v)
                cfg().position.y = v
                cfg().position.point, cfg().position.relPoint = "CENTER", "CENTER"
                NSE.OnDeck:ApplyLayout()
            end,
            "%d px")
        AddRow(s, "Y position", ySlider,
            "Vertical offset from the screen's center. Positive = up, negative = down.")

        AddRow(s, "Reset position",
            CreateButton(s.content, "Reset to center", function()
                cfg().position.point, cfg().position.relPoint = "CENTER", "CENTER"
                cfg().position.x, cfg().position.y = 0, -160
                NSE.OnDeck:ApplyLayout()
                xSlider:SetValue(0)
                ySlider:SetValue(-160)
            end, 140))

        AddRow(s, "Test display",
            CreateButton(s.content, "Toggle test icons", function()
                NSE.OnDeck:ToggleTest()
            end, 150),
            "Populates the panel with sample cooldown icons so you can preview your layout outside of combat. Loops until you click again to stop. Auto-stops if you enter an encounter or preview.")
        placeSection(s)
    end

    -- Resync X/Y sliders from the live config whenever this tab is shown,
    -- so they reflect the current drag-saved position.
    panel:HookScript("OnShow", function()
        if xSlider then xSlider:SetValue(cfg().position.x or 0) end
        if ySlider then ySlider:SetValue(cfg().position.y or 0) end
    end)

    -- ------ Layout ------
    do
        local s = CreateSection(content, "Layout")
        AddRow(s, "Orientation",
            CreateDropdown(s.content, {
                { text = "Horizontal (upcoming-left, ready-right)", value = "HORIZONTAL" },
                { text = "Vertical (upcoming-top, ready-bottom)",   value = "VERTICAL" },
            },
            function() return cfg().orientation or "HORIZONTAL" end,
            function(v) cfg().orientation = v; refresh() end, nil, 260),
            "Horizontal lays the panel across the screen; vertical stacks it top-to-bottom. Timer-above is forced off in vertical mode.")
        AddRow(s, "Queue depth",
            CreateSlider(s.content, 1, 5, 1,
                function() return cfg().queueDepth end,
                function(v) cfg().queueDepth = math.floor(v); refresh() end,
                "%d icons"),
            "How many icons total: center + N-1 upcoming.")
        AddRow(s, "Center icon size",
            CreateSlider(s.content, 20, 96, 1,
                function() return cfg().iconSize end,
                function(v) cfg().iconSize = v; refresh() end,
                "%d px"))
        AddRow(s, "Icon spacing",
            CreateSlider(s.content, 0, 20, 1,
                function() return cfg().iconSpacing end,
                function(v) cfg().iconSpacing = v; refresh() end,
                "%d px"))
        AddRow(s, "Size falloff",
            CreateSlider(s.content, 0.3, 1.0, 0.05,
                function() return cfg().sizeStep end,
                function(v) cfg().sizeStep = v; refresh() end,
                "%.2fx"),
            "Each left icon is this multiple of the previous one's size.")
        AddRow(s, "Alpha falloff",
            CreateSlider(s.content, 0.1, 1.0, 0.05,
                function() return cfg().alphaStep end,
                function(v) cfg().alphaStep = v; refresh() end,
                "%.2fx"),
            "Each left icon is this multiple of the previous one's alpha.")
        AddRow(s, "Minimum alpha",
            CreateSlider(s.content, 0.05, 1.0, 0.05,
                function() return cfg().minAlpha end,
                function(v) cfg().minAlpha = v; refresh() end,
                "%.2f"),
            "Floor on alpha so far-left icons stay visible.")
        AddRow(s, "Ready (linger)",
            CreateSlider(s.content, 0, 30, 1,
                function() return cfg().lingerSeconds or 0 end,
                function(v) cfg().lingerSeconds = v; refresh() end,
                "%d s"),
            "How long a cooldown stays in the 'use now' stack to the right after its timer hits 0.")
        AddRow(s, "Max ready slots",
            CreateSlider(s.content, 1, 5, 1,
                function() return cfg().readyStackMax or 3 end,
                function(v) cfg().readyStackMax = math.floor(v); refresh() end,
                "%d"),
            "Upper bound on how many 'use now' icons stack to the right at once.")
        placeSection(s)
    end

    -- ------ Timer font ------
    do
        local s = CreateSection(content, "Timer font")

        -- Font picker — caches dropdown options and reflects the current
        -- font path back to the user as its LSM name.
        local fontOptions = BuildFontOptions()
        local fontDropdown = CreateDropdown(s.content, fontOptions,
            function() return cfg().font end,
            function(v) cfg().font = v; refresh() end,
            nil, 180, 280)
        -- Initial display text (the dropdown uses opt.text but our DB stores
        -- paths; set the text to the friendly name).
        fontDropdown.text:SetText(FontPathToName(cfg().font))
        AddRow(s, "Font", fontDropdown)

        AddRow(s, "Font size",
            CreateSlider(s.content, 8, 40, 1,
                function() return cfg().fontSize end,
                function(v) cfg().fontSize = v; refresh() end,
                "%d"))
        AddRow(s, "Outline",
            CreateDropdown(s.content, {
                { text = "None",          value = "" },
                { text = "Outline",       value = "OUTLINE" },
                { text = "Thick outline", value = "THICKOUTLINE" },
                { text = "Monochrome",    value = "MONOCHROME" },
            },
            function() return cfg().fontOutline end,
            function(v) cfg().fontOutline = v; refresh() end))
        AddRow(s, "Color",
            CreateColorSwatch(s.content,
                function() return cfg().fontColor end,
                function(col) cfg().fontColor = col; refresh() end))
        AddRow(s, "Position",
            CreateDropdown(s.content, {
                { text = "Centered on icon", value = "CENTER" },
                { text = "Above icon",       value = "ABOVE" },
            },
            function() return cfg().timerPosition or "CENTER" end,
            function(v) cfg().timerPosition = v; refresh() end),
            "Where to draw the countdown text on the center (next) icon.")
        placeSection(s)
    end

    -- ------ Background ------
    do
        local s = CreateSection(content, "Background")
        AddRow(s, "Show background",
            CreateToggle(s.content,
                function() return cfg().showBackground end,
                function(v) cfg().showBackground = v; refresh() end),
            "Paints a solid rectangle behind the icons.")
        AddRow(s, "Color",
            CreateColorSwatch(s.content,
                function() return cfg().backgroundColor end,
                function(col) cfg().backgroundColor = col; refresh() end))
        placeSection(s)
    end

    -- ------ Ready glow ------
    do
        local s = CreateSection(content, "Ready glow")
        AddRow(s, "Enable glow",
            CreateToggle(s.content,
                function() return cfg().pandemicGlow.enabled end,
                function(v) cfg().pandemicGlow.enabled = v; refresh() end),
            "Glow every icon in the 'use now' stack to the right of center.")
        AddRow(s, "Glow type",
            CreateDropdown(s.content, {
                { text = "Pixel",    value = "Pixel" },
                { text = "AutoCast", value = "AutoCast" },
                { text = "Button",   value = "Button" },
            },
            function() return cfg().pandemicGlow.type end,
            function(v) cfg().pandemicGlow.type = v; refresh() end))
        AddRow(s, "Glow color",
            CreateColorSwatch(s.content,
                function() return cfg().pandemicGlow.color end,
                function(col) cfg().pandemicGlow.color = col; refresh() end))
        placeSection(s)
    end

    content:SetHeight(y + 20)
end

-- ---------------------------------------------------------------------------
-- Tab 3: Voice (TTS)
-- ---------------------------------------------------------------------------

local function BuildVoiceOptions(includeInherit)
    local list = {}
    if includeInherit then
        table.insert(list, { text = "(Use NSRT default)", value = false })
    end
    if C_VoiceChat and C_VoiceChat.GetTtsVoices then
        local voices = C_VoiceChat.GetTtsVoices() or {}
        for _, v in ipairs(voices) do
            table.insert(list, {
                text  = v.name or ("Voice " .. tostring(v.voiceID)),
                value = v.voiceID,
            })
        end
    end
    if #list == 0 or (includeInherit and #list == 1) then
        table.insert(list, { text = "(no voices detected)", value = 0 })
    end
    return list
end

local function VoiceIDToName(voiceID)
    if voiceID == false or voiceID == nil then return "(Use NSRT default)" end
    if C_VoiceChat and C_VoiceChat.GetTtsVoices then
        for _, v in ipairs(C_VoiceChat.GetTtsVoices() or {}) do
            if v.voiceID == voiceID then return v.name or ("Voice " .. tostring(voiceID)) end
        end
    end
    return "Voice " .. tostring(voiceID or 0)
end

-- Resolve a stored override to the actual voiceID to use for a preview call:
-- false/nil means "inherit NSRT default".
local function ResolveVoice(override)
    if override then return override end
    return (NSRT and NSRT.Settings and NSRT.Settings["TTSVoice"]) or 0
end

local function BuildVoiceTab(panel)
    local tabContent = BuildTabMaster(panel, "Voice overrides",
        function() return NSE.db.voice.enabled end,
        function(v) NSE.db.voice.enabled = v end)

    -- ScrollFrame wraps the content so it clips (and scrolls) when the
    -- two sections plus multi-line descriptions (e.g. Volume boost) are
    -- taller than the visible panel -- previously they rendered outside
    -- the main config window onto the game world.
    local scroll = CreateFrame("ScrollFrame", nil, tabContent, "UIPanelScrollFrameTemplate")
    scroll:SetPoint("TOPLEFT", 16, -16)
    scroll:SetPoint("BOTTOMRIGHT", -18, 16)
    StyleScrollFrame(scroll)

    local inner = CreateFrame("Frame", nil, scroll)
    inner:SetSize(616, 10)  -- height set after sections are finalized
    scroll:SetScrollChild(inner)

    local function currentDB() return (NSE.db and NSE.db.voice) or {} end

    -- -------- Per-source overrides --------
    local section = CreateSection(inner, "Voice per reminder source")
    section:SetPoint("TOPLEFT")
    section:SetPoint("TOPRIGHT")

    local personalDD = CreateDropdown(section.content, BuildVoiceOptions(true),
        function() return currentDB().personalVoiceID end,
        function(v) if NSE.db and NSE.db.voice then NSE.db.voice.personalVoiceID = v end end,
        nil, 260, 300)
    personalDD.text:SetText(VoiceIDToName(currentDB().personalVoiceID))
    AddRow(section, "Personal reminder voice", personalDD,
        "Used when the reminder came from YOUR personal note (the Pers Note in NSRT).")

    local assignedDD = CreateDropdown(section.content, BuildVoiceOptions(true),
        function() return currentDB().assignedVoiceID end,
        function(v) if NSE.db and NSE.db.voice then NSE.db.voice.assignedVoiceID = v end end,
        nil, 260, 300)
    assignedDD.text:SetText(VoiceIDToName(currentDB().assignedVoiceID))
    AddRow(section, "Raid-assigned voice", assignedDD,
        "Used when the raid leader assigned the cooldown to you (shared NSRT reminder note or MRT note).")

    AddRow(section, "Test personal",
        CreateButton(section.content, "Test", function()
            if _G.NSAPI and _G.NSAPI.TTS then
                _G.NSAPI:TTS("Personal reminder", ResolveVoice(currentDB().personalVoiceID))
            end
        end, 100))

    AddRow(section, "Test raid-assigned",
        CreateButton(section.content, "Test", function()
            if _G.NSAPI and _G.NSAPI.TTS then
                _G.NSAPI:TTS("Raid assigned", ResolveVoice(currentDB().assignedVoiceID))
            end
        end, 100))

    FinalizeSection(section)

    -- -------- NSRT fallback default --------
    local defaults = CreateSection(inner, "NSRT default (fallback)")
    defaults:SetPoint("TOPLEFT", section, "BOTTOMLEFT", 0, -14)
    defaults:SetPoint("TOPRIGHT", section, "BOTTOMRIGHT", 0, -14)

    local defaultDD = CreateDropdown(defaults.content, BuildVoiceOptions(false),
        function() return (NSRT and NSRT.Settings and NSRT.Settings["TTSVoice"]) or 0 end,
        function(v) if NSRT and NSRT.Settings then NSRT.Settings["TTSVoice"] = v end end,
        nil, 260, 300)
    defaultDD.text:SetText(VoiceIDToName((NSRT and NSRT.Settings and NSRT.Settings["TTSVoice"]) or 0))
    AddRow(defaults, "Default voice", defaultDD,
        "Used when either override above is set to (Use NSRT default). Mirrors NSRT's own TTS voice setting.")

    AddRow(defaults, "Volume",
        CreateSlider(defaults.content, 0, 100, 1,
            function() return (NSRT and NSRT.Settings and NSRT.Settings["TTSVolume"]) or 50 end,
            function(v) if NSRT and NSRT.Settings then NSRT.Settings["TTSVolume"] = v end end,
            "%d"),
        "Shared across all voices. 0 = silent, 100 = maximum.")

    AddRow(defaults, "Volume boost",
        CreateSlider(defaults.content, 1, 4, 1,
            function() return currentDB().volumeBoost or 1 end,
            function(v) if NSE.db and NSE.db.voice then NSE.db.voice.volumeBoost = math.floor(v) end end,
            "%dx"),
        "The API caps TTS volume at 100. Boost plays each message multiple times with overlap so it mixes louder. 1 = normal, 4 = loudest (may sound slightly distorted).")

    FinalizeSection(defaults)

    -- Size the scroll child to fit both sections so the ScrollFrame
    -- reveals everything (or offers a scrollbar when the window is shorter
    -- than the content).
    inner:SetHeight(section:GetHeight() + 14 + defaults:GetHeight() + 20)

    -- Re-sync displays when the tab is shown (NSRT may finalize its
    -- settings after our Init ran; voice list may change too).
    panel:HookScript("OnShow", function()
        personalDD.text:SetText(VoiceIDToName(currentDB().personalVoiceID))
        assignedDD.text:SetText(VoiceIDToName(currentDB().assignedVoiceID))
        defaultDD.text:SetText(VoiceIDToName((NSRT and NSRT.Settings and NSRT.Settings["TTSVoice"]) or 0))
    end)
end

-- ---------------------------------------------------------------------------
-- Public API
-- ---------------------------------------------------------------------------

-- ---------------------------------------------------------------------------
-- Tab 4: On You (DBM-driven flash-on-me)
-- ---------------------------------------------------------------------------

local function BuildOnYouTab(panel)
    local tabContent = BuildTabMaster(panel, "On You",
        function() return NSE.db.onYou.enabled end,
        function(v) NSE.db.onYou.enabled = v end)

    local scroll = CreateFrame("ScrollFrame", nil, tabContent, "UIPanelScrollFrameTemplate")
    scroll:SetPoint("TOPLEFT", 16, -16)
    scroll:SetPoint("BOTTOMRIGHT", -18, 16)
    StyleScrollFrame(scroll)

    local content = CreateFrame("Frame", nil, scroll)
    content:SetSize(610, 10)
    scroll:SetScrollChild(content)

    local cfg = function() return NSE.db.onYou end
    local y = 0
    local function placeSection(section)
        section:SetPoint("TOPLEFT", 0, -y)
        section:SetPoint("TOPRIGHT", 0, -y)
        FinalizeSection(section)
        y = y + section:GetHeight() + 14
    end

    -- ------ Flash ------
    do
        local s = CreateSection(content, "Flash")

        -- DBM status banner row
        local statusLabel = s.content:CreateFontString(nil, "OVERLAY", "GameFontNormal")
        statusLabel:SetFont(FONT_BODY, 12, "")
        statusLabel:SetPoint("TOPLEFT", 0, -2)
        if NSE.OnYou and NSE.OnYou._dbmMissing then
            statusLabel:SetText("DBM not detected -- module inactive. Install DBM for flash-on-you to fire.")
            statusLabel:SetTextColor(c(C.textMuted))
        else
            statusLabel:SetText("DBM detected -- flash will fire on personal warnings.")
            statusLabel:SetTextColor(c(C.accent))
        end
        s._cursorY = (s._cursorY or 0) + 26

        AddRow(s, "Auto mode",
            CreateToggle(s.content,
                function() return cfg().autoMode end,
                function(v) cfg().autoMode = v end),
            "Fallback when you haven't opted a spell into the list below. Flashes on any DBM 'you'-type warning and on 'target' warnings where your name appears in the text.")

        AddRow(s, "Flash color",
            CreateColorSwatch(s.content,
                function() return cfg().flashColor end,
                function(col) cfg().flashColor = col end))

        AddRow(s, "Peak opacity",
            CreateSlider(s.content, 0.1, 1.0, 0.05,
                function() return cfg().flashOpacity end,
                function(v) cfg().flashOpacity = v end,
                "%.2f"),
            "How strong the color gets at the peak of each pulse.")

        AddRow(s, "Flash count",
            CreateSlider(s.content, 1, 5, 1,
                function() return cfg().flashCount end,
                function(v) cfg().flashCount = math.floor(v) end,
                "%d"),
            "How many pulses per alert.")

        AddRow(s, "Pulse duration",
            CreateSlider(s.content, 0.10, 1.00, 0.05,
                function() return cfg().flashDuration end,
                function(v) cfg().flashDuration = v end,
                "%.2f s"),
            "Fade-in + fade-out length of a single pulse.")

        placeSection(s)
    end

    -- ------ Text ------
    do
        local s = CreateSection(content, "Text")

        AddRow(s, "Show text",
            CreateToggle(s.content,
                function() return cfg().textEnabled end,
                function(v) cfg().textEnabled = v end),
            "Draw a big centered message over the flash.")

        AddRow(s, "Message",
            CreateTextInput(s.content,
                function() return cfg().text end,
                function(v) cfg().text = v end,
                64, 220),
            "What the flash says. Enter to save.")

        AddRow(s, "Font size",
            CreateSlider(s.content, 12, 96, 1,
                function() return cfg().textSize end,
                function(v) cfg().textSize = v end,
                "%d"))

        AddRow(s, "Outline",
            CreateDropdown(s.content, {
                { text = "None",          value = "" },
                { text = "Outline",       value = "OUTLINE" },
                { text = "Thick outline", value = "THICKOUTLINE" },
                { text = "Monochrome",    value = "MONOCHROME" },
            },
            function() return cfg().textOutline end,
            function(v) cfg().textOutline = v end))

        AddRow(s, "Text color",
            CreateColorSwatch(s.content,
                function() return cfg().textColor end,
                function(col) cfg().textColor = col end))

        placeSection(s)
    end

    -- ------ Test ------
    do
        local s = CreateSection(content, "Test")
        AddRow(s, "Test flash",
            CreateButton(s.content, "Flash now", function()
                if NSE.OnYou and NSE.OnYou.Test then NSE.OnYou:Test() end
            end, 120),
            "Fires the flash with the current settings. Works even when the module is disabled, so you can preview changes.")
        placeSection(s)
    end

    -- ------ Per-spell overrides (live from DBM) ----------------------------
    --
    -- Positioned AFTER Test so that its dynamic growth/shrink only affects
    -- the outer content's scroll height, not any section above it.
    local yBeforeSpellSection = y
    local spellSection, spellListFrame, staticPreludeCursor, rebuildSpellList
    local currentTierAddonId, controlsRow
    local targetableState = { only = true }

    do
        local s = CreateSection(content, "Per-spell overrides")
        spellSection = s

        local intro = s.content:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
        intro:SetFont(FONT_BODY, 11, "")
        intro:SetPoint("TOPLEFT", 0, -2)
        intro:SetPoint("TOPRIGHT", -4, -2)
        intro:SetJustifyH("LEFT")
        intro:SetWordWrap(true)
        intro:SetTextColor(c(C.textSec))
        intro:SetText("Pulled live from DBM. Pick a tier, enable the warnings you care about, and type the message you want each to show. Flash only fires when the warning is actually on you.")
        intro:SetHeight(44)
        s._cursorY = (s._cursorY or 0) + 50

        -- Controls row gets built lazily (after we know the tier list).
        controlsRow = CreateFrame("Frame", nil, s.content)
        controlsRow:SetPoint("TOPLEFT", 0, -s._cursorY)
        controlsRow:SetPoint("TOPRIGHT", 0, -s._cursorY)
        controlsRow:SetHeight(30)

        s._cursorY = s._cursorY + 38
        staticPreludeCursor = s._cursorY

        spellListFrame = CreateFrame("Frame", nil, s.content)
        spellListFrame:SetPoint("TOPLEFT", 0, -s._cursorY)
        spellListFrame:SetPoint("TOPRIGHT", 0, -s._cursorY)
        spellListFrame:SetHeight(10)
    end

    -- Build the tier dropdown + targetable filter once. DBM.AddOns is
    -- populated at DBM init and never grows during a session, so we only
    -- need to do this once.
    local controlsBuilt = false
    local function ensureControls()
        if controlsBuilt then return end
        if not (NSE.OnYou and NSE.OnYou.ListAvailableTiers) then return end

        local tiers = NSE.OnYou:ListAvailableTiers() or {}
        if #tiers == 0 then return end  -- retry next time

        local options = {}
        for _, t in ipairs(tiers) do
            options[#options + 1] = { text = t.name, value = t.addonId }
        end
        currentTierAddonId = currentTierAddonId or options[1].value

        local tierLabel = MakeLabel(controlsRow, "DBM module:", "primary")
        tierLabel:SetPoint("LEFT", 0, 0)

        local tierDropdown = CreateDropdown(controlsRow, options,
            function() return currentTierAddonId end,
            function(v) currentTierAddonId = v end,
            function() if rebuildSpellList then rebuildSpellList() end end,
            280, 320)
        tierDropdown:SetPoint("LEFT", tierLabel, "RIGHT", 10, 0)

        local filterLabel = MakeLabel(controlsRow, "Targetable only", "primary")
        filterLabel:SetPoint("LEFT", tierDropdown, "RIGHT", 20, 0)

        local filterToggle = CreateToggle(controlsRow,
            function() return targetableState.only end,
            function(v) targetableState.only = v end,
            function() if rebuildSpellList then rebuildSpellList() end end)
        filterToggle:SetPoint("LEFT", filterLabel, "RIGHT", 10, 0)

        controlsBuilt = true
    end

    -- Pooled row/header frames (rebuilds never grow memory beyond peak use).
    local rowPool, headerPool = {}, {}

    local function acquireHeader()
        for _, h in ipairs(headerPool) do
            if not h:IsShown() then return h end
        end
        local h = CreateFrame("Frame", nil, spellListFrame)
        h:SetHeight(22)
        h.bar = h:CreateTexture(nil, "ARTWORK")
        h.bar:SetColorTexture(c(C.accent))
        h.bar:SetWidth(3)
        h.bar:SetPoint("TOPLEFT", 0, -2)
        h.bar:SetPoint("BOTTOMLEFT", 0, 2)
        h.label = MakeLabel(h, "", "section")
        h.label:SetPoint("LEFT", h.bar, "RIGHT", 8, 0)
        headerPool[#headerPool + 1] = h
        return h
    end

    local function acquireRow()
        for _, r in ipairs(rowPool) do
            if not r:IsShown() then return r end
        end
        local r = CreateFrame("Frame", nil, spellListFrame)
        r:SetHeight(48)
        SetBG(r, C.panel)

        r.toggle = CreateToggle(r,
            function()
                local e = r._entry
                return e and e.enabled or false
            end,
            function(v)
                local id = r._spellId
                if not id then return end
                if not NSE.db.onYou.spells[id] then
                    NSE.db.onYou.spells[id] = { enabled = false, customText = "" }
                end
                NSE.db.onYou.spells[id].enabled = v
                r._entry = NSE.db.onYou.spells[id]
            end)
        r.toggle:SetPoint("TOPLEFT", 10, -6)

        r.icon = r:CreateTexture(nil, "ARTWORK")
        r.icon:SetSize(22, 22)
        r.icon:SetTexCoord(0.08, 0.92, 0.08, 0.92)
        r.icon:SetPoint("TOPLEFT", 62, -4)

        r.title = r:CreateFontString(nil, "OVERLAY", "GameFontNormal")
        r.title:SetFont(FONT_BODY, 12, "")
        r.title:SetPoint("TOPLEFT", 92, -4)
        r.title:SetPoint("TOPRIGHT", -10, -4)
        r.title:SetJustifyH("LEFT")
        r.title:SetTextColor(c(C.textPrim))

        r.customInput = CreateTextInput(r,
            function()
                local e = r._entry
                return (e and e.customText) or ""
            end,
            function(v)
                local id = r._spellId
                if not id then return end
                if not NSE.db.onYou.spells[id] then
                    NSE.db.onYou.spells[id] = { enabled = false, customText = "" }
                end
                NSE.db.onYou.spells[id].customText = v
                r._entry = NSE.db.onYou.spells[id]
            end,
            128)
        r.customInput:ClearAllPoints()
        r.customInput:SetPoint("TOPLEFT", 92, -24)
        r.customInput:SetPoint("TOPRIGHT", -10, -24)
        r.customInput:SetHeight(20)

        rowPool[#rowPool + 1] = r
        return r
    end

    local function hideAllPooled()
        for _, r in ipairs(rowPool) do r:Hide() end
        for _, h in ipairs(headerPool) do h:Hide() end
    end

    local QUESTION_ICON = "Interface\\ICONS\\INV_Misc_QuestionMark"

    rebuildSpellList = function()
        hideAllPooled()

        -- Lazily build the tier dropdown + filter toggle the first time DBM
        -- AddOns is populated.
        ensureControls()

        local bosses
        if NSE.OnYou and NSE.OnYou.EnumerateTier and currentTierAddonId then
            bosses = NSE.OnYou:EnumerateTier(currentTierAddonId)
        end

        local localY = 0

        if NSE.OnYou and NSE.OnYou._dbmMissing then
            local h = acquireHeader()
            h:ClearAllPoints()
            h:SetPoint("TOPLEFT",  0, -localY)
            h:SetPoint("TOPRIGHT", 0, -localY)
            h.label:SetText("(DBM not detected)")
            h.label:SetTextColor(c(C.textMuted))
            h:Show()
            localY = localY + 28
        elseif not currentTierAddonId then
            local h = acquireHeader()
            h:ClearAllPoints()
            h:SetPoint("TOPLEFT",  0, -localY)
            h:SetPoint("TOPRIGHT", 0, -localY)
            h.label:SetText("(no DBM raid modules detected)")
            h.label:SetTextColor(c(C.textMuted))
            h:Show()
            localY = localY + 28
        elseif not bosses or #bosses == 0 then
            local h = acquireHeader()
            h:ClearAllPoints()
            h:SetPoint("TOPLEFT",  0, -localY)
            h:SetPoint("TOPRIGHT", 0, -localY)
            h.label:SetText("(no bosses in this module)")
            h.label:SetTextColor(c(C.textMuted))
            h:Show()
            localY = localY + 28
        else
            local userSpells = NSE.db.onYou.spells or {}
            for _, boss in ipairs(bosses) do
                -- Apply targetable filter.
                local visible = {}
                for _, w in ipairs(boss.warnings) do
                    if (not targetableState.only) or (NSE.OnYou and NSE.OnYou:IsWarningTargetable(w)) then
                        visible[#visible + 1] = w
                    end
                end
                if #visible > 0 then
                    table.sort(visible, function(a, b)
                        if (a.kind or "") == (b.kind or "") then
                            return (a.spellId or 0) < (b.spellId or 0)
                        end
                        return (a.kind or "") < (b.kind or "")
                    end)

                    local h = acquireHeader()
                    h:ClearAllPoints()
                    h:SetPoint("TOPLEFT",  0, -localY)
                    h:SetPoint("TOPRIGHT", 0, -localY)
                    h.label:SetText(string.upper(boss.name))
                    h.label:SetTextColor(c(C.accent))
                    h:Show()
                    localY = localY + 26

                    for _, w in ipairs(visible) do
                        local r = acquireRow()
                        r:ClearAllPoints()
                        r:SetPoint("TOPLEFT",  0, -localY)
                        r:SetPoint("TOPRIGHT", 0, -localY)

                        r._spellId = w.spellId
                        r._entry = userSpells[w.spellId]
                        if r.toggle.Refresh then r.toggle:Refresh() end

                        local tex = (C_Spell and C_Spell.GetSpellTexture and C_Spell.GetSpellTexture(w.spellId)) or QUESTION_ICON
                        r.icon:SetTexture(tex)

                        local info = C_Spell and C_Spell.GetSpellInfo and C_Spell.GetSpellInfo(w.spellId)
                        local spellName = info and info.name
                        local title = spellName
                            and string.format("%s  |cff888888(#%d)|r", spellName, w.spellId)
                            or string.format("Spell #%d", w.spellId)
                        if w.text and w.text ~= "" then
                            title = title .. "  |cff666666" .. w.text .. "|r"
                        end
                        local kindLabel = (w.kind == "specwarn") and " |cff9060c0[SPECIAL]|r" or " |cff607090[ANNOUNCE]|r"
                        r.title:SetText(title .. kindLabel)

                        r.customInput:SetText((r._entry and r._entry.customText) or "")
                        r:Show()

                        localY = localY + 52
                    end
                    localY = localY + 4
                end
            end

            if localY == 0 then
                local h = acquireHeader()
                h:ClearAllPoints()
                h:SetPoint("TOPLEFT",  0, -localY)
                h:SetPoint("TOPRIGHT", 0, -localY)
                h.label:SetText("(no targetable warnings -- toggle 'Targetable only' off to see everything)")
                h.label:SetTextColor(c(C.textMuted))
                h:Show()
                localY = localY + 28
            end
        end

        local listHeight = math.max(10, localY)
        spellListFrame:SetHeight(listHeight)
        spellSection:SetHeight(staticPreludeCursor + listHeight + 48 - 36)
        content:SetHeight(yBeforeSpellSection + spellSection:GetHeight() + 30)
    end

    placeSection(spellSection)

    -- Refresh on tab show so the list reflects whatever DBM has loaded.
    panel:HookScript("OnShow", function() rebuildSpellList() end)

    rebuildSpellList()
end

function M:Init()
    BuildMain()
    BuildPastRemindersTab(tabPanels[1])
    BuildOnDeckTab(tabPanels[2])
    BuildVoiceTab(tabPanels[3])
    BuildOnYouTab(tabPanels[4])
    SelectTab(1)
end

function M:Show()
    if mainFrame then mainFrame:Show() end
end

function M:Hide()
    if mainFrame then mainFrame:Hide() end
end

function M:Toggle()
    if not mainFrame then return end
    if mainFrame:IsShown() then mainFrame:Hide() else mainFrame:Show() end
end