Check.lua

-------------------------------------------------------------------------------
-- SmartBuff Check
-------------------------------------------------------------------------------

local SG = SMARTBUFF_GLOBALS;

-- Aura cache (rebuilt per check pass; keyed by unit then buff name)

-- SG.SMARTBUFF_ClearAuraCache
-- Clears all cached unit buff auras.
-- Parameters: none
-- Returns: nothing
function SG.SMARTBUFF_ClearAuraCache()
  wipe(SG.cAuraCache);
end

-- SG.SMARTBUFF_InvalidateAuraCache
-- Drops the aura cache entry for one unit.
-- Parameters:
--   unit (string)  Unit token
-- Returns: nothing
function SG.SMARTBUFF_InvalidateAuraCache(unit)
  if (unit) then SG.cAuraCache[unit] = nil; end
end

-- SG.SMARTBUFF_BuildAuraCache
-- Scans UnitBuff slots and builds a name-keyed cache for the unit.
-- Parameters:
--   unit (string)  Unit token
-- Returns:
--   (table)  Cache table { [buffName] = { name, icon, count, ... } }
function SG.SMARTBUFF_BuildAuraCache(unit)
  local cache = { };
  for i = 1, 40 do
    local name, icon, count, debuffType, duration, expirationTime, caster = UnitBuff(unit, i);
    if (not name) then break; end
    cache[name] = { name, icon, count, debuffType, duration, expirationTime, caster };
  end
  SG.cAuraCache[unit] = cache;
  return cache;
end

-- SG.SMARTBUFF_GetAuraCache
-- Returns the aura cache for a unit, building it if missing.
-- Parameters:
--   unit (string)  Unit token
-- Returns:
--   (table)  Aura cache for the unit
function SG.SMARTBUFF_GetAuraCache(unit)
  local cache = SG.cAuraCache[unit];
  if (not cache) then
    cache = SG.SMARTBUFF_BuildAuraCache(unit);
  end
  return cache;
end

-- SMARTBUFF_RebuildBagIndex
-- Rebuilds bag item count indexes by item ID and item name.
-- Parameters: none
-- Returns: nothing
function SMARTBUFF_RebuildBagIndex()
  wipe(SG.cBagIndexByID);
  wipe(SG.cBagIndexByName);
  for bag = 0, NUM_BAG_FRAMES do
    for slot = 1, C_Container.GetContainerNumSlots(bag) do
      local bagItemID = C_Container.GetContainerItemID(bag, slot);
      if (bagItemID) then
        local containerInfo = C_Container.GetContainerItemInfo(bag, slot);
        local stackCount = containerInfo and containerInfo.stackCount or 1;
        SG.cBagIndexByID[bagItemID] = (SG.cBagIndexByID[bagItemID] or 0) + stackCount;
        local bagItemName = GetItemInfo(bagItemID);
        if (bagItemName) then
          SG.cBagIndexByName[bagItemName] = (SG.cBagIndexByName[bagItemName] or 0) + stackCount;
        end
      end
    end
  end
  SG.cBagIndexDirty = false;
end

-- SG.SMARTBUFF_EnsureBagIndex
-- Rebuilds the bag index when marked dirty.
-- Parameters: none
-- Returns: nothing
function SG.SMARTBUFF_EnsureBagIndex()
  if (SG.cBagIndexDirty) then SMARTBUFF_RebuildBagIndex(); end
end

-- SG.SMARTBUFF_HasBagItemID
-- Checks whether the player has at least one of the given item ID in bags.
-- Parameters:
--   itemID (number)  Item ID to look up
-- Returns:
--   (boolean)  True if count > 0
function SG.SMARTBUFF_HasBagItemID(itemID)
  if (not itemID) then return false; end
  SG.SMARTBUFF_EnsureBagIndex();
  return (SG.cBagIndexByID[itemID] or 0) > 0;
end

-- SG.SMARTBUFF_HasConjuredItemList
-- Returns true if any item ID in the list is present in bags.
-- Parameters:
--   itemList (table)  Array of item IDs
-- Returns:
--   (boolean)
function SG.SMARTBUFF_HasConjuredItemList(itemList)
  if (not itemList) then return false; end
  SG.SMARTBUFF_EnsureBagIndex();
  for _, itemID in pairs(itemList) do
    if (type(itemID) == "number" and (SG.cBagIndexByID[itemID] or 0) > 0) then
      return true;
    end
  end
  return false;
end

-- SG.SMARTBUFF_GetMageGemItemID
-- Maps a mage conjure-gem buff name to its created item ID.
-- Parameters:
--   buffnS (string)  Buff short name
-- Returns:
--   (number|nil)  Item ID, or nil if not a gem conjure buff
function SG.SMARTBUFF_GetMageGemItemID(buffnS)
  if (not SG.cMageGemItemIDs) then
    SG.cMageGemItemIDs = {
      [SMARTBUFF_CREATEMGEM_AGATE] = 5514,
      [SMARTBUFF_CREATEMGEM_CITRINE] = 8007,
      [SMARTBUFF_CREATEMGEM_JADE] = 5513,
      [SMARTBUFF_CREATEMGEM_RUBY] = 8008,
      [SMARTBUFF_CREATEMGEM_EMERALD] = 22044,
    };
  end
  return SG.cMageGemItemIDs[buffnS];
end

-- SG.SMARTBUFF_IsMageConjureBuff
-- Returns whether the buff is a mage food/water/gem conjure entry.
-- Parameters:
--   buffnS (string)  Buff short name
-- Returns:
--   (boolean)
function SG.SMARTBUFF_IsMageConjureBuff(buffnS)
  return buffnS == SMARTBUFF_CONJFOOD or buffnS == SMARTBUFF_CONJWATER
    or buffnS == SMARTBUFF_CREATEMGEM_AGATE or buffnS == SMARTBUFF_CREATEMGEM_CITRINE
    or buffnS == SMARTBUFF_CREATEMGEM_JADE or buffnS == SMARTBUFF_CREATEMGEM_RUBY
    or buffnS == SMARTBUFF_CREATEMGEM_EMERALD;
end

-- SG.SMARTBUFF_IsWarlockConjureBuff
-- Returns whether the buff is a warlock soul/health/fire conjure entry.
-- Parameters:
--   buffnS (string)  Buff short name
-- Returns:
--   (boolean)
function SG.SMARTBUFF_IsWarlockConjureBuff(buffnS)
  return buffnS == SMARTBUFF_CREATEHS or buffnS == SMARTBUFF_CREATESOULS
    or buffnS == SMARTBUFF_CREATESPELLS or buffnS == SMARTBUFF_CREATEFIRES;
end

-- SMARTBUFF_PreCheck
-- Gatekeeper before a buff check: options, timers, mount/combat state, UI setup.
-- Parameters:
--   mode  (number)   0 = manual cast, 1 = auto splash, 5 = scroll wheel
--   force (boolean)  Bypass auto-timer when true
-- Returns:
--   (boolean)  True if checking may proceed
function SMARTBUFF_PreCheck(mode, force)
  if (not SG.isInit) then return false end

  if (not SG.isInitBtn) then
    SMARTBUFF_InitActionButtonPos();
  end

  if (not SG.O.Toggle) then
    if (mode == 0) then
      SMARTBUFF_AddMsg(SMARTBUFF_MSG_DISABLED);
    end
    return false;
  end

  if (mode == 1 and not force) then
    if (SG.tSkipSplashRecheck) then
      if (GetTime() < SG.tSkipSplashRecheck) then
        return false;
      end
      SG.tSkipSplashRecheck = nil;
    elseif ((GetTime() - SG.tLastCheck) < SG.O.AutoTimer) then
      return false;
    end
  end
  SG.tLastCheck = GetTime();

  -- If buffs can't casted, hide UI elements
  if (UnitInVehicle("player") or UnitHasVehicleUI("player")) then
    if (not InCombatLockdown() and SmartBuff_KeyButton:IsVisible()) then
      SmartBuff_KeyButton:Hide();
    end
    return false;
  else
    SMARTBUFF_ShowSAButton();
  end

  -- if we have nothing to do and the option is set then just hide the action button.
  if SG.O.HideSAButtonNoAction and not InCombatLockdown() then
    SmartBuff_KeyButton:Hide()
  end

  if not SG.O.HideSAButtonNoAction and not SG.O.HideSAButton then
    SMARTBUFF_SetButtonTexture(SmartBuff_KeyButton, SG.imgSB);
  end
  if (SmartBuffOptionsFrame:IsVisible()) then return false; end

  -- check for mount-spells (Classic/TBC: Paladin only)
  if (SG.sPlayerClass == "PALADIN" and (IsMounted() or IsFlying()) and not SMARTBUFF_CheckBuff("player", SMARTBUFF_CRUSADERAURA)) then
    return true;
  end
  if ((mode == 1 and not SG.O.ToggleAuto) or IsMounted() and not SG.O.ToggleMountedPrompt or IsFlying() or LootFrame:IsVisible()
    or UnitOnTaxi("player") or UnitIsDeadOrGhost("player") or UnitIsCorpse("player")
    or (mode ~= 1 and (SMARTBUFF_IsPicnic("player") or SMARTBUFF_IsFishing("player")))
    or (UnitInVehicle("player") or UnitHasVehicleUI("player"))
    or (not SG.O.BuffInCities and IsResting() and not UnitIsPVP("player"))) then

    if (UnitIsDeadOrGhost("player")) then
      SMARTBUFF_CheckBuffTimers();
    end

    return false;
  end
  if (UnitAffectingCombat("player")) then
    SG.isCombat = true;
  else
    SG.isCombat = false;
  end

  if (not SG.isCombat and SG.isSetBuffs) then
    SMARTBUFF_SetBuffs();
    SG.isSyncReq = true;
  end

  SG.sMsgWarning = "";
  SG.isFirstError = true;

  return true;
end


-- Buff timer functions

-- SMARTBUFF_CheckBuffTimers
-- Clears buff timers for dead units and resets group timers when units are cleared.
-- Parameters: none
-- Returns: nothing
function SMARTBUFF_CheckBuffTimers()
  local n = 0;
  local ct = SG.currentTemplate;
  local cGrp = SG.cUnits;
  for subgroup in pairs(cGrp) do
    n = 0;
    if (cGrp[subgroup] ~= nil) then
      for _, unit in pairs(cGrp[subgroup]) do
        if (unit) then
          if (SMARTBUFF_CheckUnitBuffTimers(unit)) then
            n = n + 1;
          end
        end
      end
      if (SG.cBuffTimer[subgroup]) then
        SG.cBuffTimer[subgroup] = nil;
        SMARTBUFF_AddMsgD("Group " .. subgroup .. ": group timer reseted");
      end
    end
  end
end

-- SMARTBUFF_CheckUnitBuffTimers
-- Clears unit and class buff timers when the unit is dead (hunters: ignores feign death).
-- Parameters:
--   unit (string)  Unit token
-- Returns:
--   (boolean|nil)  True if timers were cleared
function SMARTBUFF_CheckUnitBuffTimers(unit)
  if (UnitExists(unit) and UnitIsConnected(unit) and UnitIsFriend("player", unit) and UnitIsPlayer(unit) and UnitIsDeadOrGhost(unit)) then
    local _, uc = UnitClass(unit);
    local fd = nil;
    if (uc == "HUNTER") then
      fd = SMARTBUFF_IsFeignDeath(unit);
    end
    if (not fd) then
      if (SG.cBuffTimer[unit]) then
        SG.cBuffTimer[unit] = nil;
        SMARTBUFF_AddMsgD(UnitName(unit) .. ": unit timer reseted");
      end
      if (SG.cBuffTimer[uc]) then
        SG.cBuffTimer[uc] = nil;
        SMARTBUFF_AddMsgD(uc .. ": class timer reseted");
      end
      return true;
    end
  end
end

