local CLASSIC_STYLE_FIXED_WIDTH = 110
local CLASSIC_STYLE_FIXED_HEIGHT = 12

-- Taken from the global rather than the addon vararg. Both this file and
-- NamePlateTemplates.lua are loaded by <Script> tags inside XML, and
-- whether XML-loaded chunks receive the (addonName, addonTable) varargs on
-- 3.3.5a is not something to bet the whole driver on: if they do not, then
-- select(2, ...) is nil and indexing it throws at load, taking every mixin
-- defined below with it. The global is set by ManiaxNamePlates.lua, which
-- the toc loads first.
local Addon = _G.ManiaxNamePlates
-- LibSharedMedia is shipped in this pack but, like everything else in it, is
-- optional - a player can tick these nameplates and leave SharedMedia off. The
-- bare LibStub("name") form THROWS when the library is absent, and it is
-- called at file scope, so that would take the whole driver down at load
-- rather than degrading a font choice. The silent form plus a fallback keeps
-- the plates working with stock media instead.
local LSM = LibStub and LibStub("LibSharedMedia-3.0", true)

-- Escaped, and it matters more than it looks. Written with single backslashes
-- these are "\F", "\T" and "\U", none of which is a valid Lua escape, and
-- WoW's Lua drops the backslash rather than complaining - so the strings became
-- FontsFRIZQT__.TTF and InterfaceTargetingFrameUI-StatusBar, paths with their
-- separators deleted. Nothing throws; the texture and font simply never load
-- and every plate renders empty.
--
-- The client's own file-miss telemetry is what caught it: 117 requests for
-- FontsFRIZQT__.TTF and 78 for InterfaceTargetingFrameUI-StatusBar.blp, the
-- malformed names being exactly what reached the file system.
local DEFAULT_FONT = "Fonts\\FRIZQT__.TTF"
local DEFAULT_STATUSBAR = "Interface\\TargetingFrame\\UI-StatusBar"

-- LSM:Fetch, not Fetch. Written as the latter this called ITSELF - "local
-- function f" is sugar for "local f; f = function", so the inner name resolves
-- to this function rather than to the library - and recursed until the client
-- threw a stack overflow.
--
-- Note where that landed. Fetch is called fifteen times from
-- UpdateNamePlateOptions, which runs from Addon:UpdateAll() on PLAYER_LOGIN, so
-- the whole options apply died on its first font lookup and every plate kept
-- whatever the XML template had built: no configured font, texture, size,
-- colour or cast bar. And it only happened with SharedMedia enabled, because
-- the "if LSM" guard is what let control into the recursion at all - which is
-- precisely the configuration this add-on names in its own OptionalDeps.
--
-- The third argument is LibSharedMedia's silent flag: it returns nil for an
-- unknown key instead of substituting the library's default, which is what
-- lets the fallback below stay in charge.
local function Fetch(kind, key)
    if LSM and key then
        local path = LSM:Fetch(kind, key, true)
        if path then return path end
    end
    return kind == "font" and DEFAULT_FONT or DEFAULT_STATUSBAR
end

