EngraveHelper.lua

-- EngraveHelper - one-click weapon engraving, totem-bar style.
-- Built for Project Ascension (WotLK 3.3.5 client, Interface 30300).
--
-- TWO SLOTS on screen: Main Hand and Off Hand. Each slot is configured with
-- a WEAPON (side arrow) and an ENGRAVE (top arrow). The slot icon shows the
-- weapon with the engrave in the corner.
--   Left-click a slot   -> engraves that slot's weapon with its engrave in
--                          that one click, then puts both weapons back in
--                          their configured hands automatically.
--   Top arrow / right-click -> pick the engrave (picking also casts it).
--   Side arrow          -> pick which weapon lives in that hand.
--   Shift+drag          -> move. Right-click a top arrow -> options.
--
-- Because the desired end state is CONFIGURED (not guessed), any interrupted
-- run self-heals: clicking a slot always converges to "MH weapon in main
-- hand, OH weapon in off-hand, both engraved".
--
-- The addon LEARNS which enchant each engraving spell applies (from the item
-- link after each cast), so slot tooltips show what is currently on each
-- weapon.
--
-- /engrave or /eh opens the setup window. /eh log = event log.

local COLOR = "|cff00ccff"
local TAG = COLOR .. "Engraving Helper|r: "

-- db.spell / db.ohSpell = engrave per hand (nil = none)
-- db.putBack            = persistent list of weapons the addon set aside,
--                         { name, slot }, so they ALWAYS come back
local db
local panel, statusText, castButton, putBackBtn
local slotUI = {}          -- panel slot blocks
local widget               -- floating slots: .slots{mh,oh} .status
local spellFlyout, weaponFlyout
local logFrame, logScroll, logEdit
local logLines = {}
local refreshQueued = false

-- forward declarations
local RefreshSlots, UpdateCastButton, SetStatus, OpenSpellFlyout, OpenWeaponFlyout
local Log, SetSpell, ResetRun, DumpState, ToggleLog, InitOptionsMenu, CreateLogFrame
local Pump, QueuePump, TogglePanel, SetSlotArmed, ClearArmed