-- SMARTBUFF_ResetBuffTimers
-- Forces internal buff timers to near-expiry for all enabled buffs, then runs an auto check.
-- Parameters: none
-- Returns: nothing
function SMARTBUFF_ResetBuffTimers()
  if (not SG.isInit) then return; end

  local ct = SG.currentTemplate;
  local t = GetTime();
  local rbTime = 0;
  local i = 0;
  local d = 0;
  local tl = 0;
  local buffS = nil;
  local buff = nil;
  local unit = nil;
  local obj = nil;
  local uc = nil;

  local cGrp = SG.cGroups;
  for subgroup in pairs(cGrp) do
    n = 0;
    if (cGrp[subgroup] ~= nil) then

      for _, unit in pairs(cGrp[subgroup]) do
        if (unit and UnitExists(unit) and UnitIsConnected(unit) and UnitIsFriend("player", unit) and UnitIsPlayer(unit) and not UnitIsDeadOrGhost(unit)) then
          _, uc = UnitClass(unit);
          i = 1;
          while (SG.cBuffs[i] and SG.cBuffs[i].BuffS) do
            d = -1;
            buff = nil;
            rbTime = 0;
            buffS = SG.cBuffs[i].BuffS;

            rbTime = SG.B[SG.CS()][ct][buffS].RBTime;
            if (rbTime <= 0) then
              rbTime = SG.O.RebuffTimer;
            end

            if (SG.cBuffs[i].BuffG and SG.B[SG.CS()][ct][buffS].EnableG and SG.cBuffs[i].IDG ~= nil and SG.cBuffs[i].DurationG > 0) then
              d = SG.cBuffs[i].DurationG;
              buff = SG.cBuffs[i].BuffG;
              obj = subgroup;
            end

            if (d > 0 and buff) then
              if (not SG.cBuffTimer[obj]) then
                SG.cBuffTimer[obj] = { };
              end
              SG.cBuffTimer[obj][buff] = t - d + rbTime - 1;
            end

            buff = nil;
            if (buffS and SG.B[SG.CS()][ct][buffS].EnableS and SG.cBuffs[i].IDS ~= nil and SG.cBuffs[i].DurationS > 0
              and uc and SG.B[SG.CS()][ct][buffS][uc]) then
              d = SG.cBuffs[i].DurationS;
              buff = buffS;
              obj = unit;
            end

            if (d > 0 and buff) then
              if (not SG.cBuffTimer[obj]) then
                SG.cBuffTimer[obj] = { };
              end
              SG.cBuffTimer[obj][buff] = t - d + rbTime - 1;
            end

            i = i + 1;
          end

        end
      end
    end
  end
  SMARTBUFF_Check(1, true);
end

-- SMARTBUFF_ShowBuffTimers
-- Prints remaining time on all tracked internal buff timers to chat.
-- Parameters: none
-- Returns: nothing
function SMARTBUFF_ShowBuffTimers()
  if (not SG.isInit) then return; end

  local ct = SG.currentTemplate;
  local t = GetTime();
  local rbTime = 0;
  local i = 0;
  local d = 0;
  local tl = 0;
  local buffS = nil;

  for unit in pairs(SG.cBuffTimer) do
    for buff in pairs(SG.cBuffTimer[unit]) do
      if (unit and buff and SG.cBuffTimer[unit][buff]) then

        d = -1;
        buffS = nil;
        if (SG.cBuffIndex[buff]) then
          i = SG.cBuffIndex[buff];
          if (SG.cBuffs[i].BuffS == buff and SG.cBuffs[i].DurationS > 0) then
            d = SG.cBuffs[i].DurationS;
            buffS = SG.cBuffs[i].BuffS;
          elseif (SG.cBuffs[i].BuffG == buff and SG.cBuffs[i].DurationG > 0) then
            d = SG.cBuffs[i].DurationG;
            buffS = SG.cBuffs[i].BuffS;
          end
          i = i + 1;
        end

        if (buffS and SG.B[SG.CS()][ct][buffS] ~= nil) then
          if (d > 0) then
            rbTime = SG.B[SG.CS()][ct][buffS].RBTime;
            if (rbTime <= 0) then
              rbTime = SG.O.RebuffTimer;
            end
            tl = SG.cBuffTimer[unit][buff] + d - t;
            if (tl >= 0) then
              local s = "";
              if (string.find(unit, "^party") or string.find(unit, "^raid") or string.find(unit, "^player") or string.find(unit, "^pet")) then
                local un = UnitName(unit);
                if (un) then
                  un = " (" .. un .. ")";
                else
                  un = "";
                end
                s = "Unit " .. unit .. un;
              elseif (string.find(unit, "^%d$")) then
                s = "Grp " .. unit;
              else
                s = "Class " .. unit;
              end
              SMARTBUFF_AddMsg(string.format("%s: %s, time left: %.0f, rebuff time: %.0f", s, buff, tl, rbTime));
            else
              SG.cBuffTimer[unit][buff] = nil;
            end
          else
            SG.cBuffTimer[unit][buff] = nil;
          end
        end

      end
    end
  end

end

-- SMARTBUFF_SyncBuffTimers
-- Syncs internal buff timers with actual buff durations on all group units.
-- Parameters: none
-- Returns: nothing
function SMARTBUFF_SyncBuffTimers()
  if (not SG.isInit or SG.isSync or SG.isSetBuffs or SMARTBUFF_IsTalentFrameVisible()) then return; end
  SG.isSync = true;
  SG.tSync = GetTime();

  local ct = SG.currentTemplate;
  local rbTime = 0;
  local i = 0;
  local buffS = nil;
  local unit = nil;
  local uc = nil;

  local cGrp = SG.cGroups;
  for subgroup in pairs(cGrp) do
    n = 0;
    if (cGrp[subgroup] ~= nil) then
      for _, unit in pairs(cGrp[subgroup]) do
        if (unit and UnitExists(unit) and UnitIsConnected(unit) and UnitIsFriend("player", unit) and UnitIsPlayer(unit) and not UnitIsDeadOrGhost(unit)) then
          _, uc = UnitClass(unit);
          i = 1;
          while (SG.cBuffs[i] and SG.cBuffs[i].BuffS) do
            rbTime = 0;
            buffS = SG.cBuffs[i].BuffS;
            rbTime = SG.B[SG.CS()][ct][buffS].RBTime;
            if (rbTime <= 0) then
              rbTime = SG.O.RebuffTimer;
            end
            if (buffS and SG.B[SG.CS()][ct][buffS].EnableS and SG.cBuffs[i].IDS ~= nil and SG.cBuffs[i].DurationS > 0) then
              if (SG.cBuffs[i].Type ~= SMARTBUFF_CONST_SELF or (SG.cBuffs[i].Type == SMARTBUFF_CONST_SELF and SMARTBUFF_IsPlayer(unit))) then
                SMARTBUFF_SyncBuffTimer(unit, unit, SG.cBuffs[i]);
              end
            end
            i = i + 1;
          end -- END while
        end
      end -- END for
    end
  end -- END for
  SG.isSync = false;
  SG.isSyncReq = false;
end

-- SMARTBUFF_SyncBuffTimer
-- Updates one buff timer entry from the unit's current aura time remaining.
-- Parameters:
--   unit  (string)  Unit token to read auras from
--   grp   (string)  Timer group key (unit, subgroup, or class)
--   cBuff (table)   Buff definition from SG.cBuffs
-- Returns: nothing
function SMARTBUFF_SyncBuffTimer(unit, grp, cBuff)
  if (not unit or not grp or not cBuff) then return end
  local d = cBuff.DurationS;
  local buff = cBuff.BuffS;
  if (d and d > 0 and buff) then
    local t = GetTime();
    local ret, _, _, timeleft = SMARTBUFF_CheckUnitBuffs(unit, buff, cBuff.Type, cBuff.Links, cBuff.Chain);
    if (ret == nil and timeleft ~= nil) then
      if (not SG.cBuffTimer[grp]) then SG.cBuffTimer[grp] = { } end
      st = SG.Round(t - d + timeleft, 2);
      if (not SG.cBuffTimer[grp][buff] or (SG.cBuffTimer[grp][buff] and SG.cBuffTimer[grp][buff] ~= st)) then
        SG.cBuffTimer[grp][buff] = st;
        if (timeleft > 60) then
          SMARTBUFF_AddMsgD("Buff timer sync: " .. grp .. ", " .. buff .. ", " .. string.format("%.1f", timeleft/60) .. "min");
        else
          SMARTBUFF_AddMsgD("Buff timer sync: " .. grp .. ", " .. buff .. ", " .. string.format("%.1f", timeleft) .. "sec");
        end
      end
    end
  end
end

-- SMARTBUFF_IsShapeshifted
-- Detects whether the player is in shaman ghost wolf or druid shapeshift form.
-- Parameters: none
-- Returns:
--   (boolean)       True if shapeshifted
--   (string|nil)    Form name when shapeshifted
function SMARTBUFF_IsShapeshifted()
  if (SG.sPlayerClass == "SHAMAN") then
    if (GetShapeshiftForm(true) > 0) then
      return true, "Ghost Wolf";
    end
  elseif (SG.sPlayerClass == "DRUID") then
    local i;
    for i = 1, GetNumShapeshiftForms(), 1 do
      local icon, active, castable, spellId = GetShapeshiftFormInfo(i);
	  local name = GetSpellInfo(spellId);
      if (active and castable and name ~= SMARTBUFF_DRUID_TREANT) then
        return true, name;
      end
    end
  end
  return false, nil;
end

-- SG.buildSpellRankInfo
-- Scans the spellbook and builds SG.cSpellRankInfo for all ranks of a spell.
-- Parameters:
--   spell (string)  Base spell name
-- Returns: nothing (populates SG.cSpellRankInfo)
function SG.buildSpellRankInfo(spell)
  local spellName, spellSubName, name, spellID;
  local rank = 1;
  SG.cSpellRankInfo = {};  -- always clear it
  for i = 1, 300 do -- 300 is more than enough
    spellName, spellSubName = GetSpellBookItemName(i, BOOKTYPE_SPELL);
    if spellName == spell then
        name, _, _, _, _, _, spellID, _ = GetSpellInfo(spellName.."("..spellSubName..")");
        tinsert(SG.cSpellRankInfo, {rank, spellName, spellSubName, spellName.."("..spellSubName..")", spellID});
        rank = rank + 1;
	end
  end  
end

-- SG.getSpellRankInfo
-- Looks up one rank entry from SG.cSpellRankInfo.
-- Parameters:
--   rank (number)  Rank index (1-based)
-- Returns:
--   (number)  Rank index
--   (string)  Spell name
--   (string)  Sub name (rank text)
--   (string)  Full spell name with rank
--   (number)  Spell ID
function SG.getSpellRankInfo(rank)
  for rankcount, ranks in ipairs(SG.cSpellRankInfo) do 
      if ranks[1] == rank then
      return ranks[1], ranks[2], ranks[3], ranks[4], ranks[5];
      end
  end
end

-- SMARTBUFF_CheckSpellLevel (local)
-- Picks the highest spell rank valid for the target unit level.
-- Parameters:
--   spell      (string)  Base spell name
--   unit       (string)  Target unit token
--   buffLevels (table)   Minimum level per rank index
-- Returns:
--   (number|nil)  Rank, spell name, sub name, full rank name, spell ID; nil if max level or no levels
local function SMARTBUFF_CheckSpellLevel(spell, unit, buffLevels)  
  if not buffLevels then return nil; end
  local uLevel = nil; 
  local bSpellRank = 0;  
  local rank, spellName, spellSubName, spellNameRank, spellID;
  uLevel = UnitLevel(unit);   
  if uLevel == 80 then return nil; end  -- no reason to down-rank on a max level, just exit.
  SG.buildSpellRankInfo(spell);  
  -- get rank (ipairs ensures correct order so we pick the highest valid rank)
  for count, levelrange in ipairs(buffLevels) do
	  if uLevel >= levelrange then
		  bSpellRank = count;
	  end
  end
  rank, spellName, spellSubName, spellNameRank, spellID = SG.getSpellRankInfo(bSpellRank)
  return rank, spellName, spellSubName, spellNameRank, spellID;