-- Suppress the client's own plate art.
--
-- DisableBlizzPlate hides the plate's regions and children, which is right and
-- is not enough, because the client puts two of them back by two different
-- routes:
--
--   Re-bind. A CGNamePlate is recycled: when it stops being shown the DLL
--   fires NAME_PLATE_UNIT_REMOVED, and the same frame later takes a new
--   m_ownerGuid and fires ADDED again, re-initialising its art. Hiding again on
--   every add covers this, and that is why the call moved into
--   NamePlateUnitAdded.
--
--   Mouseover. CGNamePlate::OnGainFocus (0x0098E910) does
--       mov ecx, [esi+0x2b0]            ; m_focusFrame
--       or  byte ptr [ecx+0xcc], 0x10   ; set the shown bit
--   It flips the visibility bit on the frame directly, so a Lua Hide() is
--   simply overwritten every time the cursor crosses the plate. Hiding can
--   never win that one. OnLoseFocus is the mirror (and ..., 0xEF).
--
-- Alpha is the answer to the second: neither function touches the focus
-- frame's alpha - the only alpha work in OnGainFocus is a SetVertexColor on
-- m_levelFS, a recolour rather than a re-show - so a zero set here survives the
-- bit-flip. Hide and alpha together cover both routes.
--
-- Zeroing alpha on the plate ROOT would be wrong: the DLL's own alpha hook
-- writes unit->m_nameplate->m_alpha for target and occlusion fading, and our
-- frame is a child of the plate and inherits it. Only the client's own parts
-- are touched here, which is also why our frame has to be excluded by name -
-- DisableBlizzPlate cannot know which child belongs to the caller.
--
-- Kept in this add-on rather than folded into DisableBlizzPlate. That function
-- lives in !Maniax335Compat, which is force-installed on every player, and
-- other consumers call it without expecting their own frame to come back at
-- alpha 0. Changing shared infrastructure to fix one caller is how the
-- LibStub escalation problems in this pack started.
-- Recursive, and that depth is the whole point.
--
-- The first version of this walked one level: the plate's own regions and its
-- direct children. /mnp plate on a targeted mob then reported three textures
-- still at alpha 1.00 - UI-TargetingFrame-Flash and two UI-TargetingFrame-BarFill
-- - which is the red glow. Their alpha being 1.00 is the proof: anything this
-- function had reached would have read 0.00. They are regions of the plate's
-- CHILD frames, one level below where the pass stopped.
--
-- Hiding the child is not enough on its own because OnGainFocus re-shows it by
-- writing the bit directly, and once it is shown again its own textures are
-- untouched and draw at full alpha. Zeroing every texture in the subtree is
-- what actually holds, because nothing in the focus path rewrites their alpha.
--
-- Our own frame is skipped ENTIRELY, subtree included - recursing into it would
-- zero the health bar and the name we just built.
local function suppressBlizzPlateArt(frame, keep, depth)
    if not frame or frame == keep or not frame.GetRegions then return end
    depth = depth or 1
    if depth > 4 then return end

    for _, region in ipairs({ frame:GetRegions() }) do
        pcall(region.Hide, region)
        if region.SetAlpha then pcall(region.SetAlpha, region, 0) end
        -- Blank the texture as well, and this is the part that finally holds.
        --
        -- Hiding loses to OnGainFocus writing the shown bit directly. Alpha
        -- loses too: the end of OnGainFocus calls 0x490600, which sets a
        -- per-plate dirty flag and re-applies the plate's visual state, and
        -- that runs AFTER our handler on a target change. UI-TargetingFrame-Flash
        -- came back at alpha 1.00 through exactly that route.
        --
        -- A texture with no file draws nothing whatever its alpha or shown
        -- state, so the re-apply has nothing left to restore. Safe here because
        -- everything in this walk is the client's own plate art - our frame is
        -- excluded before we ever recurse.
        if region.SetTexture then pcall(region.SetTexture, region, nil) end
    end
    for _, child in ipairs({ frame:GetChildren() }) do
        if child ~= keep then
            pcall(child.Hide, child)
            if child.SetAlpha then pcall(child.SetAlpha, child, 0) end
            suppressBlizzPlateArt(child, keep, depth + 1)
        end
    end
end

NamePlateDriverMixin = {}

function NamePlateDriverMixin:OnLoad()
    self:RegisterEvent("PLAYER_ENTERING_WORLD")
    self:RegisterEvent("UNIT_FACTION")
    self:RegisterEvent("CVAR_UPDATE")

    -- The two transitions that make the client re-apply a plate's visual state.
    -- Suppressing once per unit covers the re-bind; these cover focus and
    -- target, which happen many times to the same plate while it is up.
    self:RegisterEvent("PLAYER_TARGET_CHANGED")
    self:RegisterEvent("UPDATE_MOUSEOVER_UNIT")

    EventRegistry:RegisterCallback("NamePlateManager.UnitAdded", self.NamePlateUnitAdded, self)
    EventRegistry:RegisterCallback("NamePlateManager.UnitRemoved", self.NamePlateUnitRemoved, self)

    C_NamePlateManager.SetEnableResizeNamePlates(true)
    self.pool = CreateFramePool("BUTTON", self, "NamePlateUnitFrameTemplate")