---------------------------------------------------------------------------
-- Simple timer queue (3.3.5 has no C_Timer)
---------------------------------------------------------------------------
local timerFrame = CreateFrame("Frame")
local timers = {}
timerFrame:Hide()
timerFrame:SetScript("OnUpdate", function(self, elapsed)
    for i = #timers, 1, -1 do
        local t = timers[i]
        t.left = t.left - elapsed
        if t.left <= 0 then
            table.remove(timers, i)
            t.fn()
        end
    end
    if #timers == 0 then self:Hide() end
end)
local function After(delay, fn)
    timers[#timers + 1] = { left = delay, fn = fn }
    timerFrame:Show()
end

---------------------------------------------------------------------------
-- Event log
---------------------------------------------------------------------------
local MAX_LOG = 400
local function RefreshLogEdit()
    if not logEdit then return end
    logEdit:SetText(table.concat(logLines, "\n"))
    logEdit:SetCursorPosition(logEdit:GetNumLetters())
end
Log = function(fmt, ...)
    local msg = (select("#", ...) > 0) and fmt:format(...) or fmt
    logLines[#logLines + 1] = date("%H:%M:%S") .. "  " .. msg
    if #logLines > MAX_LOG then table.remove(logLines, 1) end
    if logFrame and logFrame:IsShown() then RefreshLogEdit() end
end

---------------------------------------------------------------------------
-- Inventory helpers - ALWAYS live reads, never cached
---------------------------------------------------------------------------
local WEAPON_EQUIP_LOCS = {
    INVTYPE_WEAPON = true, INVTYPE_2HWEAPON = true,
    INVTYPE_WEAPONMAINHAND = true, INVTYPE_WEAPONOFFHAND = true,
    INVTYPE_RANGED = true, INVTYPE_RANGEDRIGHT = true, INVTYPE_THROWN = true,
}

local function EquippedName(slot)
    local link = GetInventoryItemLink("player", slot)
    if not link then return nil end
    return (GetItemInfo(link))
end

local function IsWeaponLink(link)
    if not link then return false end
    local name, _, _, _, _, _, _, _, equipLoc = GetItemInfo(link)
    if name and WEAPON_EQUIP_LOCS[equipLoc] then return true, name end
    return false, name
end

local function FindInBagsByName(name)
    if not name then return nil end
    for bag = 0, 4 do
        for slot = 1, (GetContainerNumSlots(bag) or 0) do
            local link = GetContainerItemLink(bag, slot)
            if link and (GetItemInfo(link)) == name then
                return bag, slot
            end
        end
    end
    return nil
end

local function FindFreeBagSlot()
    for bag = 0, 4 do
        local free, family = GetContainerNumFreeSlots(bag)
        if free and free > 0 and (not family or family == 0) then
            for slot = 1, (GetContainerNumSlots(bag) or 0) do
                if not GetContainerItemLink(bag, slot) then
                    return bag, slot
                end
            end
        end
    end
    return nil
end

local function BagItemLocked(bag, slot)
    local _, _, locked = GetContainerItemInfo(bag, slot)
    return locked
end

local function WeaponExists(name)
    if not name then return false end
    if EquippedName(16) == name or EquippedName(17) == name then return true end
    return FindInBagsByName(name) ~= nil
end

local function FindWeaponLink(name)
    if not name then return nil end
    if EquippedName(16) == name then return GetInventoryItemLink("player", 16) end
    if EquippedName(17) == name then return GetInventoryItemLink("player", 17) end
    local bag, slot = FindInBagsByName(name)
    if bag then return GetContainerItemLink(bag, slot) end
    return nil
end

local function ScanEngraveSpells()
    local found, seen = {}, {}
    local i = 1
    while true do
        local name = GetSpellName(i, "spell")
        if not name then break end
        if not seen[name] and name:lower():find("engrav") then
            seen[name] = true
            found[#found + 1] = name
        end
        i = i + 1
    end
    table.sort(found)
    return found
end

-- spellbook index for a spell name (last match = highest rank), so the picker
-- can show the real spell tooltip
local function FindSpellBookIndex(name)
    local found
    local i = 1
    while true do
        local n = GetSpellName(i, "spell")
        if not n then break end
        if n == name then found = i end
        i = i + 1
    end
    return found
end

-- Weapon Engraving is a Runemaster mechanic: the addon stays DORMANT on
-- characters that are not Runemasters and know no engraving spells
local gDormant = false
local function IsEngraver()
    local locClass, tokClass = UnitClass("player")
    if (locClass and locClass:lower():find("runemaster", 1, true))
        or (tokClass and tostring(tokClass):lower():find("runemaster", 1, true)) then
        return true
    end
    return #ScanEngraveSpells() > 0
end

-- cached scan for the frequently-refreshed displays (tooltip reads etc.)
local engraveSpellCache, engraveSpellCacheAt
local function ScanEngraveSpellsCached()
    if not engraveSpellCacheAt or GetTime() - engraveSpellCacheAt > 5 then
        engraveSpellCache = ScanEngraveSpells()
        engraveSpellCacheAt = GetTime()
    end
    return engraveSpellCache
end

-- unique weapon names across hands and bags (for the weapon picker)
local function ScanWeaponNames()
    local list, seen = {}, {}
    local function add(link)
        local isW, name = IsWeaponLink(link)
        if isW and not seen[name] then
            seen[name] = true
            list[#list + 1] = name
        end
    end
    add(GetInventoryItemLink("player", 16))
    add(GetInventoryItemLink("player", 17))
    for bag = 0, 4 do
        for slot = 1, (GetContainerNumSlots(bag) or 0) do
            add(GetContainerItemLink(bag, slot))
        end
    end
    return list
end

-- Short display name: "Weapon Engraving: Fire" -> "Fire"
local function ShortSpell(name)
    if not name then return "none" end
    local short = name:match(":%s*(.+)$")
    return short or name
end

local function SlotSpell(which)
    if which == "oh" then return db.ohSpell end
    return db.spell
end

-- the slot always mirrors whatever weapon is CURRENTLY equipped in that hand
local function SlotWeapon(which)
    local isW, name = IsWeaponLink(GetInventoryItemLink("player", (which == "oh") and 17 or 16))
    return isW and name or nil
end

local function SlotSpellText(which)
    local s = SlotSpell(which)
    return s and ShortSpell(s) or "(none)"
end

-- Engraves are TEMPORARY weapon enchants (imbue-style): they never appear in
-- the item link, only as a line on the weapon's tooltip. So we read the
-- tooltip with a hidden scanner to see what is currently on a weapon.
local scanTip = CreateFrame("GameTooltip", "EngraveHelperScanTip", nil, "GameTooltipTemplate")
scanTip:SetOwner(WorldFrame, "ANCHOR_NONE")

local function TipEngraveLine()
    for i = 2, scanTip:NumLines() do
        local fs = _G["EngraveHelperScanTipTextLeft" .. i]
        local text = fs and fs:GetText()
        if text then
            if text:lower():find("engrav") then
                -- strip a trailing "(28 min)" style duration
                return (text:gsub("%s*%(.-%)%s*$", ""))
            end
            for _, spell in ipairs(ScanEngraveSpellsCached()) do
                local short = ShortSpell(spell)
                if short and short ~= "" and text:find(short, 1, true) and text:find("%(") then
                    return short
                end
            end
        end
    end
    return nil
end

-- what engraving is CURRENTLY on this weapon (tooltip scan)
local function CurrentEngraveText(weaponName)
    if not weaponName then return "none" end
    scanTip:SetOwner(WorldFrame, "ANCHOR_NONE")
    scanTip:ClearLines()
    if EquippedName(16) == weaponName then
        scanTip:SetInventoryItem("player", 16)
    elseif EquippedName(17) == weaponName then
        scanTip:SetInventoryItem("player", 17)
    else
        local bag, slot = FindInBagsByName(weaponName)
        if not bag then return "weapon not found" end
        scanTip:SetBagItem(bag, slot)
    end
    return TipEngraveLine() or "none"
end

-- compact display of a weapon's current engrave: "Fire", or nil if none
local function CurrentEngraveShort(weaponName)
    local cur = CurrentEngraveText(weaponName)
    if not cur or cur == "none" or cur == "weapon not found" then return nil end
    local disp = cur:gsub("[Ee]ngraving", ""):gsub("^[%s:%-]+", ""):gsub("[%s:%-]+$", "")
    if disp == "" then disp = cur end
    return disp
end

-- the engraving SPELL currently on this weapon (matched from the tooltip
-- line against the known engrave spells), or nil if the weapon is bare
local function CurrentEngraveSpell(weaponName)
    local short = CurrentEngraveShort(weaponName)
    if not short then return nil end
    for _, spell in ipairs(ScanEngraveSpellsCached()) do
        local s = ShortSpell(spell)
        if s and s ~= "" and (s == short or short:find(s, 1, true)) then
            return spell
        end
    end
    return nil
end

local EMPTY_SLOT_TEX = "Interface\\Buttons\\UI-EmptySlot-Disabled"

-- default border colors per engrave (user-overridable via db.engraveColors)
local DEFAULT_ENGRAVE_COLORS = {
    Fire = { 1, 0.25, 0.15 },
    Ice = { 0.35, 0.65, 1 },
    Earth = { 0.35, 0.9, 0.35 },
    Air = { 0.92, 0.95, 1 },
    Water = { 0.25, 0.55, 0.95 },
    Arcane = { 0.75, 0.35, 0.95 },
}

local function GetEngraveColor(short)
    if db.engraveColors and db.engraveColors[short] then
        return db.engraveColors[short]
    end
    return DEFAULT_ENGRAVE_COLORS[short] or { 0.8, 0.8, 0.8 }
end

local function WeaponTexture(name)
    if not name then return nil end
    local tex = select(10, GetItemInfo(name))
    return tex
end

---------------------------------------------------------------------------
-- Engrave run engine (config + reality driven)
-- The END STATE is always the CONFIG: MH weapon in slot 16, OH weapon in
-- slot 17. Every step is decided from live inventory reads.
---------------------------------------------------------------------------
local run = {
    active = false,      -- engrave phase running
    restoring = false,   -- putting weapons back
    targets = {},        -- { { name, spell, engraved } }
    gen = 0,
    fails = 0,
    pumpQueued = false,
    mustSwap = false,
    lastMoveAt = 0,
    awaiting = nil,      -- target whose cast is in flight (guards double casts)
    awaitAt = 0,
}

local function FirstPending()
    for _, t in ipairs(run.targets) do
        if not t.engraved then return t end
    end
    return nil
end

local function CountEngraved()
    local n = 0
    for _, t in ipairs(run.targets) do
        if t.engraved then n = n + 1 end
    end
    return n
end

-- quiet = true keeps the message off chat (minor progress chatter)
SetStatus = function(text, quiet)
    if statusText then statusText:SetText(text or "") end
    if not quiet and text and text ~= "" and (not panel or not panel:IsShown()) then
        print(TAG .. text)
    end
end

local function SetWidgetStatus(text)
    if widget then widget.status:SetText(text or "") end
end

UpdateCastButton = function()
    local busy = (run.active or run.restoring) and #run.targets > 0
    if castButton then
        if busy then
            castButton:SetText(("Engrave (%d/%d)"):format(CountEngraved(), #run.targets))
        else
            castButton:SetText("Engrave Both")
        end
    end
    -- panel Engrave buttons follow the same two-click flow as the slots;
    -- while weapons are moving the buttons lock so they can't be mashed.
    -- pickS is a SECURE button: Enable/Disable on it is protected in combat,
    -- so state toggles wait for combat end (PLAYER_REGEN_ENABLED re-syncs)
    do
        local pending = (run.active and not run.restoring) and FirstPending() or nil
        local busyRun = run.active or run.restoring
        local canToggle = not InCombatLockdown()
        for which, ui in pairs(slotUI) do
            if ui.pickS then
                if pending and pending.slot == ((which == "oh") and 17 or 16) then
                    ui.pickS:SetText("|cffff3333Engrave now!|r")
                    if canToggle then ui.pickS:Enable() end
                elseif busyRun then
                    ui.pickS:SetText(run.restoring and "|cffffd700re-equipping...|r" or "|cffffd700working...|r")
                    if canToggle then ui.pickS:Disable() end
                else
                    ui.pickS:SetText("Engrave: " .. SlotSpellText(which))
                    if canToggle then ui.pickS:Enable() end
                end
            end
            if ui.pickW then
                if busyRun then
                    ui.pickW:Disable()
                else
                    ui.pickW:Enable()
                end
            end
        end
    end
    if widget then
        -- the slot icon shows the engraving CURRENTLY on that hand's weapon
        -- (empty slot = no engrave -> pick one); the weapon is the corner
        -- icon. While a pick awaits its confirming click, the slot shows the
        -- PICKED engrave desaturated and pulsing.
        local pending = run.active and FirstPending() or nil
        -- weapon icon art carries a much thicker baked-in frame than spell
        -- icons, so each type gets its own user-tunable crop
        local iconCrop = (db.ui.iconCrop or 2) / 100
        local weapCrop = (db.ui.weaponCrop or 8) / 100
        local function SetCrop(tex, cr)
            tex:SetTexCoord(cr, 1 - cr, cr, 1 - cr)
        end
        for which, slot in pairs(widget.slots) do
            local slotId = (which == "oh") and 17 or 16
            if pending and pending.slot == slotId then
                local stex = GetSpellTexture(pending.spell)
                slot.icon:SetTexture(stex or slot.emptyTex)
                SetCrop(slot.icon, iconCrop)
                slot.icon:SetDesaturated(true)
                if slot.pulse and not slot.pulse:IsPlaying() then
                    slot.pulse:Play()
                end
            elseif not (run.active or run.restoring) then
                local weapon = SlotWeapon(which)
                local curSpell = CurrentEngraveSpell(weapon)
                local engraveTex = curSpell and GetSpellTexture(curSpell)
                local weapTex = WeaponTexture(weapon)
                -- big icon = engrave or weapon (user choice); the other one
                -- is the corner mini icon
                local bigTex, cornerTex, bigCrop, cornerCrop
                if (db.ui.iconMode or "engrave") == "weapon" then
                    bigTex, cornerTex = weapTex, engraveTex
                    bigCrop, cornerCrop = weapCrop, iconCrop
                else
                    bigTex, cornerTex = engraveTex, weapTex
                    bigCrop, cornerCrop = iconCrop, weapCrop
                end
                slot.icon:SetTexture(bigTex or slot.emptyTex)
                SetCrop(slot.icon, bigTex and bigCrop or iconCrop)
                slot.icon:SetDesaturated(false)
                if slot.pulse then
                    slot.pulse:Stop()
                end
                if cornerTex and db.ui.showWeapon ~= false then
                    slot.cornerIcon:SetTexture(cornerTex)
                    SetCrop(slot.cornerIcon, cornerCrop)
                    slot.cornerIcon:Show()
                    slot.cornerBorder:Show()
                else
                    slot.cornerIcon:Hide()
                    slot.cornerBorder:Hide()
                end
                -- engrave-colored border
                if db.ui.borderOn ~= false and curSpell then
                    local col = GetEngraveColor(ShortSpell(curSpell))
                    slot.engraveBorder:SetVertexColor(col[1], col[2], col[3], 1)
                    slot.engraveBorder:Show()
                else
                    slot.engraveBorder:Hide()
                end
            end
        end
        if busy then
            if run.restoring then
                SetWidgetStatus("|cffffd700re-equipping...|r")
            else
                SetWidgetStatus("|cffffd700engraving...|r")
            end
        else
            SetWidgetStatus("")
        end
    end
end

ResetRun = function(silent)
    run.active = false
    run.restoring = false
    run.gen = run.gen + 1
    run.pumpQueued = false
    run.fails = 0
    run.mustSwap = false
    run.awaiting = nil
    wipe(run.targets)
    if putBackBtn then putBackBtn:Disable() end
    if ClearArmed then ClearArmed() end
    UpdateCastButton()
    if not silent then
        Log("Run reset by user.")
        SetStatus("Run cancelled.")
    end
end

-- which = "mh"/"oh"; value = spell name or "NONE"
SetSpell = function(which, value)
    local spell = (value ~= "NONE") and value or nil
    if which == "oh" then
        db.ohSpell = spell
    else
        db.spell = spell
    end
    Log("%s engrave set to '%s'.", which == "oh" and "Off-hand" or "Main-hand", tostring(spell))
    RefreshSlots()
    UpdateCastButton()
end

DumpState = function(reason)
    Log("---- Current state (%s) ----", reason or "now")
    Log("  Main hand now: %s", tostring(EquippedName(16)))
    Log("  Off hand now: %s", tostring(EquippedName(17)))
    if db.putBack then
        for _, pb in ipairs(db.putBack) do
            Log("  Set aside (to put back): '%s' -> slot %d", tostring(pb.name), pb.slot or -1)
        end
    end
    for i, t in ipairs(run.targets) do
        Log("  Target %d: %s with '%s' - %s", i, t.name, tostring(t.spell),
            t.engraved and "engraved" or "NOT engraved")
    end
    Log("--------------------------------")
end

local function PrepareRun()
    run.gen = run.gen + 1
    run.fails = 0
    run.pumpQueued = false
    run.mustSwap = false
    run.awaiting = nil
    run.lastMoveAt = 0
    run.cdLogged = nil
    run.lastWaitWhy = nil
    run.combatLogged = nil
    wipe(run.targets)
end

-- Remember which weapon the addon set aside so it ALWAYS comes back - kept
-- in saved variables, so it survives interrupted runs and even reloads.
local function PushPutBack(name, slot)
    if not name then return end
    db.putBack = db.putBack or {}
    for i = #db.putBack, 1, -1 do
        if db.putBack[i].name == name then
            table.remove(db.putBack, i)
        end
    end
    db.putBack[#db.putBack + 1] = { name = name, slot = slot }
end

-- The engrave target for a hand: the weapon equipped there right now - or,
-- if an interrupted run left it in a bag, the weapon we set aside for it.
local function TargetForHand(which)
    local slotId = (which == "oh") and 17 or 16
    local isW, name = IsWeaponLink(GetInventoryItemLink("player", slotId))
    if isW then return name end
    if db.putBack then
        for _, pb in ipairs(db.putBack) do
            if pb.slot == slotId and WeaponExists(pb.name) then
                return pb.name
            end
        end
    end
    return nil
end

-- One hand (used by the slot buttons and the flyout picks)
local function BuildRunFor(which, spell)
    PrepareRun()
    local name = TargetForHand(which)
    if spell and name then
        run.targets[1] = { name = name, spell = spell, slot = (which == "oh") and 17 or 16, engraved = false }
    end
    Log("=== New run (%s): '%s' with '%s' ===",
        which == "oh" and "off hand" or "main hand", tostring(name), tostring(spell))
    if name then
        Log("  Current engrave on '%s': %s.", name, CurrentEngraveText(name))
    end
end

-- Both hands (used by the setup window's "Engrave Both" button)
local function BuildRunBoth()
    PrepareRun()
    local mhName = TargetForHand("mh")
    local ohName = TargetForHand("oh")
    if db.spell and mhName then
        run.targets[#run.targets + 1] = { name = mhName, spell = db.spell, slot = 16, engraved = false }
    end
    if db.ohSpell and ohName then
        run.targets[#run.targets + 1] = { name = ohName, spell = db.ohSpell, slot = 17, engraved = false }
    end
    Log("=== New run (both hands): %d weapon%s ===", #run.targets, #run.targets == 1 and "" or "s")
    for i, t in ipairs(run.targets) do
        Log("  %d. %s with '%s' (currently: %s)", i, t.name, tostring(t.spell), CurrentEngraveText(t.name))
    end
end

-- Decide the next step purely from the CURRENT inventory.
local function ComputeAction()
    if run.active then
        local pending = FirstPending()
        if pending then
            -- the engrave lands on the ONLY equipped weapon (in either hand),
            -- as long as the cast comes AFTER the other hand's unequip has
            -- settled - so the target stays in ITS OWN slot
            local tSlot = pending.slot or 16
            local oSlot = (tSlot == 16) and 17 or 16
            if IsWeaponLink(GetInventoryItemLink("player", oSlot)) then
                return { type = "stash", slot = oSlot }
            end
            if EquippedName(tSlot) == pending.name then
                -- duplicate-name support: after engraving one copy, a fresh
                -- copy must be swapped in before casting again
                if run.mustSwap and FindInBagsByName(pending.name) then
                    return { type = "equip", name = pending.name, slot = tSlot }
                end
                return { type = "cast", target = pending }
            end
            -- bag recovery: bring the target back into its own hand
            return { type = "equip", name = pending.name, slot = tSlot }
        end
        run.active = false
        run.restoring = true
        Log("Engraving done - putting your weapons back (per slot config).")
    end
    if run.restoring then
        -- put back every weapon the addon set aside (persistent list)
        local list = db.putBack
        if list then
            for i = #list, 1, -1 do
                local pb = list[i]
                if not pb.name or not WeaponExists(pb.name) then
                    if pb.name then
                        Log("Cannot find '%s' anymore - dropping it from the put-back list.", pb.name)
                    end
                    table.remove(list, i)
                elseif EquippedName(pb.slot) == pb.name then
                    -- stale-read guard: shortly after a move an item can show
                    -- up BOTH equipped and in a bag; only trust the read once
                    -- it is coherent
                    if GetTime() - run.lastMoveAt >= 3 or not FindInBagsByName(pb.name) then
                        table.remove(list, i)
                    else
                        return { type = "verify" }
                    end
                else
                    return { type = "equip", name = pb.name, slot = pb.slot }
                end
            end
        end
        return { type = "done" }
    end
    return { type = "idle" }
end

-- Perform one move. Returns "moved", "wait" (item locked etc. - retry soon)
-- or "fail" plus a human-readable reason.
local function DoMove(act)
    if act.type == "stash" then
        local fromSlot = act.slot or 17
        local name = EquippedName(fromSlot)
        if IsInventoryItemLocked(fromSlot) then
            return "wait", "the weapon is busy (item locked) - waiting"
        end
        local bag, slot = FindFreeBagSlot()
        if not bag then
            return "fail", "no free bag slot - free up bag space and click again"
        end
        ClearCursor()
        PickupInventoryItem(fromSlot)
        if not CursorHasItem() then
            return "wait", "could not pick the weapon up yet - waiting"
        end
        PickupContainerItem(bag, slot)
        if CursorHasItem() then
            PickupInventoryItem(fromSlot)
            ClearCursor()
            return "fail", "the weapon would not go into the bag"
        end
        PushPutBack(name, fromSlot)
        Log("Set '%s' (slot %d) aside to bag %d slot %d.", tostring(name), fromSlot, bag, slot)
        return "moved"

    elseif act.type == "equip" then
        local slotName = (act.slot == 16) and "main hand" or "off hand"
        local bag, slot = FindInBagsByName(act.name)
        if bag then
            if BagItemLocked(bag, slot) then
                return "wait", ("'%s' is busy (enchant still applying) - waiting"):format(act.name)
            end
            if GetInventoryItemLink("player", act.slot) and IsInventoryItemLocked(act.slot) then
                return "wait", "the equipped weapon is busy (item locked) - waiting"
            end
            ClearCursor()
            PickupContainerItem(bag, slot)
            if not CursorHasItem() then
                return "wait", ("could not pick '%s' up yet - waiting"):format(act.name)
            end
            PickupInventoryItem(act.slot)
            if CursorHasItem() then
                PickupContainerItem(bag, slot)
                ClearCursor()
                return "fail", ("'%s' would not equip into the %s"):format(act.name, slotName)
            end
            if act.slot == 16 then run.mustSwap = false end
            Log("Equipped '%s' into the %s (was at bag %d slot %d).", act.name, slotName, bag, slot)
            return "moved"
        end
        local other = (act.slot == 16) and 17 or 16
        if EquippedName(other) == act.name then
            if IsInventoryItemLocked(other) or (GetInventoryItemLink("player", act.slot) and IsInventoryItemLocked(act.slot)) then
                return "wait", "weapons are busy (item locked) - waiting"
            end
            ClearCursor()
            PickupInventoryItem(other)
            if not CursorHasItem() then
                return "wait", "could not pick the weapon up yet - waiting"
            end
            PickupInventoryItem(act.slot)
            if CursorHasItem() then
                PickupInventoryItem(other)
                ClearCursor()
            end
            if act.slot == 16 then run.mustSwap = false end
            if run.active and act.slot == 16 and other == 17 then
                -- pulled the target out of the off-hand for its cast: it
                -- belongs back there afterwards
                PushPutBack(act.name, 17)
            end
            Log("Swapped hands to bring '%s' to the %s.", act.name, slotName)
            return "moved"
        end
        return "fail", ("cannot find '%s' in your bags or hands"):format(act.name)
    end
    return "fail", "unknown step"
end

QueuePump = function(delay)
    if run.pumpQueued then return end
    run.pumpQueued = true
    local gen = run.gen
    After(delay or 0.7, function()
        run.pumpQueued = false
        if gen == run.gen then Pump() end
    end)
end

-- The pump advances the run automatically: it performs the next MOVE whenever
-- one is possible (casts always need your click). It re-reads reality every
-- tick, waits out item locks, and stops loudly on real failures.
Pump = function()
    if not (run.active or run.restoring) then return end
    if InCombatLockdown() then
        if not run.combatLogged then
            run.combatLogged = true
            Log("In combat - the engine waits until combat ends.")
        end
        QueuePump(1.5)
        return
    end
    run.combatLogged = nil
    -- let the server catch up after a move/cast before trusting any reads
    if GetTime() - run.lastMoveAt < 0.55 then
        QueuePump(0.3)
        return
    end
    local act = ComputeAction()
    if act.type == "verify" then
        QueuePump(0.35)
        return
    end
    if act.type == "done" then
        run.restoring = false
        ClearArmed()
        Log("Restore complete - main hand '%s', off hand '%s'.",
            tostring(EquippedName(16)), tostring(EquippedName(17)))
        SetStatus("Done! Weapons engraved and re-equipped.")
        if putBackBtn then putBackBtn:Disable() end
        UpdateCastButton()
        SetWidgetStatus("|cff00ff00Done!|r")
        local gen = run.gen
        After(3, function()
            if gen == run.gen and not (run.active or run.restoring) then
                SetWidgetStatus("")
            end
        end)
        return
    elseif act.type == "cast" then
        UpdateCastButton()
        local start = GetSpellCooldown(act.target.spell)
        if start and start ~= 0 then
            if not run.cdLogged then
                run.cdLogged = true
                Log("Engrave spell not ready yet (GetSpellCooldown start=%s) - waiting.", tostring(start))
            end
            SetStatus("Waiting for the engrave spell to be ready...", true)
            QueuePump(0.4)
        else
            local whichSlot = (act.target.slot == 17) and "oh" or "mh"
            local slotW = widget and widget.slots[whichSlot]
            if slotW and slotW.castBtn and not slotW.castBtn:IsShown() then
                Log("Red Engrave button shown for '%s' - waiting for the click.", act.target.name)
            end
            SetSlotArmed(whichSlot, act.target)
            SetStatus(("Ready - click the red Engrave button to engrave %s."):format(act.target.name), true)
            SetWidgetStatus("|cffff4040click Engrave!|r")
        end
        return
    elseif act.type == "idle" then
        return
    end
    local result, why = DoMove(act)
    if result == "moved" then
        run.fails = 0
        run.lastMoveAt = GetTime()
        QueuePump(0.6)
    elseif result == "wait" then
        if why and why ~= run.lastWaitWhy then
            run.lastWaitWhy = why
            Log("Waiting: %s.", why)
        end
        if why then
            SetStatus(why .. "...", true)
            if why:find("bag slot") then
                SetWidgetStatus("|cffff5555bags full!|r")
            end
        end
        QueuePump(0.35)
    else
        run.fails = run.fails + 1
        if why and why:find("bag slot") then
            run.fails = 5 -- bags full: stop immediately, the user must free space
            SetWidgetStatus("|cffff5555bags full!|r")
        end
        Log("STEP FAILED (%d/5): %s.", run.fails, why or "?")
        if run.fails >= 5 then
            run.active = false
            run.restoring = false
            DumpState("stopped after repeated failures")
            SetStatus("Stopped: " .. (why or "problem")
                .. ". See the Event Log (/eh log), fix your bags, then use 'Put Weapons Back' in /eh.")
            if putBackBtn then putBackBtn:Enable() end
        else
            QueuePump(1.2)
        end
    end
    UpdateCastButton()
end

---------------------------------------------------------------------------
-- Cast-click helper for the setup window's "Engrave Both" button.
---------------------------------------------------------------------------
local function ArmCast(self)
    -- a cast may NEVER share a click with an item move (the engrave then
    -- races the move and can land on the wrong weapon - field-verified), and
    -- must come at least half a second after the last move
    local act = ComputeAction()
    if act.type == "cast" and GetTime() - run.lastMoveAt >= 0.5 then
        if run.awaiting == act.target and GetTime() - run.awaitAt < 2 then
            self:SetAttribute("spell", nil)
            return false
        end
        self:SetAttribute("spell", act.target.spell)
        run.awaiting = act.target
        run.awaitAt = GetTime()
        Log("Casting '%s' on '%s' (%d/%d).",
            tostring(act.target.spell), tostring(act.target.name), CountEngraved() + 1, #run.targets)
        SetStatus(("Engraving %s (%d/%d)..."):format(
            act.target.name, CountEngraved() + 1, #run.targets), true)
        return true
    end
    -- not ready: advance one prep step instead, next click casts
    if act.type == "stash" or act.type == "equip" then
        DoMove(act)
    end
    self:SetAttribute("spell", nil)
    SetWidgetStatus("|cffffd700swapping...|r")
    QueuePump(0.5)
    return false
end

---------------------------------------------------------------------------
-- Direct, cursor-verified moves used INSIDE a click. The cursor state is
-- client-immediate, but equipment link reads and item locks lag a server
-- round-trip - each item is touched AT MOST ONCE per click, and a cast is
-- NEVER sent in the same event as a move (it races the move server-side and
-- can land on the wrong weapon - field-verified).
---------------------------------------------------------------------------
local function DirectStashSlot(slotId)
    local name = EquippedName(slotId)
    local bag, slot = FindFreeBagSlot()
    if not bag then
        Log("CANNOT set '%s' aside: NO FREE BAG SLOT - free up bag space!", tostring(name))
        SetStatus("No free bag slot - free one up so a weapon can be set aside.")
        SetWidgetStatus("|cffff5555bags full!|r")
        return false
    end
    ClearCursor()
    PickupInventoryItem(slotId)
    if not CursorHasItem() then
        Log("Could not pick up '%s' (slot %d) this click - item busy/locked; the engine will retry.", tostring(name), slotId)
        return false
    end
    PickupContainerItem(bag, slot)
    if CursorHasItem() then
        PickupInventoryItem(slotId)
        ClearCursor()
        return false
    end
    run.lastMoveAt = GetTime()
    PushPutBack(name, slotId)
    Log("Set '%s' (slot %d) aside to bag %d slot %d.", tostring(name), slotId, bag, slot)
    return true
end

local function DirectEquipTo(bag, slot, equipSlot)
    local prevName = EquippedName(equipSlot)
    ClearCursor()
    PickupContainerItem(bag, slot)
    if not CursorHasItem() then
        return false
    end
    PickupInventoryItem(equipSlot)
    if CursorHasItem() then
        -- either the slot refused the item, or it swapped and the previous
        -- occupant is on the cursor: put whatever it is into the bag slot
        PickupContainerItem(bag, slot)
        ClearCursor()
        if prevName then PushPutBack(prevName, equipSlot) end
        run.lastMoveAt = GetTime()
        return false
    end
    run.lastMoveAt = GetTime()
    Log("Equipped weapon from bag %d slot %d into equip slot %d.", bag, slot, equipSlot)
    return true
end


-- Show/hide the red per-slot Engrave button (the explicit SECOND click).
SetSlotArmed = function(which, pending)
    if not widget then return end
    local slot = widget.slots[which]
    if not (slot and slot.castBtn) then return end
    -- OH slot hidden (2H build): the panel button is the confirm click
    if which == "oh" and db.ui.hideOH == true then
        slot.castBtn:Hide()
        return
    end
    if pending and not InCombatLockdown() then
        slot.castBtn:SetAttribute("spell", pending.spell)
        slot.castBtn:Show()
    else
        slot.castBtn:Hide()
    end
end

ClearArmed = function()
    SetSlotArmed("mh", nil)
    SetSlotArmed("oh", nil)
end

-- If a prep went unused, quietly put the weapons back after a moment.
local function RestoreIfIdle(gen)
    if gen == run.gen and run.active and CountEngraved() == 0 and not run.awaiting then
        Log("Prep unused - putting weapons back.")
        ClearArmed()
        run.active = false
        run.restoring = true
        Pump()
    end
end

-- CLICK 1: pick/click a slot = prepare (set the other weapon aside). When
-- the swap has settled, the red Engrave button appears under the slot -
-- CLICK 2 on it casts. Clear, explicit, no holding.
local function StartPrep(which)
    if InCombatLockdown() or run.restoring or run.active then return end
    local spell = SlotSpell(which)
    if not spell then return end
    BuildRunFor(which, spell)
    if #run.targets == 0 then
        ResetRun(true)
        SetStatus(which == "oh" and "No weapon in your off-hand." or "No weapon in your main hand.")
        return
    end
    run.active = true
    if putBackBtn then putBackBtn:Disable() end
    local target = run.targets[1]
    local oSlot = (target.slot == 16) and 17 or 16
    local oLink = GetInventoryItemLink("player", oSlot)
    if IsWeaponLink(oLink) then
        if not FindFreeBagSlot() then
            -- bags full: STOP right away - the user frees space and retries
            Log("STOPPED: no free bag slot to set '%s' aside - free up bag space and try again.", tostring(EquippedName(oSlot)))
            SetStatus("Bags are full - free a bag slot, then click again.")
            ResetRun(true)
            SetWidgetStatus("|cffff5555bags full!|r")
            return
        end
        DirectStashSlot(oSlot)
    elseif oLink then
        local n, _, _, _, _, _, _, _, loc = GetItemInfo(oLink)
        Log("Not setting aside slot %d: '%s' is not a weapon (equipLoc %s) - an engrave cannot land on it, so no switch is needed.",
            oSlot, tostring(n), tostring(loc))
    else
        Log("Other hand (slot %d) is empty - nothing to set aside.", oSlot)
    end
    if widget and widget.slots[which] and widget.slots[which].sweep then
        widget.slots[which].sweep:SetCooldown(GetTime(), 0.7)
    end
    SetStatus(("Preparing %s - click the red Engrave button when it appears."):format(target.name), true)
    SetWidgetStatus("|cffffd700swapping...|r")
    QueuePump(0.6)
    UpdateCastButton()
    local gen = run.gen
    After(10, function()
        RestoreIfIdle(gen)
    end)
end

-- When an engrave is queued and ready, a left-click on the SLOT ITSELF also
-- casts it (same gates as the red button). Returns true if this click was
-- consumed by the cast path.
local function ArmPendingCast(self, which)
    if InCombatLockdown() or not run.active then return false end
    local pending = FirstPending()
    if not pending then return false end
    if pending.slot ~= ((which == "oh") and 17 or 16) then return false end
    if run.awaiting == pending and GetTime() - run.awaitAt < 2 then
        self:SetAttribute("spell", nil)
        return true -- cast already in flight; eat the click
    end
    local act = ComputeAction()
    if act.type == "cast" and act.target == pending
        and GetTime() - run.lastMoveAt >= 0.5
        and not IsInventoryItemLocked(16) then
        self:SetAttribute("spell", pending.spell)
        run.awaiting = pending
        run.awaitAt = GetTime()
        Log("Casting '%s' on '%s' (slot click).", tostring(pending.spell), pending.name)
        SetStatus(("Engraving %s..."):format(pending.name), true)
        SetWidgetStatus("|cffffd700engraving...|r")
        UpdateCastButton()
        return true
    end
    return false
end

-- Slot / flyout-pick click (CLICK 1): never casts, only prepares.
local function SlotPrepClick(which)
    if InCombatLockdown() then
        SetStatus("You are in combat - try again after combat.")
        return
    end
    if run.restoring then
        SetWidgetStatus("|cffffd700re-equipping...|r")
        return
    end
    if run.active then
        if run.awaiting and GetTime() - run.awaitAt < 2 then
            return
        end
        local pending = FirstPending()
        if pending and pending.spell == SlotSpell(which)
            and pending.slot == ((which == "oh") and 17 or 16) then
            -- already preparing this slot: just nudge the engine
            QueuePump(0.1)
            return
        end
        ClearArmed()
        ResetRun(true) -- different/stale run: restart (put-back list persists)
    end
    if not SlotSpell(which) then
        if widget and widget.slots[which] then
            OpenSpellFlyout(which, widget.slots[which])
        end
        return
    end
    StartPrep(which)
end

-- Setup-window "Engrave Both" button: click once per weapon.
local function EngraveBothClick(self)
    if InCombatLockdown() then
        SetStatus("You are in combat - try again after combat.")
        return
    end
    if run.restoring then
        self:SetAttribute("spell", nil)
        Pump()
        return
    end
    if not run.active then
        if not (db.spell or db.ohSpell) then
            self:SetAttribute("spell", nil)
            SetStatus("Assign an engrave to a slot first.")
            return
        end
        BuildRunBoth()
        if #run.targets == 0 then
            self:SetAttribute("spell", nil)
            ResetRun(true)
            SetStatus("Nothing to engrave - set a weapon and engrave for at least one slot.")
            return
        end
        run.active = true
        if putBackBtn then putBackBtn:Disable() end
    end
    ArmCast(self)
    UpdateCastButton()
end

---------------------------------------------------------------------------
-- Flyouts: engrave picker (secure: picking also casts) + weapon picker
---------------------------------------------------------------------------
-- direction the flyouts open / where the picker arrow sits (db.ui.flyoutSide)
local FLY_ANCHORS = {
    top    = { "BOTTOM", "TOP", 0, 8 },
    bottom = { "TOP", "BOTTOM", 0, -8 },
    left   = { "RIGHT", "LEFT", -8, 0 },
    right  = { "LEFT", "RIGHT", 8, 0 },
}

-- Arrow texcoord rotations (8-arg: ULx,ULy, LLx,LLy, URx,URy, LRx,LRy).
-- One table for an UP-pointing base texture (the wrath totem-bar flyout
-- arrow), one for a RIGHT-pointing base (ChatFrameExpandArrow fallback).
local ARROW_COORDS_UPBASE = {
    top    = { 0, 0, 0, 1, 1, 0, 1, 1 },
    right  = { 0, 1, 1, 1, 0, 0, 1, 0 },
    left   = { 1, 0, 0, 0, 1, 1, 0, 1 },
    bottom = { 1, 1, 1, 0, 0, 1, 0, 0 },
}
local ARROW_COORDS_RIGHTBASE = {
    right  = { 0, 0, 0, 1, 1, 0, 1, 1 },
    top    = { 1, 0, 0, 0, 1, 1, 0, 1 },
    bottom = { 0, 1, 1, 1, 0, 0, 1, 0 },
    left   = { 1, 1, 1, 0, 0, 1, 0, 0 },
}

-- totem-bar style: the arrow is a wide flat tab centered on the slot's edge
local ARROW_EDGES = {
    top    = { "BOTTOM", "TOP", 0, -1 },
    bottom = { "TOP", "BOTTOM", 0, 1 },
    left   = { "RIGHT", "LEFT", 1, 0 },
    right  = { "LEFT", "RIGHT", -1, 0 },
}

-- Size and anchor a flyout so its panel ENCOMPASSES the slot icon (top /
-- bottom sides), with the button column extending away from it. Returns the
-- bottom offset where the first button goes.
-- Size and anchor a flyout (vertical column or horizontal row, per setting);
-- for top/bottom sides the panel ENCOMPASSES the slot icon. Returns the
-- first button's offsets and the per-button step: xBase, yBase, dx, dy.
local function LayoutFlyout(fly, anchorBtn, count)
    local BS, GAP, PAD = 30, 3, 7
    local side = (db.ui and db.ui.flyoutSide) or "top"
    local horiz = db.ui and db.ui.flyoutHoriz
    local aw = anchorBtn:GetWidth() or 36
    local ah = anchorBtn:GetHeight() or 36
    local strip = count * (BS + GAP) - GAP
    fly.anchorBtn = anchorBtn
    fly.graceElapsed = 0
    -- opened from the settings panel: float ABOVE it; from the widget
    -- slots: sit BEHIND them so the panel wraps around the icon
    if anchorBtn:GetFrameStrata() == "HIGH" then
        fly:SetFrameStrata("DIALOG")
        fly:SetFrameLevel(10)
    else
        fly:SetFrameStrata("MEDIUM")
        fly:SetFrameLevel(1)
    end
    fly:ClearAllPoints()
    local w, h, xBase, yBase, dx, dy
    if horiz then
        dx, dy = BS + GAP, 0
        if side == "top" or side == "bottom" then
            w = math.max(strip, aw) + PAD * 2
            h = PAD + ah + 2 + BS + PAD
            xBase = (w - strip) / 2
            if side == "top" then
                yBase = PAD + ah + 2
                fly:SetPoint("BOTTOM", anchorBtn, "BOTTOM", 0, -PAD)
            else
                yBase = PAD
                fly:SetPoint("TOP", anchorBtn, "TOP", 0, PAD)
            end
        else
            w = strip + PAD * 2
            h = BS + PAD * 2
            xBase, yBase = PAD, PAD
            local a = FLY_ANCHORS[side] or FLY_ANCHORS.top
            fly:SetPoint(a[1], anchorBtn, a[2], a[3], a[4])
        end
    else
        dx, dy = 0, BS + GAP
        if side == "top" or side == "bottom" then
            w = math.max(BS, aw) + PAD * 2
            h = PAD + ah + 2 + strip + PAD
            xBase = (w - BS) / 2
            if side == "top" then
                yBase = PAD + ah + 2
                fly:SetPoint("BOTTOM", anchorBtn, "BOTTOM", 0, -PAD)
            else
                yBase = PAD
                fly:SetPoint("TOP", anchorBtn, "TOP", 0, PAD)
            end
        else
            w = BS + PAD * 2
            h = strip + PAD * 2
            xBase, yBase = PAD, PAD
            local a = FLY_ANCHORS[side] or FLY_ANCHORS.top
            fly:SetPoint(a[1], anchorBtn, a[2], a[3], a[4])
        end
    end
    fly:SetWidth(w)
    fly:SetHeight(h)
    return xBase, yBase, dx, dy
end

-- shared flyout dressing: cool dark/gold panel + auto-close when the mouse
-- leaves both the flyout and its slot
local function StyleFlyout(fly)
    fly:SetBackdrop({
        bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
        edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
        tile = true, tileSize = 16, edgeSize = 12,
        insets = { left = 3, right = 3, top = 3, bottom = 3 },
    })
    fly:SetBackdropColor(0.04, 0.04, 0.1, 0.92)
    fly:SetBackdropBorderColor(0.85, 0.68, 0.2, 0.9)
    -- render BEHIND the widget slots so the panel wraps around the icon
    fly:SetFrameStrata("MEDIUM")
    fly:SetFrameLevel(1)
    fly.graceElapsed = 0
    fly:SetScript("OnUpdate", function(self, elapsed)
        if MouseIsOver(self) or (self.anchorBtn and MouseIsOver(self.anchorBtn)) then
            self.graceElapsed = 0
        else
            self.graceElapsed = self.graceElapsed + elapsed
            if self.graceElapsed > 0.5 then
                self:Hide()
            end
        end
    end)
end
-- keep the status text above the open flyout instead of underneath it
local function UpdateStatusAnchor()
    if not widget then return end
    widget.status:ClearAllPoints()
    if spellFlyout and spellFlyout:IsShown()
        and (db.ui.flyoutSide or "top") == "top"
        and spellFlyout.anchorBtn and spellFlyout.anchorBtn:GetParent() == widget then
        widget.status:SetPoint("BOTTOM", spellFlyout, "TOP", 0, 2)
    else
        widget.status:SetPoint("BOTTOM", widget, "TOP", 0, 2)
    end
end

OpenSpellFlyout = function(which, anchorBtn, noToggle)
    if weaponFlyout then weaponFlyout:Hide() end
    if not spellFlyout then
        spellFlyout = CreateFrame("Frame", "EngraveHelperSpellFlyout", UIParent)
        spellFlyout:SetFrameStrata("DIALOG")
        spellFlyout:SetClampedToScreen(true)
        spellFlyout.buttons = {}
        spellFlyout:Hide()
        StyleFlyout(spellFlyout)
        spellFlyout:SetScript("OnShow", UpdateStatusAnchor)
        spellFlyout:SetScript("OnHide", UpdateStatusAnchor)
    end
    local fly = spellFlyout
    if fly:IsShown() and fly.which == which then
        if not noToggle then
            fly:Hide()
        end
        return
    end
    fly.which = which

    -- the engrave already on this hand's weapon gets a "selected" glow
    local curSpell = CurrentEngraveSpell(SlotWeapon(which))

    local entries = {}
    for _, s in ipairs(ScanEngraveSpells()) do
        entries[#entries + 1] = { spell = s }
    end
    if #entries == 0 then return end

    local BS, GAP = 30, 3
    local xBase, yBase, dx, dy = LayoutFlyout(fly, anchorBtn, #entries)

    for i, e in ipairs(entries) do
        local b = fly.buttons[i]
        if not b then
            b = CreateFrame("Button", "EngraveHelperSpellFlyoutBtn" .. i, fly, "SecureActionButtonTemplate")
            b:SetWidth(BS)
            b:SetHeight(BS)
            b.icon = b:CreateTexture(nil, "ARTWORK")
            b.icon:SetAllPoints()
            -- golden "selected" glow on the engrave currently on this weapon
            b.currentHL = b:CreateTexture(nil, "OVERLAY")
            b.currentHL:SetTexture("Interface\\Buttons\\CheckButtonHilight")
            b.currentHL:SetBlendMode("ADD")
            b.currentHL:SetAllPoints()
            b.currentHL:Hide()
            b:SetHighlightTexture("Interface\\Buttons\\ButtonHilight-Square")
            b:RegisterForClicks("LeftButtonUp")
            b:SetScript("PreClick", function(self)
                -- CLICK 1: picking only assigns + prepares; the red Engrave
                -- button under the slot is the explicit CLICK 2 that casts
                self:SetAttribute("spell", nil)
                if self.spell then
                    SetSpell(fly.which, self.spell)
                    SlotPrepClick(fly.which)
                else
                    SetSpell(fly.which, "NONE")
                end
            end)
            b:SetScript("PostClick", function()
                -- once picked, get out of the way: suppress hover-reopen on
                -- the slot until the mouse leaves and returns, or ~4 seconds
                local anchor = fly.anchorBtn
                local pickedWhich = fly.which
                fly:Hide()
                if anchor then
                    anchor.suppressHoverUntil = GetTime() + 4
                    After(4.2, function()
                        if anchor.suppressHoverUntil and GetTime() >= anchor.suppressHoverUntil
                            and MouseIsOver(anchor) and db.ui.hoverOpen ~= false
                            and not (run.active or run.restoring) then
                            anchor.suppressHoverUntil = nil
                            OpenSpellFlyout(pickedWhich, anchor, true)
                        end
                    end)
                end
            end)
            b:SetScript("OnEnter", function(self)
                GameTooltip:SetOwner(self, "ANCHOR_RIGHT")
                if self.spell then
                    -- real spell tooltip (toggleable), so you can read what
                    -- the engrave actually does before picking it
                    local idx = (db.ui.engraveTips ~= false) and FindSpellBookIndex(self.spell) or nil
                    if idx then
                        GameTooltip:SetSpell(idx, "spell")
                        GameTooltip:AddLine(" ")
                    else
                        GameTooltip:SetText(self.spell, 1, 1, 1)
                    end
                    if self.isCurrent then
                        GameTooltip:AddLine("Currently on this weapon", 0.4, 1, 0.4)
                    end
                    GameTooltip:AddLine("Assigns this engrave - then click the red Engrave button.", 0.7, 0.7, 0.7)
                else
                    GameTooltip:SetText("Clear this slot's engrave", 1, 1, 1)
                end
                GameTooltip:Show()
            end)
            b:SetScript("OnLeave", function() GameTooltip:Hide() end)
            fly.buttons[i] = b
        end
        b:ClearAllPoints()
        b:SetPoint("BOTTOMLEFT", fly, "BOTTOMLEFT", xBase + (i - 1) * dx, yBase + (i - 1) * dy)
        b.spell = e.spell
        b.icon:SetTexture(GetSpellTexture(e.spell) or "Interface\\Icons\\INV_Misc_QuestionMark")
        -- mark the engrave that is already on this hand's weapon
        b.isCurrent = (curSpell ~= nil and e.spell == curSpell)
        if b.isCurrent then
            b.currentHL:Show()
        else
            b.currentHL:Hide()
        end
        b:Show()
    end
    for i = #entries + 1, #fly.buttons do
        fly.buttons[i]:Hide()
    end
    fly:Show()
end

-- Weapon picker = weapon SWITCHER: equips the chosen weapon into that hand.
local function EquipWeaponTo(name, which)
    if InCombatLockdown() then
        SetStatus("You are in combat - try again after combat.")
        return
    end
    if run.active and CountEngraved() == 0 and not run.awaiting then
        -- just an unused hover-prep: cancel it (stashed weapons get restored
        -- right after the switch)
        ResetRun(true)
        run.restoring = true
    elseif run.active or run.restoring then
        SetStatus("Busy engraving - one moment.", true)
        return
    end
    local slotId = (which == "oh") and 17 or 16
    if EquippedName(slotId) == name then
        SetStatus(("%s is already equipped there."):format(name), true)
        return
    end
    local result, why = DoMove({ type = "equip", name = name, slot = slotId })
    if result ~= "moved" then
        SetStatus(("Could not equip %s: %s."):format(name, tostring(why)))
    end
    if run.restoring then
        QueuePump(1.2) -- restore anything a cancelled prep left in the bags
    end
    After(0.6, function()
        RefreshSlots()
        UpdateCastButton()
    end)
end

---------------------------------------------------------------------------
-- Weapon sets: two saved loadouts (e.g. single target / AoE), pre-engraved
-- and swappable - weapons are the one gear type WoW allows swapping IN
-- COMBAT, and engraves keep ticking on bagged weapons.
---------------------------------------------------------------------------
local UpdateSwapButton -- defined below

local function GetSet(idx)
    return db.sets and db.sets[idx]
end

local function SetName(idx)
    local set = GetSet(idx)
    return (set and set.name and set.name ~= "" and set.name) or ("Set " .. idx)
end

local function SetMatches(idx)
    local set = GetSet(idx)
    if not (set and set.mh) then return false end
    if EquippedName(16) ~= set.mh then return false end
    if set.oh and EquippedName(17) ~= set.oh then return false end
    return true
end

local queuedSwap -- set index queued to equip the moment combat ends

-- the "swap queued" indicator on the widget: user-toggleable, colorable,
-- and placeable (anchor + offsets + size)
local function UpdateQueueText()
    if not (widget and widget.queueText) then return end
    local qt = widget.queueText
    if queuedSwap and db.ui.queueTextOn ~= false then
        local c = db.ui.queueTextColor or { 1, 0.82, 0 }
        qt:SetFont(GameFontNormalSmall:GetFont(), db.ui.queueTextSize or 10, "OUTLINE")
        qt:SetTextColor(c[1], c[2], c[3])
        qt:SetText(("Queued: %s"):format(SetName(queuedSwap)))
        qt:ClearAllPoints()
        local a = db.ui.queueTextAnchor or "top"
        local x, y = db.ui.queueTextX or 0, db.ui.queueTextY or 0
        if a == "bottom" then
            qt:SetPoint("TOP", widget, "BOTTOM", x, -2 + y)
        elseif a == "left" then
            qt:SetPoint("RIGHT", widget, "LEFT", -4 + x, y)
        elseif a == "right" then
            qt:SetPoint("LEFT", widget, "RIGHT", 4 + x, y)
        else
            qt:SetPoint("BOTTOM", widget, "TOP", x, 2 + y)
        end
        qt:Show()
    else
        qt:Hide()
    end
end

-- macro icons must come from the game's icon list: exact filename match
-- first, substring as fallback; cached (the list never changes in-session)
local iconIndexCache = {}
local function FindMacroIconIndex(sub)
    sub = tostring(sub or ""):lower()
    if iconIndexCache[sub] then return iconIndexCache[sub] end
    local fallback
    for i = 1, GetNumMacroIcons() do
        local tex = GetMacroIconInfo(i)
        if tex then
            local t = tostring(tex):lower()
            if t:match("([^\\/]+)$") == sub then
                iconIndexCache[sub] = i
                return i
            end
            if not fallback and t:find(sub, 1, true) then fallback = i end
        end
    end
    iconIndexCache[sub] = fallback or 1
    return iconIndexCache[sub]
end

-- keep an existing macro's icon across EditMacro calls
local function IconIndexFromTexture(tex)
    local tail = tostring(tex or ""):lower():match("([^\\/]+)$")
    if not tail or tail == "" then return 1 end
    return FindMacroIconIndex(tail)
end

-- body + icon for a set's macro. Bodies call the ADDON (/eh set n) so the
-- combat queue works; an engrave-spell icon shows dynamically via #show
-- (macro icon lists cannot hold arbitrary textures, #show can)
local function SetMacroBodyAndIcon(idx)
    local set = GetSet(idx)
    if not (set and set.mh) then return nil end
    local body = "/eh set " .. idx
    local icon = set.icon
    if icon and icon.type == "spell" then
        return "#show " .. icon.value .. "\n" .. body, 1
    end
    local tex = (icon and icon.type == "icon" and icon.value) or "ability_dualwield"
    return body, FindMacroIconIndex(tex)
end

-- the addon creates GENERAL (account) macros: 36 slots vs 18 per-character,
-- and one keybind then works on every character. Alert loudly when full.
local function MacroRoomOrAlert()
    if GetNumMacros() < 36 then return true end
    local msg = "Macro list is full (36 general macros max) - delete one in the game's Macros window, then try again."
    SetStatus(msg)
    print(TAG .. msg)
    UIErrorsFrame:AddMessage("Engraving Helper: macro list is full!", 1, 0.2, 0.2, 1, 3)
    return false
end

-- the toggle macro's name is user-configurable (default "Swap")
local function SwapMacroName()
    return db.ui.swapMacroName or "Swap"
end

local function FindSwapMacroIndex()
    local mi = 0
    if db.ui.swapMacroLast then mi = GetMacroIndexByName(db.ui.swapMacroLast) end
    if mi == 0 then mi = GetMacroIndexByName(SwapMacroName()) end
    if mi == 0 then mi = GetMacroIndexByName("EH Swap") end -- legacy name
    return mi
end

-- the set a swap would equip NEXT (the one NOT currently worn)
local function GetSwapTarget()
    local target
    if SetMatches(1) then
        target = 2
    elseif SetMatches(2) then
        target = 1
    else
        target = (GetSet(1) and GetSet(1).mh) and 1 or 2
    end
    if not (GetSet(target) and GetSet(target).mh) then
        target = (target == 1) and 2 or 1
    end
    return target
end

-- ONE toggle macro (default name "Swap"): its body calls /eh swap, and the
-- addon keeps its NAME and ICON current - the icon always shows the set it
-- will equip next, flipping after every swap
local function UpdateSwapMacro()
    local mi = FindSwapMacroIndex()
    if mi == 0 then return end
    if run.active or run.restoring or InCombatLockdown() then return end
    local target = GetSwapTarget()
    local set = GetSet(target)
    local body, iconIndex
    local icon = set and set.icon
    if icon and icon.type == "spell" then
        body = "#show " .. icon.value .. "\n/eh swap"
        iconIndex = 1 -- question mark: #show provides the displayed icon
    else
        body = "/eh swap"
        local tex = (icon and icon.type == "icon" and icon.value)
            or db.ui.swapMacroIcon or "ability_dualwield"
        iconIndex = FindMacroIconIndex(tex)
    end
    -- this runs on every (debounced) bag/equip event: skip the write when
    -- nothing changed (icon compare skipped for dynamic #show macros)
    local curName, curTex, curBody = GetMacroInfo(mi)
    if curName == SwapMacroName() and curBody == body then
        if iconIndex == 1 then
            return
        end
        local wantTex = GetMacroIconInfo(iconIndex)
        if wantTex and curTex and tostring(curTex):lower() == tostring(wantTex):lower() then
            return
        end
    end
    EditMacro(mi, SwapMacroName(), iconIndex, body)
    db.ui.swapMacroLast = SwapMacroName()
end

local function SaveSet(idx, name)
    local mh = SlotWeapon("mh")
    if not mh then
        SetStatus("Equip the weapons you want in the set first, then click Save current.")
        return
    end
    db.sets = db.sets or {}
    local set = db.sets[idx] or {}
    set.mh = mh
    set.oh = SlotWeapon("oh")
    if name and name ~= "" then set.name = name end
    -- default macro icon: the engrave currently on the set's main hand
    if not set.icon then
        local sp = CurrentEngraveSpell(set.mh)
        if sp then set.icon = { type = "spell", value = sp } end
    end
    db.sets[idx] = set
    Log("Saved %s: MH '%s'%s.", SetName(idx), set.mh, set.oh and (", OH '" .. set.oh .. "'") or "")
    SetStatus(("%s saved: %s%s."):format(SetName(idx), set.mh, set.oh and (" + " .. set.oh) or ""), true)
    -- keep this set's macro (named after the set) in sync
    if set.macroName and not InCombatLockdown() then
        local mi = GetMacroIndexByName(set.macroName)
        if mi ~= 0 then
            local body, iconIndex = SetMacroBodyAndIcon(idx)
            EditMacro(mi, set.macroName, iconIndex, body)
        end
    end
    UpdateSwapMacro()
    UpdateSwapButton()
end

-- create or refresh a set's macro - named after the SET, so renaming the
-- set renames the macro; returns the macro name
local function EnsureSetMacro(idx)
    local body, iconIndex = SetMacroBodyAndIcon(idx)
    if not body then
        SetStatus(("%s is empty - save your current weapons to it first."):format(SetName(idx)))
        return nil
    end
    if InCombatLockdown() then
        SetStatus("Cannot create or edit macros in combat.")
        return nil
    end
    local set = GetSet(idx)
    local wantName = SetName(idx)
    -- find it under its remembered name, the wanted name, or the legacy name
    local mi = 0
    if set.macroName then mi = GetMacroIndexByName(set.macroName) end
    if mi == 0 then mi = GetMacroIndexByName(wantName) end
    if mi == 0 then mi = GetMacroIndexByName("EH Set " .. idx) end
    if mi ~= 0 then
        -- never hijack an unrelated user macro that happens to share the name
        local _, _, mbody = GetMacroInfo(mi)
        if not (mbody and (mbody:find("/eh ", 1, true) or mbody:find("/equipslot", 1, true))) then
            SetStatus(("A macro named '%s' already exists - pick a different set name."):format(wantName))
            return nil
        end
        EditMacro(mi, wantName, iconIndex, body)
    else
        if not MacroRoomOrAlert() then return nil end
        if not CreateMacro(wantName, iconIndex, body, nil) then
            MacroRoomOrAlert()
            SetStatus("Could not create the macro.")
            return nil
        end
    end
    set.macroName = wantName
    return wantName
end

-- create the toggle macro (body is armed by UpdateSwapMacro)
local function EnsureSwapMacro()
    if InCombatLockdown() then
        SetStatus("Cannot create or edit macros in combat.")
        return nil
    end
    if not ((GetSet(1) and GetSet(1).mh) or (GetSet(2) and GetSet(2).mh)) then
        SetStatus("Save at least one set first.")
        return nil
    end
    if FindSwapMacroIndex() == 0 then
        if not MacroRoomOrAlert() then return nil end
        if not CreateMacro(SwapMacroName(),
            FindMacroIconIndex(db.ui.swapMacroIcon or "ability_dualwield"), "/eh swap", nil) then
            MacroRoomOrAlert()
            SetStatus("Could not create the macro.")
            return nil
        end
        db.ui.swapMacroLast = SwapMacroName()
    end
    UpdateSwapMacro()
    return SwapMacroName()
end

-- equip one weapon by NAME via the cursor (pickup + place) - unlike
-- EquipItemByName this is NOT protected, so it works in combat for weapons
local function CursorEquip(name, slotId)
    if EquippedName(slotId) == name then return true end
    ClearCursor()
    local otherSlot = (slotId == 16) and 17 or 16
    if EquippedName(otherSlot) == name then
        PickupInventoryItem(otherSlot) -- weapon is in the other hand
    else
        local bag, slot = FindInBagsByName(name)
        if not bag then
            SetStatus(("Cannot find '%s' in your bags."):format(name))
            return false
        end
        PickupContainerItem(bag, slot)
    end
    if not CursorHasItem() then return false end
    PickupInventoryItem(slotId)
    -- the displaced weapon may land on the cursor: park it in a free bag
    -- slot (ClearCursor safely returns it home if the bags are full)
    if CursorHasItem() then
        local fb, fs = FindFreeBagSlot()
        if fb then
            PickupContainerItem(fb, fs)
        else
            ClearCursor()
        end
    end
    return true
end

local function EquipSet(idx)
    local set = GetSet(idx)
    if not (set and set.mh) then
        SetStatus(("%s is empty - save your current weapons to it first."):format(SetName(idx)))
        return
    end
    if InCombatLockdown() then
        -- Ascension blocks weapon swapping in combat entirely; queue the
        -- swap so it fires the moment combat ends (press again to cancel)
        if db.ui.swapQueue ~= false then
            if queuedSwap == idx then
                queuedSwap = nil
                SetStatus("Queued swap cancelled.", true)
            else
                queuedSwap = idx
                SetStatus(("In combat - %s will be equipped when combat ends."):format(SetName(idx)), true)
            end
            UpdateQueueText()
        else
            SetStatus("Weapon swapping is blocked in combat - swap between fights.")
        end
        return
    end
    if run.active or run.restoring then
        SetStatus("Busy engraving - one moment.", true)
        return
    end
    if SetMatches(idx) then
        SetStatus(SetName(idx) .. " is already equipped.", true)
        return
    end
    CursorEquip(set.mh, 16)
    if set.oh then
        After(0.4, function()
            if not (run.active or run.restoring) then
                CursorEquip(set.oh, 17)
            end
        end)
    end
    SetStatus(("Equipping %s."):format(SetName(idx)), true)
    After(1, function()
        RefreshSlots()
        UpdateCastButton()
        UpdateSwapMacro()
        if panel and panel:IsShown() and panel.RefreshSetsTab then
            panel.RefreshSetsTab()
        end
    end)
end

-- equip whichever set is NOT currently worn
local function SwapSets()
    local target
    if SetMatches(1) then
        target = 2
    elseif SetMatches(2) then
        target = 1
    else
        target = (GetSet(1) and GetSet(1).mh) and 1 or 2
    end
    if not (GetSet(target) and GetSet(target).mh) then
        target = (target == 1) and 2 or 1
    end
    EquipSet(target)
end

UpdateSwapButton = function()
    if not (widget and widget.swap) then return end
    local s1, s2 = GetSet(1), GetSet(2)
    local btn = widget.swap
    if not (db.ui.showSwap == true and ((s1 and s1.mh) or (s2 and s2.mh))) then
        btn:Hide()
        return
    end
    -- the button shows a set's icon or name: the CURRENT one (default) or
    -- the one a press would equip NEXT - user's choice; or plain arrow art
    local mode = db.ui.swapBtnMode or "arrow"
    local showIdx
    if (db.ui.swapBtnShow or "current") == "next" then
        showIdx = GetSwapTarget()
    else
        showIdx = (SetMatches(1) and 1) or (SetMatches(2) and 2) or GetSwapTarget()
    end
    local set = GetSet(showIdx)
    local ssize = db.ui.swapBtnSize or 20
    btn:SetHeight(ssize)
    if mode == "icon" then
        btn:SetNormalTexture(nil)
        btn:SetPushedTexture(nil)
        btn:SetWidth(ssize)
        btn.label:Hide()
        local icon = set and set.icon
        local tex
        if icon and icon.type == "spell" then
            tex = GetSpellTexture(icon.value)
        elseif icon and icon.type == "icon" then
            tex = "Interface\\Icons\\" .. icon.value
        end
        btn.icon:SetTexture(tex or "Interface\\Icons\\Ability_DualWield")
        btn.icon:Show()
    elseif mode == "text" then
        btn:SetNormalTexture(nil)
        btn:SetPushedTexture(nil)
        btn.icon:Hide()
        btn.label:SetFont(GameFontNormalSmall:GetFont(),
            math.max(8, math.floor(ssize * 0.55)), "OUTLINE")
        local tc = db.ui.swapBtnTextColor or { 1, 1, 1 }
        btn.label:SetTextColor(tc[1], tc[2], tc[3])
        btn.label:SetText(SetName(showIdx))
        btn.label:Show()
        btn:SetWidth(math.max(ssize, btn.label:GetStringWidth() + 10))
    else
        btn:SetNormalTexture("Interface\\Buttons\\UI-RotationRight-Button-Up")
        btn:SetPushedTexture("Interface\\Buttons\\UI-RotationRight-Button-Down")
        btn:SetWidth(ssize)
        btn.icon:Hide()
        btn.label:Hide()
    end
    btn:Show()
end

-- when the EQUIPPED WEAPON in a hand changes (set swap, manual re-equip),
-- snap that hand's engrave selection to whatever is on the new weapon -
-- otherwise "refresh" clicks would re-cast the engrave picked for the OLD
-- weapon
local lastHandWeapon = {}
local function SyncSelectionToWeapon()
    if run.active or run.restoring then return end
    for _, which in ipairs({ "mh", "oh" }) do
        local w = SlotWeapon(which)
        if w ~= lastHandWeapon[which] then
            lastHandWeapon[which] = w
            if w then
                local cur = CurrentEngraveSpell(w)
                if cur and cur ~= SlotSpell(which) then
                    Log("Weapon changed in %s ('%s') - selection follows its engrave '%s'.",
                        which, w, cur)
                    SetSpell(which, cur)
                end
            end
        end
    end
end

OpenWeaponFlyout = function(which, anchorBtn)
    if spellFlyout then spellFlyout:Hide() end
    if not weaponFlyout then
        weaponFlyout = CreateFrame("Frame", "EngraveHelperWeaponFlyout", UIParent)
        weaponFlyout:SetFrameStrata("DIALOG")
        weaponFlyout:SetClampedToScreen(true)
        weaponFlyout.buttons = {}
        weaponFlyout:Hide()
        StyleFlyout(weaponFlyout)
    end
    local fly = weaponFlyout
    if fly:IsShown() and fly.which == which then
        fly:Hide()
        return
    end
    fly.which = which

    local names = ScanWeaponNames()
    if #names == 0 then
        SetStatus("No weapons found in your hands or bags.")
        return
    end

    local BS, GAP = 30, 3
    local xBase, yBase, dx, dy = LayoutFlyout(fly, anchorBtn, #names)

    for i, name in ipairs(names) do
        local b = fly.buttons[i]
        if not b then
            b = CreateFrame("Button", nil, fly)
            b:SetWidth(BS)
            b:SetHeight(BS)
            b.icon = b:CreateTexture(nil, "ARTWORK")
            b.icon:SetAllPoints()
            b:SetHighlightTexture("Interface\\Buttons\\ButtonHilight-Square")
            b:SetScript("OnClick", function(self)
                EquipWeaponTo(self.weapon, fly.which)
                fly:Hide()
            end)
            b:SetScript("OnEnter", function(self)
                GameTooltip:SetOwner(self, "ANCHOR_RIGHT")
                GameTooltip:SetText(self.weapon or "?", 1, 1, 1)
                GameTooltip:AddLine("Currently engraved: " .. CurrentEngraveText(self.weapon), 0.7, 0.7, 0.7)
                GameTooltip:AddLine("Equips this weapon in the "
                    .. (fly.which == "oh" and "off hand" or "main hand") .. ".", 0.6, 0.6, 0.6)
                GameTooltip:Show()
            end)
            b:SetScript("OnLeave", function() GameTooltip:Hide() end)
            fly.buttons[i] = b
        end
        b:ClearAllPoints()
        b:SetPoint("BOTTOMLEFT", fly, "BOTTOMLEFT", xBase + (i - 1) * dx, yBase + (i - 1) * dy)
        b.weapon = name
        b.icon:SetTexture(WeaponTexture(name) or "Interface\\Icons\\INV_Misc_QuestionMark")
        b:Show()
    end
    for i = #names + 1, #fly.buttons do
        fly.buttons[i]:Hide()
    end
    fly:Show()
end

---------------------------------------------------------------------------
-- Options menu (right-click a slot's top arrow)
---------------------------------------------------------------------------
InitOptionsMenu = function(self, level)
    level = level or 1
    local info = UIDropDownMenu_CreateInfo()
    info.text = "Engraving Helper"
    info.isTitle = true
    info.notCheckable = true
    UIDropDownMenu_AddButton(info, level)

    local menuWhich = (widget and widget.menuWhich) or "mh"
    info = UIDropDownMenu_CreateInfo()
    info.text = ("Clear this slot's engrave (%s)"):format(menuWhich == "oh" and "OH" or "MH")
    info.notCheckable = true
    info.func = function() SetSpell(menuWhich, "NONE") end
    UIDropDownMenu_AddButton(info, level)

    info = UIDropDownMenu_CreateInfo()
    info.text = "Open setup window"
    info.notCheckable = true
    info.func = function() TogglePanel() end
    UIDropDownMenu_AddButton(info, level)

    info = UIDropDownMenu_CreateInfo()
    info.text = "Put weapons back"
    info.notCheckable = true
    info.func = function()
        Log("Manual 'Put weapons back' from the menu.")
        run.fails = 0
        run.active = false
        run.restoring = true
        Pump()
    end
    UIDropDownMenu_AddButton(info, level)

    info = UIDropDownMenu_CreateInfo()
    info.text = "Reset run"
    info.notCheckable = true
    info.func = function() ResetRun() end
    UIDropDownMenu_AddButton(info, level)

    info = UIDropDownMenu_CreateInfo()
    info.text = "Show event log"
    info.notCheckable = true
    info.func = function() ToggleLog() end
    UIDropDownMenu_AddButton(info, level)

    info = UIDropDownMenu_CreateInfo()
    info.text = "Hide slots (/eh button to show)"
    info.notCheckable = true
    info.func = function()
        db.buttonHidden = true
        if widget then widget:Hide() end
        print(TAG .. "Slots hidden. Type " .. COLOR .. "/eh button|r to show them again.")
    end
    UIDropDownMenu_AddButton(info, level)
end

---------------------------------------------------------------------------
-- The floating slots: [<][MH][^]  [^][OH][>] - clean, no background.
-- Slot icon = weapon, corner icon = engrave. Top arrow = engrave picker,
-- side arrow = weapon picker.
---------------------------------------------------------------------------
local function WidgetDragStart(self)
    if IsShiftKeyDown() then widget:StartMoving() end
end
local function WidgetDragStop(self)
    widget:StopMovingOrSizing()
    db.buttonPos = { x = widget:GetLeft(), y = widget:GetBottom() }
end

-- Steal the REAL equipment-slot popout arrow art from Ascension's character
-- sheet at runtime (AscensionCharacterMainHandSlotPopoutButton), so our
-- arrows look exactly like the one the user pointed at.
local function HarvestAscensionArrow(arrow)
    if arrow.ascArt then return true end
    local src = _G["AscensionCharacterMainHandSlotPopoutButton"]
    if not (src and src.GetNormalTexture) then return false end
    local nt = src:GetNormalTexture()
    if not (nt and nt:GetTexture()) then return false end
    arrow:SetNormalTexture(nt:GetTexture())
    arrow.ascBase = { nt:GetTexCoord() }
    local ht = src.GetHighlightTexture and src:GetHighlightTexture()
    if ht and ht:GetTexture() then
        arrow:SetHighlightTexture(ht:GetTexture())
        local mineH = arrow:GetHighlightTexture()
        if mineH then
            mineH:SetTexCoord(ht:GetTexCoord())
        end
    end
    if not arrow.ascLogged then
        arrow.ascLogged = true
        Log("Using Ascension popout arrow art: %s", tostring(nt:GetTexture()))
    end
    arrow.ascArt = true
    return true
end

-- rotate/flip an 8-value texcoord set; the popout art points DOWN natively
local function AscCoordsForSide(base, side)
    local function flipV(t) return { t[3], t[4], t[1], t[2], t[7], t[8], t[5], t[6] } end
    local function rotCW(t) return { t[3], t[4], t[7], t[8], t[1], t[2], t[5], t[6] } end
    local function rotCCW(t) return { t[5], t[6], t[1], t[2], t[7], t[8], t[3], t[4] } end
    if side == "bottom" then
        return base
    elseif side == "top" then
        return flipV(base)
    elseif side == "right" then
        return rotCCW(base)
    else
        return rotCW(base)
    end
end

-- remaining engrave duration, from the weapon temp-enchant API
local function FormatMS(ms)
    local s = math.floor((ms or 0) / 1000)
    if s >= 3600 then
        return string.format("%.1fh", s / 3600), false
    elseif s >= 60 then
        return string.format("%dm", math.floor(s / 60)), s < 300
    else
        return s .. "s", true
    end
end

-- reminder glow engine: classic texture glows + the real WeakAuras glows
-- via LibCustomGlow (bundled - same lib and textures WA uses on Ascension)
local LCG = LibStub and LibStub("LibCustomGlow-1.0", true)
local REMIND_TEX = {
    border = { tex = "Interface\\Buttons\\UI-ActionButton-Border", blend = "ADD", inset = 0.3 },
    inner = { tex = "Interface\\Buttons\\CheckButtonHilight", blend = "ADD", inset = 0 },
}
local remindPreviewUntil = 0 -- Preview button forces the reminder on briefly

local function StopRemindGlow(slot)
    slot.remindPulse:Stop()
    slot.remindFrame:Hide()
    if LCG then
        LCG.PixelGlow_Stop(slot, "EH")
        LCG.AutoCastGlow_Stop(slot, "EH")
        LCG.ButtonGlow_Stop(slot)
    end
end

local function StartRemindGlow(slot, style, rc)
    if LCG and (style == "pixel" or style == "shine" or style == "proc") then
        slot.remindPulse:Stop()
        slot.remindFrame:Hide()
        if style ~= "pixel" then
            LCG.PixelGlow_Stop(slot, "EH")
        end
        if style ~= "shine" then
            LCG.AutoCastGlow_Stop(slot, "EH")
        end
        if style ~= "proc" then
            LCG.ButtonGlow_Stop(slot)
        end
        local color = { rc[1], rc[2], rc[3], 1 }
        if style == "pixel" then
            LCG.PixelGlow_Start(slot, color, 8, 0.25, nil, 2, 2, 2, false, "EH")
        elseif style == "shine" then
            LCG.AutoCastGlow_Start(slot, color, 4, 0.125, 1.2, 2, 2, "EH")
        else
            LCG.ButtonGlow_Start(slot, color, 0.125)
        end
    else
        if LCG then
            LCG.PixelGlow_Stop(slot, "EH")
            LCG.AutoCastGlow_Stop(slot, "EH")
            LCG.ButtonGlow_Stop(slot)
        end
        local g = REMIND_TEX[style] or REMIND_TEX.border
        slot.remindGlow:SetTexture(g.tex)
        slot.remindGlow:SetBlendMode(g.blend)
        slot.remindGlow:SetVertexColor(rc[1], rc[2], rc[3])
        slot.remindFrame:Show()
        if not slot.remindPulse:IsPlaying() then
            slot.remindPulse:Play()
        end
    end
end

local function UpdateDurations()
    if not widget then return end
    local show = db.ui.showDuration ~= false
    local hasMH, mhExp, _, hasOH, ohExp = GetWeaponEnchantInfo()
    local c = db.ui.durColor or { 1, 1, 1 }
    local function apply(slot, has, exp)
        if show and has and exp then
            local text, low = FormatMS(exp)
            slot.duration:SetText(text)
            if low then
                slot.duration:SetTextColor(1, 0.35, 0.35)
            else
                slot.duration:SetTextColor(c[1], c[2], c[3])
            end
        else
            slot.duration:SetText("")
        end
        -- expiry reminder: glow/text when the engrave is about to run out
        -- (the Preview button forces it on briefly so styles can be tuned)
        local active = (remindPreviewUntil > GetTime())
            or (db.ui.remindOn == true and has and exp
                and (exp / 1000) <= (tonumber(db.ui.remindSecs) or 300))
        if active and db.ui.remindGlowOn ~= false then
            StartRemindGlow(slot, db.ui.remindGlowType or "border",
                db.ui.remindColor or { 1, 0.35, 0.35 })
        else
            StopRemindGlow(slot)
        end
        if active and db.ui.remindTextOn == true then
            local tc = db.ui.remindTextColor or { 1, 0.35, 0.35 }
            slot.remindText:SetText(db.ui.remindText or "Engrave fading!")
            slot.remindText:SetTextColor(tc[1], tc[2], tc[3])
            slot.remindText:Show()
        else
            slot.remindText:Hide()
        end
    end
    apply(widget.slots.mh, hasMH, mhExp)
    apply(widget.slots.oh, hasOH, ohExp)
end

local function CreateWidgetSlot(which, x, label, weaponArrowSide)
    local slot = CreateFrame("Button", "EngraveHelperSlot_" .. which, widget, "SecureActionButtonTemplate")
    slot:SetWidth(36)
    slot:SetHeight(36)
    slot:SetPoint("TOPLEFT", x, -12)

    -- clean look: the raw spell icon, no chunky Blizzard ring (Ascension's
    -- custom icons carry their own border art). Empty = the character-sheet
    -- empty weapon-slot background.
    slot.emptyTex = (which == "oh") and "Interface\\PaperDoll\\UI-PaperDoll-Slot-SecondaryHand"
        or "Interface\\PaperDoll\\UI-PaperDoll-Slot-MainHand"
    slot.icon = slot:CreateTexture(nil, "BACKGROUND")
    slot.icon:SetAllPoints()
    slot.icon:SetTexture(slot.emptyTex)

    -- the weapon shown as a mini icon in the bottom-right corner, on a
    -- raised child frame with a thin dark edge
    local corner = CreateFrame("Frame", nil, slot)
    corner:SetWidth(16)
    corner:SetHeight(16)
    corner:SetPoint("BOTTOMRIGHT", 2, -2)
    corner:SetFrameLevel(slot:GetFrameLevel() + 5)
    slot.cornerBorder = corner:CreateTexture(nil, "BACKGROUND")
    slot.cornerBorder:SetTexture("Interface\\Buttons\\WHITE8X8")
    slot.cornerBorder:SetVertexColor(0, 0, 0, 0.9)
    slot.cornerBorder:SetPoint("TOPLEFT", -1, 1)
    slot.cornerBorder:SetPoint("BOTTOMRIGHT", 1, -1)
    slot.cornerBorder:Hide()
    slot.cornerIcon = corner:CreateTexture(nil, "ARTWORK")
    slot.cornerIcon:SetAllPoints()
    slot.cornerIcon:Hide()

    slot:SetHighlightTexture("Interface\\Buttons\\ButtonHilight-Square")

    -- engrave-colored border (like Blizzard's purple temp-enchant border);
    -- texture/points set per style in ApplyWidgetLayout
    slot.engraveBorder = slot:CreateTexture(nil, "OVERLAY")
    slot.engraveBorder:Hide()

    -- expiry reminder: pulsing glow + text, driven by UpdateDurations
    local remindFrame = CreateFrame("Frame", nil, slot)
    remindFrame:SetFrameLevel(slot:GetFrameLevel() + 6)
    slot.remindFrame = remindFrame
    slot.remindGlow = remindFrame:CreateTexture(nil, "OVERLAY")
    slot.remindGlow:SetAllPoints()
    slot.remindGlow:SetTexture("Interface\\Buttons\\UI-ActionButton-Border")
    slot.remindGlow:SetBlendMode("ADD")
    slot.remindPulse = remindFrame:CreateAnimationGroup()
    slot.remindPulse:SetLooping("BOUNCE")
    local remindAnim = slot.remindPulse:CreateAnimation("Alpha")
    remindAnim:SetChange(-0.6)
    remindAnim:SetDuration(0.5)
    remindFrame:Hide()
    slot.remindText = slot:CreateFontString(nil, "OVERLAY")
    slot.remindText:SetFont(GameFontNormalSmall:GetFont(), 11, "OUTLINE")
    slot.remindText:Hide()

    -- radial sweep shown while the weapons swap
    slot.sweep = CreateFrame("Cooldown", nil, slot, "CooldownFrameTemplate")
    slot.sweep:SetAllPoints()

    -- small MH/OH tag in the icon's top-left corner (toggleable in settings)
    slot.label = slot:CreateFontString(nil, "OVERLAY")
    slot.label:SetFont(GameFontNormalSmall:GetFont(), 9, "OUTLINE")
    slot.label:SetTextColor(1, 0.82, 0)
    slot.label:SetPoint("TOPLEFT", slot, "TOPLEFT", 2, -2)
    slot.label:SetText(label)

    -- the red Engrave button: appears ONLY when the confirming click is
    -- needed. Parented to the WIDGET (not the slot) so the slot's ready-pulse
    -- does not make it flicker - only the icon pulses.
    local castBtn = CreateFrame("Button", "EngraveHelperCast_" .. which, widget,
        "SecureActionButtonTemplate, UIPanelButtonTemplate")
    castBtn:SetWidth(58)
    castBtn:SetHeight(18)
    castBtn:SetPoint("TOP", slot, "BOTTOM", 0, 0)
    castBtn:SetFrameLevel(slot:GetFrameLevel() + 6)
    castBtn:SetText("|cffffffffEngrave|r")
    local castFS = castBtn:GetFontString()
    if castFS then
        castFS:SetFont(GameFontNormalSmall:GetFont(), 8, "OUTLINE")
    end
    -- (no own pulse: the button inherits the slot's ready-pulse as its child)
    local nt = castBtn:GetNormalTexture()
    if nt then nt:SetVertexColor(1, 0.25, 0.25) end
    local pt = castBtn:GetPushedTexture()
    if pt then pt:SetVertexColor(1, 0.25, 0.25) end
    castBtn:SetAttribute("type1", "spell")
    castBtn:RegisterForClicks("LeftButtonUp")
    castBtn:SetScript("PreClick", function(self)
        if InCombatLockdown() then return end
        local pending = FirstPending()
        if not (run.active and pending) then
            self:SetAttribute("spell", nil)
            self:Hide()
            return
        end
        if run.awaiting == pending and GetTime() - run.awaitAt < 2 then
            self:SetAttribute("spell", nil)
            return
        end
        local act = ComputeAction()
        if act.type == "cast" and act.target == pending and GetTime() - run.lastMoveAt >= 0.5 then
            self:SetAttribute("spell", pending.spell)
            run.awaiting = pending
            run.awaitAt = GetTime()
            Log("Casting '%s' on '%s' (Engrave button).", tostring(pending.spell), pending.name)
            SetStatus(("Engraving %s..."):format(pending.name), true)
            SetWidgetStatus("|cffffd700engraving...|r")
        else
            self:SetAttribute("spell", nil)
            SetWidgetStatus("|cffffd700not yet...|r")
            QueuePump(0.4)
        end
        UpdateCastButton()
    end)
    castBtn:SetScript("PostClick", function(self)
        if run.awaiting then
            self:Hide()
        end
    end)
    castBtn:Hide()
    slot.castBtn = castBtn

    -- flyout picker arrow: the wrath TOTEM-BAR style flat tab centered on the
    -- slot's edge (authentic flyout-arrow art if the client has it)
    local arrow = CreateFrame("Button", nil, slot)
    arrow:SetWidth(22)
    arrow:SetHeight(12)
    arrow:SetFrameLevel(slot:GetFrameLevel() + 7)
    arrow:SetNormalTexture("Interface\\Buttons\\ActionBarFlyoutButton-ArrowUp")
    local ntex = arrow:GetNormalTexture()
    if not (ntex and ntex:GetTexture()) then
        -- client lacks the flyout art: fall back to the expand arrow
        arrow:SetNormalTexture("Interface\\ChatFrame\\ChatFrameExpandArrow")
        arrow.baseRight = true
    end
    arrow:SetHighlightTexture("Interface\\Buttons\\UI-Common-MouseHilight", "ADD")
    arrow:RegisterForClicks("LeftButtonUp", "RightButtonUp")
    arrow:SetScript("OnClick", function(self, button)
        if button == "RightButton" then
            widget.menuWhich = which
            UIDropDownMenu_Initialize(widget.menu, InitOptionsMenu, "MENU")
            ToggleDropDownMenu(1, nil, widget.menu, self, 0, 0)
        else
            OpenSpellFlyout(which, slot)
        end
    end)
    arrow:SetScript("OnEnter", function(self)
        GameTooltip:SetOwner(self, "ANCHOR_TOP")
        GameTooltip:SetText("Pick the engrave for this slot", 1, 1, 1)
        GameTooltip:AddLine("Right-click: options", 0.6, 0.6, 0.6)
        GameTooltip:Show()
    end)
    arrow:SetScript("OnLeave", function() GameTooltip:Hide() end)
    slot.arrow = arrow

    -- soft pulse while a picked engrave waits for its confirming click
    slot.pulse = slot:CreateAnimationGroup()
    slot.pulse:SetLooping("BOUNCE")
    local pulseAnim = slot.pulse:CreateAnimation("Alpha")
    pulseAnim:SetChange(-0.45)
    pulseAnim:SetDuration(0.55)

    -- remaining engrave duration, bottom-left (clear of the weapon corner icon)
    slot.duration = slot:CreateFontString(nil, "OVERLAY")
    slot.duration:SetFont(GameFontNormalSmall:GetFont(), 10, "OUTLINE")
    slot.duration:SetPoint("BOTTOMLEFT", slot, "BOTTOMLEFT", 2, 2)

    HarvestAscensionArrow(arrow)

    -- CLICK 1 on the slot = prepare; hovering auto-opens the engrave picker;
    -- right-click = options menu (clear engrave etc.)
    slot:RegisterForClicks("LeftButtonUp", "RightButtonUp")
    slot:SetScript("PreClick", function(self, button)
        if button == "RightButton" then
            self:SetAttribute("spell", nil)
            GameTooltip:Hide()
            widget.menuWhich = which
            UIDropDownMenu_Initialize(widget.menu, InitOptionsMenu, "MENU")
            ToggleDropDownMenu(1, nil, widget.menu, self, 0, 0)
            return
        end
        -- queued and ready? this click casts right here
        if ArmPendingCast(self, which) then
            return
        end
        self:SetAttribute("spell", nil)
        SlotPrepClick(which)
    end)
    slot:RegisterForDrag("LeftButton")
    slot:SetScript("OnDragStart", WidgetDragStart)
    slot:SetScript("OnDragStop", WidgetDragStop)
    slot:SetScript("OnEnter", function(self)
        -- hover auto-opens the engrave picker (default interaction), unless
        -- a fresh pick suppressed it or a run is still engraving/restoring
        if db.ui.hoverOpen ~= false
            and not (run.active or run.restoring)
            and (not self.suppressHoverUntil or GetTime() >= self.suppressHoverUntil) then
            self.suppressHoverUntil = nil
            OpenSpellFlyout(which, self, true)
        end
        if db.ui.showTooltip == false then return end
        -- tiny tooltip, anchored where the user wants (default: left)
        local TIP_ANCHORS = {
            left = "ANCHOR_LEFT", right = "ANCHOR_RIGHT",
            top = "ANCHOR_TOP", bottom = "ANCHOR_BOTTOM",
            cursor = "ANCHOR_CURSOR",
        }
        GameTooltip:SetOwner(self, TIP_ANCHORS[db.ui.tipAnchor or "left"] or "ANCHOR_LEFT")
        if db.ui.tipSmall ~= false then
            GameTooltip:SetScale(0.85)
        end
        local weapon = SlotWeapon(which)
        GameTooltip:SetText(weapon or (which == "oh" and "Off Hand" or "Main Hand"), 0.95, 0.95, 0.95)
        if weapon then
            local cur = CurrentEngraveShort(weapon)
            if cur then
                GameTooltip:AddLine(cur .. " Engraving", 0.4, 1, 0.4)
            else
                GameTooltip:AddLine("no engrave", 1, 0.4, 0.4)
            end
        end
        GameTooltip:AddLine("L: engrave   R: menu   Shift-drag: move", 0.5, 0.5, 0.5)
        -- shrink every line (weapon name included)
        for i = 1, GameTooltip:NumLines() do
            local fs = _G["GameTooltipTextLeft" .. i]
            if fs then fs:SetFontObject(GameTooltipTextSmall) end
        end
        GameTooltip:Show()
    end)
    slot:SetScript("OnLeave", function(self)
        -- leaving re-arms the hover-open
        self.suppressHoverUntil = nil
        GameTooltip:Hide()
        -- restore the shared tooltip fonts/scale for the rest of the UI
        GameTooltip:SetScale(1)
        if GameTooltipTextLeft1 then GameTooltipTextLeft1:SetFontObject(GameTooltipHeaderText) end
        for i = 2, 4 do
            local fs = _G["GameTooltipTextLeft" .. i]
            if fs then fs:SetFontObject(GameTooltipText) end
        end
    end)

    widget.slots[which] = slot
end

local function CreateWidget()
    if widget then return end
    widget = CreateFrame("Frame", "EngraveHelperWidget", UIParent)
    widget:SetWidth(124)
    widget:SetHeight(66)
    widget:SetFrameStrata("MEDIUM")
    widget:SetMovable(true)
    widget:SetClampedToScreen(true)
    widget.slots = {}
    if db.buttonPos and db.buttonPos.x and db.buttonPos.y then
        widget:SetPoint("BOTTOMLEFT", UIParent, "BOTTOMLEFT", db.buttonPos.x, db.buttonPos.y)
    else
        widget:SetPoint("CENTER", UIParent, "CENTER", 0, -170)
    end

    widget.menu = CreateFrame("Frame", "EngraveHelperOptionsMenu", UIParent, "UIDropDownMenuTemplate")
    widget.menu:Hide()

    -- always-drag grip handle (toggleable)
    widget.grip = CreateFrame("Button", nil, widget)
    local gripBG = widget.grip:CreateTexture(nil, "BACKGROUND")
    gripBG:SetTexture("Interface\\Buttons\\WHITE8X8")
    gripBG:SetVertexColor(0, 0, 0, 0.55)
    gripBG:SetAllPoints()
    widget.grip.dots = widget.grip:CreateFontString(nil, "OVERLAY", "GameFontDisableSmall")
    widget.grip.dots:SetPoint("CENTER", 0, 0)
    widget.grip.dots:SetText("::")
    widget.grip:RegisterForDrag("LeftButton")
    widget.grip:SetScript("OnDragStart", function() widget:StartMoving() end)
    widget.grip:SetScript("OnDragStop", WidgetDragStop)

    -- weapon-set swap button (appears once a set is saved; works in combat)
    local swap = CreateFrame("Button", "EngraveHelperSwapButton", widget)
    swap:SetWidth(20)
    swap:SetHeight(20)
    swap:SetNormalTexture("Interface\\Buttons\\UI-RotationRight-Button-Up")
    swap:SetPushedTexture("Interface\\Buttons\\UI-RotationRight-Button-Down")
    swap:SetHighlightTexture("Interface\\Buttons\\UI-Common-MouseHilight", "ADD")
    -- alternate looks: the target set's icon or its name
    swap.icon = swap:CreateTexture(nil, "ARTWORK")
    swap.icon:SetAllPoints()
    swap.icon:SetTexCoord(0.07, 0.93, 0.07, 0.93)
    swap.icon:Hide()
    swap.label = swap:CreateFontString(nil, "OVERLAY")
    swap.label:SetFont(GameFontNormalSmall:GetFont(), 11, "OUTLINE")
    swap.label:SetPoint("CENTER")
    swap.label:Hide()
    swap:SetScript("OnClick", function()
        SwapSets()
    end)
    swap:SetScript("OnEnter", function(self)
        GameTooltip:SetOwner(self, "ANCHOR_RIGHT")
        GameTooltip:SetText("Swap weapon set", 1, 1, 1)
        for i = 1, 2 do
            local set = GetSet(i)
            if set and set.mh then
                local line = SetName(i) .. ": " .. set.mh .. (set.oh and (" + " .. set.oh) or "")
                if SetMatches(i) then
                    GameTooltip:AddLine(line .. " (equipped)", 0.4, 1, 0.4)
                else
                    GameTooltip:AddLine(line, 0.8, 0.8, 0.8)
                end
            end
        end
        GameTooltip:AddLine("Swapping is blocked while in combat.", 0.5, 0.5, 0.5)
        GameTooltip:Show()
    end)
    swap:SetScript("OnLeave", function() GameTooltip:Hide() end)
    swap:Hide()
    widget.swap = swap

    -- "swap queued" indicator (position/color/size are user-set)
    widget.queueText = widget:CreateFontString(nil, "OVERLAY")
    widget.queueText:SetFont(GameFontNormalSmall:GetFont(), 10, "OUTLINE")
    widget.queueText:Hide()
    widget.grip:SetScript("OnEnter", function(self)
        GameTooltip:SetOwner(self, "ANCHOR_TOP")
        GameTooltip:SetText("Drag to move", 1, 1, 1)
        GameTooltip:Show()
    end)
    widget.grip:SetScript("OnLeave", function() GameTooltip:Hide() end)

    CreateWidgetSlot("mh", 18, "MH", "left")
    CreateWidgetSlot("oh", 70, "OH", "right")

    widget.status = widget:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
    widget.status:SetPoint("BOTTOM", widget, "TOP", 0, 2)
    widget.status:SetJustifyH("CENTER")

    -- duration ticker: only runs while the widget is visible
    local durTicker = CreateFrame("Frame", nil, widget)
    durTicker.elapsed = 1
    durTicker:SetScript("OnUpdate", function(self, elapsed)
        self.elapsed = self.elapsed + elapsed
        if self.elapsed < 1 then return end
        self.elapsed = 0
        UpdateDurations()
    end)

    if db.buttonHidden then widget:Hide() end
    UpdateCastButton()
end

-- apply the user's widget settings: icon size, spacing, orientation,
-- flyout/arrow side, weapon corner icon
local function ApplyWidgetLayout()
    if not widget then return end
    local ui = db.ui
    local size = ui.size or 36
    local gap = ui.spacing or 14
    local vertical = ui.vertical and true or false
    local side = ui.flyoutSide or "top"
    local pad = 6
    local labelRoom = 4
    local showOH = ui.hideOH ~= true -- 2H builds can hide the off-hand slot
    if vertical then
        widget:SetWidth(size + pad * 2)
        widget:SetHeight((showOH and (size * 2 + gap + labelRoom * 2) or (size + labelRoom)) + pad * 2)
    else
        widget:SetWidth((showOH and (size * 2 + gap) or size) + pad * 2)
        widget:SetHeight(size + labelRoom + pad * 2)
    end
    for i, which in ipairs({ "mh", "oh" }) do
        local slot = widget.slots[which]
        if which == "oh" and not showOH then
            slot:Hide()
        else
            slot:Show()
        end
        slot:SetWidth(size)
        slot:SetHeight(size)
        slot:ClearAllPoints()
        if vertical then
            slot:SetPoint("TOP", widget, "TOP", 0, -(pad + (i - 1) * (size + gap + labelRoom)))
        else
            slot:SetPoint("TOPLEFT", widget, "TOPLEFT", pad + (i - 1) * (size + gap), -pad)
        end
        -- weapon corner icon scales with the slot
        local corner = slot.cornerIcon:GetParent()
        local cs = math.max(10, math.floor(size * 0.42))
        corner:SetWidth(cs)
        corner:SetHeight(cs)
        -- (icon crop is applied in UpdateCastButton, per icon type)
        -- MH/OH tag visibility
        if ui.showLabels == false then
            slot.label:Hide()
        else
            slot.label:Show()
        end
    end
    -- drag grip: left of the row (or above the column)
    if widget.grip then
        if ui.showHandle == false then
            widget.grip:Hide()
        else
            widget.grip:Show()
            widget.grip:ClearAllPoints()
            if vertical then
                widget.grip:SetWidth(size)
                widget.grip:SetHeight(10)
                widget.grip.dots:SetText("...")
                widget.grip:SetPoint("BOTTOM", widget.slots.mh, "TOP", 0, 3)
            else
                widget.grip:SetWidth(10)
                widget.grip:SetHeight(size)
                widget.grip.dots:SetText("::")
                widget.grip:SetPoint("RIGHT", widget.slots.mh, "LEFT", -3, 0)
            end
        end
    end
    -- set-swap button: user-chosen edge + offsets ("auto" = the free edge)
    if widget.swap then
        local btn = widget.swap
        btn:ClearAllPoints()
        local anchor = ui.swapBtnAnchor or "auto"
        local sx, sy = ui.swapBtnX or 0, ui.swapBtnY or 0
        if anchor == "auto" then
            anchor = vertical and "bottom" or "right"
        end
        if anchor == "right" then
            btn:SetPoint("LEFT", widget, "RIGHT", 2 + sx, sy)
        elseif anchor == "left" then
            btn:SetPoint("RIGHT", widget, "LEFT", -2 + sx, sy)
        elseif anchor == "top" then
            btn:SetPoint("BOTTOM", widget, "TOP", sx, 2 + sy)
        else
            btn:SetPoint("TOP", widget, "BOTTOM", sx, -2 + sy)
        end
        UpdateSwapButton()
    end
    for _, which in ipairs({ "mh", "oh" }) do
        local slot = widget.slots[which]
        -- duration text styling + user offsets; the font scales with the icon
        local sh = ui.durShadow ~= false
        local dsize = math.max(6, math.floor((ui.durSize or 10) * size / 30 + 0.5))
        slot.duration:SetFont(GameFontNormalSmall:GetFont(), dsize, "OUTLINE")
        slot.duration:SetShadowColor(0, 0, 0, sh and 1 or 0)
        slot.duration:SetShadowOffset(1, -1)
        slot.duration:ClearAllPoints()
        slot.duration:SetPoint("BOTTOM", slot, "BOTTOM", ui.durX or 0, ui.durY or 2)
        -- reminder glow hugs the icon; reminder text sits above it
        local rg = REMIND_TEX[ui.remindGlowType or "border"] or REMIND_TEX.border
        local rinset = math.floor(size * rg.inset)
        slot.remindFrame:ClearAllPoints()
        slot.remindFrame:SetPoint("TOPLEFT", -rinset, rinset)
        slot.remindFrame:SetPoint("BOTTOMRIGHT", rinset, -rinset)
        slot.remindText:SetFont(GameFontNormalSmall:GetFont(), dsize + 1, "OUTLINE")
        slot.remindText:ClearAllPoints()
        slot.remindText:SetPoint("BOTTOM", slot, "TOP", 0, 3)
        -- engrave border style
        local eb = slot.engraveBorder
        eb:ClearAllPoints()
        if (ui.borderStyle or "classic") == "glow" then
            eb:SetTexture("Interface\\Buttons\\UI-ActionButton-Border")
            eb:SetTexCoord(0, 1, 0, 1)
            eb:SetBlendMode("ADD")
            eb:SetPoint("TOPLEFT", -math.floor(size * 0.3), math.floor(size * 0.3))
            eb:SetPoint("BOTTOMRIGHT", math.floor(size * 0.3), -math.floor(size * 0.3))
        else
            -- neutral white border art (the debuff border) so the vertex
            -- color renders TRUE - the old temp-enchant art was purple and
            -- tinted every color toward purple
            eb:SetTexture("Interface\\Buttons\\UI-Debuff-Overlays")
            eb:SetTexCoord(0.296875, 0.5703125, 0, 0.515625)
            eb:SetBlendMode("BLEND")
            eb:SetPoint("TOPLEFT", -1, 1)
            eb:SetPoint("BOTTOMRIGHT", 1, -1)
        end
        -- the red button scales with the icon; default = centered ON it
        slot.castBtn:SetWidth(math.max(40, size))
        slot.castBtn:SetHeight(math.max(13, math.floor(size * 0.4)))
        slot.castBtn:ClearAllPoints()
        local bp = ui.btnPos or "center"
        if bp == "below" then
            slot.castBtn:SetPoint("TOP", slot, "BOTTOM", 0, 0)
        elseif bp == "above" then
            slot.castBtn:SetPoint("BOTTOM", slot, "TOP", 0, 0)
        else
            slot.castBtn:SetPoint("CENTER", slot, "CENTER", 0, 0)
        end
        -- picker arrow: the Ascension equipment-slot popout tab on the
        -- flyout-side edge, rotated to point where the flyout opens
        local arrow = slot.arrow
        if ui.showArrow == false then
            arrow:Hide()
        else
            arrow:Show()
            HarvestAscensionArrow(arrow)
            local tex = arrow:GetNormalTexture()
            if tex then
                local c
                if arrow.ascArt and arrow.ascBase then
                    c = AscCoordsForSide(arrow.ascBase, side)
                else
                    local coords = arrow.baseRight and ARROW_COORDS_RIGHTBASE or ARROW_COORDS_UPBASE
                    c = coords[side] or coords.top
                end
                tex:SetTexCoord(c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8])
            end
            -- the arrow tab stretches across the FULL side of the icon
            if side == "left" or side == "right" then
                arrow:SetWidth(12)
                arrow:SetHeight(size)
            else
                arrow:SetWidth(size)
                arrow:SetHeight(12)
            end
            arrow:ClearAllPoints()
            local ae = ARROW_EDGES[side] or ARROW_EDGES.top
            arrow:SetPoint(ae[1], slot, ae[2], ae[3], ae[4])
        end
    end
    UpdateCastButton()
end

---------------------------------------------------------------------------
-- Minimap button
---------------------------------------------------------------------------
local minimapBtn

local function UpdateMinimapButton()
    if not minimapBtn then return end
    local angle = math.rad(db.ui.minimapPos or 210)
    minimapBtn:ClearAllPoints()
    minimapBtn:SetPoint("CENTER", Minimap, "CENTER", 80 * math.cos(angle), 80 * math.sin(angle))
    if db.ui.minimapHide then minimapBtn:Hide() else minimapBtn:Show() end
end

local function CreateMinimapButton()
    if minimapBtn then
        UpdateMinimapButton()
        return
    end
    local btn = CreateFrame("Button", "EngraveHelperMinimapButton", Minimap)
    btn:SetWidth(31)
    btn:SetHeight(31)
    btn:SetFrameStrata("MEDIUM")
    btn:SetFrameLevel(8)
    btn:RegisterForClicks("LeftButtonUp", "RightButtonUp")
    btn:RegisterForDrag("LeftButton")

    local icon = btn:CreateTexture(nil, "BACKGROUND")
    icon:SetWidth(20)
    icon:SetHeight(20)
    icon:SetTexture("Interface\\Icons\\INV_Misc_ArmorKit_17")
    icon:SetTexCoord(0.07, 0.93, 0.07, 0.93)
    icon:SetPoint("CENTER", 0, 1)

    local border = btn:CreateTexture(nil, "OVERLAY")
    border:SetWidth(53)
    border:SetHeight(53)
    border:SetTexture("Interface\\Minimap\\MiniMap-TrackingBorder")
    border:SetPoint("TOPLEFT")

    btn:SetScript("OnDragStart", function(self)
        self:SetScript("OnUpdate", function()
            local mx, my = Minimap:GetCenter()
            local px, py = GetCursorPosition()
            local scale = Minimap:GetEffectiveScale()
            px, py = px / scale, py / scale
            db.ui.minimapPos = math.deg(math.atan2(py - my, px - mx))
            UpdateMinimapButton()
        end)
    end)
    btn:SetScript("OnDragStop", function(self)
        self:SetScript("OnUpdate", nil)
    end)
    btn:SetScript("OnClick", function(self, button)
        if button == "RightButton" then
            db.buttonHidden = not db.buttonHidden
            if widget then
                if db.buttonHidden then widget:Hide() else widget:Show() end
            end
        else
            TogglePanel()
        end
    end)
    btn:SetScript("OnEnter", function(self)
        GameTooltip:SetOwner(self, "ANCHOR_LEFT")
        GameTooltip:SetText("Engraving Helper", 0, 0.8, 1)
        GameTooltip:AddLine("Left-click: settings", 1, 1, 1)
        GameTooltip:AddLine("Right-click: show/hide the slots", 1, 1, 1)
        GameTooltip:AddLine("Drag: move this button", 1, 1, 1)
        GameTooltip:Show()
    end)
    btn:SetScript("OnLeave", function() GameTooltip:Hide() end)

    minimapBtn = btn
    UpdateMinimapButton()
end

---------------------------------------------------------------------------
-- Texture browser (/eh tex): preview any texture path in-game and cycle a
-- list of arrow/flyout/expand candidates - for hunting down the exact asset.
---------------------------------------------------------------------------
local texBrowser
local TEX_CANDIDATES = {
    "Interface\\Buttons\\ActionBarFlyoutButton-ArrowUp",
    "Interface\\Buttons\\ActionBarFlyoutButton-FlyoutBorder",
    "Interface\\Buttons\\ActionBarFlyoutButton",
    "Interface\\PaperDollInfoFrame\\UI-GearManager-FlyoutButton",
    "Interface\\ChatFrame\\ChatFrameExpandArrow",
    "Interface\\Buttons\\Arrow-Up-Up",
    "Interface\\Buttons\\Arrow-Down-Up",
    "Interface\\Buttons\\UI-SpellbookIcon-NextPage-Up",
    "Interface\\Buttons\\UI-ScrollBar-ScrollUpButton-Up",
    "Interface\\ChatFrame\\UI-ChatIcon-ScrollUp-Up",
    "Interface\\ChatFrame\\UI-InChatFriendsArrow",
    "Interface\\MainMenuBar\\UI-MainMenu-ScrollUpButton-Up",
    "Interface\\Buttons\\UI-PlusButton-Up",
    "Interface\\Buttons\\UI-MinusButton-Up",
    "Interface\\Buttons\\UI-Panel-QuestHideButton",
    "Interface\\TUTORIALFRAME\\UI-TutorialFrame-GlowDragArrow",
    "Interface\\Minimap\\ROTATING-MINIMAPGUIDEARROW",
    "Interface\\CONTAINERFRAME\\Bags",
    "Interface\\Buttons\\JumpUpArrow",
    "Interface\\PETBATTLES\\PetBattle-GoldSpeedArrow",
}

local function TexPreview(path)
    if not texBrowser or not path or path == "" then return end
    texBrowser.tex:SetTexture(nil)
    texBrowser.tex:SetTexture(path)
    texBrowser.small:SetTexture(nil)
    texBrowser.small:SetTexture(path)
    texBrowser.edit:SetText(path)
    local ok = texBrowser.tex:GetTexture()
    if ok then
        texBrowser.result:SetText("|cff55ff55loaded|r  " .. path)
    else
        texBrowser.result:SetText("|cffff5555NOT FOUND|r  " .. path)
    end
end

local function ShowTexBrowser(path)
    if not texBrowser then
        texBrowser = CreateFrame("Frame", "EngraveHelperTexBrowser", UIParent)
        texBrowser:SetWidth(400)
        texBrowser:SetHeight(250)
        texBrowser:SetPoint("CENTER", UIParent, "CENTER", 0, 120)
        texBrowser:SetFrameStrata("DIALOG")
        texBrowser:SetBackdrop({
            bgFile = "Interface\\DialogFrame\\UI-DialogBox-Background",
            edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border",
            tile = true, tileSize = 32, edgeSize = 32,
            insets = { left = 11, right = 12, top = 12, bottom = 11 },
        })
        texBrowser:SetMovable(true)
        texBrowser:EnableMouse(true)
        texBrowser:RegisterForDrag("LeftButton")
        texBrowser:SetScript("OnDragStart", function(self) self:StartMoving() end)
        texBrowser:SetScript("OnDragStop", function(self) self:StopMovingOrSizing() end)
        tinsert(UISpecialFrames, "EngraveHelperTexBrowser")

        local title = texBrowser:CreateFontString(nil, "OVERLAY", "GameFontNormal")
        title:SetPoint("TOP", 0, -14)
        title:SetText(COLOR .. "Texture Browser|r")

        local close = CreateFrame("Button", nil, texBrowser, "UIPanelCloseButton")
        close:SetPoint("TOPRIGHT", -4, -4)

        local bg = texBrowser:CreateTexture(nil, "BACKGROUND")
        bg:SetTexture("Interface\\Buttons\\WHITE8X8")
        bg:SetVertexColor(0, 0, 0, 0.6)
        bg:SetPoint("TOPLEFT", 20, -34)
        bg:SetPoint("BOTTOMRIGHT", -20, 96)

        texBrowser.tex = texBrowser:CreateTexture(nil, "ARTWORK")
        texBrowser.tex:SetWidth(220)
        texBrowser.tex:SetHeight(80)
        texBrowser.tex:SetPoint("TOP", 30, -44)

        texBrowser.small = texBrowser:CreateTexture(nil, "ARTWORK")
        texBrowser.small:SetWidth(24)
        texBrowser.small:SetHeight(24)
        texBrowser.small:SetPoint("LEFT", texBrowser.tex, "RIGHT", 14, 0)

        texBrowser.result = texBrowser:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
        texBrowser.result:SetPoint("BOTTOMLEFT", 24, 80)
        texBrowser.result:SetWidth(352)
        texBrowser.result:SetJustifyH("LEFT")

        texBrowser.edit = CreateFrame("EditBox", "EngraveHelperTexEdit", texBrowser, "InputBoxTemplate")
        texBrowser.edit:SetPoint("BOTTOMLEFT", 30, 46)
        texBrowser.edit:SetWidth(340)
        texBrowser.edit:SetHeight(20)
        texBrowser.edit:SetAutoFocus(false)
        texBrowser.edit:SetScript("OnEnterPressed", function(self)
            TexPreview(self:GetText())
            self:ClearFocus()
        end)
        texBrowser.edit:SetScript("OnEscapePressed", function(self) self:ClearFocus() end)

        texBrowser.index = 1
        local prev = CreateFrame("Button", nil, texBrowser, "UIPanelButtonTemplate")
        prev:SetWidth(80)
        prev:SetHeight(22)
        prev:SetPoint("BOTTOMLEFT", 24, 16)
        prev:SetText("< Prev")
        prev:SetScript("OnClick", function()
            texBrowser.index = (texBrowser.index - 2) % #TEX_CANDIDATES + 1
            TexPreview(TEX_CANDIDATES[texBrowser.index])
        end)
        local nxt = CreateFrame("Button", nil, texBrowser, "UIPanelButtonTemplate")
        nxt:SetWidth(80)
        nxt:SetHeight(22)
        nxt:SetPoint("LEFT", prev, "RIGHT", 6, 0)
        nxt:SetText("Next >")
        nxt:SetScript("OnClick", function()
            texBrowser.index = texBrowser.index % #TEX_CANDIDATES + 1
            TexPreview(TEX_CANDIDATES[texBrowser.index])
        end)
        local hint = texBrowser:CreateFontString(nil, "OVERLAY", "GameFontDisableSmall")
        hint:SetPoint("LEFT", nxt, "RIGHT", 10, 0)
        hint:SetText("or type a path + Enter")
    end
    texBrowser:Show()
    TexPreview(path or TEX_CANDIDATES[texBrowser.index])
end

-- entry under Interface -> AddOns
local function RegisterInterfaceOptions()
    local p = CreateFrame("Frame", "EngraveHelperInterfaceOptions")
    p.name = "Engraving Helper"
    local title = p:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge")
    title:SetPoint("TOPLEFT", 16, -16)
    title:SetText("Engraving Helper")
    local desc = p:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    desc:SetPoint("TOPLEFT", title, "BOTTOMLEFT", 0, -8)
    desc:SetWidth(380)
    desc:SetJustifyH("LEFT")
    desc:SetText("Two-click weapon engraving: pick an engrave on a slot, then click the red Engrave button. Size, spacing, layout and more are in the main window.")
    local open = CreateFrame("Button", nil, p, "UIPanelButtonTemplate")
    open:SetWidth(200)
    open:SetHeight(24)
    open:SetPoint("TOPLEFT", desc, "BOTTOMLEFT", 0, -12)
    open:SetText("Open Engraving Helper")
    open:SetScript("OnClick", function() TogglePanel() end)
    if InterfaceOptions_AddCategory then
        InterfaceOptions_AddCategory(p)
    end
end

---------------------------------------------------------------------------
-- Event log window
---------------------------------------------------------------------------
CreateLogFrame = function()
    if logFrame then return logFrame end
    logFrame = CreateFrame("Frame", "EngraveHelperLog", UIParent)
    logFrame:SetWidth(460)
    logFrame:SetHeight(360)
    logFrame:SetPoint("CENTER", UIParent, "CENTER", 300, 0)
    logFrame:SetFrameStrata("HIGH")
    logFrame:SetBackdrop({
        bgFile = "Interface\\DialogFrame\\UI-DialogBox-Background",
        edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border",
        tile = true, tileSize = 32, edgeSize = 32,
        insets = { left = 11, right = 12, top = 12, bottom = 11 },
    })
    logFrame:SetMovable(true)
    logFrame:EnableMouse(true)
    logFrame:RegisterForDrag("LeftButton")
    logFrame:SetScript("OnDragStart", function(self) self:StartMoving() end)
    logFrame:SetScript("OnDragStop", function(self) self:StopMovingOrSizing() end)
    logFrame:SetClampedToScreen(true)
    logFrame:Hide()
    tinsert(UISpecialFrames, "EngraveHelperLog")

    local title = logFrame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
    title:SetPoint("TOP", 0, -14)
    title:SetText(COLOR .. "Engraving Helper - Event Log|r")

    local close = CreateFrame("Button", nil, logFrame, "UIPanelCloseButton")
    close:SetPoint("TOPRIGHT", -4, -4)

    logScroll = CreateFrame("ScrollFrame", "EngraveHelperLogScroll", logFrame, "UIPanelScrollFrameTemplate")
    logScroll:SetPoint("TOPLEFT", 16, -36)
    logScroll:SetPoint("BOTTOMRIGHT", -34, 44)
    logScroll:EnableMouseWheel(true)
    logScroll:SetScript("OnMouseWheel", function(self, delta)
        local new = self:GetVerticalScroll() - delta * 30
        local max = self:GetVerticalScrollRange()
        if new < 0 then new = 0 elseif new > max then new = max end
        self:SetVerticalScroll(new)
    end)

    logEdit = CreateFrame("EditBox", "EngraveHelperLogEdit", logScroll)
    logEdit:SetMultiLine(true)
    logEdit:SetAutoFocus(false)
    logEdit:SetFontObject("ChatFontNormal")
    logEdit:SetWidth(398)
    logEdit:SetMaxLetters(0)
    logEdit:EnableMouse(true)
    logEdit:SetScript("OnEscapePressed", function(self) self:ClearFocus() end)
    logScroll:SetScrollChild(logEdit)

    local selectBtn = CreateFrame("Button", nil, logFrame, "UIPanelButtonTemplate")
    selectBtn:SetWidth(110)
    selectBtn:SetHeight(24)
    selectBtn:SetPoint("BOTTOMLEFT", 16, 12)
    selectBtn:SetText("Select All")
    selectBtn:SetScript("OnClick", function()
        logEdit:SetFocus()
        logEdit:HighlightText()
    end)

    local hint = logFrame:CreateFontString(nil, "OVERLAY", "GameFontDisableSmall")
    hint:SetPoint("LEFT", selectBtn, "RIGHT", 8, 0)
    hint:SetText("then Ctrl+C to copy it to me")

    local clearBtn = CreateFrame("Button", nil, logFrame, "UIPanelButtonTemplate")
    clearBtn:SetWidth(90)
    clearBtn:SetHeight(24)
    clearBtn:SetPoint("BOTTOMRIGHT", -34, 12)
    clearBtn:SetText("Clear")
    clearBtn:SetScript("OnClick", function()
        wipe(logLines)
        RefreshLogEdit()
    end)

    RefreshLogEdit()
    return logFrame
end

ToggleLog = function()
    CreateLogFrame()
    if logFrame:IsShown() then
        logFrame:Hide()
    else
        RefreshLogEdit()
        logFrame:Show()
    end
end

---------------------------------------------------------------------------
-- Setup panel (secondary): big slot view, Engrave Both, restore + log tools.
---------------------------------------------------------------------------
local PANEL_W, PANEL_H = 640, 720

-- shared card visual: faint fill + hairline outline; every box on the panel
-- (slot blocks and option sections) uses this so the layout reads as one grid
local function PanelCard(owner, x, y, w, h)
    local fill = owner:CreateTexture(nil, "BORDER")
    fill:SetTexture("Interface\\Buttons\\WHITE8X8")
    fill:SetVertexColor(1, 1, 1, 0.03)
    fill:SetPoint("TOPLEFT", x, y)
    fill:SetWidth(w)
    fill:SetHeight(h)
    local function edge(ex, ey, ew, eh)
        local t = owner:CreateTexture(nil, "ARTWORK")
        t:SetTexture("Interface\\Buttons\\WHITE8X8")
        t:SetVertexColor(1, 1, 1, 0.08)
        t:SetPoint("TOPLEFT", ex, ey)
        t:SetWidth(ew)
        t:SetHeight(eh)
    end
    edge(x, y, w, 1)
    edge(x, y - h + 1, w, 1)
    edge(x, y, 1, h)
    edge(x + w - 1, y, 1, h)
end

local function CreateSlotBlock(which, x, headerText, emptyIcon)
    local blk = CreateFrame("Frame", nil, panel)
    blk:SetWidth(296)
    blk:SetHeight(158)
    blk:SetPoint("TOPLEFT", x, -44)

    local hdr = blk:CreateFontString(nil, "OVERLAY", "GameFontNormal")
    hdr:SetPoint("TOP", 0, -10)
    hdr:SetText("|cffffd700" .. headerText .. "|r")

    local icon = blk:CreateTexture(nil, "ARTWORK")
    icon:SetWidth(34)
    icon:SetHeight(34)
    icon:SetPoint("TOP", 0, -30)
    icon:SetTexCoord(0.07, 0.93, 0.07, 0.93)

    local iconBorder = blk:CreateTexture(nil, "OVERLAY")
    iconBorder:SetTexture("Interface\\Buttons\\UI-Quickslot2")
    iconBorder:SetPoint("TOPLEFT", icon, "TOPLEFT", -11, 11)
    iconBorder:SetPoint("BOTTOMRIGHT", icon, "BOTTOMRIGHT", 11, -11)

    -- weapon mini-icon in the corner of the engrave icon (raised child frame
    -- so it draws above the slot border)
    local wiconHolder = CreateFrame("Frame", nil, blk)
    wiconHolder:SetWidth(16)
    wiconHolder:SetHeight(16)
    wiconHolder:SetPoint("BOTTOMRIGHT", icon, "BOTTOMRIGHT", 3, -3)
    wiconHolder:SetFrameLevel(blk:GetFrameLevel() + 5)
    local wicon = wiconHolder:CreateTexture(nil, "ARTWORK")
    wicon:SetAllPoints()
    wicon:SetTexCoord(0.07, 0.93, 0.07, 0.93)
    wicon:Hide()

    local wname = blk:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    wname:SetPoint("TOP", 0, -68)
    wname:SetWidth(260)
    wname:SetJustifyH("CENTER")

    local current = blk:CreateFontString(nil, "OVERLAY", "GameFontDisableSmall")
    current:SetPoint("TOP", 0, -82)
    current:SetWidth(260)
    current:SetJustifyH("CENTER")

    local pickW = CreateFrame("Button", nil, blk, "UIPanelButtonTemplate")
    pickW:SetWidth(200)
    pickW:SetHeight(21)
    pickW:SetPoint("TOP", 0, -100)
    pickW:SetNormalFontObject(GameFontNormalSmall)
    pickW:SetHighlightFontObject(GameFontHighlightSmall)
    pickW:SetScript("OnClick", function(self)
        OpenWeaponFlyout(which, self)
    end)

    -- same flow as the floating slots: click 1 preps (stashes the other
    -- weapon), click 2 on the same button casts; right-click opens the picker
    local pickS = CreateFrame("Button", "EngraveHelperPanelEngrave_" .. which, blk,
        "SecureActionButtonTemplate,UIPanelButtonTemplate")
    pickS:SetWidth(200)
    pickS:SetHeight(21)
    pickS:SetPoint("TOP", 0, -124)
    pickS:SetNormalFontObject(GameFontNormalSmall)
    pickS:SetHighlightFontObject(GameFontHighlightSmall)
    pickS:SetAttribute("type1", "spell")
    pickS:RegisterForClicks("LeftButtonUp", "RightButtonUp")
    pickS:SetScript("PreClick", function(self, button)
        if button == "RightButton" then
            self:SetAttribute("spell", nil)
            OpenSpellFlyout(which, self)
            return
        end
        -- queued and ready? this click casts right here
        if ArmPendingCast(self, which) then
            return
        end
        self:SetAttribute("spell", nil)
        if not SlotSpell(which) then
            OpenSpellFlyout(which, self)
            return
        end
        SlotPrepClick(which)
    end)
    pickS:SetScript("PostClick", function()
        UpdateCastButton()
    end)
    pickS:SetScript("OnEnter", function(self)
        GameTooltip:SetOwner(self, "ANCHOR_RIGHT")
        GameTooltip:SetText("Engrave this hand", 1, 1, 1)
        GameTooltip:AddLine("Click once to prepare (sets the other weapon aside),", 0.7, 0.7, 0.7)
        GameTooltip:AddLine("then click again when it says Engrave now!", 0.7, 0.7, 0.7)
        GameTooltip:AddLine("Right-click: pick a different engrave.", 0.5, 0.5, 0.5)
        GameTooltip:Show()
    end)
    pickS:SetScript("OnLeave", function() GameTooltip:Hide() end)

    slotUI[which] = {
        block = blk, icon = icon, wicon = wicon, wname = wname, current = current,
        pickW = pickW, pickS = pickS, emptyIcon = emptyIcon,
    }
end

RefreshSlots = function()
    if not panel then
        UpdateCastButton()
        return
    end
    for which, ui in pairs(slotUI) do
        local weapon = SlotWeapon(which)
        -- the ENGRAVE is the big picture; the weapon is the corner icon
        local spell = SlotSpell(which)
        local stex = spell and GetSpellTexture(spell)
        ui.icon:SetTexture(stex or ui.emptyIcon)
        local wtex = weapon and WeaponTexture(weapon)
        if wtex then
            ui.wicon:SetTexture(wtex)
            ui.wicon:Show()
        else
            ui.wicon:Hide()
        end
        if weapon then
            ui.wname:SetText(weapon)
            local cur = CurrentEngraveShort(weapon)
            if cur then
                ui.current:SetText("Currently: |cff55ff55" .. cur .. "|r")
            else
                ui.current:SetText("Currently: |cffff5555no engrave|r - pick one below!")
            end
        else
            ui.wname:SetText("|cff888888(no weapon equipped)|r")
            ui.current:SetText("")
        end
        ui.pickW:SetText(weapon and ("Weapon: " .. weapon) or "Pick weapon...")
    end
    UpdateCastButton()
end

local function CreatePanel()
    if panel then return panel end

    panel = CreateFrame("Frame", "EngraveHelperPanel", UIParent)
    panel:SetWidth(PANEL_W)
    panel:SetHeight(PANEL_H)
    panel:SetPoint("CENTER")
    panel:SetFrameStrata("HIGH")
    panel:SetBackdrop({
        bgFile = "Interface\\Buttons\\WHITE8X8",
        edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border",
        tile = false, edgeSize = 32,
        insets = { left = 11, right = 12, top = 12, bottom = 11 },
    })
    panel:SetBackdropColor(0.07, 0.07, 0.09, 0.97)
    panel:SetMovable(true)
    panel:EnableMouse(true)
    panel:RegisterForDrag("LeftButton")
    panel:SetScript("OnDragStart", function(self) self:StartMoving() end)
    panel:SetScript("OnDragStop", function(self) self:StopMovingOrSizing() end)
    panel:SetClampedToScreen(true)

    -- bottom-right grabber: drag to scale the whole window (saved)
    local sizer = CreateFrame("Button", nil, panel)
    sizer:SetWidth(16)
    sizer:SetHeight(16)
    sizer:SetPoint("BOTTOMRIGHT", -6, 7)
    sizer:SetNormalTexture("Interface\\ChatFrame\\UI-ChatIM-SizeGrabber-Up")
    sizer:SetHighlightTexture("Interface\\ChatFrame\\UI-ChatIM-SizeGrabber-Highlight")
    sizer:SetPushedTexture("Interface\\ChatFrame\\UI-ChatIM-SizeGrabber-Down")
    sizer:SetFrameLevel(panel:GetFrameLevel() + 10)
    sizer:SetScript("OnMouseDown", function()
        -- pin the top-left corner (UIParent coords), scale toward the cursor
        panel.sizeLeft = panel:GetLeft() * panel:GetScale()
        panel.sizeTop = panel:GetTop() * panel:GetScale()
        panel:SetScript("OnUpdate", function(self)
            local cx, cy = GetCursorPosition()
            local ues = UIParent:GetEffectiveScale()
            cx, cy = cx / ues, cy / ues
            local s = math.min((cx - self.sizeLeft) / PANEL_W, (self.sizeTop - cy) / PANEL_H)
            if s < 0.55 then s = 0.55 elseif s > 1.25 then s = 1.25 end
            self:SetScale(s)
            self:ClearAllPoints()
            self:SetPoint("TOPLEFT", UIParent, "BOTTOMLEFT", self.sizeLeft / s, self.sizeTop / s)
            db.ui.panelScale = s
        end)
    end)
    sizer:SetScript("OnMouseUp", function()
        panel:SetScript("OnUpdate", nil)
    end)
    panel:Hide()
    tinsert(UISpecialFrames, "EngraveHelperPanel")

    local title = panel:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge")
    title:SetPoint("TOP", 0, -16)
    title:SetText(COLOR .. "Engraving Helper|r")

    local headerLine = panel:CreateTexture(nil, "ARTWORK")
    headerLine:SetTexture("Interface\\Buttons\\WHITE8X8")
    headerLine:SetVertexColor(1, 0.82, 0, 0.25)
    headerLine:SetHeight(1)
    headerLine:SetWidth(592)
    headerLine:SetPoint("TOPLEFT", 24, -38)

    local close = CreateFrame("Button", nil, panel, "UIPanelCloseButton")
    close:SetPoint("TOPRIGHT", -4, -4)

    -- one shared weapons card; the two hands split by a hairline divider
    PanelCard(panel, 24, -44, 592, 158)
    CreateSlotBlock("mh", 24, "Main Hand", "Interface\\PaperDoll\\UI-PaperDoll-Slot-MainHand")
    CreateSlotBlock("oh", 320, "Off Hand", "Interface\\PaperDoll\\UI-PaperDoll-Slot-SecondaryHand")
    local handsMid = panel:CreateTexture(nil, "ARTWORK")
    handsMid:SetTexture("Interface\\Buttons\\WHITE8X8")
    handsMid:SetVertexColor(1, 1, 1, 0.08)
    handsMid:SetWidth(1)
    handsMid:SetHeight(158)
    handsMid:SetPoint("TOPLEFT", 320, -44)

    -- tab strip over one shared content card (WeakAuras-style)
    local TAB_Y, CARD_Y, CARD_H = -214, -238, 412
    PanelCard(panel, 24, CARD_Y, 592, CARD_H)

    local pages, tabs = {}, {}
    panel.pages = pages

    local function SelectTab(key)
        for k, t in pairs(tabs) do
            if k == key then
                t.fill:SetVertexColor(1, 0.82, 0, 0.10)
                t.label:SetTextColor(1, 0.82, 0)
                pages[k]:Show()
            else
                t.fill:SetVertexColor(1, 1, 1, 0.02)
                t.label:SetTextColor(0.6, 0.6, 0.6)
                pages[k]:Hide()
            end
        end
        db.ui.panelTab = key
    end
    panel.SelectTab = SelectTab

    local lastTab
    local function MakeTab(key, text, w)
        local b = CreateFrame("Button", nil, panel)
        b:SetWidth(w)
        b:SetHeight(24)
        if lastTab then
            b:SetPoint("TOPLEFT", lastTab, "TOPRIGHT", 2, 0)
        else
            b:SetPoint("TOPLEFT", 24, TAB_Y)
        end
        lastTab = b
        b.fill = b:CreateTexture(nil, "BORDER")
        b.fill:SetTexture("Interface\\Buttons\\WHITE8X8")
        b.fill:SetAllPoints()
        local hl = b:CreateTexture(nil, "HIGHLIGHT")
        hl:SetTexture("Interface\\Buttons\\WHITE8X8")
        hl:SetAllPoints()
        hl:SetAlpha(0.06)
        b.label = b:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
        b.label:SetPoint("CENTER")
        b.label:SetText(text)
        b:SetScript("OnClick", function() SelectTab(key) end)
        tabs[key] = b
        local p = CreateFrame("Frame", nil, panel)
        p:SetPoint("TOPLEFT", 24, CARD_Y)
        p:SetWidth(592)
        p:SetHeight(CARD_H)
        p:Hide()
        pages[key] = p
        return b
    end

    MakeTab("slots", "Slots", 66)
    MakeTab("sets", "Sets", 60)
    MakeTab("icon", "Icon", 60)
    MakeTab("flyout", "Flyout", 70)
    MakeTab("duration", "Duration Text", 104)
    MakeTab("remind", "Reminder", 80)
    MakeTab("tooltip", "Tooltip", 70)

    local function MakeCheck(parent, labelText, x, y, onClick)
        local cb = CreateFrame("CheckButton", nil, parent, "UICheckButtonTemplate")
        cb:SetWidth(22)
        cb:SetHeight(22)
        cb:SetPoint("TOPLEFT", x, y)
        local fs = parent:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
        fs:SetPoint("LEFT", cb, "RIGHT", 2, 0)
        fs:SetText(labelText)
        cb:SetScript("OnClick", onClick)
        return cb
    end

    -- faint horizontal spacer line inside a tab page
    local function PageDivider(page, y)
        local line = page:CreateTexture(nil, "ARTWORK")
        line:SetTexture("Interface\\Buttons\\WHITE8X8")
        line:SetVertexColor(1, 0.82, 0, 0.22)
        line:SetHeight(1)
        line:SetWidth(564)
        line:SetPoint("TOPLEFT", 14, y)
    end

    -- plain styled edit box (matches the slider input boxes)
    local function MakeBox(parent, w, x, y)
        local box = CreateFrame("EditBox", nil, parent)
        box:SetWidth(w)
        box:SetHeight(17)
        box:SetPoint("TOPLEFT", x, y)
        box:SetAutoFocus(false)
        box:SetFontObject(GameFontHighlightSmall)
        box:SetJustifyH("LEFT")
        box:SetTextInsets(4, 4, 0, 0)
        box:SetBackdrop({
            bgFile = "Interface\\Buttons\\WHITE8X8",
            edgeFile = "Interface\\Buttons\\WHITE8X8",
            edgeSize = 1,
        })
        box:SetBackdropColor(0, 0, 0, 0.5)
        box:SetBackdropBorderColor(1, 1, 1, 0.15)
        box:SetScript("OnEscapePressed", function(self) self:ClearFocus() end)
        return box
    end

    -- small labeled number box (Enter commits via `set`, display via `get`)
    local function NumBox(parent, labelText, lx, bx, y, get, set)
        local lbl = parent:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
        lbl:SetPoint("TOPLEFT", lx, y - 4)
        lbl:SetText(labelText)
        local box = MakeBox(parent, 40, bx, y)
        box:SetJustifyH("CENTER")
        box:SetScript("OnEnterPressed", function(self)
            local v = tonumber(self:GetText())
            if v then set(v) end
            self:SetText(tostring(get()))
            self:ClearFocus()
        end)
        return box
    end

    -- labeled color swatch with a get/set pair
    local function ColorSwatch(parent, x, y, labelText, get, set)
        local lbl = parent:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
        lbl:SetPoint("TOPLEFT", x, y)
        lbl:SetText(labelText)
        local sw = CreateFrame("Button", nil, parent)
        sw:SetWidth(16)
        sw:SetHeight(16)
        sw:SetPoint("LEFT", lbl, "RIGHT", 8, 0)
        local bd = sw:CreateTexture(nil, "BACKGROUND")
        bd:SetTexture("Interface\\Buttons\\WHITE8X8")
        bd:SetVertexColor(0.1, 0.1, 0.1, 1)
        bd:SetAllPoints()
        sw.tex = sw:CreateTexture(nil, "ARTWORK")
        sw.tex:SetTexture("Interface\\Buttons\\WHITE8X8")
        sw.tex:SetPoint("TOPLEFT", 1, -1)
        sw.tex:SetPoint("BOTTOMRIGHT", -1, 1)
        sw:SetScript("OnClick", function()
            local cur = get()
            ColorPickerFrame.func = function()
                local r, g, b = ColorPickerFrame:GetColorRGB()
                set({ r, g, b })
                sw.tex:SetVertexColor(r, g, b)
            end
            ColorPickerFrame.cancelFunc = function(prev)
                if prev then
                    set({ prev.r, prev.g, prev.b })
                    sw.tex:SetVertexColor(prev.r, prev.g, prev.b)
                end
            end
            ColorPickerFrame.hasOpacity = false
            ColorPickerFrame.previousValues = { r = cur[1], g = cur[2], b = cur[3] }
            ColorPickerFrame:SetColorRGB(cur[1], cur[2], cur[3])
            ColorPickerFrame:Show()
        end)
        return sw
    end

    -- type-in box BELOW a slider: Enter commits (clamped to slider range)
    local function AttachSliderInput(slider)
        local box = CreateFrame("EditBox", nil, slider:GetParent())
        box:SetWidth(44)
        box:SetHeight(17)
        box:SetPoint("TOP", slider, "BOTTOM", 0, -4)
        box:SetAutoFocus(false)
        box:SetFontObject(GameFontHighlightSmall)
        box:SetJustifyH("CENTER")
        box:SetBackdrop({
            bgFile = "Interface\\Buttons\\WHITE8X8",
            edgeFile = "Interface\\Buttons\\WHITE8X8",
            edgeSize = 1,
        })
        box:SetBackdropColor(0, 0, 0, 0.5)
        box:SetBackdropBorderColor(1, 1, 1, 0.15)
        box:SetScript("OnEnterPressed", function(self)
            local v = tonumber(self:GetText())
            if v then
                local lo, hi = slider:GetMinMaxValues()
                if v < lo then v = lo elseif v > hi then v = hi end
                slider:SetValue(v)
            end
            self:ClearFocus()
        end)
        box:SetScript("OnEscapePressed", function(self) self:ClearFocus() end)
        slider:HookScript("OnValueChanged", function(self, value)
            if not box:HasFocus() then
                box:SetText(math.floor(value + 0.5))
            end
        end)
        slider.inputBox = box
        return box
    end

    -- ---------------- Slots page ----------------
    local pgSlots = pages.slots

    local sizeSlider = CreateFrame("Slider", "EngraveHelperSizeSlider", pgSlots, "OptionsSliderTemplate")
    sizeSlider:SetWidth(240)
    sizeSlider:SetPoint("TOPLEFT", 30, -34)
    sizeSlider:SetMinMaxValues(16, 80)
    sizeSlider:SetValueStep(2)
    _G["EngraveHelperSizeSliderLow"]:SetText("16")
    _G["EngraveHelperSizeSliderHigh"]:SetText("80")
    sizeSlider:SetScript("OnValueChanged", function(self, value)
        value = math.floor(value + 0.5)
        _G["EngraveHelperSizeSliderText"]:SetText("Icon size: " .. value)
        if not self.updating then
            db.ui.size = value
            ApplyWidgetLayout()
        end
    end)
    panel.sizeSlider = sizeSlider

    local gapSlider = CreateFrame("Slider", "EngraveHelperGapSlider", pgSlots, "OptionsSliderTemplate")
    gapSlider:SetWidth(240)
    gapSlider:SetPoint("TOPLEFT", 322, -34)
    gapSlider:SetMinMaxValues(0, 100)
    gapSlider:SetValueStep(2)
    _G["EngraveHelperGapSliderLow"]:SetText("0")
    _G["EngraveHelperGapSliderHigh"]:SetText("100")
    gapSlider:SetScript("OnValueChanged", function(self, value)
        value = math.floor(value + 0.5)
        _G["EngraveHelperGapSliderText"]:SetText("Spacing: " .. value)
        if not self.updating then
            db.ui.spacing = value
            ApplyWidgetLayout()
        end
    end)
    panel.gapSlider = gapSlider
    AttachSliderInput(sizeSlider)
    AttachSliderInput(gapSlider)

    PageDivider(pgSlots, -98)

    panel.vertCheck = MakeCheck(pgSlots, "Vertical layout", 20, -110, function(self)
        db.ui.vertical = self:GetChecked() and true or false
        ApplyWidgetLayout()
    end)
    panel.lblCheck = MakeCheck(pgSlots, "MH/OH text", 220, -110, function(self)
        db.ui.showLabels = self:GetChecked() and true or false
        ApplyWidgetLayout()
    end)
    panel.arrowCheck = MakeCheck(pgSlots, "Pick arrows", 420, -110, function(self)
        db.ui.showArrow = self:GetChecked() and true or false
        ApplyWidgetLayout()
    end)
    panel.mmCheck = MakeCheck(pgSlots, "Minimap button", 20, -136, function(self)
        db.ui.minimapHide = not self:GetChecked()
        UpdateMinimapButton()
    end)
    panel.handleCheck = MakeCheck(pgSlots, "Drag handle", 220, -136, function(self)
        db.ui.showHandle = self:GetChecked() and true or false
        ApplyWidgetLayout()
    end)
    panel.hideOHCheck = MakeCheck(pgSlots, "Hide off-hand slot", 420, -136, function(self)
        db.ui.hideOH = self:GetChecked() and true or false
        ApplyWidgetLayout()
        UpdateCastButton()
    end)

    -- (swap button customization lives on the Sets tab)

    -- ---------------- Flyout page ----------------
    local pgFly = pages.flyout

    panel.hoverCheck = MakeCheck(pgFly, "Open picker on hover", 20, -24, function(self)
        db.ui.hoverOpen = self:GetChecked() and true or false
    end)
    panel.horizFlyCheck = MakeCheck(pgFly, "Horizontal layout", 20, -50, function(self)
        db.ui.flyoutHoriz = self:GetChecked() and true or false
    end)

    PageDivider(pgFly, -78)

    local sideLabel2 = pgFly:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    sideLabel2:SetPoint("TOPLEFT", 26, -94)
    sideLabel2:SetText("Opens:")

    -- ---------------- Tooltip page ----------------
    local pgTip = pages.tooltip

    panel.tipCheck = MakeCheck(pgTip, "Show tooltip", 20, -24, function(self)
        db.ui.showTooltip = self:GetChecked() and true or false
    end)
    panel.tipSmallCheck = MakeCheck(pgTip, "Small text", 250, -24, function(self)
        db.ui.tipSmall = self:GetChecked() and true or false
    end)
    panel.engraveTipCheck = MakeCheck(pgTip, "Show the engrave's spell tooltip in the picker", 20, -98, function(self)
        db.ui.engraveTips = self:GetChecked() and true or false
    end)

    PageDivider(pgTip, -50)

    local tipAnchorLabel = pgTip:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    tipAnchorLabel:SetPoint("TOPLEFT", 26, -62)
    tipAnchorLabel:SetText("Anchor:")

    local TIP_LABELS = { left = "Left", right = "Right", top = "Top", bottom = "Bottom", cursor = "Cursor" }
    local tipDrop = CreateFrame("Frame", "EngraveHelperTipDropdown", pgTip, "UIDropDownMenuTemplate")
    tipDrop:SetPoint("TOPLEFT", 70, -54)
    UIDropDownMenu_SetWidth(tipDrop, 78)
    UIDropDownMenu_Initialize(tipDrop, function()
        for _, a in ipairs({ "left", "right", "top", "bottom", "cursor" }) do
            local info = UIDropDownMenu_CreateInfo()
            info.text = TIP_LABELS[a]
            info.checked = ((db.ui.tipAnchor or "left") == a)
            info.func = function()
                db.ui.tipAnchor = a
                UIDropDownMenu_SetText(tipDrop, TIP_LABELS[a])
            end
            UIDropDownMenu_AddButton(info)
        end
    end)
    panel.tipDrop = tipDrop
    panel.TIP_LABELS = TIP_LABELS

    -- ---------------- Sets page ----------------
    local pgSets = pages.sets

    local setsInfo = pgSets:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    setsInfo:SetPoint("TOPLEFT", 20, -18)
    setsInfo:SetWidth(552)
    setsInfo:SetJustifyH("LEFT")
    setsInfo:SetText("Save two weapon loadouts (say single target and AoE), engrave them all once, then swap between fights with one click or keybind.")

    PageDivider(pgSets, -56)

    -- apply a chosen macro icon to a set + restamp its macro and the toggle
    local function ApplySetIcon(idx, opt)
        local set = GetSet(idx)
        if not set then return end
        set.icon = opt
        if set.macroName and not InCombatLockdown() then
            local mi = GetMacroIndexByName(set.macroName)
            if mi ~= 0 then
                local body, iconIndex = SetMacroBodyAndIcon(idx)
                EditMacro(mi, set.macroName, iconIndex, body)
            end
        end
        UpdateSwapMacro()
        panel.RefreshSetsTab()
    end

    -- icon picker popup: the SAME icon list the macro window shows, with
    -- the engraving icons pinned on top; mouse wheel scrolls
    local iconPicker
    local PICKER_COLS, PICKER_ROWS = 10, 7
    local function UpdateIconPickerCells()
        for i, b in ipairs(iconPicker.cells) do
            local opt = iconPicker.list[iconPicker.offset * PICKER_COLS + i]
            if opt then
                b.opt = { type = opt.type, value = opt.value }
                b.tex:SetTexture(opt.tex)
                b:Show()
            else
                b.opt = nil
                b:Hide()
            end
        end
    end

    local function OpenIconPicker(idx, anchor)
        if not iconPicker then
            iconPicker = CreateFrame("Frame", "EngraveHelperIconPicker", panel)
            iconPicker:SetFrameStrata("DIALOG")
            iconPicker:SetWidth(326)
            iconPicker:SetHeight(248)
            iconPicker:SetBackdrop({
                bgFile = "Interface\\Buttons\\WHITE8X8",
                edgeFile = "Interface\\Buttons\\WHITE8X8",
                edgeSize = 1,
            })
            iconPicker:SetBackdropColor(0.07, 0.07, 0.09, 0.98)
            iconPicker:SetBackdropBorderColor(1, 0.82, 0, 0.35)
            iconPicker:SetClampedToScreen(true)
            local title = iconPicker:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
            title:SetPoint("TOPLEFT", 10, -8)
            title:SetText("Pick an icon |cff888888(mouse wheel scrolls)|r")
            local close = CreateFrame("Button", nil, iconPicker, "UIPanelCloseButton")
            close:SetPoint("TOPRIGHT", 2, 2)
            iconPicker.cells = {}
            local SIZE, PAD = 26, 2
            for i = 1, PICKER_COLS * PICKER_ROWS do
                local c = (i - 1) % PICKER_COLS
                local r = math.floor((i - 1) / PICKER_COLS)
                local b = CreateFrame("Button", nil, iconPicker)
                b:SetWidth(SIZE)
                b:SetHeight(SIZE)
                b:SetPoint("TOPLEFT", 12 + c * (SIZE + PAD), -28 - r * (SIZE + PAD))
                b.tex = b:CreateTexture(nil, "ARTWORK")
                b.tex:SetAllPoints()
                b.tex:SetTexCoord(0.07, 0.93, 0.07, 0.93)
                b:SetHighlightTexture("Interface\\Buttons\\ButtonHilight-Square")
                b:SetScript("OnClick", function(self)
                    if not self.opt then return end
                    ApplySetIcon(iconPicker.forIdx, self.opt)
                    iconPicker:Hide()
                end)
                iconPicker.cells[i] = b
            end
            -- scrollbar on the right (mouse wheel drives it too)
            local sb = CreateFrame("Slider", nil, iconPicker)
            sb:SetOrientation("VERTICAL")
            sb:SetWidth(12)
            sb:SetPoint("TOPRIGHT", -8, -28)
            sb:SetPoint("BOTTOMRIGHT", -8, 10)
            sb:SetThumbTexture("Interface\\Buttons\\UI-ScrollBar-Knob")
            local sbBG = sb:CreateTexture(nil, "BACKGROUND")
            sbBG:SetTexture("Interface\\Buttons\\WHITE8X8")
            sbBG:SetVertexColor(0, 0, 0, 0.5)
            sbBG:SetAllPoints()
            sb:SetMinMaxValues(0, 0)
            sb:SetValueStep(1)
            sb:SetScript("OnValueChanged", function(self, v)
                v = math.floor(v + 0.5)
                if iconPicker.offset ~= v then
                    iconPicker.offset = v
                    UpdateIconPickerCells()
                end
            end)
            iconPicker.scroll = sb
            iconPicker:EnableMouseWheel(true)
            iconPicker:SetScript("OnMouseWheel", function(self, delta)
                local _, maxOff = self.scroll:GetMinMaxValues()
                self.scroll:SetValue(math.max(0, math.min(maxOff, self.offset - delta)))
            end)
            iconPicker:Hide()
        end
        local list = {}
        for _, s in ipairs(ScanEngraveSpells()) do
            list[#list + 1] = { type = "spell", value = s, tex = GetSpellTexture(s) }
        end
        for i = 1, GetNumMacroIcons() do
            local tex = GetMacroIconInfo(i)
            if tex then
                local tail = tostring(tex):lower():match("([^\\/]+)$")
                if tail then
                    list[#list + 1] = { type = "icon", value = tail, tex = tex }
                end
            end
        end
        iconPicker.list = list
        iconPicker.forIdx = idx
        iconPicker.offset = 0
        local maxOff = math.max(0, math.ceil(#list / PICKER_COLS) - PICKER_ROWS)
        iconPicker.scroll:SetMinMaxValues(0, maxOff)
        iconPicker.scroll:SetValue(0)
        UpdateIconPickerCells()
        iconPicker:ClearAllPoints()
        iconPicker:SetPoint("TOP", anchor, "BOTTOM", 0, -4)
        iconPicker:Show()
    end

    local function SetRow(idx, y)
        local nameBox = MakeBox(pgSets, 90, 20, y)
        local function ApplyName(self)
            db.sets = db.sets or {}
            db.sets[idx] = db.sets[idx] or {}
            local set = db.sets[idx]
            local t = strtrim(self:GetText() or "")
            local newName = (t ~= "") and t or nil
            if set.name ~= newName then
                set.name = newName
                -- the set's macro follows the name
                if set.macroName and GetMacroIndexByName(set.macroName) ~= 0 then
                    EnsureSetMacro(idx)
                end
                UpdateSwapMacro()
            end
            self:SetText(SetName(idx))
            self:ClearFocus()
            panel.RefreshSetsTab()
        end
        nameBox:SetScript("OnEnterPressed", ApplyName)
        nameBox:SetScript("OnEditFocusLost", ApplyName)
        nameBox:SetScript("OnEnter", function(self)
            GameTooltip:SetOwner(self, "ANCHOR_TOP")
            GameTooltip:SetText("Set name", 1, 1, 1)
            GameTooltip:AddLine("Type a name (say ST or AoE) and press Enter - or just", 0.7, 0.7, 0.7)
            GameTooltip:AddLine("click away - to save it. The set's macro is renamed too.", 0.7, 0.7, 0.7)
            GameTooltip:Show()
        end)
        nameBox:SetScript("OnLeave", function() GameTooltip:Hide() end)
        local info = pgSets:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
        info:SetPoint("TOPLEFT", 124, y - 4)
        info:SetWidth(212)
        info:SetJustifyH("LEFT")
        -- macro icon for this set: click to cycle (engrave icons first)
        local iconBtn = CreateFrame("Button", nil, pgSets)
        iconBtn:SetWidth(20)
        iconBtn:SetHeight(20)
        iconBtn:SetPoint("TOPLEFT", 348, y + 2)
        local ibd = iconBtn:CreateTexture(nil, "BACKGROUND")
        ibd:SetTexture("Interface\\Buttons\\WHITE8X8")
        ibd:SetVertexColor(0, 0, 0, 0.6)
        ibd:SetPoint("TOPLEFT", -1, 1)
        ibd:SetPoint("BOTTOMRIGHT", 1, -1)
        iconBtn.tex = iconBtn:CreateTexture(nil, "ARTWORK")
        iconBtn.tex:SetAllPoints()
        iconBtn.tex:SetTexCoord(0.07, 0.93, 0.07, 0.93)
        iconBtn:SetHighlightTexture("Interface\\Buttons\\ButtonHilight-Square")
        iconBtn:SetScript("OnEnter", function(self)
            GameTooltip:SetOwner(self, "ANCHOR_TOP")
            GameTooltip:SetText("Macro icon for this set", 1, 1, 1)
            GameTooltip:AddLine("Click to pick from all macro icons (engraving icons on top).", 0.7, 0.7, 0.7)
            GameTooltip:AddLine("The swap macro always shows the set it will equip NEXT.", 0.7, 0.7, 0.7)
            GameTooltip:Show()
        end)
        iconBtn:SetScript("OnLeave", function() GameTooltip:Hide() end)
        iconBtn:SetScript("OnClick", function(self)
            local set = GetSet(idx)
            if not (set and set.mh) then
                SetStatus("Save the set first.")
                return
            end
            OpenIconPicker(idx, self)
        end)
        local save = CreateFrame("Button", nil, pgSets, "UIPanelButtonTemplate")
        save:SetWidth(100)
        save:SetHeight(20)
        save:SetPoint("TOPLEFT", 386, y + 2)
        save:SetNormalFontObject(GameFontNormalSmall)
        save:SetHighlightFontObject(GameFontHighlightSmall)
        save:SetText("Save current")
        save:SetScript("OnClick", function()
            SaveSet(idx, strtrim(nameBox:GetText() or ""))
            panel.RefreshSetsTab()
        end)
        local equip = CreateFrame("Button", nil, pgSets, "UIPanelButtonTemplate")
        equip:SetWidth(70)
        equip:SetHeight(20)
        equip:SetPoint("TOPLEFT", 494, y + 2)
        equip:SetNormalFontObject(GameFontNormalSmall)
        equip:SetHighlightFontObject(GameFontHighlightSmall)
        equip:SetText("Equip")
        equip:SetScript("OnClick", function()
            EquipSet(idx)
        end)
        return { nameBox = nameBox, info = info, iconBtn = iconBtn }
    end
    panel.setRows = { SetRow(1, -74), SetRow(2, -110) }

    function panel.RefreshSetsTab()
        for idx, row in ipairs(panel.setRows) do
            row.nameBox:SetText(SetName(idx))
            local set = GetSet(idx)
            if set and set.mh then
                local equipped = SetMatches(idx) and " |cff55ff55(equipped)|r" or ""
                row.info:SetText(set.mh .. (set.oh and (" + " .. set.oh) or "") .. equipped)
            else
                row.info:SetText("|cff888888empty - equip the weapons, then Save current|r")
            end
            if panel.setMacroBtns and panel.setMacroBtns[idx] then
                panel.setMacroBtns[idx]:SetText(SetName(idx))
            end
            local icon = set and set.icon
            local tex
            if icon and icon.type == "spell" then
                tex = GetSpellTexture(icon.value)
            elseif icon and icon.type == "icon" then
                tex = "Interface\\Icons\\" .. icon.value
            end
            row.iconBtn.tex:SetTexture(tex or "Interface\\Icons\\Ability_DualWield")
        end
    end

    PageDivider(pgSets, -146)

    panel.swapCheck = MakeCheck(pgSets, "Show the swap button next to the slots", 20, -158, function(self)
        db.ui.showSwap = self:GetChecked() and true or false
        UpdateSwapButton()
    end)
    panel.queueCheck = MakeCheck(pgSets, "In combat, queue the swap for after combat", 20, -184, function(self)
        db.ui.swapQueue = self:GetChecked() and true or false
    end)

    -- macros are the ONLY thing that can swap weapons in combat (secure
    -- Blizzard path). "Swap macro" = ONE toggle button the addon re-points
    -- at the not-worn set after every swap; Set 1/2 = direct macros.
    local swapMacroBtn = CreateFrame("Button", nil, pgSets, "UIPanelButtonTemplate")
    swapMacroBtn:SetWidth(110)
    swapMacroBtn:SetHeight(22)
    swapMacroBtn:SetPoint("TOPLEFT", 330, -152)
    swapMacroBtn:SetNormalFontObject(GameFontNormalSmall)
    swapMacroBtn:SetHighlightFontObject(GameFontHighlightSmall)
    swapMacroBtn:SetText("Swap macro")
    swapMacroBtn:SetScript("OnEnter", function(self)
        GameTooltip:SetOwner(self, "ANCHOR_RIGHT")
        GameTooltip:SetText("Pick up the toggle macro", 1, 1, 1)
        GameTooltip:AddLine("ONE macro ('" .. SwapMacroName() .. "') that always equips the set you", 0.7, 0.7, 0.7)
        GameTooltip:AddLine("are NOT wearing; its icon shows the set it will equip.", 0.7, 0.7, 0.7)
        GameTooltip:AddLine("Drop it on an action bar and keybind it. Pressed in", 0.7, 0.7, 0.7)
        GameTooltip:AddLine("combat, the swap is queued for when combat ends.", 0.7, 0.7, 0.7)
        GameTooltip:Show()
    end)
    swapMacroBtn:SetScript("OnLeave", function() GameTooltip:Hide() end)
    swapMacroBtn:SetScript("OnClick", function()
        local name = EnsureSwapMacro()
        if name then
            PickupMacro(name)
            SetStatus("Toggle macro on cursor - drop it on an action bar, then keybind that slot.", true)
        end
    end)

    panel.setMacroBtns = {}
    for idx = 1, 2 do
        local mBtn = CreateFrame("Button", nil, pgSets, "UIPanelButtonTemplate")
        mBtn:SetWidth(70)
        mBtn:SetHeight(22)
        mBtn:SetPoint("TOPLEFT", 444 + (idx - 1) * 74, -152)
        mBtn:SetNormalFontObject(GameFontNormalSmall)
        mBtn:SetHighlightFontObject(GameFontHighlightSmall)
        mBtn:SetText("Set " .. idx)
        mBtn:SetScript("OnEnter", function(self)
            GameTooltip:SetOwner(self, "ANCHOR_RIGHT")
            GameTooltip:SetText("Pick up the " .. SetName(idx) .. " macro", 1, 1, 1)
            GameTooltip:AddLine("A macro named after the set that equips it directly.", 0.7, 0.7, 0.7)
            GameTooltip:AddLine("Re-saving or renaming the set updates the macro.", 0.7, 0.7, 0.7)
            GameTooltip:Show()
        end)
        mBtn:SetScript("OnLeave", function() GameTooltip:Hide() end)
        mBtn:SetScript("OnClick", function()
            local name = EnsureSetMacro(idx)
            if name then
                PickupMacro(name)
                SetStatus("Macro on cursor - drop it on an action bar, then keybind that slot.", true)
            end
        end)
        panel.setMacroBtns[idx] = mBtn
    end

    -- toggle macro name (default "Swap"); Enter or clicking away saves
    local swapNameLabel = pgSets:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    swapNameLabel:SetPoint("TOPLEFT", 330, -190)
    swapNameLabel:SetText("Macro name:")
    local swapNameBox = MakeBox(pgSets, 100, 408, -186)
    local function ApplySwapName(self)
        local t = strtrim(self:GetText() or "")
        if t == "" then t = "Swap" end
        t = t:sub(1, 16) -- macro name limit
        local old = SwapMacroName()
        if t ~= old then
            local mi = FindSwapMacroIndex()
            local clash = GetMacroIndexByName(t)
            if clash ~= 0 and clash ~= mi then
                SetStatus(("A macro named '%s' already exists - pick another name."):format(t))
            elseif InCombatLockdown() and mi ~= 0 then
                SetStatus("Cannot rename macros in combat.")
            else
                db.ui.swapMacroName = (t ~= "Swap") and t or nil
                UpdateSwapMacro() -- renames and restamps the macro
            end
        end
        self:SetText(SwapMacroName())
        self:ClearFocus()
    end
    swapNameBox:SetScript("OnEnterPressed", ApplySwapName)
    swapNameBox:SetScript("OnEditFocusLost", ApplySwapName)
    swapNameBox:SetScript("OnEnter", function(self)
        GameTooltip:SetOwner(self, "ANCHOR_TOP")
        GameTooltip:SetText("Swap macro name", 1, 1, 1)
        GameTooltip:AddLine("Press Enter (or click away) to save. The macro on your", 0.7, 0.7, 0.7)
        GameTooltip:AddLine("action bar is renamed to match.", 0.7, 0.7, 0.7)
        GameTooltip:Show()
    end)
    swapNameBox:SetScript("OnLeave", function() GameTooltip:Hide() end)
    panel.swapNameBox = swapNameBox

    local setsHint = pgSets:CreateFontString(nil, "OVERLAY", "GameFontDisableSmall")
    setsHint:SetPoint("TOPLEFT", 24, -220)
    setsHint:SetWidth(552)
    setsHint:SetJustifyH("LEFT")
    setsHint:SetText("Weapon swapping is blocked in combat on Ascension. Press a swap keybind in combat and the swap is QUEUED - it happens the moment combat ends (press again to cancel).")

    -- ---- swap button look & placement ----
    PageDivider(pgSets, -248)

    local swapBtnHdr = pgSets:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
    swapBtnHdr:SetPoint("TOPLEFT", 20, -256)
    swapBtnHdr:SetText("|cffffd700Swap button|r")

    local swapStyleLabel = pgSets:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    swapStyleLabel:SetPoint("TOPLEFT", 20, -288)
    swapStyleLabel:SetText("Style:")
    local SWAPBTN_MODES = { arrow = "Arrow", icon = "Set icon", text = "Set name" }
    local swapStyleDrop = CreateFrame("Frame", "EngraveHelperSwapStyleDropdown", pgSets, "UIDropDownMenuTemplate")
    swapStyleDrop:SetPoint("TOPLEFT", 52, -280)
    UIDropDownMenu_SetWidth(swapStyleDrop, 80)
    UIDropDownMenu_Initialize(swapStyleDrop, function()
        for _, m in ipairs({ "arrow", "icon", "text" }) do
            local info = UIDropDownMenu_CreateInfo()
            info.text = SWAPBTN_MODES[m]
            info.checked = ((db.ui.swapBtnMode or "arrow") == m)
            info.func = function()
                db.ui.swapBtnMode = m
                UIDropDownMenu_SetText(swapStyleDrop, SWAPBTN_MODES[m])
                UpdateSwapButton()
            end
            UIDropDownMenu_AddButton(info)
        end
    end)
    panel.swapStyleDrop = swapStyleDrop
    panel.SWAPBTN_MODES = SWAPBTN_MODES

    local swapShowLabel = pgSets:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    swapShowLabel:SetPoint("TOPLEFT", 186, -288)
    swapShowLabel:SetText("Shows:")
    local SWAPBTN_SHOWS = { current = "Current set", next = "Next set" }
    local swapShowDrop = CreateFrame("Frame", "EngraveHelperSwapShowDropdown", pgSets, "UIDropDownMenuTemplate")
    swapShowDrop:SetPoint("TOPLEFT", 228, -280)
    UIDropDownMenu_SetWidth(swapShowDrop, 90)
    UIDropDownMenu_Initialize(swapShowDrop, function()
        for _, m in ipairs({ "current", "next" }) do
            local info = UIDropDownMenu_CreateInfo()
            info.text = SWAPBTN_SHOWS[m]
            info.checked = ((db.ui.swapBtnShow or "current") == m)
            info.func = function()
                db.ui.swapBtnShow = m
                UIDropDownMenu_SetText(swapShowDrop, SWAPBTN_SHOWS[m])
                UpdateSwapButton()
            end
            UIDropDownMenu_AddButton(info)
        end
    end)
    panel.swapShowDrop = swapShowDrop
    panel.SWAPBTN_SHOWS = SWAPBTN_SHOWS

    local swapAnchorLabel = pgSets:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    swapAnchorLabel:SetPoint("TOPLEFT", 374, -288)
    swapAnchorLabel:SetText("Anchor:")
    local SWAPBTN_ANCHORS = { auto = "Auto", left = "Left", right = "Right", top = "Top", bottom = "Bottom" }
    local swapAnchorDrop = CreateFrame("Frame", "EngraveHelperSwapAnchorDropdown", pgSets, "UIDropDownMenuTemplate")
    swapAnchorDrop:SetPoint("TOPLEFT", 420, -280)
    UIDropDownMenu_SetWidth(swapAnchorDrop, 76)
    UIDropDownMenu_Initialize(swapAnchorDrop, function()
        for _, a in ipairs({ "auto", "left", "right", "top", "bottom" }) do
            local info = UIDropDownMenu_CreateInfo()
            info.text = SWAPBTN_ANCHORS[a]
            info.checked = ((db.ui.swapBtnAnchor or "auto") == a)
            info.func = function()
                db.ui.swapBtnAnchor = a
                UIDropDownMenu_SetText(swapAnchorDrop, SWAPBTN_ANCHORS[a])
                ApplyWidgetLayout()
            end
            UIDropDownMenu_AddButton(info)
        end
    end)
    panel.swapAnchorDrop = swapAnchorDrop
    panel.SWAPBTN_ANCHORS = SWAPBTN_ANCHORS

    panel.swapSizeBox = NumBox(pgSets, "Size:", 24, 62, -320,
        function() return db.ui.swapBtnSize or 20 end,
        function(v)
            db.ui.swapBtnSize = math.max(10, math.min(64, math.floor(v)))
            ApplyWidgetLayout()
        end)
    panel.swapXBox = NumBox(pgSets, "X:", 140, 162, -320,
        function() return db.ui.swapBtnX or 0 end,
        function(v)
            db.ui.swapBtnX = math.max(-200, math.min(200, math.floor(v)))
            ApplyWidgetLayout()
        end)
    panel.swapYBox = NumBox(pgSets, "Y:", 240, 262, -320,
        function() return db.ui.swapBtnY or 0 end,
        function(v)
            db.ui.swapBtnY = math.max(-200, math.min(200, math.floor(v)))
            ApplyWidgetLayout()
        end)
    panel.swapTextSwatch = ColorSwatch(pgSets, 330, -324, "Text color:",
        function() return db.ui.swapBtnTextColor or { 1, 1, 1 } end,
        function(c)
            db.ui.swapBtnTextColor = c
            UpdateSwapButton()
        end)

    -- ---- queued-swap text on the widget ----
    PageDivider(pgSets, -348)

    panel.queueTextCheck = MakeCheck(pgSets, "Show the queued-swap text on the slots", 20, -356, function(self)
        db.ui.queueTextOn = self:GetChecked() and true or false
        UpdateQueueText()
    end)
    panel.queueColorSwatch = ColorSwatch(pgSets, 380, -360, "Color:",
        function() return db.ui.queueTextColor or { 1, 0.82, 0 } end,
        function(c)
            db.ui.queueTextColor = c
            UpdateQueueText()
        end)

    local queueAnchorLabel = pgSets:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    queueAnchorLabel:SetPoint("TOPLEFT", 20, -392)
    queueAnchorLabel:SetText("Anchor:")
    local QUEUE_ANCHORS = { top = "Top", bottom = "Bottom", left = "Left", right = "Right" }
    local queueAnchorDrop = CreateFrame("Frame", "EngraveHelperQueueAnchorDropdown", pgSets, "UIDropDownMenuTemplate")
    queueAnchorDrop:SetPoint("TOPLEFT", 66, -384)
    UIDropDownMenu_SetWidth(queueAnchorDrop, 76)
    UIDropDownMenu_Initialize(queueAnchorDrop, function()
        for _, a in ipairs({ "top", "bottom", "left", "right" }) do
            local info = UIDropDownMenu_CreateInfo()
            info.text = QUEUE_ANCHORS[a]
            info.checked = ((db.ui.queueTextAnchor or "top") == a)
            info.func = function()
                db.ui.queueTextAnchor = a
                UIDropDownMenu_SetText(queueAnchorDrop, QUEUE_ANCHORS[a])
                UpdateQueueText()
            end
            UIDropDownMenu_AddButton(info)
        end
    end)
    panel.queueAnchorDrop = queueAnchorDrop
    panel.QUEUE_ANCHORS = QUEUE_ANCHORS

    panel.queueXBox = NumBox(pgSets, "X:", 220, 242, -388,
        function() return db.ui.queueTextX or 0 end,
        function(v)
            db.ui.queueTextX = math.max(-200, math.min(200, math.floor(v)))
            UpdateQueueText()
        end)
    panel.queueYBox = NumBox(pgSets, "Y:", 300, 322, -388,
        function() return db.ui.queueTextY or 0 end,
        function(v)
            db.ui.queueTextY = math.max(-200, math.min(200, math.floor(v)))
            UpdateQueueText()
        end)
    panel.queueSizeBox = NumBox(pgSets, "Size:", 380, 418, -388,
        function() return db.ui.queueTextSize or 10 end,
        function(v)
            db.ui.queueTextSize = math.max(6, math.min(32, math.floor(v)))
            UpdateQueueText()
        end)

    -- ---------------- Icon page ----------------
    local pgIcon = pages.icon

    local modeLabel = pgIcon:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    modeLabel:SetPoint("TOPLEFT", 20, -24)
    modeLabel:SetText("Big icon shows:")

    local MODE_LABELS = { engrave = "Engrave", weapon = "Weapon" }
    local modeDrop = CreateFrame("Frame", "EngraveHelperModeDropdown", pgIcon, "UIDropDownMenuTemplate")
    modeDrop:SetPoint("TOPLEFT", 130, -16)
    UIDropDownMenu_SetWidth(modeDrop, 80)
    UIDropDownMenu_Initialize(modeDrop, function()
        for _, mode in ipairs({ "engrave", "weapon" }) do
            local info = UIDropDownMenu_CreateInfo()
            info.text = MODE_LABELS[mode]
            info.checked = ((db.ui.iconMode or "engrave") == mode)
            info.func = function()
                db.ui.iconMode = mode
                UIDropDownMenu_SetText(modeDrop, MODE_LABELS[mode])
                UpdateCastButton()
            end
            UIDropDownMenu_AddButton(info)
        end
    end)
    panel.modeDrop = modeDrop
    panel.MODE_LABELS = MODE_LABELS

    panel.weapCheck = MakeCheck(pgIcon, "Secondary icon", 340, -20, function(self)
        db.ui.showWeapon = self:GetChecked() and true or false
        UpdateCastButton()
    end)

    PageDivider(pgIcon, -56)

    panel.borderCheck = MakeCheck(pgIcon, "Engrave-colored border", 20, -68, function(self)
        db.ui.borderOn = self:GetChecked() and true or false
        UpdateCastButton()
    end)

    -- put every color the addon uses back to the shipped defaults
    local resetColors = CreateFrame("Button", nil, pgIcon, "UIPanelButtonTemplate")
    resetColors:SetWidth(110)
    resetColors:SetHeight(20)
    resetColors:SetPoint("TOPLEFT", 462, -20)
    resetColors:SetNormalFontObject(GameFontNormalSmall)
    resetColors:SetHighlightFontObject(GameFontHighlightSmall)
    resetColors:SetText("Reset colors")
    resetColors:SetScript("OnEnter", function(self)
        GameTooltip:SetOwner(self, "ANCHOR_RIGHT")
        GameTooltip:SetText("Reset colors", 1, 1, 1)
        GameTooltip:AddLine("Puts the engrave border colors, duration text color", 0.7, 0.7, 0.7)
        GameTooltip:AddLine("and reminder colors back to the defaults.", 0.7, 0.7, 0.7)
        GameTooltip:Show()
    end)
    resetColors:SetScript("OnLeave", function() GameTooltip:Hide() end)
    resetColors:SetScript("OnClick", function()
        db.engraveColors = {}
        db.ui.durColor = { 1, 0.82, 0 }
        db.ui.remindColor = nil
        db.ui.remindTextColor = nil
        panel.RefreshEngraveSwatches()
        panel.durSwatch.tex:SetVertexColor(1, 0.82, 0)
        panel.remindGlowSwatch.tex:SetVertexColor(1, 0.35, 0.35)
        panel.remindTextSwatch.tex:SetVertexColor(1, 0.35, 0.35)
        UpdateCastButton()
        UpdateDurations()
        SetStatus("Colors reset to defaults.", true)
    end)

    PageDivider(pgIcon, -140)

    -- red Engrave button placement
    local btnPosLabel = pgIcon:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    btnPosLabel:SetPoint("TOPLEFT", 20, -156)
    btnPosLabel:SetText("Engrave button:")

    local BTNPOS_LABELS = { center = "Center", below = "Below", above = "Above" }
    local btnPosDrop = CreateFrame("Frame", "EngraveHelperBtnPosDropdown", pgIcon, "UIDropDownMenuTemplate")
    btnPosDrop:SetPoint("TOPLEFT", 130, -148)
    UIDropDownMenu_SetWidth(btnPosDrop, 72)
    UIDropDownMenu_Initialize(btnPosDrop, function()
        for _, p in ipairs({ "center", "below", "above" }) do
            local info = UIDropDownMenu_CreateInfo()
            info.text = BTNPOS_LABELS[p]
            info.checked = ((db.ui.btnPos or "center") == p)
            info.func = function()
                db.ui.btnPos = p
                UIDropDownMenu_SetText(btnPosDrop, BTNPOS_LABELS[p])
                ApplyWidgetLayout()
            end
            UIDropDownMenu_AddButton(info)
        end
    end)
    panel.btnPosDrop = btnPosDrop
    panel.BTNPOS_LABELS = BTNPOS_LABELS

    local styleLabel = pgIcon:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    styleLabel:SetPoint("TOPLEFT", 46, -104)
    styleLabel:SetText("Style:")

    local STYLE_LABELS = { classic = "Classic", glow = "Glow" }
    local styleDrop = CreateFrame("Frame", "EngraveHelperStyleDropdown", pgIcon, "UIDropDownMenuTemplate")
    styleDrop:SetPoint("TOPLEFT", 100, -96)
    UIDropDownMenu_SetWidth(styleDrop, 76)
    UIDropDownMenu_Initialize(styleDrop, function()
        for _, style in ipairs({ "classic", "glow" }) do
            local info = UIDropDownMenu_CreateInfo()
            info.text = STYLE_LABELS[style]
            info.checked = ((db.ui.borderStyle or "classic") == style)
            info.func = function()
                db.ui.borderStyle = style
                UIDropDownMenu_SetText(styleDrop, STYLE_LABELS[style])
                ApplyWidgetLayout()
            end
            UIDropDownMenu_AddButton(info)
        end
    end)
    panel.styleDrop = styleDrop
    panel.STYLE_LABELS = STYLE_LABELS

    -- icon crop: trims the outer edge of the icon art (Ascension icon art
    -- carries baked-in dark frames; weapon art much thicker than spells)
    local cropSlider = CreateFrame("Slider", "EngraveHelperCropSlider", pgIcon, "OptionsSliderTemplate")
    cropSlider:SetWidth(220)
    cropSlider:SetPoint("TOPLEFT", 340, -162)
    cropSlider:SetMinMaxValues(0, 20)
    cropSlider:SetValueStep(1)
    _G["EngraveHelperCropSliderLow"]:SetText("0")
    _G["EngraveHelperCropSliderHigh"]:SetText("20")
    cropSlider:SetScript("OnValueChanged", function(self, value)
        value = math.floor(value + 0.5)
        _G["EngraveHelperCropSliderText"]:SetText("Engrave crop: " .. value .. "%")
        if not self.updating then
            db.ui.iconCrop = value
            UpdateCastButton()
        end
    end)
    panel.cropSlider = cropSlider
    AttachSliderInput(cropSlider)

    local weapCropSlider = CreateFrame("Slider", "EngraveHelperWeapCropSlider", pgIcon, "OptionsSliderTemplate")
    weapCropSlider:SetWidth(220)
    weapCropSlider:SetPoint("TOPLEFT", 340, -216)
    weapCropSlider:SetMinMaxValues(0, 20)
    weapCropSlider:SetValueStep(1)
    _G["EngraveHelperWeapCropSliderLow"]:SetText("0")
    _G["EngraveHelperWeapCropSliderHigh"]:SetText("20")
    weapCropSlider:SetScript("OnValueChanged", function(self, value)
        value = math.floor(value + 0.5)
        _G["EngraveHelperWeapCropSliderText"]:SetText("Weapon crop: " .. value .. "%")
        if not self.updating then
            db.ui.weaponCrop = value
            UpdateCastButton()
        end
    end)
    panel.weapCropSlider = weapCropSlider
    AttachSliderInput(weapCropSlider)

    -- one color swatch per known engraving
    panel.engSwatches = {}
    function panel.RefreshEngraveSwatches()
        local spells = ScanEngraveSpells()
        for i, spell in ipairs(spells) do
            if i > 6 then break end
            local short = ShortSpell(spell)
            local sw = panel.engSwatches[i]
            if not sw then
                sw = CreateFrame("Button", nil, pgIcon)
                sw:SetWidth(15)
                sw:SetHeight(15)
                sw:SetPoint("TOPLEFT", 320 + (i - 1) * 44, -100)
                local bd = sw:CreateTexture(nil, "BACKGROUND")
                bd:SetTexture("Interface\\Buttons\\WHITE8X8")
                bd:SetVertexColor(0.1, 0.1, 0.1, 1)
                bd:SetAllPoints()
                sw.tex = sw:CreateTexture(nil, "ARTWORK")
                sw.tex:SetTexture("Interface\\Buttons\\WHITE8X8")
                sw.tex:SetPoint("TOPLEFT", 1, -1)
                sw.tex:SetPoint("BOTTOMRIGHT", -1, 1)
                sw.label = pgIcon:CreateFontString(nil, "OVERLAY", "GameFontDisableSmall")
                sw.label:SetPoint("TOP", sw, "BOTTOM", 0, -1)
                sw:SetScript("OnClick", function(self)
                    local cur = GetEngraveColor(self.short)
                    ColorPickerFrame.func = function()
                        local r, g, b = ColorPickerFrame:GetColorRGB()
                        db.engraveColors = db.engraveColors or {}
                        db.engraveColors[self.short] = { r, g, b }
                        self.tex:SetVertexColor(r, g, b)
                        UpdateCastButton()
                    end
                    ColorPickerFrame.cancelFunc = function(prev)
                        if prev then
                            db.engraveColors = db.engraveColors or {}
                            db.engraveColors[self.short] = { prev.r, prev.g, prev.b }
                            self.tex:SetVertexColor(prev.r, prev.g, prev.b)
                            UpdateCastButton()
                        end
                    end
                    ColorPickerFrame.hasOpacity = false
                    ColorPickerFrame.previousValues = { r = cur[1], g = cur[2], b = cur[3] }
                    ColorPickerFrame:SetColorRGB(cur[1], cur[2], cur[3])
                    ColorPickerFrame:Show()
                end)
                panel.engSwatches[i] = sw
            end
            sw.short = short
            sw.label:SetText(short)
            local c = GetEngraveColor(short)
            sw.tex:SetVertexColor(c[1], c[2], c[3])
            sw:Show()
            sw.label:Show()
        end
        for i = #spells + 1, #panel.engSwatches do
            panel.engSwatches[i]:Hide()
            panel.engSwatches[i].label:Hide()
        end
    end

    -- ---------------- Duration Text page ----------------
    local pgDur = pages.duration

    panel.durCheck = MakeCheck(pgDur, "Show duration", 20, -24, function(self)
        db.ui.showDuration = self:GetChecked() and true or false
        UpdateDurations()
    end)
    panel.shadowCheck = MakeCheck(pgDur, "Text shadow", 250, -24, function(self)
        db.ui.durShadow = self:GetChecked() and true or false
        ApplyWidgetLayout()
    end)

    PageDivider(pgDur, -92)

    local durSizeSlider = CreateFrame("Slider", "EngraveHelperDurSizeSlider", pgDur, "OptionsSliderTemplate")
    durSizeSlider:SetWidth(240)
    durSizeSlider:SetPoint("TOPLEFT", 30, -104)
    durSizeSlider:SetMinMaxValues(6, 24)
    durSizeSlider:SetValueStep(1)
    _G["EngraveHelperDurSizeSliderLow"]:SetText("6")
    _G["EngraveHelperDurSizeSliderHigh"]:SetText("24")
    durSizeSlider:SetScript("OnValueChanged", function(self, value)
        value = math.floor(value + 0.5)
        _G["EngraveHelperDurSizeSliderText"]:SetText("Text size: " .. value)
        if not self.updating then
            db.ui.durSize = value
            ApplyWidgetLayout()
        end
    end)
    panel.durSizeSlider = durSizeSlider

    local durXSlider = CreateFrame("Slider", "EngraveHelperDurXSlider", pgDur, "OptionsSliderTemplate")
    durXSlider:SetWidth(240)
    durXSlider:SetPoint("TOPLEFT", 30, -168)
    durXSlider:SetMinMaxValues(-50, 50)
    durXSlider:SetValueStep(1)
    _G["EngraveHelperDurXSliderLow"]:SetText("-50")
    _G["EngraveHelperDurXSliderHigh"]:SetText("50")
    durXSlider:SetScript("OnValueChanged", function(self, value)
        value = math.floor(value + 0.5)
        _G["EngraveHelperDurXSliderText"]:SetText("X offset: " .. value)
        if not self.updating then
            db.ui.durX = value
            ApplyWidgetLayout()
        end
    end)
    panel.durXSlider = durXSlider

    local durYSlider = CreateFrame("Slider", "EngraveHelperDurYSlider", pgDur, "OptionsSliderTemplate")
    durYSlider:SetWidth(240)
    durYSlider:SetPoint("TOPLEFT", 322, -168)
    durYSlider:SetMinMaxValues(-50, 50)
    durYSlider:SetValueStep(1)
    _G["EngraveHelperDurYSliderLow"]:SetText("-50")
    _G["EngraveHelperDurYSliderHigh"]:SetText("50")
    durYSlider:SetScript("OnValueChanged", function(self, value)
        value = math.floor(value + 0.5)
        _G["EngraveHelperDurYSliderText"]:SetText("Y offset: " .. value)
        if not self.updating then
            db.ui.durY = value
            ApplyWidgetLayout()
        end
    end)
    panel.durYSlider = durYSlider
    AttachSliderInput(durSizeSlider)
    AttachSliderInput(durXSlider)
    AttachSliderInput(durYSlider)

    -- ---------------- Reminder page ----------------
    local pgRem = pages.remind

    panel.remindCheck = MakeCheck(pgRem, "Remind me before an engrave runs out", 20, -16, function(self)
        db.ui.remindOn = self:GetChecked() and true or false
        panel.RefreshRemindUI()
        UpdateDurations()
    end)

    -- everything below only shows while the reminder is enabled
    local remBody = CreateFrame("Frame", nil, pgRem)
    remBody:SetAllPoints()

    local remAtLabel = remBody:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    remAtLabel:SetPoint("TOPLEFT", 20, -54)
    remAtLabel:SetText("Remind at:")
    local remSecsBox = MakeBox(remBody, 54, 96, -50)
    remSecsBox:SetJustifyH("CENTER")
    remSecsBox:SetScript("OnEnterPressed", function(self)
        local v = tonumber(self:GetText())
        if v and v > 0 then
            db.ui.remindSecs = math.floor(v * 60)
        end
        self:SetText(string.format("%g", (tonumber(db.ui.remindSecs) or 300) / 60))
        self:ClearFocus()
        UpdateDurations()
    end)
    panel.remindSecsBox = remSecsBox
    local remAtUnits = remBody:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    remAtUnits:SetPoint("LEFT", remSecsBox, "RIGHT", 6, 0)
    remAtUnits:SetText("minutes left")

    local remPreview = CreateFrame("Button", nil, remBody, "UIPanelButtonTemplate")
    remPreview:SetWidth(110)
    remPreview:SetHeight(22)
    remPreview:SetPoint("TOPLEFT", 452, -48)
    remPreview:SetNormalFontObject(GameFontNormalSmall)
    remPreview:SetHighlightFontObject(GameFontHighlightSmall)
    remPreview:SetText("Preview (5s)")
    remPreview:SetScript("OnClick", function()
        remindPreviewUntil = GetTime() + 5
        UpdateDurations()
    end)

    -- shared color swatch for the reminder options
    local function RemSwatch(parent, x, y, field)
        local lbl = parent:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
        lbl:SetPoint("TOPLEFT", x, y)
        lbl:SetText("Color:")
        local sw = CreateFrame("Button", nil, parent)
        sw:SetWidth(16)
        sw:SetHeight(16)
        sw:SetPoint("LEFT", lbl, "RIGHT", 8, 0)
        local bd = sw:CreateTexture(nil, "BACKGROUND")
        bd:SetTexture("Interface\\Buttons\\WHITE8X8")
        bd:SetVertexColor(0.1, 0.1, 0.1, 1)
        bd:SetAllPoints()
        sw.tex = sw:CreateTexture(nil, "ARTWORK")
        sw.tex:SetTexture("Interface\\Buttons\\WHITE8X8")
        sw.tex:SetPoint("TOPLEFT", 1, -1)
        sw.tex:SetPoint("BOTTOMRIGHT", -1, 1)
        sw:SetScript("OnClick", function()
            local cur = db.ui[field] or { 1, 0.35, 0.35 }
            ColorPickerFrame.func = function()
                local r, g, b = ColorPickerFrame:GetColorRGB()
                db.ui[field] = { r, g, b }
                sw.tex:SetVertexColor(r, g, b)
                remindPreviewUntil = GetTime() + 3
                UpdateDurations()
            end
            ColorPickerFrame.cancelFunc = function(prev)
                if prev then
                    db.ui[field] = { prev.r, prev.g, prev.b }
                    sw.tex:SetVertexColor(prev.r, prev.g, prev.b)
                    UpdateDurations()
                end
            end
            ColorPickerFrame.hasOpacity = false
            ColorPickerFrame.previousValues = { r = cur[1], g = cur[2], b = cur[3] }
            ColorPickerFrame:SetColorRGB(cur[1], cur[2], cur[3])
            ColorPickerFrame:Show()
        end)
        return sw
    end

    PageDivider(remBody, -80)

    panel.remindGlowCheck = MakeCheck(remBody, "Glow", 20, -88, function(self)
        db.ui.remindGlowOn = self:GetChecked() and true or false
        panel.RefreshRemindUI()
        ApplyWidgetLayout()
        UpdateDurations()
    end)

    local glowOpts = CreateFrame("Frame", nil, remBody)
    glowOpts:SetAllPoints()

    local remGlowStyleLabel = glowOpts:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    remGlowStyleLabel:SetPoint("TOPLEFT", 46, -124)
    remGlowStyleLabel:SetText("Style:")
    local REMIND_GLOW_LABELS = { border = "Outer glow", inner = "Inner glow", pixel = "Pixel glow", shine = "Autocast shine", proc = "Proc glow" }
    local remindGlowDrop = CreateFrame("Frame", "EngraveHelperRemindGlowDropdown", glowOpts, "UIDropDownMenuTemplate")
    remindGlowDrop:SetPoint("TOPLEFT", 86, -116)
    UIDropDownMenu_SetWidth(remindGlowDrop, 110)
    UIDropDownMenu_Initialize(remindGlowDrop, function()
        for _, t in ipairs({ "border", "inner", "pixel", "shine", "proc" }) do
            local info = UIDropDownMenu_CreateInfo()
            info.text = REMIND_GLOW_LABELS[t]
            info.checked = ((db.ui.remindGlowType or "border") == t)
            info.func = function()
                db.ui.remindGlowType = t
                UIDropDownMenu_SetText(remindGlowDrop, REMIND_GLOW_LABELS[t])
                ApplyWidgetLayout()
                remindPreviewUntil = GetTime() + 3
                UpdateDurations()
            end
            UIDropDownMenu_AddButton(info)
        end
    end)
    panel.remindGlowDrop = remindGlowDrop
    panel.REMIND_GLOW_LABELS = REMIND_GLOW_LABELS

    panel.remindGlowSwatch = RemSwatch(glowOpts, 300, -124, "remindColor")

    PageDivider(remBody, -148)

    panel.remindTextCheck = MakeCheck(remBody, "Text", 20, -156, function(self)
        db.ui.remindTextOn = self:GetChecked() and true or false
        panel.RefreshRemindUI()
        UpdateDurations()
    end)

    local textOpts = CreateFrame("Frame", nil, remBody)
    textOpts:SetAllPoints()

    local remTextLabel = textOpts:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    remTextLabel:SetPoint("TOPLEFT", 46, -194)
    remTextLabel:SetText("Text:")
    local remTextBox = MakeBox(textOpts, 190, 86, -190)
    remTextBox:SetScript("OnEnterPressed", function(self)
        local t = self:GetText()
        db.ui.remindText = (t and t ~= "") and t or nil
        self:SetText(db.ui.remindText or "Engrave fading!")
        self:ClearFocus()
        remindPreviewUntil = GetTime() + 3
        UpdateDurations()
    end)
    panel.remindTextBox = remTextBox

    panel.remindTextSwatch = RemSwatch(textOpts, 300, -194, "remindTextColor")

    function panel.RefreshRemindUI()
        if db.ui.remindOn == true then
            remBody:Show()
        else
            remBody:Hide()
        end
        if db.ui.remindGlowOn ~= false then
            glowOpts:Show()
        else
            glowOpts:Hide()
        end
        if db.ui.remindTextOn == true then
            textOpts:Show()
        else
            textOpts:Hide()
        end
    end

    -- footer: divider + status line
    local footerLine = panel:CreateTexture(nil, "ARTWORK")
    footerLine:SetTexture("Interface\\Buttons\\WHITE8X8")
    footerLine:SetVertexColor(1, 0.82, 0, 0.25)
    footerLine:SetHeight(1)
    footerLine:SetWidth(592)
    footerLine:SetPoint("TOPLEFT", 24, -664)

    statusText = panel:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    statusText:SetPoint("TOPLEFT", 24, -676)
    statusText:SetWidth(592)
    statusText:SetHeight(28)
    statusText:SetJustifyH("LEFT")
    statusText:SetJustifyV("TOP")

    -- duration text color swatch
    PageDivider(pgDur, -52)

    local swLabel = pgDur:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
    swLabel:SetPoint("TOPLEFT", 24, -66)
    swLabel:SetText("Duration color:")
    local swatch = CreateFrame("Button", nil, pgDur)
    swatch:SetWidth(16)
    swatch:SetHeight(16)
    swatch:SetPoint("LEFT", swLabel, "RIGHT", 6, 0)
    local swBorder = swatch:CreateTexture(nil, "BACKGROUND")
    swBorder:SetTexture("Interface\\Buttons\\WHITE8X8")
    swBorder:SetVertexColor(0.1, 0.1, 0.1, 1)
    swBorder:SetAllPoints()
    swatch.tex = swatch:CreateTexture(nil, "ARTWORK")
    swatch.tex:SetTexture("Interface\\Buttons\\WHITE8X8")
    swatch.tex:SetPoint("TOPLEFT", 1, -1)
    swatch.tex:SetPoint("BOTTOMRIGHT", -1, 1)
    swatch:SetScript("OnClick", function()
        local cur = db.ui.durColor or { 1, 1, 1 }
        ColorPickerFrame.func = function()
            local r, g, b = ColorPickerFrame:GetColorRGB()
            db.ui.durColor = { r, g, b }
            swatch.tex:SetVertexColor(r, g, b)
            UpdateDurations()
        end
        ColorPickerFrame.cancelFunc = function(prev)
            if prev then
                db.ui.durColor = { prev.r, prev.g, prev.b }
                swatch.tex:SetVertexColor(prev.r, prev.g, prev.b)
                UpdateDurations()
            end
        end
        ColorPickerFrame.hasOpacity = false
        ColorPickerFrame.previousValues = { r = cur[1], g = cur[2], b = cur[3] }
        ColorPickerFrame:SetColorRGB(cur[1], cur[2], cur[3])
        ColorPickerFrame:Show()
    end)
    panel.durSwatch = swatch

    local SIDE_LABELS = { top = "Up", bottom = "Down", left = "Left", right = "Right" }
    local sideDrop = CreateFrame("Frame", "EngraveHelperSideDropdown", pgFly, "UIDropDownMenuTemplate")
    sideDrop:SetPoint("TOPLEFT", 68, -86)
    UIDropDownMenu_SetWidth(sideDrop, 70)
    UIDropDownMenu_Initialize(sideDrop, function()
        for _, side in ipairs({ "top", "bottom", "left", "right" }) do
            local info = UIDropDownMenu_CreateInfo()
            info.text = SIDE_LABELS[side]
            info.checked = ((db.ui.flyoutSide or "top") == side)
            info.func = function()
                db.ui.flyoutSide = side
                UIDropDownMenu_SetText(sideDrop, SIDE_LABELS[side])
                ApplyWidgetLayout()
            end
            UIDropDownMenu_AddButton(info)
        end
    end)
    panel.sideDrop = sideDrop
    panel.SIDE_LABELS = SIDE_LABELS

    return panel
end

local function OpenPanel()
    CreatePanel()
    -- scale to fit the screen; a user-dragged size wins but is capped to fit
    local fit = math.min((UIParent:GetWidth() - 40) / PANEL_W,
                         (UIParent:GetHeight() - 40) / PANEL_H, 1)
    local s = db.ui.panelScale or fit
    if s > fit then s = fit end
    if s < 0.55 then s = 0.55 end
    panel:SetScale(s)
    panel.SelectTab(db.ui.panelTab or "slots")
    -- sync the settings controls with the saved values
    local function SyncSlider(slider, textName, label, value)
        slider.updating = true
        slider:SetValue(value)
        slider.updating = false
        _G[textName]:SetText(label .. ": " .. value)
    end
    SyncSlider(panel.sizeSlider, "EngraveHelperSizeSliderText", "Icon size", db.ui.size or 36)
    SyncSlider(panel.gapSlider, "EngraveHelperGapSliderText", "Spacing", db.ui.spacing or 14)
    SyncSlider(panel.durXSlider, "EngraveHelperDurXSliderText", "X offset", db.ui.durX or 0)
    SyncSlider(panel.durYSlider, "EngraveHelperDurYSliderText", "Y offset", db.ui.durY or 2)
    SyncSlider(panel.durSizeSlider, "EngraveHelperDurSizeSliderText", "Text size", db.ui.durSize or 10)
    SyncSlider(panel.cropSlider, "EngraveHelperCropSliderText", "Engrave crop", db.ui.iconCrop or 2)
    SyncSlider(panel.weapCropSlider, "EngraveHelperWeapCropSliderText", "Weapon crop", db.ui.weaponCrop or 8)
    panel.vertCheck:SetChecked(db.ui.vertical and true or false)
    panel.weapCheck:SetChecked(db.ui.showWeapon ~= false)
    panel.mmCheck:SetChecked(not db.ui.minimapHide)
    panel.lblCheck:SetChecked(db.ui.showLabels == true)
    panel.arrowCheck:SetChecked(db.ui.showArrow == true)
    panel.handleCheck:SetChecked(db.ui.showHandle ~= false)
    panel.hideOHCheck:SetChecked(db.ui.hideOH == true)
    panel.swapCheck:SetChecked(db.ui.showSwap == true)
    panel.queueCheck:SetChecked(db.ui.swapQueue ~= false)
    panel.swapNameBox:SetText(SwapMacroName())
    UIDropDownMenu_SetText(panel.swapStyleDrop, panel.SWAPBTN_MODES[db.ui.swapBtnMode or "arrow"])
    UIDropDownMenu_SetText(panel.swapShowDrop, panel.SWAPBTN_SHOWS[db.ui.swapBtnShow or "current"])
    UIDropDownMenu_SetText(panel.swapAnchorDrop, panel.SWAPBTN_ANCHORS[db.ui.swapBtnAnchor or "auto"])
    panel.swapSizeBox:SetText(tostring(db.ui.swapBtnSize or 20))
    panel.swapXBox:SetText(tostring(db.ui.swapBtnX or 0))
    panel.swapYBox:SetText(tostring(db.ui.swapBtnY or 0))
    local stc = db.ui.swapBtnTextColor or { 1, 1, 1 }
    panel.swapTextSwatch.tex:SetVertexColor(stc[1], stc[2], stc[3])
    panel.queueTextCheck:SetChecked(db.ui.queueTextOn ~= false)
    local qtc = db.ui.queueTextColor or { 1, 0.82, 0 }
    panel.queueColorSwatch.tex:SetVertexColor(qtc[1], qtc[2], qtc[3])
    UIDropDownMenu_SetText(panel.queueAnchorDrop, panel.QUEUE_ANCHORS[db.ui.queueTextAnchor or "top"])
    panel.queueXBox:SetText(tostring(db.ui.queueTextX or 0))
    panel.queueYBox:SetText(tostring(db.ui.queueTextY or 0))
    panel.queueSizeBox:SetText(tostring(db.ui.queueTextSize or 10))
    panel.RefreshSetsTab()
    panel.durCheck:SetChecked(db.ui.showDuration ~= false)
    panel.hoverCheck:SetChecked(db.ui.hoverOpen ~= false)
    panel.shadowCheck:SetChecked(db.ui.durShadow ~= false)
    panel.tipCheck:SetChecked(db.ui.showTooltip ~= false)
    local dc = db.ui.durColor or { 1, 1, 1 }
    panel.durSwatch.tex:SetVertexColor(dc[1], dc[2], dc[3])
    UIDropDownMenu_SetText(panel.sideDrop, panel.SIDE_LABELS[db.ui.flyoutSide or "top"])
    UIDropDownMenu_SetText(panel.modeDrop, panel.MODE_LABELS[db.ui.iconMode or "engrave"])
    UIDropDownMenu_SetText(panel.styleDrop, panel.STYLE_LABELS[db.ui.borderStyle or "classic"])
    UIDropDownMenu_SetText(panel.tipDrop, panel.TIP_LABELS[db.ui.tipAnchor or "left"])
    UIDropDownMenu_SetText(panel.btnPosDrop, panel.BTNPOS_LABELS[db.ui.btnPos or "center"])
    UIDropDownMenu_SetText(panel.remindGlowDrop, panel.REMIND_GLOW_LABELS[db.ui.remindGlowType or "border"] or "Outer glow")
    panel.remindCheck:SetChecked(db.ui.remindOn == true)
    panel.remindGlowCheck:SetChecked(db.ui.remindGlowOn ~= false)
    panel.remindTextCheck:SetChecked(db.ui.remindTextOn == true)
    panel.remindSecsBox:SetText(string.format("%g", (tonumber(db.ui.remindSecs) or 300) / 60))
    panel.remindTextBox:SetText(db.ui.remindText or "Engrave fading!")
    local rgc = db.ui.remindColor or { 1, 0.35, 0.35 }
    panel.remindGlowSwatch.tex:SetVertexColor(rgc[1], rgc[2], rgc[3])
    local rtc = db.ui.remindTextColor or { 1, 0.35, 0.35 }
    panel.remindTextSwatch.tex:SetVertexColor(rtc[1], rtc[2], rtc[3])
    panel.RefreshRemindUI()
    panel.tipSmallCheck:SetChecked(db.ui.tipSmall ~= false)
    panel.engraveTipCheck:SetChecked(db.ui.engraveTips ~= false)
    panel.horizFlyCheck:SetChecked(db.ui.flyoutHoriz == true)
    panel.borderCheck:SetChecked(db.ui.borderOn ~= false)
    panel.RefreshEngraveSwatches()
    RefreshSlots()
    if not (run.active or run.restoring) then
        SetStatus("Hover a floating slot to pick an engrave; the red button applies it.", true)
    end
    UpdateCastButton()
    panel:Show()
end

TogglePanel = function()
    if panel and panel:IsShown() then
        panel:Hide()
    else
        OpenPanel()
    end
end

---------------------------------------------------------------------------
-- Events
---------------------------------------------------------------------------
local function ActivateAddon()
    CreateWidget()
    ApplyWidgetLayout()
    CreateMinimapButton()
    RegisterInterfaceOptions()
    print(TAG .. "Loaded. Click a slot's arrow to pick an engrave, then the red Engrave button. "
        .. COLOR .. "/eh|r for settings.")
end

local f = CreateFrame("Frame")
f:RegisterEvent("ADDON_LOADED")
f:RegisterEvent("PLAYER_ENTERING_WORLD")
f:RegisterEvent("UNIT_SPELLCAST_SUCCEEDED")
f:RegisterEvent("UNIT_SPELLCAST_FAILED")
f:RegisterEvent("UNIT_SPELLCAST_INTERRUPTED")
f:RegisterEvent("BAG_UPDATE")
f:RegisterEvent("PLAYER_EQUIPMENT_CHANGED")
f:RegisterEvent("ITEM_LOCK_CHANGED")
f:RegisterEvent("PLAYER_REGEN_ENABLED")
f:SetScript("OnEvent", function(self, event, arg1, arg2)
    if event == "PLAYER_REGEN_ENABLED" then
        -- combat ended: apply the secure-button state toggles that had to
        -- wait (Enable/Disable on the panel Engrave buttons is protected),
        -- re-stamp the toggle swap macro, and fire a queued swap
        UpdateCastButton()
        UpdateSwapMacro()
        if queuedSwap then
            local idx = queuedSwap
            queuedSwap = nil
            UpdateQueueText()
            EquipSet(idx)
        end
        return
    end
    if event == "ADDON_LOADED" then
        if arg1 ~= "EngraveHelper" then return end
        self:UnregisterEvent("ADDON_LOADED")
        EngraveHelperDB = EngraveHelperDB or {}
        db = EngraveHelperDB
        -- v6: slots mirror the EQUIPPED weapons; put-back list is persistent
        if db.selectionVersion ~= 6 then
            db.selected = nil
            db.perSlot = nil
            db.enchantMap = nil
            db.mhWeapon = nil
            db.ohWeapon = nil
            if db.ohSpell == "NONE" then db.ohSpell = nil end
            db.selectionVersion = 6
        end
        db.putBack = db.putBack or {}
        db.sets = db.sets or {}
        db.ui = db.ui or {}
        -- first-install defaults (the field-tested setup)
        if db.ui.size == nil then db.ui.size = 30 end
        if db.ui.spacing == nil then db.ui.spacing = 4 end
        if db.ui.flyoutSide == nil then db.ui.flyoutSide = "top" end
        if db.ui.showWeapon == nil then db.ui.showWeapon = false end
        if db.ui.showLabels == nil then db.ui.showLabels = false end
        if db.ui.showDuration == nil then db.ui.showDuration = true end
        if db.ui.hoverOpen == nil then db.ui.hoverOpen = true end
        if db.ui.durShadow == nil then db.ui.durShadow = true end
        if db.ui.showHandle == nil then db.ui.showHandle = false end
        if db.ui.showTooltip == nil then db.ui.showTooltip = true end
        if db.ui.durX == nil then db.ui.durX = 0 end
        if db.ui.durY == nil then db.ui.durY = -10 end
        if db.ui.durColor == nil then db.ui.durColor = { 1, 0.82, 0 } end
        if db.ui.iconMode == nil then db.ui.iconMode = "engrave" end
        if db.ui.borderOn == nil then db.ui.borderOn = true end
        if db.ui.borderStyle == nil then db.ui.borderStyle = "classic" end
        if db.ui.tipAnchor == nil then db.ui.tipAnchor = "left" end
        if db.ui.tipSmall == nil then db.ui.tipSmall = true end
        if db.ui.btnPos == nil then db.ui.btnPos = "center" end
        db.engraveColors = db.engraveColors or {}
        db.ui.remindMode = nil -- dead key from an old reminder version
        -- arrows and MH/OH text are OFF by default; one-time flips
        if not db.ui.arrowDefaulted then
            db.ui.showArrow = false
            db.ui.arrowDefaulted = true
        end
        if not db.ui.labelsDefaulted then
            db.ui.showLabels = false
            db.ui.labelsDefaulted = true
        end
        if IsEngraver() then
            ActivateAddon()
        else
            -- the spellbook can be incomplete this early - the first
            -- PLAYER_ENTERING_WORLD re-checks before going dormant for good
            gDormant = true
        end

    elseif event == "PLAYER_ENTERING_WORLD" then
        if gDormant then
            if IsEngraver() then
                gDormant = false
                ActivateAddon()
            else
                print(TAG .. "No engraving spells on this character (Weapon Engraving is a Runemaster mechanic) - addon inactive.")
                self:UnregisterAllEvents()
                return
            end
        end
        if db then
            -- a reload/relog may have interrupted a run: offer the put-back
            if db.putBack and #db.putBack > 0 then
                Log("A set-aside weapon from an earlier session is pending - putting it back.")
                run.restoring = true
                QueuePump(2.0)
            end
            -- Ascension's character frame may load after us: retry the
            -- popout-arrow art harvest, then refresh
            if widget then
                for _, which in ipairs({ "mh", "oh" }) do
                    HarvestAscensionArrow(widget.slots[which].arrow)
                end
                ApplyWidgetLayout()
                UpdateDurations()
            end
            SyncSelectionToWeapon()
            RefreshSlots()
            UpdateSwapMacro()
        end

    elseif event == "UNIT_SPELLCAST_SUCCEEDED" then
        if arg1 ~= "player" or not run.active then return end
        local pending = FirstPending()
        if not pending then return end
        local spellName = arg2
        if type(spellName) == "number" then spellName = GetSpellInfo(spellName) end
        if spellName ~= pending.spell then return end
        pending.engraved = true
        run.mustSwap = true
        run.awaiting = nil
        run.lastMoveAt = GetTime() -- let the post-cast state settle too
        ClearArmed()
        Log("Engrave SUCCEEDED: '%s' on '%s' (%d/%d done).",
            tostring(spellName), pending.name, CountEngraved(), #run.targets)
        -- real verification: once things settle, read the weapon's tooltip
        -- and confirm the engrave actually landed on it
        local targetName = pending.name
        local expectShort = ShortSpell(spellName)
        After(1.2, function()
            local cur = CurrentEngraveText(targetName)
            if cur and expectShort and cur:find(expectShort, 1, true) then
                Log("Verified: '%s' now carries '%s'.", targetName, cur)
            else
                Log("CHECK: '%s' now shows engrave '%s' (expected '%s') - if that is wrong, click the slot again. (If the addon just cannot read the tooltip line, tell Arc what the weapon tooltip says.)",
                    targetName, tostring(cur), tostring(expectShort))
            end
            RefreshSlots()
        end)
        UpdateCastButton()
        QueuePump(0.7) -- wait out the item lock, then keep the run moving

    elseif event == "UNIT_SPELLCAST_FAILED" or event == "UNIT_SPELLCAST_INTERRUPTED" then
        if arg1 == "player" and run.active then
            local pending = FirstPending()
            if pending and arg2 == pending.spell then
                run.awaiting = nil
                SetStatus("Cast failed or was interrupted. Click the slot to try again.")
            end
        end

    elseif event == "ITEM_LOCK_CHANGED" then
        if run.active or run.restoring then
            QueuePump(0.3)
        end

    elseif event == "BAG_UPDATE" or event == "PLAYER_EQUIPMENT_CHANGED" then
        -- keep the slots mirroring the real equipped weapons (debounced)
        if not refreshQueued then
            refreshQueued = true
            After(0.3, function()
                refreshQueued = false
                SyncSelectionToWeapon()
                RefreshSlots()
                UpdateSwapMacro()
                UpdateSwapButton()
            end)
        end
        if run.active or run.restoring then
            QueuePump(0.4)
        end
    end
end)

---------------------------------------------------------------------------
-- Slash commands
---------------------------------------------------------------------------
SLASH_ENGRAVEHELPER1 = "/engrave"
SLASH_ENGRAVEHELPER2 = "/eh"
SlashCmdList["ENGRAVEHELPER"] = function(msg)
    if gDormant then
        print(TAG .. "Inactive on this character - Weapon Engraving is a Runemaster mechanic.")
        return
    end
    msg = strtrim((msg or ""):lower())
    if msg == "button" then
        if InCombatLockdown() then
            print(TAG .. "Cannot toggle the slots in combat.")
            return
        end
        db.buttonHidden = not db.buttonHidden
        if widget then
            if db.buttonHidden then widget:Hide() else widget:Show() end
        end
        print(TAG .. "Slots " .. (db.buttonHidden and "hidden" or "shown")
            .. ". Type " .. COLOR .. "/eh button|r to toggle them.")
    elseif msg == "swap" then
        SwapSets()
    elseif msg:find("^set%s*[12]$") then
        EquipSet(tonumber(msg:match("([12])$")))
    elseif msg == "log" then
        ToggleLog()
    elseif msg:find("^tex") then
        local path = msg:match("^tex%s+(.+)$")
        ShowTexBrowser(path)
    else
        TogglePanel()
    end
end