end

-- SMARTBUFF_Check
-- Main buff check: combat buffs, target, then party/raid units in order.
-- Parameters:
--   mode  (number)   0 = manual, 1 = auto splash, 5 = scroll wheel
--   force (boolean)  Force check past auto-timer
-- Returns:
--   (number)              Result code from SMARTBUFF_BuffUnit (0/1/3) or nil
--   (string|nil)          Action type (spell/item)
--   (string|nil)          Spell or item name
--   (number|nil)          Inventory slot
--   (string|nil)          Unit token
--   (number|nil)          Buff type constant
function SMARTBUFF_Check(mode, force)
  if (SG.IsChecking or not SMARTBUFF_PreCheck(mode, force)) then return; end
  SG.IsChecking = true;
  SG.SMARTBUFF_ClearAuraCache();
  SG.SMARTBUFF_EnsureBagIndex();
  local ct = SG.currentTemplate;
  local unit = nil;
  local units = nil;
  local unitsGrp = nil;
  local unitB = nil;
  local unitL = nil;
  local unitU = nil;
  local idL = nil;
  local idU = nil;
  local subgroup = 0;
  local i;
  local j;
  local n;
  local m;
  local rc;
  local rank;
  local reagent;
  local nGlobal = 0;

  SMARTBUFF_checkBlacklist();

  -- 1. check in combat buffs
  if (InCombatLockdown()) then -- and SG.O.InCombat
    for spell in pairs(SG.cBuffsCombat) do
      if (spell) then
        local ret, actionType, spellName, slot, unit, buffType = SMARTBUFF_BuffUnit("player", 0, mode, spell)
        SMARTBUFF_AddMsgD("Check combat spell: " .. spell .. ", ret = " .. ret);
        if (ret and ret == 0) then
          SG.IsChecking = false;
          return;
        end
      end
    end
  end

  -- 2. buff target, if enabled
  if ((mode == 0 or mode == 5) and SG.O.BuffTarget) then
    local actionType, spellName, slot, buffType;
    i, actionType, spellName, slot, _, buffType = SMARTBUFF_BuffUnit("target", 0, mode);
    if (i <= 1) then
      if (i == 0) then
        --SG.tLastCheck = GetTime() - SG.O.AutoTimer + SG.GlobalCd;
      end
      SG.IsChecking = false;
      return i, actionType, spellName, slot, "target", buffType;
    end
  end

  -- 3. check groups
  local cGrp = SG.cGroups;
  local cOrd = SG.cOrderGrp;
  SG.isMounted = IsMounted() or IsFlying();

  for _, subgroup in pairs(cOrd) do
    if (cGrp[subgroup] ~= nil or (type(subgroup) == "number" and subgroup == 1)) then
      if (cGrp[subgroup] ~= nil) then
        units = cGrp[subgroup];
      else
        units = nil;
      end
      if (SG.cUnits and type(subgroup) == "number" and subgroup == 1) then
        unitsGrp = SG.cUnits[1];
      else
        unitsGrp = units;
      end 

      -- check buffs
      if (units) then
        for _, unit in pairs(units) do
          if (SG.isSetBuffs) then break; end
          SMARTBUFF_AddMsgD("Checking single unit = "..unit);
          local spellName, actionType, slot, buffType;
          i, actionType, spellName, slot, _, buffType = SMARTBUFF_BuffUnit(unit, subgroup, mode);

          if (i <= 1) then
            if (i == 0 and mode ~= 1) then
              --SG.tLastCheck = GetTime() - SG.O.AutoTimer + SG.GlobalCd;
              if (actionType == SMARTBUFF_ACTION_ITEM) then
                --SG.tLastCheck = SG.tLastCheck + 2;
              end
            end
            SG.IsChecking = false;
            return i, actionType, spellName, slot, unit, buffType;
          end
        end
      end
    end
  end -- for groups

  if (mode == 0) then
    if (SG.sMsgWarning == "" or SG.sMsgWarning == " ") then
      SMARTBUFF_AddMsg(SMARTBUFF_MSG_NOTHINGTODO);
    else
      SMARTBUFF_AddMsgWarn(SG.sMsgWarning);
      SG.sMsgWarning = "";
    end
  end
  SG.IsChecking = false;
end