end

function NamePlateDriverMixin:GetUnitFrame(baseFrame, unit)
    local frame, isNew = self.pool:Acquire()

    -- Parent AND anchor, on every acquire rather than only for a new frame.
    --
    -- Two separate faults, both of which leave a frame that reports itself
    -- perfectly healthy and draws nothing:
    --
    -- 1. The template is setAllPoints="true", so a new frame is anchored to
    --    whatever it was created under - the pool's parent, which is the
    --    hidden NamePlateDriverFrame. But CreateFramePool defaults its
    --    resetter to FramePool_HideAndClearAnchors, and Acquire runs the
    --    resetter on NEW objects too, so ClearAllPoints() wipes that anchor
    --    before the frame is ever used. SetParent does not restore it. The
    --    result is shown=1, the right size, the right texture, the right
    --    text - and no position, so nothing renders. That is precisely what
    --    /mnp debug reported: healthBar 110x4, value 42/42, all correct, all
    --    invisible.
    --
    -- 2. On REUSE the original never called SetParent at all, so a frame
    --    recycled onto a second plate stayed parented to the first one.
    --
    -- Both are fixed by treating parenting and anchoring as per-acquire work,
    -- which is what they are: the frame is being attached to a different plate
    -- each time it comes out of the pool.
    frame:SetParent(baseFrame)
    frame:SetAllPoints(baseFrame)

    -- Also per-acquire: the size hook binds to THIS plate, and the client's
    -- own plate for THIS unit is the one to hide.
    baseFrame:SetScript("OnSizeChanged", function(self, width, height)
        frame:SetSize(width, height)
    end)

    if isNew then
        frame:EnableMouse(false)
        C_NamePlateManager.ApplyFPSIncrease(frame)
    end
    return frame
end

-- NamePlateDriverMixin:SetNamePlateSize was here and is deliberately gone.
--
-- Nothing called it - zero callers anywhere in the pack - and this repo has
-- been bitten enough times by code that is present, plausible and never
-- reached to treat an unreferenced method as a liability rather than as spare
-- capacity. Addon:UpdateAll drives the size path directly.
--
-- Removed rather than left for someone to wire up, because wiring it up would
-- have introduced a bug: it returned early when the size was unchanged, and
-- that early return skipped UpdateNamePlateOptions. Every real caller of this
-- path needs the options applied on every pass - that is what carries a font,
-- colour or bar-texture change onto the plates - so "the size did not change"
-- is exactly the case where returning early is wrong. Addon:UpdateAll gets
-- this right, calling UpdateNamePlateOptions unconditionally at the end.
--
-- Two of the three things it touched do not exist on this client anyway:
-- nameplateWidth and nameplateHeight have zero hits in Wow.exe and realm.dll,
-- and C_NamePlateManager.SetNamePlateSize is a no-op in !Maniax335Compat.

