Core.lua

local ADDON, ns = ...

ns.DEFAULT_DEADZONE = 8
ns.MIN_DEADZONE     = 0
ns.MAX_DEADZONE     = 600
ns.DEFAULT_DURATION = 3.0

function ns.ClampDeadzone(v)
    v = tonumber(v)
    if not v then return nil end
    if v < ns.MIN_DEADZONE then v = ns.MIN_DEADZONE end
    if v > ns.MAX_DEADZONE then v = ns.MAX_DEADZONE end
    return math.floor(v * 10 + 0.5) / 10
end

local DEFAULTS = {
    enabled      = true,
    queueMode    = false,   -- one lane > sequential
    layeredMode  = false,   -- one lane per NPC, lanes overlap
    queueMax     = 2,       -- lines allowed to wait per lane
    channel      = "Dialog",
    stopPrevious = true,
    entries      = nil,
    seeded       = false,
}

local function CopyDefaults(src, dst)
    if type(dst) ~= "table" then dst = {} end
    for k, v in pairs(src) do
        if type(v) == "table" then
            dst[k] = CopyDefaults(v, dst[k])
        elseif dst[k] == nil then
            dst[k] = v
        end
    end
    return dst
end

--------------------------------------------------------------------------------
-- Duration estimate
--------------------------------------------------------------------------------
function ns.EstimateDuration(line)
    if type(line) ~= "string" then return ns.DEFAULT_DURATION end
    local words = 0
    for _ in line:gmatch("%S+") do words = words + 1 end
    if words == 0 then return ns.DEFAULT_DURATION end
    return 0.85 + 0.32 * words
end

--------------------------------------------------------------------------------
-- Entries
--------------------------------------------------------------------------------
function ns.BuildEntriesFromPresets()
    local entries = {}
    for i, p in ipairs(ns.presets) do
        local spellID = ns.ResolveSpell(p.spells)
        entries[i] = {
            key      = p.key,
            npc      = p.npc,
            boss     = p.boss,
            line     = p.line,
            sound    = p.sound,
            hint     = p.hint,
            spec     = p.spec,
            spellID  = spellID,
            deadzone = p.dz or ns.DEFAULT_DEADZONE,
            dur      = p.dur or ns.EstimateDuration(p.line),
            enabled  = true,
        }
    end
    return entries
end

function ns.RestoreDefaults()
    ns.DB.entries = ns.BuildEntriesFromPresets()
    ns.RebuildIndex()
end

ns.index = {}

function ns.RebuildIndex()
    wipe(ns.index)
    for _, e in ipairs(ns.DB.entries) do
        if e.spellID then ns.index[e.spellID] = e end
    end
end

function ns.AssignSpell(entry, spellID)
    for _, e in ipairs(ns.DB.entries) do
        if e ~= entry and e.spellID == spellID then
            e.spellID = nil
        end
    end
    entry.spellID = spellID
    ns.RebuildIndex()
end

--------------------------------------------------------------------------------
-- Spell info helpers
--------------------------------------------------------------------------------
function ns.SpellName(spellID)
    if not spellID then return nil end
    if C_Spell and C_Spell.GetSpellInfo then
        local info = C_Spell.GetSpellInfo(spellID)
        if info and info.name then return info.name end
    end
    return nil
end

function ns.SpellIcon(spellID)
    if not spellID then return nil end
    if C_Spell and C_Spell.GetSpellTexture then
        return C_Spell.GetSpellTexture(spellID)
    end
end

function ns.IsKnown(spellID)
    return spellID and IsPlayerSpell and IsPlayerSpell(spellID)
end

--------------------------------------------------------------------------------
-- Playback
--
-- Handles are tracked per lane so that "stop previous" only cuts a line from the same lane.
--------------------------------------------------------------------------------
local handles = {}

function ns.LaneKey(entry)
    if ns.DB.layeredMode then return entry.npc or "misc" end
    return "all"
end

function ns.Play(fileDataID, laneKey)
    fileDataID = tonumber(fileDataID)
    if not fileDataID or fileDataID == 0 then return false end
    laneKey = laneKey or "all"

    if ns.DB.stopPrevious and handles[laneKey] then
        StopSound(handles[laneKey])
        handles[laneKey] = nil
    end

    local ok, handle = PlaySoundFile(fileDataID, ns.DB.channel or "Dialog")
    if ok then handles[laneKey] = handle end
    return ok
end

function ns.StopAll()
    for _, h in pairs(handles) do StopSound(h) end
    wipe(handles)
end

-- used by the Play button in the UI
function ns.Preview(entry)
    return ns.Play(entry.sound, ns.LaneKey(entry))
end

--------------------------------------------------------------------------------
-- Lanes
--
-- queueMode   -> a single lane called "all", so nothing ever overlaps.
-- layeredMode -> one lane per NPC, so up to three lines run at once while each
--                NPC still finishes a sentence before starting the next.
--------------------------------------------------------------------------------
local lanes = {}
local StartLane

StartLane = function(laneKey, lane, entry)
    ns.Play(entry.sound, laneKey)
    local dur = math.max(tonumber(entry.dur) or ns.DEFAULT_DURATION, 0.3)
    lane.timer = C_Timer.NewTimer(dur, function()
        lane.timer = nil
        local nxt = table.remove(lane.queue, 1)
        if nxt then StartLane(laneKey, lane, nxt) end
    end)
end

function ns.ClearQueue()
    for _, lane in pairs(lanes) do
        if lane.timer then lane.timer:Cancel() end
    end
    wipe(lanes)
end

function ns.QueueLength()
    local n = 0
    for _, lane in pairs(lanes) do n = n + #lane.queue end
    return n
end