-- SMARTBUFF_BuffUnit
-- Evaluates all enabled buffs in list order for one unit; casts or shows splash.
-- Parameters:
--   unit      (string)       Unit token
--   subgroup  (number|string) Raid/party subgroup key for group timers
--   mode      (number)       0 = cast, 1 = splash check, 5 = scroll wheel
--   spell     (string|nil)   Optional single-spell filter (combat buffs)
-- Returns:
--   (number)       0 = action/splash taken, 1 = cooldown, 3 = nothing to do
--   plus actionType, spellName, slot, unit, buffType when casting (mode 0/5)
function SMARTBUFF_BuffUnit(unit, subgroup, mode, spell)
  local bs = nil;
  local buff = nil;
  local buffname = nil;
  local buffnS = nil;
  local uc = nil;
  local ur = "NONE";
  local un = nil;
  local uct = nil;
  local ucf = nil;
  local r;
  local i;
  local bt = 0;
  local cd = 0;
  local cds = 0;
  local charges = 0;
  local handtype = "";
  local bExpire = false;
  local isPvP = false;
  local bufftarget = nil;
  local rbTime = 0;
  local bUsable = false;
  local time = GetTime();
  local cBuff = nil;
  local iId = nil;
  local iSlot = -1;
  local spellNameRank = nil

  if (UnitIsPVP("player")) then isPvP = true end

  SMARTBUFF_CheckUnitBuffTimers(unit);
  
  SG.isPrompting = false;

  if (UnitExists(unit) and UnitIsFriend("player", unit) and not UnitIsDeadOrGhost(unit) and not UnitIsCorpse(unit) and (UnitInRange(unit) or unit == "player" or (unit == "target" and (UnitIsPlayer("target") or UnitCreatureType("target")))))
    and (UnitIsConnected(unit) or not UnitIsPlayer(unit)) and UnitIsVisible(unit) and not UnitOnTaxi(unit) and not SG.cBlacklist[unit] and ((not UnitIsPVP(unit) and (not isPvP or SG.O.BuffPvP)) or (UnitIsPVP(unit) 
	and (isPvP or SG.O.BuffPvP))) then

    _, uc = UnitClass(unit);
    un = UnitName(unit);
    ur = UnitGroupRolesAssigned(unit);
    uct = UnitCreatureType(unit);
    ucf = UnitCreatureFamily(unit);
    if (uct == nil) then uct = ""; end
    if (ucf == nil) then ucf = ""; end

    SG.isShapeshifted, SG.sShapename = SMARTBUFF_IsShapeshifted();
    SG.BeginSkipSplashPass(unit);
    for i, buffnS in ipairs(SG.B[SG.CS()].Order) do
      if (SG.isSetBuffs or SmartBuffOptionsFrame:IsVisible()) then break; end
      cBuff = SG.cBuffs[SG.cBuffIndex[buffnS]];
      bs = SG.GetBuffSettings(buffnS);
      bExpire = false;
      handtype = "";
      charges = -1;
      bufftarget = nil;
      bUsable = false;
      iId = nil;
      iSlot = -1;

      if (cBuff and bs) then bUsable = bs.EnableS end

      if (bUsable and spell and spell ~= buffnS) then
        bUsable = false;
        SMARTBUFF_AddMsgD("Exclusive check on " .. spell .. ", current spell = " .. buffnS);
      end
      if (bUsable and cBuff.Type == SMARTBUFF_CONST_SELF and not SMARTBUFF_IsPlayer(unit)) then bUsable = false end
      local spellToCheck = buffnS;
      if (bUsable and cBuff.LevelsS and unit) then
        local _, _, _, spellNameRank = SMARTBUFF_CheckSpellLevel(buffnS, unit, cBuff.LevelsS);
        if (spellNameRank) then spellToCheck = spellNameRank; end
      end
      if (bUsable and cBuff.Type ~= SMARTBUFF_CONST_TRACK and not SMARTBUFF_IsItem(cBuff.Type) and not IsUsableSpell(spellToCheck)) then bUsable = false end
      if (bUsable and bs.SelfNot and SMARTBUFF_IsPlayer(unit)) then bUsable = false end
      if (bUsable and cBuff.Params == SG.CheckFishingPole and SMARTBUFF_IsFishingPoleEquiped()) then bUsable = false end

      -- Check for buffs which depends on a pet
      if (bUsable and cBuff.Params == SG.CheckPet and UnitExists("pet")) then bUsable = false end
      if (bUsable and cBuff.Params == SG.CheckPetNeeded and not UnitExists("pet")) then bUsable = false end

      if SG.O.HideSAButtonNoAction and not SG.O.HideSAButton and not InCombatLockdown() then
	    SmartBuff_KeyButton:Show();
	  end

      -- Check for mount auras (Classic/TBC: Paladin only)
      if (bUsable and SG.sPlayerClass == "PALADIN") then
        SG.isMounted = IsMounted() or IsFlying();
        if ((buffnS ~= SMARTBUFF_CRUSADERAURA and SG.isMounted) or (buffnS == SMARTBUFF_CRUSADERAURA and not SG.isMounted)) then
          bUsable = false;
        end
      end

      -- check for mage conjured items (only for relevant conjure buffs)
      if (bUsable and SG.sPlayerClass == "MAGE" and SG.SMARTBUFF_IsMageConjureBuff(buffnS)) then
        local lookupData;
        local gemItemID = SG.SMARTBUFF_GetMageGemItemID(buffnS);
        if (buffnS == SMARTBUFF_CONJFOOD) then
          lookupData = ConjuredMageFood;
        elseif (buffnS == SMARTBUFF_CONJWATER) then
          lookupData = ConjuredMageWater;
        end
        if (lookupData or gemItemID) then
          if (SG.isPlayerMoving) then
            bUsable = false;
          elseif (lookupData and SG.SMARTBUFF_HasConjuredItemList(lookupData)) then
            bUsable = false;
            SG.ClearSkipSplashCount(buffnS);
          elseif (gemItemID and SG.SMARTBUFF_HasBagItemID(gemItemID)) then
            bUsable = false;
            SG.ClearSkipSplashCount(buffnS);
          end
        end
      end

      -- check for warlock conjured items (only for relevant conjure buffs)
      if (bUsable and SG.sPlayerClass == "WARLOCK" and SG.SMARTBUFF_IsWarlockConjureBuff(buffnS)) then
        local lookupData;
        if (not (SG.SMARTBUFF_HasBagItemID(6265) or SG.buildInfo >= SMARTBUFF_CLIENTHIGH)) then
          SMARTBUFF_AddMsgD("Soul Shard is missing in bag, cannot continue.");
          bUsable = false;
        else
          if (buffnS == SMARTBUFF_CREATEHS) then lookupData = ConjuredLockHealthStones
          elseif (buffnS == SMARTBUFF_CREATESOULS) then lookupData = ConjuredLockSoulstones
          elseif (buffnS == SMARTBUFF_CREATESPELLS) then lookupData = ConjuredLockSpellstones
          elseif (buffnS == SMARTBUFF_CREATEFIRES) then lookupData = ConjuredLockFirestones end
          if (lookupData) then
            if (SG.isPlayerMoving) then
              bUsable = false;
            elseif (SG.SMARTBUFF_HasConjuredItemList(lookupData)) then
              bUsable = false;
              SG.ClearSkipSplashCount(buffnS);
            end
          end
          if (bUsable and buffnS == SMARTBUFF_CREATEHS and UnitHealth("player") == UnitHealthMax("player")) then
            bUsable = false;
          end
        end
      end

      -- extra testing for revive pet on hunters, 
	  -- only allow if the pet is actually dead
      if (bUsable and SG.sPlayerClass == "HUNTER") and buffnS == SMARTBUFF_REVIVEPET then
	    if not UnitIsDead("pet") then
            SMARTBUFF_AddMsgD("Pet appears to be very much alive!");
		    bUsable = false;
        else
            SMARTBUFF_AddMsgD("Pet appears to be dead, revive available.");
		end
	  end

      if (bUsable and not (cBuff.Type == SMARTBUFF_CONST_TRACK or SMARTBUFF_IsItem(cBuff.Type))) then
        -- check if you have enough mana/rage/energy to cast
        local isUsable, notEnoughMana = IsUsableSpell(buffnS);
        if (notEnoughMana) then
          bUsable = false;
          SMARTBUFF_AddMsgD("Buff " .. cBuff.BuffS .. ", not enough mana!");
        elseif (mode ~= 1 and isUsable == nil and buffnS ~= SMARTBUFF_PWS) then
          bUsable = false;
          SMARTBUFF_AddMsgD("Buff " .. cBuff.BuffS .. " is not usable!");
        end
      end

      if (bUsable and bs.EnableS and (cBuff.IDS ~= nil or SMARTBUFF_IsItem(cBuff.Type) or cBuff.Type == SMARTBUFF_CONST_TRACK)
        and ((mode ~= 1 and ((SG.isCombat and bs.CIn) or (not SG.isCombat and bs.COut)))
        or (mode == 1 and bs.Reminder and ((not SG.isCombat and bs.COut)
        or (SG.isCombat and (bs.CIn or SG.O.ToggleAutoCombat)))))) then

        -- do we want to have normal camera zoom when buffing?
        if not SG.O.ScrollWheelZooming then SG.isPrompting = true; end

        if (not bs.SelfOnly or (bs.SelfOnly and SMARTBUFF_IsPlayer(unit))) then
          -- get current spell cooldown
          cd = 0;
          cds = 0;
          if (cBuff.IDS) then
            cds, cd = GetSpellCooldown(buffnS);
            if cds then
                cd = (cds + cd) - GetTime();
                if (cd < 0) then
                  cd = 0;
                end
                SMARTBUFF_AddMsgD(buffnS.." cd = "..cd);
            else
                cd = 0;
			end
          end

          -- check if spell has cooldown
          if (cd <= 0 or (mode == 1 and cd <= 1.5)) then
            if (cBuff.IDS and SG.sMsgWarning == SMARTBUFF_MSG_CD) then
              SG.sMsgWarning = " ";
            end

            rbTime = bs.RBTime;
            if (rbTime <= 0) then
              rbTime = SG.O.RebuffTimer;
            end

            SMARTBUFF_AddMsgD(uc.." "..SG.CT());

            if (not SMARTBUFF_IsInList(unit, un, bs.IgnoreList) and (((cBuff.Type == SMARTBUFF_CONST_GROUP or cBuff.Type == SMARTBUFF_CONST_ITEMGROUP)
              and (bs[ur]
              or (bs.SelfOnly and SMARTBUFF_IsPlayer(unit))
              or (bs[uc] and (UnitIsPlayer(unit) or uct == SMARTBUFF_HUMANOID or (uc == "DRUID" and (uct == SMARTBUFF_BEAST or uct == SMARTBUFF_ELEMENTAL))))
              or (bs["HPET"] and uct == SMARTBUFF_BEAST and uc ~= "DRUID")
              or (bs["WPET"] and (uct == SMARTBUFF_DEMON or (uc ~= "DRUID" and uct == SMARTBUFF_ELEMENTAL)) and ucf ~= SMARTBUFF_DEMONTYPE)))
              or (cBuff.Type ~= SMARTBUFF_CONST_GROUP and SMARTBUFF_IsPlayer(unit))
              or SMARTBUFF_IsInList(unit, un, bs.AddList))) then
              buff = nil;

              -- Gathering ability ------------------------------------------------------------------------
              if (cBuff.Type == SMARTBUFF_CONST_GATHERING) then
                local b = false;
                for key, spellId in ipairs(SBClassicGatherers) do
		            spellName = GetSpellInfo(spellId)
                    if spellName ~= nil and spellName ~= SG.tracker then
		                if IsPlayerSpell(spellId) and spellName == buffnS then
		                    CastSpellByName(spellName)
                            SG.tracker = spellName
                            SMARTBUFF_AddMsgD(spellName.." applied.");
		                end
                    else
                        SG.isPrompting = false  
                    end
	            end	

              -- Tracking ability ------------------------------------------------------------------------
              elseif (cBuff.Type == SMARTBUFF_CONST_TRACK) then
                local count = C_Minimap.GetNumTrackingTypes();
                for n = 1, C_Minimap.GetNumTrackingTypes() do
	                local trackN, trackT, trackA, trackC = C_Minimap.GetTrackingInfo(n);
	                if (trackN ~= nil and not trackA) then
	                  SMARTBUFF_AddMsgD(n..". "..trackN.." ("..trackC..")");
	                  if (trackN == buffnS) then
	                    if (SG.sPlayerClass == "DRUID" and buffnS == SMARTBUFF_DRUID_TRACK) then
	                      if (SG.isShapeshifted and SG.sShapename == SMARTBUFF_DRUID_CAT) then
                          buff = buffnS;
                          C_Minimap.SetTracking(n, 1);      -- bugfix: not referencing C_Minimap. 7/5/2023
                        end
                      else
                        buff = buffnS;
                        C_Minimap.SetTracking(n, 1);
                      end
                      if (buff ~= nil) then
	                      SMARTBUFF_AddMsgD("Tracking enabled: "..buff);
	                      buff = nil;
	                    end
	                  end
	                end
                end

              -- Food, Scroll, Potion or conjured items ------------------------------------------------------------------------
              elseif (cBuff.Type == SMARTBUFF_CONST_FOOD or cBuff.Type == SMARTBUFF_CONST_SCROLL or cBuff.Type == SMARTBUFF_CONST_POTION or cBuff.Type == SMARTBUFF_CONST_ITEM or
                cBuff.Type == SMARTBUFF_CONST_ITEMGROUP) then

        				if (cBuff.Type == SMARTBUFF_CONST_ITEM) then
      				    bt = nil;
      				    buff = nil;
      				    if (cBuff.Params ~= SG.NIL) then
    				        local cr = SMARTBUFF_CountReagent(cBuff.Params, cBuff.Chain);
    				        SMARTBUFF_AddMsgD(cr.." "..cBuff.Params.." found");
    				        if (cr == 0) then
    				            buff = cBuff.Params;
    				        end
      				    end

                -- dont attempt to use food while moving or we will waste them.
                elseif (cBuff.Type == SMARTBUFF_CONST_FOOD) then
                  if (not SMARTBUFF_IsPicnic(unit)) then
                    buff, index, buffname, bt, charges = SMARTBUFF_CheckUnitBuffs(unit, SMARTBUFF_FOOD_AURA, cBuff.Type, cBuff.Links, cBuff.Chain);
                  end
                  if (SG.isPlayerMoving) then
                    -- Skip prompts/casts while moving (prevents waste), but detect buff presence
                    return 3;  -- Treat as "out of range" to avoid message/spam
                  end

                else                    
      			    if (cBuff.Params ~= SG.NIL) then
      			        if (cBuff.Links and cBuff.Links == SG.CheckFishingPole) then
                            if (SMARTBUFF_IsFishingPoleEquiped()) then
                              buff, index, buffname, bt, charges = SMARTBUFF_CheckUnitBuffs(unit, cBuff.Params, cBuff.Type);
                            else
                              buff = nil;
                            end
      			        else
      				        buff, index, buffname, bt, charges = SMARTBUFF_CheckUnitBuffs(unit, cBuff.Params, cBuff.Type, cBuff.Links, cBuff.Chain);
      				    end
      			        SMARTBUFF_AddMsgD("Buff time ("..cBuff.Params..") = "..tostring(bt));
           		    else
      				    buff = nil;
      			    end
      		    end

                if (buff == nil and cBuff.DurationS >= 1 and rbTime > 0) then
                  if (charges == nil) then charges = -1; end
                  if (charges > 1) then cBuff.CanCharge = true; end
                  bufftarget = nil;
                end

                if (bt and bt <= rbTime) then
                  buff = buffnS;
                  bExpire = true;
                end

                if (buff) then
                  if (cBuff.Type ~= SMARTBUFF_CONST_ITEM) then
                    local cr, iid = SMARTBUFF_CountReagent(buffnS, cBuff.Chain);
                    if (cr > 0) then
                      buff = buffnS;
                      if (cBuff.Type == SMARTBUFF_CONST_ITEMGROUP or cBuff.Type == SMARTBUFF_CONST_SCROLL) then
                        cds, cd = C_Container.GetItemCooldown(iid);
                        cd = (cds + cd) - GetTime();
                        SMARTBUFF_AddMsgD(cr.." "..buffnS.." found, cd = "..cd);
                        if (cd > 0) then
                          buff = nil;
                        end
                      end
                      SMARTBUFF_AddMsgD(cr .. " " .. buffnS .. " found");
                    else
                      SMARTBUFF_AddMsgD("No " .. buffnS .. " found");
                      buff = nil;
                      bExpire = false;
                    end
                  end
                end

              -- Weapon buff ------------------------------------------------------------------------

              elseif (cBuff.Type == SMARTBUFF_CONST_WEAPON or cBuff.Type == SMARTBUFF_CONST_INV) then
                SMARTBUFF_AddMsgD("Check weapon Buff");
                hasMainHandEnchant, mainHandExpiration, mainHandCharges, mainHandEnchantID, hasOffHandEnchant, offHandExpiration, offHandCharges, offHandEnchantID = GetWeaponEnchantInfo();
                bMh = hasMainHandEnchant;
                tMh = mainHandExpiration;
                cMh = mainHandCharges;
                bOh = hasOffHandEnchant;
                tOh = offHandExpiration;
                cOh = offHandCharges;

                if (bs.MH) then
                  iSlot = 16;
                  iId = GetInventoryItemID("player", iSlot);
                  if (iId and SMARTBUFF_CanApplyWeaponBuff(buffnS, iSlot)) then
                    if (bMh) then
                      if (rbTime > 0 and cBuff.DurationS >= 1) then
                        tMh = floor(tMh/1000);
                        charges = cMh;
                        if (charges == nil) then charges = -1; end
                        if (charges > 1) then cBuff.CanCharge = true; end
                        if (tMh <= rbTime or (SG.O.CheckCharges and cBuff.CanCharge and charges > 0 and charges <= SG.O.MinCharges)) then
                          buff = buffnS;
                          bt = tMh;
                          bExpire = true;
                        end
                      end
                    else
                      handtype = "main";
                      buff = buffnS;
                    end
                  else
                    SMARTBUFF_AddMsgD("Weapon Buff cannot be cast, no mainhand weapon equipped or wrong weapon/stone type");
                  end
                end

                if (bs.OH and not bExpire and handtype == "") then
                  iSlot = 17
                  iId = GetInventoryItemID("player", iSlot);
                  if (iId and SMARTBUFF_CanApplyWeaponBuff(buffnS, iSlot)) then
                    if (bOh) then
                      if (rbTime > 0 and cBuff.DurationS >= 1) then
                        tOh = floor(tOh/1000);
                        charges = cOh;
                        if (charges == nil) then charges = -1; end
                        if (charges > 1) then cBuff.CanCharge = true; end
                        if (tOh <= rbTime or (SG.O.CheckCharges and cBuff.CanCharge and charges > 0 and charges <= SG.O.MinCharges)) then
                          buff = buffnS;
                          bt = tOh;
                          bExpire = true;
                        end
                      end
                    else
                      handtype = "off";
                      buff = buffnS;
                    end
                  else
                    SMARTBUFF_AddMsgD("Weapon Buff cannot be cast, no offhand weapon equipped or wrong weapon/stone type");
                  end
                end

                if (buff and cBuff.Type == SMARTBUFF_CONST_INV) then
                  local cr = SMARTBUFF_CountReagent(buffnS, cBuff.Chain);
                  if (cr > 0) then
                    SMARTBUFF_AddMsgD(cr .. " " .. buffnS .. " found");
                  else
                    SMARTBUFF_AddMsgD("No " .. buffnS .. " found");
                    buff = nil;
                  end
                end

              -- Normal buff ------------------------------------------------------------------------
              else
                local index = nil;
                -- For chained buffs like AI/AB or MotW/GotW, decide whether to
                -- use the single-target version for this unit (saves reagents
                -- when only one unit in the group is missing the effect).
                -- IMPORTANT: Only apply this optimisation to true group buffs.
                -- Chains that represent mutually exclusive self-buffs (e.g. Mage armors)
                -- must NOT be rewritten here, or we will swap Molten Armor to Ice Armor, etc.
                if (cBuff.Type == SMARTBUFF_CONST_GROUP and cBuff.Chain and #cBuff.Chain > 1) then
                  local newBuff = SMARTBUFF_SelectChainBuffForUnit(unit, subgroup, buffnS, cBuff.Chain, cBuff, bs);
                  if newBuff ~= buffnS then
                    buffnS = newBuff;
                    if SG.cBuffIndex[buffnS] then
                      cBuff = SG.cBuffs[SG.cBuffIndex[buffnS]];
                    end
                  end
                end
                -- check timer object
                buff, index, buffname, bt, charges = SMARTBUFF_CheckUnitBuffs(unit, buffnS, cBuff.Type, cBuff.Links, cBuff.Chain);
                if (charges == nil) then charges = -1; end
                if (charges > 1) then cBuff.CanCharge = true; end
                  if (unit ~= "target" and buff == nil and cBuff.DurationS >= 1 and rbTime > 0) then
                  if (SMARTBUFF_IsPlayer(unit)) then
                    if (SG.cBuffTimer[unit] ~= nil and SG.cBuffTimer[unit][buffnS] ~= nil) then
                      local tbt = cBuff.DurationS - (time - SG.cBuffTimer[unit][buffnS]);
                        if type(bt) ~= "number" then
                            bt = 0
                        end
                      if (not bt or bt - tbt > rbTime) then
                        bt = tbt;
                      end
                    end
                    bufftarget = nil;
                  elseif (SG.cBuffTimer[unit] ~= nil and SG.cBuffTimer[unit][buffnS] ~= nil) then
                    bt = cBuff.DurationS - (time - SG.cBuffTimer[unit][buffnS]);
                    bufftarget = nil;
                  elseif (cBuff.BuffG ~= nil and SG.cBuffTimer[subgroup] ~= nil and SG.cBuffTimer[subgroup][cBuff.BuffG] ~= nil) then
                    bt = cBuff.DurationG - (time - SG.cBuffTimer[subgroup][cBuff.BuffG]);
                    if (type(subgroup) == "number") then
                      bufftarget = SMARTBUFF_MSG_GROUP .. " " .. subgroup;
                    else
                      bufftarget = SMARTBUFF_MSG_CLASS .. " " .. UnitClass(unit);
                    end
                  elseif (cBuff.BuffG ~= nil and SG.cBuffTimer[uc] ~= nil and SG.cBuffTimer[uc][cBuff.BuffG] ~= nil) then
                    bt = cBuff.DurationG - (time - SG.cBuffTimer[uc][cBuff.BuffG]);
                    bufftarget = SMARTBUFF_MSG_CLASS .. " " .. UnitClass(unit);
                  else
                    bt = nil;
                  end
                  if ((bt and bt <= rbTime) or (SG.O.CheckCharges and cBuff.CanCharge and charges > 0 and charges <= SG.O.MinCharges)) then
                    if (buffname) then
                      buff = buffname;
                    else
                      buff = buffnS;
                    end
                    bExpire = true;
                  end
                end

                -- check if the group buff is active, in this case it is not possible to cast the single buff
                if (buffname and mode ~= 1 and buffname ~= buffnS) then
                  buff = nil;
                end

              end -- END normal buff

              -- check if shapeshifted and cancel buff if it is not possible to cast it
              if (buff and cBuff.Type ~= SMARTBUFF_CONST_TRACK and cBuff.Type ~= SMARTBUFF_CONST_FORCESELF) then
                if (SG.isShapeshifted) then
                  if (string.find(cBuff.Params, SG.sShapename)) then
                  else
                    if(cBuff.Params == SMARTBUFF_DRUID_CAT) then
                      buff = nil;
                    end
                    if (buff and mode ~= 1 and not SG.O.InShapeshift and (SG.sShapename ~= SMARTBUFF_DRUID_MOONKIN and SG.sShapename ~= SMARTBUFF_DRUID_TREANT)) then
                      buff = nil;
                    end
                  end
                elseif(cBuff.Params == SMARTBUFF_DRUID_CAT) then
                    buff = nil;
                end
              end

              if (buff and SG.ShouldSkipBuff(buffnS)) then
                SMARTBUFF_AddMsgD("Skip over buffing: " .. buffnS);
                SG.NoteSkipSplashSkipped();
              elseif (buff) then

                if (cBuff.IDS) then
                  SMARTBUFF_AddMsgD("Checking " ..i .. " - " .. cBuff.IDS .. " " .. buffnS);
                end

                -- Cast mode ---------------------------------------------------------------------------------------
                if (mode == 0 or mode == 5) then
                  SG.NoteSkipSplashAction();
                  SG.currentUnit = nil;
                  SG.currentSpell = nil;

                --try to apply weapon buffs on main/off hand
                  if (cBuff.Type == SMARTBUFF_CONST_INV) then
                    if (iSlot and (handtype ~= "" or bExpire)) then
                      local bag, slot, count = SMARTBUFF_FindItem(buffnS, cBuff.Chain);
                      if (count > 0) then
                        SG.sMsgWarning = "";
                        SG.CancelSkipSplashPass();
                        return 0, SMARTBUFF_ACTION_ITEM, GetItemInfo(buffnS), iSlot, "player", cBuff.Type;
                      end
                    end
                    r = 50;
                  elseif (cBuff.Type == SMARTBUFF_CONST_WEAPON) then
                    if (iId and (handtype ~= "" or bExpire)) then
                      SG.sMsgWarning = "";
                      SG.CancelSkipSplashPass();
                      return 0, SMARTBUFF_ACTION_SPELL, buffnS, iSlot, "player", cBuff.Type;
                    end
                    r = 50;

                  -- eat food or use scroll or potion
                  elseif (cBuff.Type == SMARTBUFF_CONST_FOOD or cBuff.Type == SMARTBUFF_CONST_SCROLL or cBuff.Type == SMARTBUFF_CONST_POTION) then
                    local bag, slot, count = SMARTBUFF_FindItem(buffnS, cBuff.Chain);
                    if (count > 0 or bExpire) then
                      SG.sMsgWarning = "";
                      SG.CancelSkipSplashPass();
                      return 0, SMARTBUFF_ACTION_ITEM, buffnS, 0, "player", cBuff.Type;
                    end
                    r = 20;

                  -- use item on a unit
                  elseif (cBuff.Type == SMARTBUFF_CONST_ITEMGROUP) then
                    local bag, slot, count = SMARTBUFF_FindItem(buffnS, cBuff.Chain);
                    if (count > 0) then
                      SG.sMsgWarning = "";
                      SG.CancelSkipSplashPass();
                      return 0, SMARTBUFF_ACTION_ITEM, buffnS, 0, unit, cBuff.Type;
                    end
                    r = 20;

                  -- create item
                  elseif (cBuff.Type == SMARTBUFF_CONST_ITEM) then
                    r = 20;
                    local bag, slot, count = SMARTBUFF_FindItem(buff, cBuff.Chain);
                    if (count == 0) then
                      r = SMARTBUFF_doCast(unit, cBuff.IDS, buffnS, cBuff.LevelsS, cBuff.Type);
                      if (r == 0) then
                        SG.currentUnit = unit;
                        SG.currentSpell = buffnS;
                      end
                    end

                  -- cast spell
                  else                    
                    r = SMARTBUFF_doCast(unit, cBuff.IDS, buffnS, cBuff.LevelsS, cBuff.Type);
                    if (r == 0) then
                      SG.currentUnit = unit;
                      SG.currentSpell = buffnS;
                    end
                  end

                -- Check mode ---------------------------------------------------------------------------------------
                elseif (mode == 1) then
                  SG.currentUnit = nil;
                  SG.currentSpell = nil;                  
                  if type(bt) ~= "number" then bt = 0; end    
                  if (bufftarget == nil) then bufftarget = un; end
                  if (cBuff.IDS ~= nil or SMARTBUFF_IsItem(cBuff.Type) or cBuff.Type == SMARTBUFF_CONST_TRACK) then
                    -- clean up buff timer, if expired
                    if (bt and bt < 0 and bExpire) then
                      bt = 0;
                      if (SG.cBuffTimer[unit] ~= nil and SG.cBuffTimer[unit][buffnS] ~= nil) then
                        SG.cBuffTimer[unit][buffnS] = nil;
                      end
                      if (cBuff.IDG ~= nil) then
                        if (SG.cBuffTimer[subgroup] ~= nil and SG.cBuffTimer[subgroup][cBuff.BuffG] ~= nil) then
                          SG.cBuffTimer[subgroup][cBuff.BuffG] = nil;
                        end
                        if (SG.cBuffTimer[uc] ~= nil and SG.cBuffTimer[uc][cBuff.BuffG] ~= nil) then
                          SG.cBuffTimer[uc][cBuff.BuffG] = nil;
                        end
                      end
                      SG.tLastCheck = time - SG.O.AutoTimer + 0.5;
                      SG.CancelSkipSplashPass();
                      return 0;
                    end
                    SG.IncrementSkipSplashCount(buffnS);
                    SMARTBUFF_SetMissingBuffMessage(bufftarget, buff, cBuff.IconS, cBuff.CanCharge, charges, bt, bExpire);
                    SMARTBUFF_SetButtonTexture(SmartBuff_KeyButton, cBuff.IconS);
                    SG.CancelSkipSplashPass();
                    return 0;
                  end
                end

                if (r == 0) then
                  -- target buffed
                  -- Message will printed in the "SPELLCAST_STOP" event
                  SG.sMsgWarning = "";
                  _, _, _, spellNameRank, _ = SMARTBUFF_CheckSpellLevel(buffnS, unit, cBuff.LevelsS)
                  if spellNameRank then
                    -- we have ranks, process them.
                    SMARTBUFF_AddMsgD("Buff down-ranked to: " .. spellNameRank);
                    SG.CancelSkipSplashPass();
                    return 0, SMARTBUFF_ACTION_SPELL, spellNameRank, -1, unit, cBuff.Type;
				  else
                    -- nothing special here, just continue.
                    SG.CancelSkipSplashPass();
                    return 0, SMARTBUFF_ACTION_SPELL, buffnS, -1, unit, cBuff.Type;
                  end
                elseif (r == 1) then
                  -- spell cooldown
                  if (mode == 0) then SMARTBUFF_AddMsgWarn(buffnS .. " " .. SMARTBUFF_MSG_CD); end
                  SG.CancelSkipSplashPass();
                  return 1;
                elseif (r == 2) then
                  -- can not target
                  if (mode == 0 and ucf ~= SMARTBUFF_DEMONTYPE) then SMARTBUFF_AddMsgD("Can not target " .. un); end
                elseif (r == 3) then
                  -- target oor
                  if (mode == 0) then SMARTBUFF_AddMsgWarn(un .. " " .. SMARTBUFF_MSG_OOR); end
                  break;
                elseif (r == 4) then
                  -- spell cooldown > SG.maxSkipCoolDown
                  if (mode == 0) then SMARTBUFF_AddMsgD(buffnS .. " " .. SMARTBUFF_MSG_CD .. " > " .. SG.maxSkipCoolDown); end
                elseif (r == 5) then
                  -- target to low
                  if (mode == 0) then SMARTBUFF_AddMsgD(un .. " is to low to get buffed with " .. buffnS); end
                elseif (r == 6) then
                  -- not enough mana/rage/energy
                  SG.sMsgWarning = SMARTBUFF_MSG_OOM;
                elseif (r == 7) then
                  -- tracking ability is already active
                  if (mode == 0) then SMARTBUFF_AddMsgD(buffnS .. " not used, other ability already active"); end
                elseif (r == 8) then
                  -- actionslot is not defined
                  if (mode == 0) then SMARTBUFF_AddMsgD(buffnS .. " has no actionslot"); end
                elseif (r == 9) then
                  -- spell ID not found
                  if (mode == 0) then SMARTBUFF_AddMsgD(buffnS .. " spellID not found"); end
                elseif (r == 10) then
                  -- target could not buffed
                  if (mode == 0) then SMARTBUFF_AddMsgD(buffnS .. " could not be buffed on " .. un); end
                elseif (r == 20) then
                  -- item not found
                  if (mode == 0) then SMARTBUFF_AddMsgD(buffnS .. " could not be used"); end
                elseif (r == 50) then
                  -- weapon buff could not applied
                  if (mode == 0) then SMARTBUFF_AddMsgD(buffnS .. " could not be applied"); end
                else
                  -- no spell selected
                  if (mode == 0) then SMARTBUFF_AddMsgD(SMARTBUFF_MSG_CHAT); end
                end
              else
                SG.ClearSkipSplashCount(buffnS);
              end
            end
          else
            -- cooldown
            if (SG.sMsgWarning == "") then
              SG.sMsgWarning = SMARTBUFF_MSG_CD;
            end
          end
        end -- group or self
      end
    end -- for buff
  end
  if SG.O.HideSAButtonNoAction and not SG.O.HideSAButton and not InCombatLockdown() then
    SmartBuff_KeyButton:Hide();
  end
  SG.isPrompting = false
  SG.FinishSkipSplashPass();
  return 3;
end

-- SMARTBUFF_IsInList
-- Checks whether a player unit name appears in an ignore/add list table.
-- Parameters:
--   unit     (string)  Unit token
--   unitname (string)  Unit name
--   list     (table)   Name-keyed list from buff settings
-- Returns:
--   (boolean)
function SMARTBUFF_IsInList(unit, unitname, list)
  if (list ~= nil) then
    for un in pairs(list) do
      if (un ~= nil and UnitIsPlayer(unit) and un == unitname) then
        return true;
      end
    end
  end
  return false;
end

-- SMARTBUFF_SetMissingBuffMessage
-- Shows splash, chat, and sound alerts for a missing or expiring buff.
-- Parameters:
--   target        (string)   Display target name or group label
--   buff          (string)   Buff name to display
--   icon          (string)   Spell/item icon path
--   bCanCharge    (boolean)  Buff uses charge tracking
--   nCharges      (number)   Remaining charges
--   tBuffTimeLeft (number)   Seconds until expiry
--   bExpire       (boolean)  True if rebuff (expiring) rather than missing
-- Returns: nothing
function SMARTBUFF_SetMissingBuffMessage(target, buff, icon, bCanCharge, nCharges, tBuffTimeLeft, bExpire)
  
  if (not SG.isInit) then
    return;
  end;

  local f = SmartBuffSplashFrame;

  -- show splash buff message
  if (f and SG.O.ToggleAutoSplash and not SmartBuffOptionsFrame:IsVisible()) then
    local s;
    local sd = SG.O.SplashDuration;
    local si = "";

    if (SG.OG.SplashIcon and icon) then
      local n = SG.O.SplashIconSize;
      if (n == nil or n <= 0) then
        n = SG.O.CurrentFontSize;
      end
      si = string.format("\124T%s:%d:%d:1:0\124t ", icon, n, n) or "";
    end
    if (SG.OG.SplashMsgShort and si == "") then si = buff end
    if (SG.O.AutoTimer < 4) then
      sd = 1;
      f:Clear();
    end

    f:SetTimeVisible(sd);
    if (not nCharges) then nCharges = 0; end
    if (SG.O.CheckCharges and bCanCharge and nCharges > 0 and nCharges <= SG.O.MinCharges and bExpire) then
      if (SG.OG.SplashMsgShort) then
        s = target.." > "..si.." < "..format(SMARTBUFF_ABBR_CHARGES_OL, nCharges);
      else
        s = target.."\n"..SMARTBUFF_MSG_REBUFF.." "..si..buff..": "..format(ITEM_SPELL_CHARGES, nCharges).." "..SMARTBUFF_MSG_LEFT;
      end
    elseif (bExpire) then
      if (SG.OG.SplashMsgShort) then
        s = target.." > "..si.." < "..format(SECOND_ONELETTER_ABBR, tBuffTimeLeft);
      else
        s = target.."\n"..SMARTBUFF_MSG_REBUFF.." "..si..buff..": "..format(SECONDS_ABBR, tBuffTimeLeft).." "..SMARTBUFF_MSG_LEFT;
      end
    else
      if (SG.OG.SplashMsgShort) then
        s = target.." > "..si;
      else
        s = target.." "..SMARTBUFF_MSG_NEEDS.." "..si..buff;
      end
    end
    f:AddMessage(s, SG.O.ColSplashFont.r, SG.O.ColSplashFont.g, SG.O.ColSplashFont.b, 1.0);
  end

  -- show chat buff message
  if (SG.O.ToggleAutoChat) then
    if (SG.O.CheckCharges and bCanCharge and nCharges > 0 and nCharges <= SG.O.MinCharges and bExpire) then
      SMARTBUFF_AddMsgWarn(target..": "..SMARTBUFF_MSG_REBUFF.." "..buff..", "..format(ITEM_SPELL_CHARGES, nCharges).." ".. SMARTBUFF_MSG_LEFT, true);
    elseif (bExpire) then
      SMARTBUFF_AddMsgWarn(target..": "..SMARTBUFF_MSG_REBUFF.." "..buff..format(SECONDS_ABBR, tBuffTimeLeft).." "..SMARTBUFF_MSG_LEFT, true);
    else
      SMARTBUFF_AddMsgWarn(target.." "..SMARTBUFF_MSG_NEEDS.." "..buff, true);
    end
  end

  -- play sound
  if (SG.O.ToggleAutoSound) then
    SG.PlaySplashSound();
  end
end

local cWeaponStandard = {0, 1, 4, 5, 6, 7, 8, 10, 13, 15, 16}; -- "Daggers", "Axes", "Swords", "Maces", "Staves", "Fist Weapons", "Polearms", "Thrown"
local cWeaponBlunt = {4, 5, 10, 13}; -- "Maces", "Staves", "Fist Weapons"
local cWeaponSharp = {0, 1, 6, 7, 8, 15}; -- "Daggers", "Axes", "Swords", "Polearms"

-- SMARTBUFF_CanApplyWeaponBuff
-- Checks whether a weapon buff stone/oil matches the equipped weapon subclass.
-- Parameters:
--   buff (string)  Weapon buff name (sharp/blunt pattern selects weapon list)
--   slot (number)  Inventory slot (16 = main hand, 17 = off hand)
-- Returns:
--   (boolean)       True if buff can apply
--   (string|nil)    Weapon subtype name when applicable
function SMARTBUFF_CanApplyWeaponBuff(buff, slot)
  local cWeaponTypes = nil;
  if (string.find(buff, SMARTBUFF_WEAPON_SHARP_PATTERN)) then
    cWeaponTypes = cWeaponSharp;
  elseif (string.find(buff, SMARTBUFF_WEAPON_BLUNT_PATTERN)) then
    cWeaponTypes = cWeaponBlunt;
  else
    cWeaponTypes = cWeaponStandard;
  end  
  local itemLink = GetInventoryItemLink("player", slot);
  if (itemLink == nil) then return false end
  local itemType, itemSubType, _, _, _, _, classId, subclassId = select(6, GetItemInfo(itemLink));
  if (SG.tcontains(cWeaponTypes, subclassId)) then
    return true, itemSubType;
  end
  return false;
end

-- SMARTBUFF_checkBlacklist
-- Expires stale unit blacklist entries past BlacklistTimer.
-- Parameters: none
-- Returns: nothing
function SMARTBUFF_checkBlacklist()
  local t = GetTime();
  for unit in pairs(SG.cBlacklist) do
    if (t > (SG.cBlacklist[unit] + SG.O.BlacklistTimer)) then
      SG.cBlacklist[unit] = nil;
    end
  end
end

-- SMARTBUFF_IsPlayer
-- Returns true when unit is the local player.
-- Parameters:
--   unit (string)  Unit token
-- Returns:
--   (boolean)
function SMARTBUFF_IsPlayer(unit)
  if (unit and UnitIsUnit("player", unit)) then
    return true;
  end
  return false;
end

-- UnitBuffByBuffName
-- Finds a helpful buff on a unit by exact name (cache or filtered scan).
-- Parameters:
--   target   (string)       Unit token
--   buffname (string)       Buff name to match
--   filter   (string|nil)   Optional UnitBuff filter; nil uses aura cache
-- Returns:
--   UnitBuff return values when found, or nil
function UnitBuffByBuffName(target, buffname, filter)
  if (not target or not buffname) then return; end
  if (filter) then
    for i = 1, 40 do
      local name = UnitBuff(target, i, filter);
      if (not name) then return; end
      if (name == buffname) then
        return UnitBuff(target, i, filter);
      end
    end
    return;
  end
  local entry = SG.SMARTBUFF_GetAuraCache(target)[buffname];
  if (entry) then
    return unpack(entry);
  end
end

-- SMARTBUFF_CheckUnitBuffs
-- Determines whether a unit needs a buff; handles links, chains, and stances.
-- Parameters:
--   unit  (string)       Unit token
--   buffN (string|nil)   Default buff name
--   buffT (number)       Buff type constant
--   buffL (table|nil)    Linked buff names
--   buffC (table|nil)    Chained buff names (e.g. AI/AB)
-- Returns:
--   (string|nil)  Buff name to cast when missing
--   (number|nil)  Buff index in link/chain
--   (string|nil)  Display buff name
--   (number|nil)  Time left in seconds (-1 = present, no expiry concern)
--   (number|nil)  Charge count
function SMARTBUFF_CheckUnitBuffs(unit, buffN, buffT, buffL, buffC)
  if (not unit or (not buffN and not buffL)) then return end
  local i, n, v;
  local buff = nil;
  local defBuff = nil;
  local timeleft = nil;
  local duration = nil;
  local caster = nil;
  local count = nil;
  local icon = nil;
  local time = GetTime();
  local uname = UnitName(unit) or "?";
  if (buffN) then
    defBuff = buffN;
  else
    defBuff = buffL[1];
  end
  -- Stance/Presence/Seal check, these are not in the aura list
  n = SG.cBuffIndex[defBuff];
  if (SG.cBuffs[n] and SG.cBuffs[n].Type == SMARTBUFF_CONST_STANCE) then
    if (defBuff and buffC and #buffC >= 1) then
      local t = SG.B[SG.CS()].Order;
      if (t and #t >= 1) then
        for i = 1, #t, 1 do
          if (t[i] and SG.tfind(buffC, t[i])) then
            v = SG.GetBuffSettings(t[i]);
            if (v and v.EnableS) then
              for n = 1, GetNumShapeshiftForms(), 1 do
                local _, name, active, castable = GetShapeshiftFormInfo(n);
                if (name and not active and castable and name == t[i]) then
                  return defBuff, nil, nil, nil, nil;
                elseif (name and active and castable and name == t[i]) then
                  return nil, i, defBuff, 1800, -1;
                end
              end
            end
          end
        end
      end
    end
    return defBuff, nil, nil, nil, nil;
  end

  -- Check linked buffs
  if (buffL) then
    if (not SG.O.LinkSelfBuffCheck and buffT == SMARTBUFF_CONST_SELF) then
      -- Do not check linked self buffs
    elseif (not SG.O.LinkGrpBuffCheck and buffT == SMARTBUFF_CONST_GROUP) then
      -- Do not check linked group buffs
    else
      for n, v in pairs(buffL) do
        if (v and v ~= defBuff) then
          SMARTBUFF_AddMsgD("Check linked buff ("..uname.."): "..v);
          buff, icon, count, _, duration, timeleft, caster = UnitBuffByBuffName(unit, v);
          if (buff) then
            timeleft = timeleft - GetTime();
            if (timeleft <= 0) then
                timeleft = time;
            end
            SMARTBUFF_AddMsgD("Linked buff found: "..buff..", "..timeleft..", "..icon);
            return nil, n, defBuff, timeleft, count;
          end
        end
      end
    end
  end

  -- Check chained buffs (group buffs only: AI/AB, MotW/GotW, etc.).
  -- Skip for self-buff chains (e.g. mage armors): those are mutually exclusive, so we only
  -- care whether the unit has this specific buff, not "any from chain".
  if (defBuff and buffC and #buffC > 1 and buffT ~= SMARTBUFF_CONST_SELF) then
    local t = SG.B[SG.CS()].Order;
    if (t and #t > 1) then
      --SMARTBUFF_AddMsgD("Check chained buff ("..uname.."): "..defBuff);
      for i = 1, #t, 1 do
        if (t[i] and SG.tfind(buffC, t[i])) then
          v = SG.GetBuffSettings(t[i]);
          if (v and v.EnableS) then
            local b, tl, im = SMARTBUFF_CheckBuff(unit, t[i]);
            if (b and im) then
              --SMARTBUFF_AddMsgD("Chained buff found: "..t[i]..", "..tl);
              if (SMARTBUFF_CheckBuffLink(unit, t[i], v.Type, v.Links)) then
                return nil, i, defBuff, tl, -1;
              end
            elseif (not b and t[i] == defBuff) then
              return defBuff, nil, nil, nil, nil;
            end
          end
        end
      end
    end
  end

  -- Check default buff
  if (defBuff) then
    SMARTBUFF_AddMsgD("Check default buff ("..uname.."): "..defBuff);
    buff, icon, count, _, duration, timeleft, caster = UnitBuffByBuffName(unit, defBuff);
    if (buff) then
      timeleft = timeleft - GetTime();
      if (timeleft <= 0) then
        timeleft = time;
      end
      if (SMARTBUFF_IsPlayer(caster)) then
        SMARTBUFF_UpdateBuffDuration(defBuff, duration);
      end
      SMARTBUFF_AddMsgD("Default buff found: "..buff..", "..timeleft..", "..icon);
      return nil, 0, defBuff, timeleft, count;
    end
  end
  -- Buff not found, return default buff
  return defBuff, nil, nil, nil, nil;
end

-- SMARTBUFF_CheckBuffLink
-- Returns true if the unit has any linked buff from buffL (respects link options).
-- Parameters:
--   unit    (string)  Unit token
--   defBuff (string)  Primary buff being checked
--   buffT   (number)  Buff type constant
--   buffL   (table)   Linked buff name list
-- Returns:
--   (boolean)
function SMARTBUFF_CheckBuffLink(unit, defBuff, buffT, buffL)
  if (not unit or not defBuff or not buffL) then return false; end
  if (not SG.O.LinkSelfBuffCheck and buffT == SMARTBUFF_CONST_SELF) then
    return false;
  end
  if (not SG.O.LinkGrpBuffCheck and buffT == SMARTBUFF_CONST_GROUP) then
    return false;
  end
  local now = GetTime();
  local uname = UnitName(unit) or "?";
  for _, linkBuff in pairs(buffL) do
    if (linkBuff and linkBuff ~= defBuff) then
      SMARTBUFF_AddMsgD("Check linked buff ("..uname.."): "..linkBuff);
      local buff, icon, _, _, _, expiration = UnitBuffByBuffName(unit, linkBuff);
      if (buff) then
        local timeleft = expiration and (expiration - now) or 0;
        if (timeleft <= 0) then
          timeleft = now;
        end
        SMARTBUFF_AddMsgD("Linked buff found: "..buff..", "..timeleft..", "..tostring(icon));
        return true;
      end
    end
  end
  return false;
end

-- SMARTBUFF_UnitEligibleForGroupBuff (local)
-- Same class/role rules as SMARTBUFF_BuffUnit for group buff eligibility.
-- Parameters:
--   unit  (string)  Unit token
--   cBuff (table)   Buff definition
--   bs    (table)   Per-buff settings
-- Returns:
--   (boolean)
local function SMARTBUFF_UnitEligibleForGroupBuff(unit, cBuff, bs)
  if (not unit or not cBuff or not bs) then return false; end
  if (not UnitExists(unit) or not UnitIsFriend("player", unit)) then return false; end
  if (UnitIsDeadOrGhost(unit) or UnitIsCorpse(unit)) then return false; end
  if (UnitIsPlayer(unit) and not UnitIsConnected(unit)) then return false; end

  local un = UnitName(unit);
  local _, uc = UnitClass(unit);
  local ur = UnitGroupRolesAssigned(unit);
  local uct = UnitCreatureType(unit) or "";
  local ucf = UnitCreatureFamily(unit) or "";

  if (SMARTBUFF_IsInList(unit, un, bs.IgnoreList)) then return false; end
  if (bs.SelfOnly and not SMARTBUFF_IsPlayer(unit)) then return false; end
  if (bs.SelfNot and SMARTBUFF_IsPlayer(unit)) then return false; end
  if (SMARTBUFF_IsInList(unit, un, bs.AddList)) then return true; end

  if (cBuff.Type ~= SMARTBUFF_CONST_GROUP and cBuff.Type ~= SMARTBUFF_CONST_ITEMGROUP) then
    return SMARTBUFF_IsPlayer(unit);
  end

  if (cBuff.LevelsS) then
    local uLevel = UnitLevel(unit);
    if (uLevel and uLevel < cBuff.LevelsS[1]) then return false; end
  end

  return (bs[ur]
    or (bs.SelfOnly and SMARTBUFF_IsPlayer(unit))
    or (bs[uc] and (UnitIsPlayer(unit) or uct == SMARTBUFF_HUMANOID or (uc == "DRUID" and (uct == SMARTBUFF_BEAST or uct == SMARTBUFF_ELEMENTAL))))
    or (bs["HPET"] and uct == SMARTBUFF_BEAST and uc ~= "DRUID")
    or (bs["WPET"] and (uct == SMARTBUFF_DEMON or (uc ~= "DRUID" and uct == SMARTBUFF_ELEMENTAL)) and ucf ~= SMARTBUFF_DEMONTYPE));
end

-- SMARTBUFF_GetUnitsForGroupBuffScope (local)
-- Collects units in party/raid scope for group-buff threshold checks.
-- Parameters:
--   subgroup (number|string)  Current subgroup context
-- Returns:
--   (table)  Array of unit tokens
local function SMARTBUFF_GetUnitsForGroupBuffScope(subgroup)
  local units = {};
  local seen = {};

  local function addUnit(u)
    if (u and not seen[u]) then
      seen[u] = true;
      units[#units + 1] = u;
    end
  end

  if (IsInRaid() and SG.cGroups) then
    for _, grp in pairs(SG.cGroups) do
      if (type(grp) == "table") then
        for _, u in pairs(grp) do
          addUnit(u);
        end
      end
    end
  elseif (IsInGroup() and SG.cGroups and SG.cGroups[1]) then
    for _, u in pairs(SG.cGroups[1]) do
      addUnit(u);
    end
  elseif (SG.cGroups and type(subgroup) == "number" and SG.cGroups[subgroup]) then
    for _, u in pairs(SG.cGroups[subgroup]) do
      addUnit(u);
    end
  elseif (SG.cGroups and SG.cGroups[0]) then
    for _, u in pairs(SG.cGroups[0]) do
      addUnit(u);
    end
  end

  return units;
end

-- SMARTBUFF_UnitHasChainBuff (local)
-- Returns true if the unit has any buff from a chain list.
-- Parameters:
--   u     (string)  Unit token
--   chain (table)   Chained buff names
-- Returns:
--   (boolean)
local function SMARTBUFF_UnitHasChainBuff(u, chain)
  for _, cname in ipairs(chain) do
    if (SMARTBUFF_CheckBuff(u, cname, false)) then
      return true;
    end
  end
  return false;
end

-- SMARTBUFF_SelectChainBuffForUnit
-- Chooses single-target vs group rank when few party members are missing a chain buff.
-- Parameters:
--   unit      (string)  Unit being evaluated
--   subgroup  (number)  Raid/party subgroup
--   buffName  (string)  Current chain buff name in list order
--   chain     (table)   Chain entries { single, ..., group }
--   cBuff     (table)   Buff definition
--   bs        (table)   Per-buff settings
-- Returns:
--   (string)  Buff name to use (single or group version)
function SMARTBUFF_SelectChainBuffForUnit(unit, subgroup, buffName, chain, cBuff, bs)
  if (not chain or #chain < 2) then return buffName; end
  if (not SG.O or SG.O.UseSingleForOneMissing == false) then return buffName; end
  if (not cBuff or not bs) then return buffName; end

  local single = chain[1];
  local group  = chain[#chain];

  -- Only override when we're currently processing the group version.
  if (buffName ~= group) then
    return buffName;
  end

  local scopeUnits = SMARTBUFF_GetUnitsForGroupBuffScope(subgroup);
  if (#scopeUnits == 0 and unit) then
    scopeUnits = { unit };
  elseif (#scopeUnits == 0) then
    return buffName;
  end

  local missing = 0;
  local threshold = (SG.O and SG.O.UseSingleThreshold) or 1;
  if (threshold < 1) then threshold = 1; end

  for _, u in ipairs(scopeUnits) do
    if (SMARTBUFF_UnitEligibleForGroupBuff(u, cBuff, bs)) then
      if (not SMARTBUFF_UnitHasChainBuff(u, chain)) then
        missing = missing + 1;
        if (missing > threshold) then
          return buffName;
        end
      end
    end
  end

  if (missing > 0 and missing <= threshold) then
    return single;
  end

  return buffName;
end

-- SMARTBUFF_CheckBuffChain
-- Scans chain alternatives; returns nil if another enabled chain buff is present.
-- Parameters:
--   unit  (string)  Unit token
--   buff  (string)  Buff name being checked
--   chain (table)   Chained buff names
-- Returns:
--   (string|nil)  Original buff when castable
--   or nil, index, buff, timeleft, charges when a chain buff blocks casting
function SMARTBUFF_CheckBuffChain(unit, buff, chain)
  local i;
  if (buff and chain and #chain > 1) then
    local t = SG.B[SG.CS()].Order;
    if (t and #t > 1) then
      SMARTBUFF_AddMsgD("Check chained buff: "..buff);
      for i = 1, #t, 1 do
        if (t[i] and t[i] ~= buff and SG.tfind(chain, t[i])) then
          local b, tl, im = SMARTBUFF_CheckBuff(unit, t[i], true);
          if (b and im) then
            SMARTBUFF_AddMsgD("Chained buff found: "..t[i]);
            return nil, i, buff, tl, -1;
          end
        end
      end
    end
  end
  return buff;
end

-- SMARTBUFF_UpdateBuffDuration
-- Updates SG.cBuffs duration from an observed aura duration on the player.
-- Parameters:
--   buff     (string)  Buff short name
--   duration (number)  Observed aura duration in seconds
-- Returns: nothing
function SMARTBUFF_UpdateBuffDuration(buff, duration)
  local i = SG.cBuffIndex[buff];
  if (i ~= nil and SG.cBuffs[i] ~= nil and buff == SG.cBuffs[i].BuffS) then
    if (SG.cBuffs[i].DurationS ~= nil and SG.cBuffs[i].DurationS > 0 and SG.cBuffs[i].DurationS ~= duration) then
      SMARTBUFF_AddMsgD("Updated buff duration: "..buff.." = "..duration.."sec, old = "..SG.cBuffs[i].DurationS);
      SG.cBuffs[i].DurationS = duration;
    end
  end
end

-- UnitAuraBySpellName
-- Finds an aura on a unit by spell name (cache for HELPFUL, else slot scan).
-- Parameters:
--   target     (string)       Unit token
--   spellname  (string)       Aura name
--   filter     (string|nil)   Aura filter (e.g. "HELPFUL")
-- Returns:
--   UnitAura return values when found, or nil
function UnitAuraBySpellName(target, spellname, filter)
  if (not target or not spellname) then return; end
  if (filter == "HELPFUL" or not filter) then
    local entry = SG.SMARTBUFF_GetAuraCache(target)[spellname];
    if (entry) then
      return unpack(entry);
    end
    return;
  end
  for i = 1, 40 do
    local name = UnitAura(target, i, filter);
    if (not name) then return; end
    if (name == spellname) then
      return UnitAura(target, i, filter);
    end
  end
end

-- SMARTBUFF_CheckBuff
-- Simple check whether a unit has a named helpful buff.
-- Parameters:
--   unit     (string)   Unit token
--   buffName (string)   Buff name
--   isMine   (boolean)  When true, only buffs cast by the player count
-- Returns:
--   (boolean)       True if buff present (per isMine rules)
--   (number)        Time left in seconds
--   (boolean|nil)   True when caster is the player (when not using isMine filter)
function SMARTBUFF_CheckBuff(unit, buffName, isMine)
  if (not unit or not buffName) then
    return false, 0;
  end
  local now = GetTime();
  local buff, _, _, _, _, timeleft, caster = UnitAuraBySpellName(unit, buffName, "HELPFUL");
  if (buff) then
    SMARTBUFF_AddMsgD(UnitName(unit).." buff found: "..buff, 0, 1, 0.5);
    if (buff == buffName) then
      timeleft = timeleft - now;
      if (timeleft <= 0) then
        timeleft = now;
      end
      if (isMine and caster) then
        if (SMARTBUFF_IsPlayer(caster)) then
          return true, timeleft, caster;
        end
        return false, 0, nil;
      end
      return true, timeleft, SMARTBUFF_IsPlayer(caster);
    end
  end
  return false, 0;
end

-- SMARTBUFF_GetBuffName
-- Reads buff tooltip text for a unit buff index via SmartBuffTooltip.
-- Parameters:
--   unit      (string)  Unit token
--   buffIndex (number)  Buff index (1–40)
--   line      (number)  Tooltip text line to read
-- Returns:
--   (string|nil)  Tooltip line text
function SMARTBUFF_GetBuffName(unit, buffIndex, line)
  local i = buffIndex;
  local name = nil;
  if (i < 0 or i > SG.maxBuffs) then
    return nil;
  end
  SmartBuffTooltip:ClearLines();
  SmartBuffTooltip:SetUnitBuff(unit, i);
  local obj = _G["SmartBuffTooltipTextLeft" .. line];
  if (obj) then
    name = obj:GetText();
  end
  return name;
end

-- SMARTBUFF_IsFeignDeath
-- Wrapper for UnitIsFeignDeath.
-- Parameters:
--   unit (string)  Unit token
-- Returns:
--   (boolean)
function SMARTBUFF_IsFeignDeath(unit)
  return UnitIsFeignDeath(unit);
end

-- SMARTBUFF_IsPicnic
-- Returns true when the unit is eating/drinking (food aura absent = picnicking).
-- Parameters:
--   unit (string)  Unit token
-- Returns:
--   (boolean)
function SMARTBUFF_IsPicnic(unit)
  if (not SMARTBUFF_CheckUnitBuffs(unit, SMARTBUFF_FOOD_SPELL, SMARTBUFF_CONST_FOOD, {SMARTBUFF_FOOD_SPELL, SMARTBUFF_DRINK_SPELL})) then
    return true;
  end
  return false;
end

-- SMARTBUFF_IsFishing
-- Returns true when the unit is channeling the fishing spell.
-- Parameters:
--   unit (string)  Unit token
-- Returns:
--   (boolean)
function SMARTBUFF_IsFishing(unit)
  -- spell, rank, displayName, icon, startTime, endTime, isTradeSkill = UnitChannelInfo("unit")
  local spell = UnitChannelInfo(unit);
  if (spell ~= nil and SMARTBUFF_FISHING ~= nil and spell == SMARTBUFF_FISHING) then
    return true;
  end
  return false;
end

-- SMARTBUFF_IsFishingPoleEquiped
-- Returns true when a fishing pole is equipped in the main hand.
-- Parameters: none
-- Returns:
--   (boolean)
function SMARTBUFF_IsFishingPoleEquiped()
  if (not SG or not SG.FishingPole) then return false end

  local link = GetInventoryItemLink("player", GetInventorySlotInfo("MainHandSlot"));
  if (not link) then return false end

  local _, _, _, _, _, _, subType = GetItemInfo(link);
  if (not subType) then return false end

  --print(SG.FishingPole.." - "..subType);
  if (SG.FishingPole == subType) then return true end

  return false;
end

-- SMARTBUFF_IsSpell
-- Returns true for buff types that are cast as spells.
-- Parameters:
--   sType (number)  SMARTBUFF_CONST_* type
-- Returns:
--   (boolean)
function SMARTBUFF_IsSpell(sType)
  return sType == SMARTBUFF_CONST_GROUP or sType == SMARTBUFF_CONST_GROUPALL or sType == SMARTBUFF_CONST_SELF or sType == SMARTBUFF_CONST_FORCESELF or sType == SMARTBUFF_CONST_WEAPON or sType == SMARTBUFF_CONST_STANCE or sType == SMARTBUFF_CONST_ITEM;
end

-- SMARTBUFF_IsItem
-- Returns true for buff types that use inventory items.
-- Parameters:
--   sType (number)  SMARTBUFF_CONST_* type
-- Returns:
--   (boolean)
function SMARTBUFF_IsItem(sType)
  return sType == SMARTBUFF_CONST_INV or sType == SMARTBUFF_CONST_FOOD or sType == SMARTBUFF_CONST_SCROLL or sType == SMARTBUFF_CONST_POTION or sType == SMARTBUFF_CONST_ITEMGROUP;
end

-- SMARTBUFF_IsDebuffTexture
-- Scans unit debuffs for an icon texture path substring match.
-- Parameters:
--   unit      (string)  Unit token
--   debufftex (string)  Texture path fragment to find
-- Returns:
--   (boolean)
function SMARTBUFF_IsDebuffTexture(unit, debufftex)
  local active = false;
  local i = 1;
  local name, icon;
  -- name,rank,icon,count,type = UnitDebuff("unit", id or "name"[,"rank"])
  while (UnitDebuff(unit, i)) do
    name, icon, _, _ = UnitDebuff(unit, i);
    --SMARTBUFF_AddMsgD(i .. ". " .. name .. ", " .. icon);
    if (string.find(icon, debufftex)) then
      active = true;
      break
    end
    i = i + 1;
  end
  return active;
end

-- SG.SMARTBUFF_FindFirstBagSlot
-- Finds the first bag slot containing an item ID.
-- Parameters:
--   itemID (number)  Item ID
-- Returns:
--   (number|nil)  Bag index
--   (number|nil)  Slot index
--   (number|nil)  Icon file ID
function SG.SMARTBUFF_FindFirstBagSlot(itemID)
  if (not itemID) then return nil, nil, nil; end
  for bag = 0, NUM_BAG_FRAMES do
    for slot = 1, C_Container.GetContainerNumSlots(bag) do
      if (C_Container.GetContainerItemID(bag, slot) == itemID) then
        local containerInfo = C_Container.GetContainerItemInfo(bag, slot);
        return bag, slot, containerInfo and containerInfo.iconFileID;
      end
    end
  end
  return nil, nil, nil;
end

-- SG.SMARTBUFF_FindReagent
-- Totals bag count for a reagent or item-link chain; returns first slot location.
-- Parameters:
--   reagent (string)  Item link or name key
--   chain   (table)    Optional alternate item links
-- Returns:
--   (number)        Total stack count (-1 if reagent nil)
--   (number|nil)    First matching item ID
--   (number|nil)    First bag index
--   (number|nil)    First slot index
--   (number|nil)    Icon file ID
function SG.SMARTBUFF_FindReagent(reagent, chain)
  if (reagent == nil) then
    return -1, nil, nil, nil, nil;
  end
  SG.SMARTBUFF_EnsureBagIndex();
  local total = 0;
  local id = nil;
  local firstBag, firstSlot, firstTexture = nil, nil, nil;
  if not (chain) then chain = { reagent }; end
  for i = 1, #chain, 1 do
    local buffItemID = tonumber(string.match(chain[i], "item:(%d+)"));
    if (buffItemID) then
      local count = SG.cBagIndexByID[buffItemID] or 0;
      if (count > 0) then
        total = total + count;
        if (id == nil) then
          id = buffItemID;
          firstBag, firstSlot, firstTexture = SG.SMARTBUFF_FindFirstBagSlot(buffItemID);
        end
      end
    end
  end
  return total, id, firstBag, firstSlot, firstTexture;
end

-- SMARTBUFF_CountReagent
-- Returns total bag count and item ID for a reagent or chain.
-- Parameters:
--   reagent (string)  Item link or name
--   chain   (table)    Optional item link chain
-- Returns:
--   (number)        Total count
--   (number|nil)    Item ID
function SMARTBUFF_CountReagent(reagent, chain)
  local total, id = SG.SMARTBUFF_FindReagent(reagent, chain);
  return total, id;
end

-- SMARTBUFF_FindItem
-- Locates a reagent in bags for casting; returns slot and texture for UI/macros.
-- Parameters:
--   reagent (string)  Item link or name
--   chain   (table)    Optional item link chain
-- Returns:
--   (number|nil)  Bag index
--   (number|nil)  Slot index
--   (number)      Total count
--   (number|nil)  Icon file ID
function SMARTBUFF_FindItem(reagent, chain)
  local total, id, bag, slot, texture = SG.SMARTBUFF_FindReagent(reagent, chain);
  return bag, slot, total, texture;
end

-- SMARTBUFF_CheckBagItem
-- Returns whether an item (by name, pattern, or ID) exists in player bags.
-- Parameters:
--   itemName (string|number)  Item name, pattern, or item ID
-- Returns:
--   (boolean)
function SMARTBUFF_CheckBagItem(itemName)
  if (not itemName) then return false; end
  if (type(itemName) == "number") then
    return SG.SMARTBUFF_HasBagItemID(itemName);
  end
  SG.SMARTBUFF_EnsureBagIndex();
  if ((SG.cBagIndexByName[itemName] or 0) > 0) then
    return true;
  end
  for bagItemName, count in pairs(SG.cBagIndexByName) do
    if (count > 0 and string.match(bagItemName, itemName)) then
      return true;
    end
  end
  return false;
end