function NamePlateDriverMixin:UpdateNamePlateOptions()
    -- general settings
    local useClassicStyle = Addon:GetGeneralOption("useClassicStyle")
    
    -- enemy settings
    DefaultCompactNamePlateEnemyFrameOptions.nameplateTargetScale = Addon:GetGeneralOption("clickable", "targetScale")
    DefaultCompactNamePlateEnemyFrameOptions.useClassicStyle = useClassicStyle

    DefaultCompactNamePlateEnemyFrameOptions.displayName = Addon:GetEnemyOption("name", "displayName")
    DefaultCompactNamePlateEnemyFrameOptions.nameFont = Fetch("font", Addon:GetEnemyOption("name", "font"))
    DefaultCompactNamePlateEnemyFrameOptions.nameFontHeight = Addon:GetEnemyOption("name", "fontSize")
    DefaultCompactNamePlateEnemyFrameOptions.nameFontFlags = Addon:GetEnemyOption("name", "fontFlags")

    if useClassicStyle then
        DefaultCompactNamePlateEnemyFrameOptions.healthHeight = CLASSIC_STYLE_FIXED_HEIGHT
        DefaultCompactNamePlateEnemyFrameOptions.healthWidth = CLASSIC_STYLE_FIXED_WIDTH
    else
        DefaultCompactNamePlateEnemyFrameOptions.healthHeight = Addon:GetEnemyOption("health", "height")
        DefaultCompactNamePlateEnemyFrameOptions.healthWidth = Addon:GetEnemyOption("health", "width")
    end
    DefaultCompactNamePlateEnemyFrameOptions.healthText = Addon:GetEnemyOption("health", "textFormat")
    DefaultCompactNamePlateEnemyFrameOptions.displayStatusText = Addon:GetEnemyOption("health", "showTextFormat")
    DefaultCompactNamePlateEnemyFrameOptions.healthTextFont = Fetch("font", Addon:GetEnemyOption("health", "font"))
    DefaultCompactNamePlateEnemyFrameOptions.healthTextFontHeight = Addon:GetEnemyOption("health", "fontSize")
    DefaultCompactNamePlateEnemyFrameOptions.healthTextFontFlags = Addon:GetEnemyOption("health", "fontFlags")
    DefaultCompactNamePlateEnemyFrameOptions.healthStatusBar = Fetch("statusbar", Addon:GetEnemyOption("health", "statusBar"))
    DefaultCompactNamePlateEnemyFrameOptions.useClassColors = Addon:GetEnemyOption("health", "useClassColor")
    DefaultCompactNamePlateEnemyFrameOptions.backgroundColor = Addon:GetEnemyOption("health", "backgroundColor")
    DefaultCompactNamePlateEnemyFrameOptions.nameOnly = false

    DefaultCompactNamePlateEnemyFrameOptions.hideCastbar = not Addon:GetEnemyOption("castBar", "enabled")
    DefaultCompactNamePlateEnemyFrameOptions.castBarFont = Fetch("font", Addon:GetEnemyOption("castBar", "font"))
    DefaultCompactNamePlateEnemyFrameOptions.castBarFontHeight = Addon:GetEnemyOption("castBar", "fontSize")
    DefaultCompactNamePlateEnemyFrameOptions.castBarFontFlags = Addon:GetEnemyOption("castBar", "fontFlags")
    DefaultCompactNamePlateEnemyFrameOptions.castBarStatusBar = Fetch("statusbar", Addon:GetEnemyOption("castBar", "statusBar"))
    if useClassicStyle then
        DefaultCompactNamePlateEnemyFrameOptions.castBarHeight = CLASSIC_STYLE_FIXED_HEIGHT
        DefaultCompactNamePlateEnemyFrameOptions.showPlayerLevel = true
        DefaultCompactNamePlateEnemyFrameOptions.showNPCLevel = true
        DefaultCompactNamePlateEnemyFrameOptions.defaultBorderColor = CreateColor(0, 0, 0, 0)
    else
        DefaultCompactNamePlateEnemyFrameOptions.castBarHeight = Addon:GetEnemyOption("castBar", "height")
        DefaultCompactNamePlateEnemyFrameOptions.showPlayerLevel = Addon:GetEnemyOption("levelIndicator", "showPlayerLevel")
        DefaultCompactNamePlateEnemyFrameOptions.showNPCLevel = Addon:GetEnemyOption("levelIndicator", "showNPCLevel")
        DefaultCompactNamePlateEnemyFrameOptions.defaultBorderColor = CreateColor(0, 0, 0, 0.6)
    end
    
    DefaultCompactNamePlateEnemyFrameOptions.showQuestNPCIcons = Addon:GetEnemyOption("objectiveIcons", "showQuestNPCs")
    DefaultCompactNamePlateEnemyFrameOptions.showQuestObjectives = Addon:GetEnemyOption("objectiveIcons", "showQuestObjectives")
    DefaultCompactNamePlateEnemyFrameOptions.questIconScale = Addon:GetEnemyOption("objectiveIcons", "iconScale") * 0.5
    DefaultCompactNamePlateEnemyFrameOptions.questIconAnchor = Addon:GetEnemyOption("objectiveIcons", "anchor")

    -- friendly settings
    DefaultCompactNamePlateFriendlyFrameOptions.nameplateTargetScale = Addon:GetGeneralOption("clickable", "targetScale")
    DefaultCompactNamePlateFriendlyFrameOptions.useClassicStyle = useClassicStyle

    DefaultCompactNamePlateFriendlyFrameOptions.displayName = Addon:GetFriendlyOption("name", "displayName")
    DefaultCompactNamePlateFriendlyFrameOptions.nameFont = Fetch("font", Addon:GetFriendlyOption("name", "font"))
    DefaultCompactNamePlateFriendlyFrameOptions.nameFontHeight = Addon:GetFriendlyOption("name", "fontSize")
    DefaultCompactNamePlateFriendlyFrameOptions.nameFontFlags = Addon:GetFriendlyOption("name", "fontFlags")

    if useClassicStyle then
        DefaultCompactNamePlateFriendlyFrameOptions.healthHeight = CLASSIC_STYLE_FIXED_HEIGHT
        DefaultCompactNamePlateFriendlyFrameOptions.healthWidth = CLASSIC_STYLE_FIXED_WIDTH
    else
        DefaultCompactNamePlateFriendlyFrameOptions.healthHeight = Addon:GetFriendlyOption("health", "height")
        DefaultCompactNamePlateFriendlyFrameOptions.healthWidth = Addon:GetFriendlyOption("health", "width")
    end
    DefaultCompactNamePlateFriendlyFrameOptions.healthText = Addon:GetFriendlyOption("health", "textFormat")
    DefaultCompactNamePlateFriendlyFrameOptions.displayStatusText = Addon:GetFriendlyOption("health", "showTextFormat")
    DefaultCompactNamePlateFriendlyFrameOptions.healthTextFont = Fetch("font", Addon:GetFriendlyOption("health", "font"))
    DefaultCompactNamePlateFriendlyFrameOptions.healthTextFontHeight = Addon:GetFriendlyOption("health", "fontSize")
    DefaultCompactNamePlateFriendlyFrameOptions.healthTextFontFlags = Addon:GetFriendlyOption("health", "fontFlags")
    DefaultCompactNamePlateFriendlyFrameOptions.healthStatusBar = Fetch("statusbar", Addon:GetFriendlyOption("health", "statusBar"))
    DefaultCompactNamePlateFriendlyFrameOptions.useClassColors = Addon:GetFriendlyOption("health", "useClassColor")
    DefaultCompactNamePlateFriendlyFrameOptions.backgroundColor = Addon:GetFriendlyOption("health", "backgroundColor")
    DefaultCompactNamePlateFriendlyFrameOptions.nameOnly = Addon:GetFriendlyOption("health", "nameOnly")

    DefaultCompactNamePlateFriendlyFrameOptions.hideCastbar = not Addon:GetFriendlyOption("castBar", "enabled")
    DefaultCompactNamePlateFriendlyFrameOptions.castBarFont = Fetch("font", Addon:GetFriendlyOption("castBar", "font"))
    DefaultCompactNamePlateFriendlyFrameOptions.castBarFontHeight = Addon:GetFriendlyOption("castBar", "fontSize")
    DefaultCompactNamePlateFriendlyFrameOptions.castBarFontFlags = Addon:GetFriendlyOption("castBar", "fontFlags")
    DefaultCompactNamePlateFriendlyFrameOptions.castBarStatusBar = Fetch("statusbar", Addon:GetFriendlyOption("castBar", "statusBar"))
    if useClassicStyle then
        DefaultCompactNamePlateFriendlyFrameOptions.castBarHeight = CLASSIC_STYLE_FIXED_HEIGHT
        DefaultCompactNamePlateFriendlyFrameOptions.showPlayerLevel = true
        DefaultCompactNamePlateFriendlyFrameOptions.showNPCLevel = true
        DefaultCompactNamePlateFriendlyFrameOptions.defaultBorderColor = CreateColor(0, 0, 0, 0)
    else
        DefaultCompactNamePlateFriendlyFrameOptions.castBarHeight = Addon:GetFriendlyOption("castBar", "height")
        DefaultCompactNamePlateFriendlyFrameOptions.showPlayerLevel = Addon:GetFriendlyOption("levelIndicator", "showPlayerLevel")
        DefaultCompactNamePlateFriendlyFrameOptions.showNPCLevel = Addon:GetFriendlyOption("levelIndicator", "showNPCLevel")
        DefaultCompactNamePlateFriendlyFrameOptions.defaultBorderColor = CreateColor(0, 0, 0, 0.6)
    end

    DefaultCompactNamePlateFriendlyFrameOptions.showQuestNPCIcons = Addon:GetFriendlyOption("objectiveIcons", "showQuestNPCs")
    DefaultCompactNamePlateFriendlyFrameOptions.showQuestObjectives = Addon:GetFriendlyOption("objectiveIcons", "showQuestObjectives")
    DefaultCompactNamePlateFriendlyFrameOptions.questIconScale = Addon:GetFriendlyOption("objectiveIcons", "iconScale") * 0.5
    DefaultCompactNamePlateFriendlyFrameOptions.questIconAnchor = Addon:GetFriendlyOption("objectiveIcons", "anchor")

    -- player settings
    DefaultCompactNamePlatePlayerFrameOptions.healthHeight = Addon:GetPlayerOption("health", "height")
    DefaultCompactNamePlatePlayerFrameOptions.healthWidth = Addon:GetPlayerOption("health", "width")
    DefaultCompactNamePlatePlayerFrameOptions.healthText = Addon:GetPlayerOption("health", "textFormat")
    DefaultCompactNamePlatePlayerFrameOptions.displayStatusText = Addon:GetPlayerOption("health", "showTextFormat")
    DefaultCompactNamePlatePlayerFrameOptions.healthTextFont = Fetch("font", Addon:GetPlayerOption("health", "font"))
    DefaultCompactNamePlatePlayerFrameOptions.healthTextFontHeight = Addon:GetPlayerOption("health", "fontSize")
    DefaultCompactNamePlatePlayerFrameOptions.healthTextFontFlags = Addon:GetPlayerOption("health", "fontFlags")
    DefaultCompactNamePlatePlayerFrameOptions.healthStatusBar = Fetch("statusbar", Addon:GetPlayerOption("health", "statusBar"))
    DefaultCompactNamePlatePlayerFrameOptions.backgroundColor = Addon:GetPlayerOption("health", "backgroundColor")
    DefaultCompactNamePlatePlayerFrameOptions.nameOnly = false

    local drawClickBox = C_CVar.GetBool("DrawNameplateClickBox")
    for frame in C_NamePlateManager.EnumerateActiveNamePlates() do
        if drawClickBox then
            if not frame.ClickBoxDebug then
                frame.ClickBoxDebug = frame:CreateTexture(nil, "OVERLAY")
                frame.ClickBoxDebug:SetTexture(1, 1, 1, 0.5)
                frame.ClickBoxDebug:SetAllPoints()
            end
            frame.ClickBoxDebug:Show()
        elseif frame.ClickBoxDebug then
            frame.ClickBoxDebug:Hide()
        end
        -- Guarded, because a plate can be active without carrying a unit frame
        -- yet: EnumerateActiveNamePlates answers for every plate the client has
        -- up, and this add-on attaches its frame from the UnitAdded callback,
        -- so anything enumerated between those two points has UnitFrame nil.
        -- The line below used to dereference it unguarded while the very next
        -- line guarded the same object one field deeper, which is the shape of
        -- a check that was added after a crash and put one line too low.
        local unitFrame = frame.UnitFrame
        if unitFrame then
            unitFrame:SetUnit(unitFrame.unit)
            if unitFrame.unit then
                self:ApplyFrameOptions(unitFrame, unitFrame.unit)
            end
        end
    end

    --[[if self.nameplateBar then
        self.nameplateBar:OnOptionsUpdated()
    end
    if self.nameplateManaBar then
        self.nameplateManaBar:OnOptionsUpdated()
    end
    self:SetupClassNameplateBars()]]