-- single entry point for the cast handler
function ns.Trigger(entry)
    if not (ns.DB.queueMode or ns.DB.layeredMode) then
        ns.Play(entry.sound, "all")          -- unchanged legacy behaviour
        return
    end

    local laneKey = ns.LaneKey(entry)
    local lane = lanes[laneKey]
    if not lane then
        lane = { queue = {} }
        lanes[laneKey] = lane
    end

    if lane.timer then
        if #lane.queue >= (ns.DB.queueMax or 2) then return end  
        for _, q in ipairs(lane.queue) do
            if q == entry then return end                       
        end
        lane.queue[#lane.queue + 1] = entry
    else
        StartLane(laneKey, lane, entry)
    end
end

--------------------------------------------------------------------------------
-- Cast handling
--------------------------------------------------------------------------------
ns.captureCallback = nil

local lastPlay = setmetatable({}, { __mode = "k" })

function ns.GetRemaining(entry)
    local t = lastPlay[entry]
    if not t then return 0 end
    local dz = entry.deadzone or ns.DEFAULT_DEADZONE
    local left = dz - (GetTime() - t)
    return left > 0 and left or 0
end

function ns.ResetDeadzones()
    wipe(lastPlay)
end

local function OnCast(unit, castGUID, spellID)
    if ns.captureCallback then
        local cb = ns.captureCallback
        ns.captureCallback = nil
        cb(spellID)
        return
    end

    if not ns.DB.enabled then return end
    local e = ns.index[spellID]
    if not e or not e.enabled then return end

    local now = GetTime()
    local last = lastPlay[e]
    
    -- 0.25s hard floor also swallows the duplicate SUCCEEDED some spells fire
    local gap = math.max(e.deadzone or ns.DEFAULT_DEADZONE, 0.25)
    if last and (now - last) < gap then return end
    lastPlay[e] = now

    ns.Trigger(e)
end

--------------------------------------------------------------------------------
-- Migrations
--------------------------------------------------------------------------------
function ns.RunMigrations()
    local from = ns.DB.dataVersion or 1
    if from >= ns.DATA_VERSION then return end

    local changed = 0
    for v = from + 1, ns.DATA_VERSION do
        for _, m in ipairs(ns.MIGRATIONS[v] or {}) do
            for _, e in ipairs(ns.DB.entries) do
                if e.key == m.key then
                    local isOldDefault = false
                    for _, id in ipairs(m.oldSpells) do
                        if e.spellID == id then isOldDefault = true break end
                    end
                    if isOldDefault or e.spellID == nil then
                        e.spellID = ns.ResolveSpell(m.newSpells)
                        local p
                        for _, pp in ipairs(ns.presets) do
                            if pp.key == m.key then p = pp break end
                        end
                        if p then e.hint = p.hint end
                        changed = changed + 1
                    end
                end
            end
        end
    end

    if changed > 0 then
        print("|cffffd28fVanguardMe|r: updated " .. changed ..
              " default binding(s) for this version.")
    end
end

--------------------------------------------------------------------------------
-- Events
--------------------------------------------------------------------------------
local f = CreateFrame("Frame")
f:RegisterEvent("ADDON_LOADED")
f:RegisterEvent("PLAYER_LOGIN")
f:RegisterUnitEvent("UNIT_SPELLCAST_SUCCEEDED", "player")
f:SetScript("OnEvent", function(self, event, ...)
    if event == "UNIT_SPELLCAST_SUCCEEDED" then
        OnCast(...)

    elseif event == "ADDON_LOADED" and ... == ADDON then
        VanguardMeDB = CopyDefaults(DEFAULTS, VanguardMeDB or {})
        ns.DB = VanguardMeDB

    elseif event == "PLAYER_LOGIN" then
        if not ns.DB.seeded or not ns.DB.entries then
            ns.DB.entries = ns.BuildEntriesFromPresets()
            ns.DB.seeded = true
        else
            -- backfill fields added by later versions
            local byKey = {}
            for _, p in ipairs(ns.presets) do byKey[p.key] = p end
            for _, e in ipairs(ns.DB.entries) do
                local p = byKey[e.key]
                if e.deadzone == nil then
                    e.deadzone = (p and p.dz) or ns.DEFAULT_DEADZONE
                end
                if e.dur == nil then
                    e.dur = (p and p.dur) or ns.EstimateDuration(e.line)
                end
            end
            ns.RunMigrations()
        end
        ns.DB.dataVersion = ns.DATA_VERSION
        -- queue and layered are mutually exclusive; layered wins if both stuck
        if ns.DB.queueMode and ns.DB.layeredMode then
            ns.DB.queueMode = false
        end
        ns.RebuildIndex()
        if ns.BuildUI then ns.BuildUI() end
    end
end)

--------------------------------------------------------------------------------
-- Slash
--------------------------------------------------------------------------------
SLASH_VANGUARDME1 = "/vgm"
SLASH_VANGUARDME2 = "/vanguardme"
SlashCmdList["VANGUARDME"] = function(msg)
    msg = (msg or ""):lower():gsub("^%s+", ""):gsub("%s+$", "")
    if msg == "off" then
        ns.DB.enabled = false
        ns.StopAll()
        ns.ClearQueue()
        print("|cffffd28fVanguardMe|r: off.")
    elseif msg == "on" then
        ns.DB.enabled = true
        ns.ResetDeadzones()
        ns.ClearQueue()
        print("|cffffd28fVanguardMe|r: on.")
    elseif msg == "reset" then
        ns.RestoreDefaults()
        ns.ResetDeadzones()
        ns.ClearQueue()
        if ns.Refresh then ns.Refresh() end
        print("|cffffd28fVanguardMe|r: bindings restored to defaults.")
    else
        if ns.Toggle then ns.Toggle() end
    end
end