end

function NamePlateDriverMixin:ApplyFrameOptions(unitFrame, unit)
    if unit and UnitIsUnit(unit, "player") then
        unitFrame:SetUpFrame(DefaultCompactNamePlatePlayerFrameSetup)
    elseif unit and UnitIsFriend("player", unit) then
        unitFrame:SetUpFrame(DefaultCompactNamePlateFriendlyFrameSetup)
    else
        unitFrame:SetUpFrame(DefaultCompactNamePlateEnemyFrameSetup)
    end
end

local unitFrames = {}
function NamePlateDriverMixin:PLAYER_ENTERING_WORLD()
    RunNextFrame(function()
        self:UpdateNamePlateOptions()
        for np in C_NamePlateManager.EnumerateActiveNamePlates() do
            -- The plate as well as the unit. NamePlateUnitAdded's first
            -- statement is "if not nameplate then return end", so passing one
            -- argument made this entire re-attach loop a silent no-op and any
            -- plate already up at zone-in went without a unit frame until the
            -- client happened to remove and re-add it.
            --
            -- Two arguments is the contract everywhere else: !Maniax335Compat
            -- fires EventRegistry:TriggerEvent("NamePlateManager.UnitAdded",
            -- unit, plate), so the callback path always supplied both and this
            -- call site was the odd one out.
            self:NamePlateUnitAdded(np._unit, np)
        end
    end)
end

function NamePlateDriverMixin:NamePlateUnitAdded(unit, nameplate)
    if not nameplate then
        return
    end
    local unitFrame = nameplate.UnitFrame
    if not unitFrame then
        unitFrame = self:GetUnitFrame(nameplate, unit)
        nameplate.UnitFrame = unitFrame
        EventRegistry:TriggerEvent("NamePlateDriver.UnitFrameCreated", nameplate)
    end

    -- Hide the client's own plate HERE, on every add, not inside GetUnitFrame.
    --
    -- GetUnitFrame runs only when nameplate.UnitFrame is nil, which is once per
    -- plate frame for the lifetime of the session - the frame is kept on the
    -- plate deliberately. The client recycles its plate frames, so every mob
    -- after the first to land on a given plate had its stock plate left
    -- showing: the rounded border, the level number and the stock health bar
    -- drawing underneath ours. Two level numbers on one plate is the tell.
    --
    -- The comment in GetUnitFrame already called this "per-acquire" work. It
    -- was right about what it needed and wrong about where that happens, which
    -- is the same mistake the anchoring fix corrected for SetParent/SetAllPoints
    -- - per-creation is not per-add. NAME_PLATE_UNIT_ADDED is the hook that
    -- fires once per unit, and it is the same hook SetStackingEnabled needs.
    C_NamePlateManager.DisableBlizzPlate(unit)
    suppressBlizzPlateArt(nameplate, unitFrame)

    unitFrames[unit] = unitFrame

    unitFrame:SetSize(C_NamePlateManager.GetNamePlateSize())
    if UnitIsUnit(unit, "player") then
        unitFrame:SetUpFrame(DefaultCompactNamePlatePlayerFrameSetup)
    elseif UnitIsFriend("player", unit) then
        unitFrame:SetUpFrame(DefaultCompactNamePlateFriendlyFrameSetup)
    else
        unitFrame:SetUpFrame(DefaultCompactNamePlateEnemyFrameSetup)
    end
    unitFrame:Show()
    unitFrame.BuffFrame:SetActive(true)
    unitFrame:SetUnit(unit)
    unitFrame:UpdateRaidTarget()
end

function NamePlateDriverMixin:NamePlateUnitRemoved(unit, nameplate)
    -- Symmetric with NamePlateUnitAdded. !Maniax335Compat always passes the
    -- plate, but this is the boundary with a provider that could be swapped -
    -- the client's own C_NamePlate, or another compat layer - and one of the
    -- two handlers already checked.
    if not nameplate then
        return
    end

    -- Drop the unit -> frame entry. It was left behind, and because unit
    -- tokens are a small recycled set ("nameplate1".."nameplate40") the stale
    -- entry is not a leak - it is a wrong answer. The token gets handed to the
    -- next mob to come into view, and until that mob's own UnitAdded lands,
    -- UNIT_FACTION below would look the token up, find the PREVIOUS mob's
    -- hidden frame, and re-run SetUpFrame on it: friendly setup applied to a
    -- frame belonging to something else, on a frame nobody can see.
    unitFrames[unit] = nil

    local unitFrame = nameplate.UnitFrame
    if not unitFrame then
        return
    end
    unitFrame.BuffFrame:SetActive(false)
    unitFrame:SetUnit(nil)
    unitFrame:Hide()

    -- Deliberately NOT self.pool:Release(unitFrame), and nameplate.UnitFrame is
    -- deliberately left set. The frames are one-to-one with the client's own
    -- plate frames, which the client itself recycles, so the set is already
    -- bounded and there is nothing to reclaim. Releasing would hand this frame
    -- to a different plate on the next acquire while this plate still points at
    -- it - the orphaned-frame failure the conflict list warns about, bought for
    -- no saving.
end

-- Re-suppress the client's art on a plate the client has just re-styled.
--
-- Blanking the textures should make this unnecessary, and it is kept anyway:
-- the re-apply path (0x490600 -> 0x490270) is the client restoring plate state
-- wholesale, and if any build of it re-sets a texture rather than only its
-- alpha, this is what catches it. One plate, twice per target change - the cost
-- does not register.
function NamePlateDriverMixin:ResuppressPlateFor(token)
    local plate = C_NamePlate and C_NamePlate.GetNamePlateForUnit
                  and C_NamePlate.GetNamePlateForUnit(token)
    if plate then
        suppressBlizzPlateArt(plate, plate.UnitFrame)
    end
end

function NamePlateDriverMixin:PLAYER_TARGET_CHANGED()
    self:ResuppressPlateFor("target")
end

function NamePlateDriverMixin:UPDATE_MOUSEOVER_UNIT()
    self:ResuppressPlateFor("mouseover")
end

function NamePlateDriverMixin:UNIT_FACTION(unit)
    local unitFrame = unitFrames[unit]
    -- unitFrame.unit as well as the entry: a frame that has been through
    -- SetUnit(nil) is torn down and has no faction to re-read.
    if unitFrame and unitFrame.unit then
        self:ApplyFrameOptions(unitFrame, unit)
    end
end

function NamePlateDriverMixin:CVAR_UPDATE(name)
    if name == "SHOW_CLASS_COLOR_IN_V_KEY" or name == "SHOW_PRIMARY_STAT_IN_NAMEPLATE" or name == "USE_CLASSIC_NAMEPLATE_STYLE" then
        self:UpdateNamePlateOptions()
    end
end