--[[

  HealBot Contined
    
]]

local HealBot_CalcEquipBonus=false;
local HealBot_HasDivineSpirit=2;
local HealBot_CheckForDivineSpirit=false;
local HealBot_NeedEquipUpdate=0;
local HealBot_IamRessing = nil;
local HealBot_RequestVer=nil;
local HealBot_IamHealing = nil;
local HealBot_Loaded=nil;
local HealBot_InnerFocusTalent=nil;
local HealBot_Talents={}
local HealBot_SpellPowerHealAdj=1.88
local HealBot_CheckTalents=false
local HealBot_CheckSpells=false
local HealBot_Player_HoT={};
local HealBot_Player_HoT_Icons={};
local HealBot_Watch_HoT={};
local HealBot_Watch_Timed_HoT={};
local HealBot_Watch_AM_HoT=0
local HealBot_HoT_Count={};
local HealBot_CheckZoneFlag=false
local HealBot_InCombatUpdate=false
local HealBot_SmartCast_Spells={};
local HealBot_AddonMsgType=3;
local HealBot_InBG=nil;
local HealBot_HoT_Texture={};
local HealBot_SpamCnt=0;
local HealBot_ErrorCnt=0;
local HealBot_CurrentSpells = {};
local HealBot_Ressing = {};
local HealBot_DelayBuffCheck = {};
local HealBot_DelayDebuffCheck = {};
local HealBot_DelayAuraCheck = {};
local HealBot_HealsIn={}
local HealBot_HealsIncCnt={}
local HealBot_Vers={}
local HealBot_MainTanks={};
local HealBot_CastingTarget = "player";
local i=nil
local w=nil
local x=nil
local y=nil
local z=nil
local strfind=strfind
local strsub=strsub
local gsub=gsub
local format=format
local tonumber=tonumber
local HealBot_ThrottleCnt=5
local HealBot_Aggro={}
local HealBot_Reset_flag=nil
local HB_Timer1=2
local HB_Timer2=1
local HB_Timer3=0.8
local HealBot_UpUnitInCombat={}
local HealBot_InCombatUpdCnt=0
local HealBot_InCombatUpdCntFlag=nil
local k=nil
local s=nil
local HealBot_Buff_Spells_List ={}
local HealBot_BuffNameSwap = {}            
local HealBot_VehicleCheck={};   
local HealBot_ReCheckBuffsTime=nil
local HealBot_ReCheckBuffsTimed={}

local HealBot_Ignore_Class_Debuffs = {
    ["WARR"] = { [HEALBOT_DEBUFF_ANCIENT_HYSTERIA] = true,    
                          [HEALBOT_DEBUFF_IGNITE_MANA] = true, 
                          [HEALBOT_DEBUFF_TAINTED_MIND] = true, 
                          [HEALBOT_DEBUFF_VIPER_STING] = true,
                          [HEALBOT_DEBUFF_IMPOTENCE] = true,
                          [HEALBOT_DEBUFF_DECAYED_INT] = true,
                          [HEALBOT_DEBUFF_UNSTABLE_AFFL] = true,},
    ["ROGU"] = {   [HEALBOT_DEBUFF_SILENCE] = true,    
                          [HEALBOT_DEBUFF_ANCIENT_HYSTERIA] = true, 
                          [HEALBOT_DEBUFF_IGNITE_MANA] = true, 
                          [HEALBOT_DEBUFF_TAINTED_MIND] = true, 
                          [HEALBOT_DEBUFF_VIPER_STING] = true,
                          [HEALBOT_DEBUFF_IMPOTENCE] = true,
                          [HEALBOT_DEBUFF_DECAYED_INT] = true,
                          [HEALBOT_DEBUFF_UNSTABLE_AFFL] = true,},
    ["HUNT"] = {  [HEALBOT_DEBUFF_MAGMA_SHACKLES] = true, 
                          [HEALBOT_DEBUFF_UNSTABLE_AFFL] = true,},
    ["MAGE"] = {    [HEALBOT_DEBUFF_MAGMA_SHACKLES] = true, 
                          [HEALBOT_DEBUFF_DECAYED_STR] = true,
                          [HEALBOT_DEBUFF_CRIPPLE] = true,
                          [HEALBOT_DEBUFF_UNSTABLE_AFFL] = true,},
    ["DRUI"] = {   [HEALBOT_DEBUFF_UNSTABLE_AFFL] = true,},
    ["PALA"] = { [HEALBOT_DEBUFF_UNSTABLE_AFFL] = true,},
    ["PRIE"] = {  [HEALBOT_DEBUFF_DECAYED_STR] = true,
                          [HEALBOT_DEBUFF_CRIPPLE] = true,
                          [HEALBOT_DEBUFF_UNSTABLE_AFFL] = true,},
    ["SHAM"] = {  [HEALBOT_DEBUFF_UNSTABLE_AFFL] = true,},
    ["WARL"] = { [HEALBOT_DEBUFF_DECAYED_STR] = true,
                          [HEALBOT_DEBUFF_CRIPPLE] = true,
                          [HEALBOT_DEBUFF_UNSTABLE_AFFL] = true,},
    ["DEAT"] = { [HEALBOT_DEBUFF_UNSTABLE_AFFL] = true,},
};

local HealBot_Ignore_Movement_Debuffs = {
                                  [HEALBOT_DEBUFF_FROSTBOLT] = true,
                                  [HEALBOT_DEBUFF_MAGMA_SHACKLES] = true,
                                  [HEALBOT_DEBUFF_SLOW] = true,
                                  [HEALBOT_DEBUFF_CHILLED] = true,
                                  [HEALBOT_DEBUFF_CONEOFCOLD] = true,
                                  [HEALBOT_DEBUFF_CONCUSSIVESHOT] = true,
                                  [HEALBOT_DEBUFF_THUNDERCLAP] = true,
                                  [HEALBOT_DEBUFF_HOWLINGSCREECH] = true,
                                  [HEALBOT_DEBUFF_DAZED] = true,
                                  [HEALBOT_DEBUFF_FROST_SHOCK] = true,
};

local HealBot_Ignore_NonHarmful_Debuffs = {
                                  [HEALBOT_DEBUFF_HUNTERS_MARK] = true,
                                  [HEALBOT_DEBUFF_ARCANE_BLAST] = true,
                                  [HEALBOT_DEBUFF_MAJOR_DREAMLESS] = true,
                                  [HEALBOT_DEBUFF_GREATER_DREAMLESS] = true,
                                  [HEALBOT_DEBUFF_DREAMLESS_SLEEP] = true,
};

local healingbonus_penalty=nil
local HealBot_Timer1,HealBot_Timer2,HealBot_Timer3 = -1,-4,-2;
local Ti=nil
local inc_msg=nil
local datatype=nil
local datamsg=nil
local sender=nil
local arr=nil
local arrg = {}
local HoTActive=nil
local DebuffType=nil
local checkthis=nil
local WatchTarget=nil
local WatchGUID=nil
local debuff_type=nil
local dName=nil
local HealBot_Ignore_Debuffs_Class=nil
local bName=nil
local PlayerBuffs = {}
local addIcon=true
local xButton=nil
local bar=nil
local iconName=nil
local id=0
local sName=nil
local sRank=nil
local sNameRank=nil
local uName=nil
local xUnit=nil
local xGUID = nil
local uClass=nil
local QuickHealth = nil
local HealBot_PlayerBuff={}
local HealBot_CheckBuffs = {}
local HealBot_ShortBuffs = {}
local HealBot_CheckBuffsTime=nil
local HealBot_CheckBuffsTimehbGUID=nil
local HealBot_QueueCheckBuffs={}
local PlayerBuffsGUID=nil
local huUnit,huHoTtime,huHoTicon=nil,nil,nil
local HealBot_TrackWS={}
local HEALBOT_ADDON_ID="hbGUID"
local HealBot_BuffWatch={}
local HealBot_DeBuff_Texture={}
local iTexture, bCount, expirationTime, isMine=nil,nil,nil,nil
local DeBuff_Count={}
local HealBot_unitHealth={}
local HealBot_unitHealthMax={}
local LSM = LibStub("LibSharedMedia-3.0")
local HealComm = LibStub("LibHealComm-4.0")
local WrapperHC = LibStub("LibWrapperHealComm-1.0")
local BuffClass=nil
local HasWeaponBuff=false
local CheckWeaponBuffs={[HEALBOT_ROCKBITER_WEAPON]=true, 
                        [HEALBOT_FLAMETONGUE_WEAPON]=true, 
                        [HEALBOT_EARTHLIVING_WEAPON]=true, 
                        [HEALBOT_WINDFURY_WEAPON]=true,
                        [HEALBOT_FROSTBRAND_WEAPON]=true,}
local CooldownBuffs={[HEALBOT_FEAR_WARD]=true, 
                     [HEALBOT_PAIN_SUPPRESSION]=true, 
                     [HEALBOT_POWER_INFUSION]=true,}
local debuffCodes={ [HEALBOT_DISEASE_en]=5, [HEALBOT_MAGIC_en]=6, [HEALBOT_POISON_en]=7, [HEALBOT_CURSE_en]=8, [HEALBOT_CUSTOM_en]=9}
local HealBot_WeaponBuffCheck=nil
local HealBot_VehicleUnit={}
local HealBot_UnitInVehicle={}
local hGUID=nil
local hUnit=nil
local vGUID=nil
local vUnit=nil
local tGUID=nil
local HBvUnits=nil
local HealBot_TargetUnitID="player"
local HealBot_TargetIcons={}
local HealBot_MsgOthers=false
local HealBot_PetGUID={}
local HealBot_Casters={}
local HealBot_LHC4 = {}
local HealBot_IsReallyFightingFlag=nil
local HealBot_HelpCnt=nil

function HealBot_UpdTargetUnitID(unit)
    HealBot_TargetUnitID=unit
end

function HealBot_Check_WeaponBuffs(spellName)
    if CheckWeaponBuffs[spellName] then
        HealBot_WeaponBuffCheck=3
    end
end

function HealBot_Clear_BuffWatch()
    for x,_ in pairs(HealBot_BuffWatch) do
        HealBot_BuffWatch[x]=nil;
    end
end

function HealBot_Set_BuffWatch(buffName)
    table.insert(HealBot_BuffWatch,buffName);
end

function HealBot_Clear_CheckBuffs()
    for x,_ in pairs(HealBot_CheckBuffs) do
        HealBot_CheckBuffs[x]=nil;
    end
end

function HealBot_Set_CheckBuffs(buffName)
    if not CheckWeaponBuffs[buffName] and not CooldownBuffs[buffName] then
        HealBot_CheckBuffs[buffName]=buffName;
    end
end

function HealBot_Queue_MyBuffsCheck(hbGUID,unit)
    HealBot_QueueCheckBuffs[hbGUID]=unit
end

function HealBot_Queue_AllActiveMyBuffs()
    for z,y in pairs(HealBot_UnitID) do
        HealBot_Queue_MyBuffsCheck(z,y)
    end
end

function HealBot_RetMyBuffTime(hbGUID,buffName)
    if not HealBot_PlayerBuff[hbGUID] or not HealBot_PlayerBuff[hbGUID][buffName] then return end
    if HealBot_ShortBuffs[buffName] then
        return HealBot_PlayerBuff[hbGUID][buffName]+HealBot_Config.ShortBuffTimer
    else
        return HealBot_PlayerBuff[hbGUID][buffName]+HealBot_Config.LongBuffTimer
    end
end

function HealBot_retInnerFocus()
    return HealBot_Talents["InnerFocus"]
end

function HealBot_retAddonID()
    return HEALBOT_ADDON_ID
end

function HealBot_retHealBot_MainTanks(id)
    return HealBot_MainTanks[id]
end

function HealBot_SetResetFlag(mode)
    if mode=="HARD" then
        ReloadUI()
    else
        HealBot_Reset_flag=1
    end
end

function HealBot_AltBuffNames(buffName)
    return HealBot_BuffNameSwap[buffName]
end

function HealBot_GetHealBot_AddonMsgType()
    return HealBot_AddonMsgType;
end

function HealBot_RetHealBot_Ressing(hbGUID)
    return HealBot_Ressing[hbGUID];
end

function HealBot_RetNumCurrentSpells()
    return table.getn(HealBot_CurrentSpells)
end

function HealBot_UnsetHealBot_Ressing(hbGUID)
    HealBot_Ressing[hbGUID]=nil;
end

function HealBot_TooltipInit()
    if ( HealBot_ScanTooltip:IsOwned(HealBot) ) then return; end;
    HealBot_ScanTooltip:SetOwner(HealBot, 'ANCHOR_NONE' );
    HealBot_ScanTooltip:ClearLines();
end

function HealBot_AddChat(HBmsg)
    x=HealBot_Comms_GetChan("HBmsg");
    if x and HealBot_SpamCnt < 24 then
        HealBot_SpamCnt=HealBot_SpamCnt+1;
        w,y = GetGameTime();
        if y==0 then
            HBmsg="["..w..":00] "..HBmsg;
        elseif y<10 then
            HBmsg="["..w..":0"..y.."] "..HBmsg; 
        else
            HBmsg="["..w..":"..y.."] "..HBmsg; 
        end
        SendChatMessage(HBmsg , "CHANNEL", nil, x); 
    elseif ( DEFAULT_CHAT_FRAME ) then
        DEFAULT_CHAT_FRAME:AddMessage(HBmsg, 0.7, 0.7, 1.0);
    end
end

function HealBot_AddDebug(HBmsg)
    x=HealBot_Comms_GetChan("HBmsg");
    if x and HealBot_SpamCnt < 17 then
        HealBot_SpamCnt=HealBot_SpamCnt+1;
        w,y = GetGameTime();
        if y==0 then
            HBmsg="["..w..":00] DEBUG: "..HBmsg;
        elseif y<10 then
            HBmsg="["..w..":0"..y.."] DEBUG: "..HBmsg; 
        else
            HBmsg="["..w..":"..y.."] DEBUG: "..HBmsg; 
        end
        SendChatMessage(HBmsg , "CHANNEL", nil, x);
    end
end

function HealBot_Report_Error(HBmsg)
    if HealBot_ErrorCnt<28 then
        HealBot_ErrorCnt=HealBot_ErrorCnt+1;
        HealBot_ErrorsIn(HBmsg,HealBot_ErrorCnt);
    end
end

function HealBot_ErrorCntReset()
    HealBot_ErrorCnt=0;
end

function HealBot_AddError(HBmsg)
    UIErrorsFrame:AddMessage(HBmsg, 1.0, 1.0, 1.0, 1.0, UIERRORS_HOLD_TIME);
    HealBot_AddDebug(HBmsg);
end

function HealBot_TogglePanel(HBpanel)
    if not HBpanel then return end
    if ( HBpanel:IsVisible() ) then
        HideUIPanel(HBpanel);
    else
        ShowUIPanel(HBpanel);
    end
end

function HealBot_StartMoving(HBframe)
    if ( not HBframe.isMoving ) and ( HBframe.isLocked ~= 1 ) then
        HBframe:StartMoving();
        HBframe.isMoving = true;
    end
end

function HealBot_StopMoving(HBframe,ActionFrame)
    if ( HBframe.isMoving ) then
        HBframe:StopMovingOrSizing();
        HBframe.isMoving = false;
    end
    if ActionFrame then
        HealBot_CheckActionFrame()
    end
end

function HealBot_CheckActionFrame()
    if HealBot_Config.Panel_Anchor==1 then
        HealBot_Config.PanelAnchorY = HealBot_Action:GetTop();
        HealBot_Config.PanelAnchorX = HealBot_Action:GetLeft()
    elseif HealBot_Config.Panel_Anchor==2 then
        HealBot_Config.PanelAnchorY = HealBot_Action:GetBottom();
        HealBot_Config.PanelAnchorX = HealBot_Action:GetLeft()
    elseif HealBot_Config.Panel_Anchor==3 then
        HealBot_Config.PanelAnchorY = HealBot_Action:GetTop();
        HealBot_Config.PanelAnchorX = HealBot_Action:GetRight()
    elseif HealBot_Config.Panel_Anchor==4 then
        HealBot_Config.PanelAnchorY = HealBot_Action:GetBottom();
        HealBot_Config.PanelAnchorX = HealBot_Action:GetRight()
    end
    HealBot_CheckFrame()
end

function HealBot_CheckFrame()
    if not GetScreenWidth() or not Healbot_Config_Skins.bwidth[Healbot_Config_Skins.Current_Skin] then return end
    if HealBot_Config.Panel_Anchor==1 then
        if HealBot_Config.PanelAnchorX<-9 then 
            HealBot_Config.PanelAnchorX=-9
        elseif HealBot_Config.PanelAnchorX>(GetScreenWidth()-(Healbot_Config_Skins.bwidth[Healbot_Config_Skins.Current_Skin]+7)) then
            HealBot_Config.PanelAnchorX=GetScreenWidth()-(Healbot_Config_Skins.bwidth[Healbot_Config_Skins.Current_Skin]+7)
        end
        if HealBot_Config.PanelAnchorY<11+Healbot_Config_Skins.bheight[Healbot_Config_Skins.Current_Skin] then
            HealBot_Config.PanelAnchorY=11+Healbot_Config_Skins.bheight[Healbot_Config_Skins.Current_Skin] 
        elseif HealBot_Config.PanelAnchorY>GetScreenHeight()+12 then
            HealBot_Config.PanelAnchorY=GetScreenHeight()+12
        end
    elseif HealBot_Config.Panel_Anchor==2 then
        if HealBot_Config.PanelAnchorX<-9 then 
            HealBot_Config.PanelAnchorX=-9
        elseif HealBot_Config.PanelAnchorX>(GetScreenWidth()-(Healbot_Config_Skins.bwidth[Healbot_Config_Skins.Current_Skin]+7)) then
            HealBot_Config.PanelAnchorX=GetScreenWidth()-(Healbot_Config_Skins.bwidth[Healbot_Config_Skins.Current_Skin]+7)
        end
        if HealBot_Config.PanelAnchorY<-15 then
            HealBot_Config.PanelAnchorY=-15
        elseif HealBot_Config.PanelAnchorY>GetScreenHeight()-15-Healbot_Config_Skins.bheight[Healbot_Config_Skins.Current_Skin] then
            HealBot_Config.PanelAnchorY=GetScreenHeight()-15-Healbot_Config_Skins.bheight[Healbot_Config_Skins.Current_Skin]
        end
    elseif HealBot_Config.Panel_Anchor==3 then
        if HealBot_Config.PanelAnchorX<Healbot_Config_Skins.bwidth[Healbot_Config_Skins.Current_Skin]+7 then 
            HealBot_Config.PanelAnchorX=Healbot_Config_Skins.bwidth[Healbot_Config_Skins.Current_Skin]+7
        elseif HealBot_Config.PanelAnchorX>(GetScreenWidth()+8) then
            HealBot_Config.PanelAnchorX=GetScreenWidth()+8
        end
        if HealBot_Config.PanelAnchorY<11+Healbot_Config_Skins.bheight[Healbot_Config_Skins.Current_Skin] then
            HealBot_Config.PanelAnchorY=11+Healbot_Config_Skins.bheight[Healbot_Config_Skins.Current_Skin] 
        elseif HealBot_Config.PanelAnchorY>GetScreenHeight()+12 then
            HealBot_Config.PanelAnchorY=GetScreenHeight()+12
        end
    elseif HealBot_Config.Panel_Anchor==4 then
        if HealBot_Config.PanelAnchorX<Healbot_Config_Skins.bwidth[Healbot_Config_Skins.Current_Skin]+7 then 
            HealBot_Config.PanelAnchorX=Healbot_Config_Skins.bwidth[Healbot_Config_Skins.Current_Skin]+7
        elseif HealBot_Config.PanelAnchorX>(GetScreenWidth()+8) then
            HealBot_Config.PanelAnchorX=GetScreenWidth()+8
        end
        if HealBot_Config.PanelAnchorY<-15 then
            HealBot_Config.PanelAnchorY=-15
        elseif HealBot_Config.PanelAnchorY>GetScreenHeight()-15-Healbot_Config_Skins.bheight[Healbot_Config_Skins.Current_Skin] then
            HealBot_Config.PanelAnchorY=GetScreenHeight()-15-Healbot_Config_Skins.bheight[Healbot_Config_Skins.Current_Skin]
        end
    end
end

function HealBot_SlashCmd(HBcmd)
    HBcmd, x, y, z = string.split(" ", HBcmd)
    if (HBcmd=="") then
        HealBot_TogglePanel(HealBot_Action);
    elseif (HBcmd=="o" or HBcmd=="options" or HBcmd=="opt" or HBcmd=="config" or HBcmd=="cfg") then
        HealBot_TogglePanel(HealBot_Options);
    elseif (HBcmd=="d" or HBcmd=="defaults") then
        HealBot_Options_Defaults_OnClick(HealBot_Options_Defaults);
    elseif (HBcmd=="ui") then
        HealBot_AddChat("[HealBot] Reload UI requested")
        HealBot_SetResetFlag("HARD")
    elseif (HBcmd=="ri" or (HBcmd=="reset" and x and x=="healbot")) then
        HealBot_AddChat("[HealBot] Reload healbot requested")
        HealBot_SetResetFlag("SOFT")
    elseif (HBcmd=="rc" or (HBcmd=="reset" and x and x=="customdebuffs")) then
        HealBot_Reset_flag=2
    elseif (HBcmd=="rs" or (HBcmd=="reset" and x and x=="skin")) then
        HealBot_Reset_flag=3
    elseif (HBcmd=="info" or HBcmd=="ver" or HBcmd=="status") then
        HealBot_Comms_Info()
    elseif (HBcmd=="show") then
        HealBot_Action_Reset()
    elseif (HBcmd=="fast") then
        if HealBot_Config.FastAttrib==0 then
            HealBot_Config.FastAttrib=1
            HealBot_AddChat("[HealBot]Fast attrib setting is ON")
        else
            HealBot_Config.FastAttrib=0
            HealBot_AddChat("[HealBot]Fast attrib setting is OFF")
        end
    elseif (HBcmd=="cb") then
        HealBot_Panel_ClearBlackList()
        if Delay_RecalcParty<3 then Delay_RecalcParty=3 end
    elseif (HBcmd=="disable") then
        HealBot_Options_DisableHealBot:SetChecked(1)
        HealBot_Options_ToggleHealBot(1)
        HealBot_AddChat("[HealBot] Entering disabled state")
    elseif (HBcmd=="enable") then
        HealBot_Options_DisableHealBot:SetChecked(0)
        HealBot_Options_ToggleHealBot(0)
        HealBot_AddChat("[HealBot] Entering enabled state")
    elseif (HBcmd=="t") then
        HB_Timer1=0.1
        if HealBot_Config.DisableHealBot==0 then
            HealBot_Options_DisableHealBot:SetChecked(1)
            HealBot_Options_ToggleHealBot(1)
            HealBot_AddChat("[HealBot] Entering disabled state")
        else
            HealBot_Options_DisableHealBot:SetChecked(0)
            HealBot_Options_ToggleHealBot(0)
            HealBot_AddChat("[HealBot] Entering enabled state")
        end
    elseif (HBcmd=="tinfo") then
        if UnitExists("target") then
            HealBot_Comms_TargetInfo()
        else
            HealBot_AddDebug( "No Target" );
        end
    elseif (HBcmd=="help" or HBcmd=="h") then
        HealBot_HelpCnt=0
    elseif (HBcmd=="tt" and x) then
        HealBot_AddChat("incHealDur = "..HealBot_Config.incHealDur[x])
    elseif (HBcmd=="skin" and x) then
        if y then x=x.." "..y end
        if z then x=x.." "..z end
        HealBot_Options_Set_Current_Skin(x)
    else
        if x then HBcmd=HBcmd.." "..x end
        if y then HBcmd=HBcmd.." "..y end
        if z then HBcmd=HBcmd.." "..z end
        HealBot_AddChat("[HealBot] Unknown slash command: /hb "..HBcmd)
        HealBot_HelpCnt=0
    end
end

function HealBot_Reset()
    HB_Timer2=2
    HealBot_UnRegister_Events()
    HealBot_Panel_ClearBlackList()
    HealBot_Panel_ClearHealTarget()
    HealBot_Action_SetAllBars()
    HealBot_ClearAggro()
    HealBot_Loaded=1
    HealBot_setOptions_Timer(150)
    HealBot_PlayerGUID=nil
    HealBot_OnEvent_PlayerEnteringWorld(nil);
end

function HealBot_ResetCustomDebuffs()
    HealBot_Config.HealBot_Custom_Debuffs = HealBot_ConfigDefaults.HealBot_Custom_Debuffs
    HealBot_Options_NewCDebuff:SetText("")
    HealBot_Options_CDebuffTxt1_Initialize()
    HealBot_AddChat("[HealBot] Custom Debuffs reset")
end

function HealBot_ResetSkins()
    Healbot_Config_Skins = HealBot_Config_SkinsDefaults
    HealBot_AddChat("[HealBot] Skin set to Defaults")
    HealBot_Reset_flag=1
end

function HealBot_GetSpellName(id)
    if (not id) then return nil end
    sName, sRank = GetSpellName(id,BOOKTYPE_SPELL);
    if (not sName) then
        return nil;
    end
    if (not sRank or sRank=="") then
        return sName;
    end
    return sName, sRank;
end

function HealBot_GetSpellId(spellName)
    if (not spellName) then return nil end
    x,y = 1,0;
    if HealBot_Spells[spellName] then   
        if HealBot_Spells[spellName].x then return HealBot_Spells[spellName].x; end
    end
    while true do 
        sName, sRank = GetSpellName(x,BOOKTYPE_SPELL);
        if (sName) then
            if (spellName == sName .. "(" .. sRank .. ")") then
                return x;
            end
            if (spellName == sName) then
                y=x;
            end   
        else
            do break end
        end
        x = x + 1;
    end
    if y>0 then
        return y
    else
        return nil;
    end
end

function HealBot_UnitHealth(hbGUID, unit)
    x,y=nil,nil
    if HealBot_unitHealth[hbGUID] then
        x=HealBot_unitHealth[hbGUID]
        y=HealBot_unitHealthMax[hbGUID]
    elseif unit and UnitHealth(unit) then
        x=UnitHealth(unit)
        y=UnitHealthMax(unit)
    end
    if not x or not y then
        if unit then
            HealBot_AddDebug("HealBot_UnitHealth - Health(Max) is nil!  unit passed in = "..unit.." ("..UnitName(unit)..")")
        else
            HealBot_AddDebug("HealBot_UnitHealth - Health(Max) is nil! unitid is nil")
        end
        x=500
        y=1000
    end
    return x,y;
end


local talenty,talentx,talentz=0,0,0
function HealBot_FindHealSpells()
  
    talentz=GetSpellBonusHealing()*HealBot_SpellPowerHealAdj;
    if HealBot_CalcEquipBonus then
        if strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_PRIEST] then 
            talentx=1+HealBot_Talents["SpiritalHealing"]+HealBot_Talents["FocusedPower"]
        elseif strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_DRUID] then 
            talentx=1+HealBot_Talents["GiftOfNature"]
        elseif strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_SHAMAN] then 
            talentx=1+HealBot_Talents["Purification"]
        else
            talentx=1
        end
    end
  
    table.foreach(HealBot_Spells, function (spell,_)
        if HealBot_CalcEquipBonus then
            if HealBot_Spells[spell].NoBonus then
                HealBot_Spells[spell].RealHealing = 0
            else
                talenty=talentx
                if strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_DRUID] then
                    y=HealBot_Talents["NurturingInstinct"]
                elseif strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_SHAMAN] then
                    y=HealBot_Talents["NatureBlessing"]
                else
                    y=0
                end
                healingbonus_penalty=1;
                if HealBot_Spells[spell].Level < 20 then
                    healingbonus_penalty=(1-((20-HealBot_Spells[spell].Level)*0.0375));
                end
                if strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_DRUID] and HealBot_Spells[spell].HealsExt>0 then
                    y=y+(GetSpellBonusHealing()*HealBot_Talents["EmpoweredRejuvenation"])
                end
                if HealBot_Spells[spell].Cast == 0 then
                    if strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_PRIEST] then 
                        talenty=talenty+HealBot_Talents["TwinDisciplines"]
                        if strfind(spell,HEALBOT_RENEW,1) then
                            talenty=talenty+HealBot_Talents["ImprovedRenew"]
                        end
                    elseif strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_DRUID] then
                        talenty=talenty+HealBot_Talents["Genesis"]
                        if strfind(spell,HEALBOT_REJUVENATION,1) then
                            talenty=talenty+HealBot_Talents["ImprovedRejuvenation"]
                        end
                    end
                    w=3.5;
                else
                    if strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_PRIEST] then 
                        if strfind(spell,HEALBOT_GREATER_HEAL,1) then
                            y=y+(GetSpellBonusHealing()*(HealBot_Talents["EmpoweredPower"]*2))
                        elseif strfind(spell,HEALBOT_FLASH_HEAL,1) then
                            y=y+(GetSpellBonusHealing()*HealBot_Talents["EmpoweredPower"])
                        elseif strfind(spell,HEALBOT_BINDING_HEAL,1) then
                            talenty=talenty+HealBot_Talents["DivineProvidence"]
                            y=y+(GetSpellBonusHealing()*HealBot_Talents["EmpoweredPower"])
                        elseif strfind(spell,HEALBOT_PRAYER_OF_HEALING,1) then
                            talentz=GetSpellBonusHealing()
                            talenty=talenty+HealBot_Talents["DivineProvidence"]
                        end
                    elseif strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_DRUID] then
                        if strfind(spell,HEALBOT_HEALING_TOUCH,1) then
                            y=y+(GetSpellBonusHealing()*HealBot_Talents["EmpoweredTouch"])
                        end
                    elseif strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_PALADIN] then 
                        talenty=talenty+HealBot_Talents["HealingLight"]
                    elseif strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_SHAMAN] then
                        if strfind(spell,HEALBOT_CHAIN_HEAL,1) then            
                            talenty=talenty+HealBot_Talents["ImprovedChainHeal"]
                        end
                    end
                    if HealBot_Spells[spell].Cast >= 1.5 and HealBot_Spells[spell].Cast < 3.5 then
                        w=HealBot_Spells[spell].Cast;
                    else
                        w=3.5
                    end
                end
                x = ((talentz * healingbonus_penalty) * (w/3.5));
                z = ((HealBot_Spells[spell].Level)+6)/(UnitLevel("player"))
                if z<1 then x=x*z; end
                x=x+y
                if talenty>1 then
                    x=x*talenty
                    x=x+(floor((HealBot_Spells[spell].HealsCast+HealBot_Spells[spell].HealsExt)*(talenty-1)))
                end
                HealBot_Spells[spell].RealHealing = floor(x);
            end
        end
        HealBot_Spells[spell].HealsDur = floor((HealBot_Spells[spell].HealsCast+HealBot_Spells[spell].HealsExt) + HealBot_Spells[spell].RealHealing);
    end);

    HealBot_CalcEquipBonus=false;
end

function HealBot_RecalcHeals(hbGUID)
    HealBot_Action_Refresh(hbGUID);
end

function HealBot_RecalcParty(HealBot_PreCombat)
    Delay_RecalcParty=0;
    HealBot_Action_PartyChanged(HealBot_PreCombat);
end

function HealBot_RecalcSpells()
    HealBot_FindHealSpells();
end

function HealBot_OnLoad(self)
    HealBot_PlayerClass, HealBot_PlayerClassEN=UnitClass("player")
    HealBot_PlayerRace, HealBot_PlayerRaceEN=UnitRace("player")
    HealBot_PlayerName=UnitName("player")
    HealBot:RegisterEvent("VARIABLES_LOADED");
    HealBot:RegisterEvent("PLAYER_REGEN_DISABLED");
    HealBot:RegisterEvent("PLAYER_REGEN_ENABLED");
    SLASH_HEALBOT1 = "/healbot";
    SLASH_HEALBOT2 = "/hb";
    SlashCmdList["HEALBOT"] = function(msg)
        HealBot_SlashCmd(msg);
    end
end

local ouName=nil
local aSwitch=0

function HealBot_Set_Timers()
    if HealBot_Config.DisableHealBot==0 then
        HB_Timer1=1
        HB_Timer2=HealBot_Comm_round(HealBot_Config.RangeCheckFreq/5, 4)   
        HB_Timer3=0.5
    else
        HB_Timer1=2
        HB_Timer2=10
        HB_Timer3=5
    end
end

local HealBot_Options_Timer={}
function HealBot_setOptions_Timer(value)
    HealBot_Options_Timer[value]=true
end

local HealBot_ErrorNum=0
function HealBot_OnUpdate(self,arg1)
    HealBot_Timer1 = HealBot_Timer1+arg1;
    HealBot_Timer2 = HealBot_Timer2+arg1;
    HealBot_Timer3 = HealBot_Timer3+arg1;
    if HealBot_Loaded and HealBot_Loaded==1 then  
        HealBot_OnEvent_PlayerEnteringWorld(self);
    elseif HealBot_Timer1>=HB_Timer1 then
        HealBot_Timer1 = 0;
        if HealBot_Watch_AM_HoT>0 then
            HealBot_Watch_AM_HoT=HealBot_Watch_AM_HoT-1
        end
        for xGUID,_ in pairs(HealBot_Watch_Timed_HoT) do
            HealBot_Watch_Timed_HoT[xGUID] = HealBot_Watch_Timed_HoT[xGUID]-1;
            if HealBot_Watch_Timed_HoT[xGUID]<0 then HealBot_Watch_Timed_HoT[xGUID]=nil end
        end
        if not HealBot_IsFighting then
            if HealBot_Reset_flag then
                if HealBot_Reset_flag==1 then
                    HealBot_Reset()
                elseif HealBot_Reset_flag==2 then
                    HealBot_ResetCustomDebuffs()
                elseif HealBot_Reset_flag==3 then
                    HealBot_ResetSkins()
                end
                HealBot_Reset_flag=nil
            elseif Delay_RecalcParty>0 then
                Delay_RecalcParty=Delay_RecalcParty+1
                if Delay_RecalcParty>3 then
                    HealBot_Timer2=0-HB_Timer2
                    HealBot_RecalcParty(nil);
                    HealBot_InCombatUpdCnt=0
                end
            elseif HealBot_CheckZoneFlag then
                HealBot_CheckZoneFlag=false; 
                HealBot_CheckZone();
            elseif HealBot_NeedEquipUpdate then
                HealBot_CalcEquipBonus=true;
                HealBot_NeedEquipUpdate=false
                HealBot_RecalcSpells();
                if strsub(HealBot_PlayerClassEN,1,4)=="SHAM" then
                    HealBot_CheckAllBuffs(HealBot_PlayerGUID)
                end
            elseif HealBot_CheckSpells then
                HealBot_CheckSpells=false
                HealBot_InitSpells()
            elseif HealBot_CheckTalents then
                HealBot_CheckTalents=false; 
                HealBot_NeedEquipUpdate=true
                if strsub(HealBot_PlayerClassEN,1,4)=="PRIE" then 
                    HealBot_Talents[HEALBOT_BODY_AND_SOUL]=HealBot_HasTalent(2,20,HEALBOT_BODY_AND_SOUL)
                    if HealBot_HasTalent(1,8,HEALBOT_INNER_FOCUS)>0 then 
                        HealBot_InnerFocusTalent=true
                    else
                        HealBot_InnerFocusTalent=nil
                    end
                    HealBot_Talents["ImprovedRenew"]=(5*HealBot_HasTalent(2,2,HEALBOT_IMPROVED_RENEW))/100
                    HealBot_Talents["SpiritalHealing"]=(2*HealBot_HasTalent(2,16,HEALBOT_SPIRITAL_HEALING))/100
                    HealBot_Talents["TwinDisciplines"]=HealBot_HasTalent(1,2,HEALBOT_TWIN_DISCIPLINES)/100
                    HealBot_Talents["FocusedPower"]=(2*HealBot_HasTalent(1,16,HEALBOT_FOCUSED_POWER))/100
                    HealBot_Talents["EmpoweredPower"]=(4*HealBot_HasTalent(2,21,HEALBOT_EMPOWERED_HEALING))/100
                    HealBot_Talents["DivineProvidence"]=(2*HealBot_HasTalent(2,26,HEALBOT_DIVINE_PROVIDENCE))/100
                elseif strsub(HealBot_PlayerClassEN,1,4)=="DRUI" then 
                    HealBot_Talents["Genesis"]=HealBot_HasTalent(1,2,HEALBOT_GENESIS)/100
                    _,i=UnitStat("player", 2)
                    HealBot_Talents["NurturingInstinct"]=i*(0+(35*HealBot_HasTalent(2,15,HEALBOT_NURTURING_INSTINCT)/100))
                    HealBot_Talents["ImprovedRejuvenation"]=(5*HealBot_HasTalent(3,11,HEALBOT_IMPROVED_REJUVENATION))/100
                    HealBot_Talents["GiftOfNature"]=(2*HealBot_HasTalent(3,13,HEALBOT_GIFT_OF_NATURE))/100
                    HealBot_Talents["EmpoweredTouch"]=(20*HealBot_HasTalent(3,15,HEALBOT_EMPOWERED_TOUCH))/100
                    HealBot_Talents["EmpoweredRejuvenation"]=(4*HealBot_HasTalent(3,20,HEALBOT_EMPOWERED_REJUVENATION))/100
                elseif strsub(HealBot_PlayerClassEN,1,4)=="SHAM" then 
                    HealBot_Talents["Purification"]=(2*HealBot_HasTalent(3,15,HEALBOT_PURIFICATION))/100
                    HealBot_Talents["ImprovedChainHeal"]=(10*HealBot_HasTalent(3,20,HEALBOT_IMPROVED_CHAIN_HEAL))/100
                    _,i=UnitStat("player", 4)
                    HealBot_Talents["NatureBlessing"]=i*(0+(5*HealBot_HasTalent(3,21,HEALBOT_NATURES_BLESSING)/100))
                elseif strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_PALADIN] then 
                    HealBot_Talents["HealingLight"]=(4*HealBot_HasTalent(1,3,HEALBOT_HEALING_LIGHT))/100
                end        
                HealBot_Config.CurrentSpec=HealBot_GetTalentInfo(HealBot_PlayerGUID)
                HealBot_Options_ComboClass_Text()
                HealBot_Buff_Spells_List=HealBot_Options_InitBuffList() -- added by Diacono of Ursin
                HealBot_Options_BuffTxt1_Refresh()
                HealBot_Options_BuffGroups1_Refresh()
                HealBot_Options_BuffTxt2_Refresh()
                HealBot_Options_BuffGroups2_Refresh()
                HealBot_Options_BuffTxt3_Refresh()
                HealBot_Options_BuffGroups3_Refresh()
                HealBot_Options_BuffTxt4_Refresh()
                HealBot_Options_BuffGroups4_Refresh()
                HealBot_Options_BuffTxt5_Refresh()
                HealBot_Options_BuffGroups5_Refresh()
                HealBot_Options_BuffTxt6_Refresh()
                HealBot_Options_BuffGroups6_Refresh()
                HealBot_Options_BuffTxt7_Refresh()
                HealBot_Options_BuffGroups7_Refresh()
                HealBot_Options_BuffTxt8_Refresh()
                HealBot_Options_BuffGroups8_Refresh()
                HealBot_Options_BuffTxt9_Refresh()
                HealBot_Options_BuffGroups9_Refresh()
                HealBot_Options_BuffTxt10_Refresh()
                HealBot_Options_BuffGroups10_Refresh()
                HealBot_Options_CDCTxt1_Refresh()
                HealBot_Options_CDCTxt2_Refresh()
                HealBot_Options_CDCTxt3_Refresh()
                HealBot_Options_CDCGroups1_Refresh()
                HealBot_Options_CDCGroups2_Refresh()
                HealBot_Options_CDCGroups3_Refresh()
                HealBot_Options_Debuff_Reset()
                HealBot_Options_Buff_Reset()
                HealBot_ClearAllBuffs()
                HealBot_ClearAllDebuffs()
                HealBot_Action_SetAllAttribs()
                HealBot_Queue_AllActiveMyBuffs()
                HealBot_RecalcParty(nil)
            elseif HealBot_CheckForDivineSpirit then
                HealBot_CheckForDivineSpirit=false
                x=0;
                Ti=1;
                while true do
                    bName,_,_,_,_,_ = UnitBuff("player",Ti) 
                    if bName then
                        if bName==HEALBOT_DIVINE_SPIRIT or bName==HEALBOT_PRAYER_OF_SPIRIT then
                            x=1;
                            do break end;
                        end
                        Ti = Ti + 1;
                    else
                        do break end
                    end
                end
                if x~=HealBot_HasDivineSpirit then
                    HealBot_HasDivineSpirit=x;
                    HealBot_RecalcSpells()
                end
            elseif HealBot_CheckBuffsTimehbGUID and HealBot_CheckBuffsTime<GetTime() and not HealBot_UnitBuff[HealBot_CheckBuffsTimehbGUID] then
                if HealBot_UnitSpec[HealBot_CheckBuffsTimehbGUID] then
                    PlayerBuffsGUID=HealBot_PlayerBuff[HealBot_CheckBuffsTimehbGUID]
                    Ti=0
                    if PlayerBuffsGUID then
                        for bName,_ in pairs (PlayerBuffsGUID) do
                            if PlayerBuffsGUID[bName] < GetTime() then
                                HealBot_CheckUnitBuffs(HealBot_CheckBuffsTimehbGUID)
                                Ti=1
                                do break end
                            end
                        end
                    end
                    if Ti==0 then
                        HealBot_CheckMyBuffs(HealBot_CheckBuffsTimehbGUID)
                        HealBot_ResetCheckBuffsTime()  
                    end
                else
                    HealBot_PlayerBuff[HealBot_CheckBuffsTimehbGUID]=nil
                    HealBot_ResetCheckBuffsTime()
                end
            elseif HealBot_ReCheckBuffsTime and HealBot_ReCheckBuffsTime<GetTime() then
                HealBot_CheckAllBuffs(HealBot_ReCheckBuffsTimed[HealBot_ReCheckBuffsTime])
                HealBot_ReCheckBuffsTimed[HealBot_ReCheckBuffsTime]=nil
                z=HealBot_ReCheckBuffsTime+1000000
                HealBot_ReCheckBuffsTime=nil 
                for Time,_ in pairs (HealBot_ReCheckBuffsTimed) do
                    if Time < z then
                        z=Time
                        HealBot_ReCheckBuffsTime=Time
                    end
                end
            elseif HealBot_WeaponBuffCheck then
                HealBot_WeaponBuffCheck=HealBot_WeaponBuffCheck-1
                if HealBot_WeaponBuffCheck<=0 then HealBot_WeaponBuffCheck=nil end
                if HealBot_UnitBuff[HealBot_PlayerGUID] then HealBot_CheckUnitBuffs(HealBot_PlayerGUID) end
            end
            if HealBot_Options_Timer then
                if HealBot_Options_Timer[150] then
                    HealBot_Options_Timer[150]=nil
                    HealBot_Action_ResetSkin()
                    HealBot_setOptions_Timer(200)
                elseif HealBot_Options_Timer[9000] and HealBot_Config.Skin_ID then
                    HealBot_Options_Set_Current_Skin()
                    HealBot_Options_Skins_Initialize()
                    HealBot_Options_Skins2_Initialize()
                    HealBot_Options_Timer[9000]=nil
                elseif HealBot_Options_Timer[200] then
                    HealBot_Options_Timer[200]=nil
                    if Healbot_Config_Skins.ShowRaidIcon[Healbot_Config_Skins.Current_Skin]==1 then 
                        HealBot_RaidTargetToggle(true) 
                    else
                        HealBot_RaidTargetToggle(nil) 
                    end
                elseif HealBot_Options_Timer[10] then
                    HealBot_Options_Timer[10]=nil
                    HealBot_Queue_AllActiveMyBuffs()
                elseif HealBot_Options_Timer[20] then
                    HealBot_Options_Timer[20]=nil
                    HealBot_CheckAllDebuffs()
                elseif HealBot_Options_Timer[30] then
                    HealBot_Options_Timer[30]=nil
                    HealBot_CheckAllBuffs()
                elseif HealBot_Options_Timer[40] then
                    HealBot_Options_Timer[40]=nil
                    HealBot_Options_Buff_Reset()
                elseif HealBot_Options_Timer[50] then
                    HealBot_Options_Timer[50]=nil
                    HealBot_Options_Debuff_Reset()
                elseif HealBot_Options_Timer[60] then
                    HealBot_Options_Timer[60]=nil
                    HealBot_Options_EmergencyFilter_Reset()
                elseif HealBot_Options_Timer[70] then
                    HealBot_Options_Timer[70]=nil
                    HealBot_Options_CheckCombos()
                elseif HealBot_Options_Timer[80] then
                    HealBot_Options_Timer[80]=nil
                    HealBot_Action_ResetUnitStatus()
                elseif HealBot_Options_Timer[90] then
                    HealBot_Options_Timer[90]=nil
                    HealBot_SetSkinColours();
                elseif HealBot_Options_Timer[100] then
                    HealBot_Options_Timer[100]=nil
                    HealBot_SetBuffBarColours()
                elseif HealBot_Options_Timer[500] or HealBot_Options_Timer[501] then
                    if HealBot_Options_Timer[500] then
                        HealBot_SetResetFlag("SOFT")
                        ShowUIPanel(HealBot_Action)
                        HealBot_Options_Timer[500]=nil
                    else
                        HealBot_UnRegister_Events()
                        HealBot_Register_Events()
                        HideUIPanel(HealBot_Action)
                        HealBot_SetResetFlag("SOFT")
                        HealBot_Options_Timer[501]=nil
                    end
                    HealBot_Set_Timers()
                    HealBot_Action_Set_Timers()
                end
            end
            if HealBot_Config.TooltipUpdate==1 and HealBot_Action_TooltipUnit then
                HealBot_Action_RefreshTooltip(HealBot_Action_TooltipUnit,"Enabled");
            elseif HealBot_Config.TooltipUpdate==1 and HealBot_Action_DisableTooltipUnit then
                HealBot_Action_RefreshTooltip(HealBot_Action_DisableTooltipUnit,"Disabled");
            end
        elseif HealBot_IsReallyFightingFlag then
            if not InCombatLockdown() then
                HealBot_IsReallyFightingFlag = nil
                HealBot_IsFighting = nil;
            end
        end
        HealBot_SpamCnt = 0;
        if HealBot_RequestVer then
            HealBot_Comms_SendAddonMsg("HealBot", ">> SendVersion <<=>> "..HealBot_RequestVer.." <<=>> Version="..HEALBOT_VERSION, HealBot_AddonMsgType, HealBot_PlayerName)
            HealBot_RequestVer=nil;
        end
    
        for xGUID in pairs(HealBot_Ressing) do
            if HealBot_Ressing[xGUID]=="_NIL_" then 
                HealBot_Ressing[xGUID]=nil;
                if HealBot_UnitID[xGUID] then HealBot_Action_ResetUnitStatus(HealBot_UnitID[xGUID]) end
            elseif HealBot_Ressing[xGUID]=="_RESSED3_" then 
                HealBot_Ressing[xGUID]="_NIL_"
            elseif HealBot_Ressing[xGUID]=="_RESSED2_" then 
                HealBot_Ressing[xGUID]="_RESSED3_"
            elseif HealBot_Ressing[xGUID]=="_RESSED1_" then 
                HealBot_Ressing[xGUID]="_RESSED2_";
            elseif HealBot_Ressing[xGUID]=="_RESSED_" then 
                HealBot_Ressing[xGUID]="_RESSED1_";
            end
        end

    elseif HealBot_Timer3>=HB_Timer3 and HealBot_Loaded then
        HealBot_Timer3=0

        for xGUID in pairs(HealBot_Player_HoT) do
            huHoTtime=HealBot_Player_HoT[xGUID]
            for sName in pairs(huHoTtime) do
                if huHoTtime[sName]<40 then
                    huHoTtime[sName]=huHoTtime[sName]-1
                    if huHoTtime[sName]<2 then
                        if HealBot_Player_HoT_Icons[xGUID][sName]>0 then
                            HealBot_HoT_Update(xGUID, sName)
                        else
                            huHoTtime[sName]=nil
                        end
                    end
                else
                    HealBot_HoT_Update(xGUID, sName)
                end
            end
        end
        
        HealBot_ThrottleCnt=0
        Ti=0;
        if not HealBot_IsFighting then
            for xGUID,_ in pairs(HealBot_DelayDebuffCheck) do
                if Ti<3 then
                    if not HealBot_UnitDebuff[xGUID] then
                        HealBot_CheckUnitDebuffs(xGUID)
                        Ti=Ti+1
                    end
                    HealBot_DelayDebuffCheck[xGUID] = nil;
                end
            end
            for xGUID,_ in pairs(HealBot_DelayBuffCheck) do
                if Ti<4 then
                    HealBot_CheckUnitBuffs(xGUID)
                    Ti=Ti+1
                    HealBot_DelayBuffCheck[xGUID] = nil;
                end
            end
        end
        for xGUID,xUnit in pairs(HealBot_QueueCheckBuffs) do
            if Ti<3 then
                HealBot_CheckMyBuffs(xGUID)
                HealBot_DelayAuraCheck[xGUID]=xUnit
                HealBot_QueueCheckBuffs[xGUID]=nil
                Ti=Ti+1
            end
        end
        for xUnit,_ in pairs(HealBot_VehicleCheck) do
            if Ti<5 then
                HealBot_OnEvent_VehicleChange(nil, xUnit, true)
                HealBot_VehicleCheck[xUnit]=nil
                Ti=Ti+1
            end
        end
        if HealBot_InCombatUpdate then
            HealBot_IC_PartyMembersChanged()
        end
    end
    if HealBot_Timer2>HB_Timer2 then
        HealBot_Timer2=0
        aSwitch=aSwitch+1
        if aSwitch==1 then
            HealBot_Action_RefreshButtons()
        elseif aSwitch==2 then
            for xGUID,xUnit in pairs(HealBot_DelayAuraCheck) do
                if UnitIsVisible(xUnit) then 
                    HealBot_HasMyBuffs(xUnit,xGUID) 
                end
                HealBot_DelayAuraCheck[xGUID] = nil;
            end
        elseif aSwitch==3 then
            HealBot_Action_RefreshButtons()
        elseif aSwitch==4 then
            for xGUID in pairs(HealBot_HealsIncCnt) do
                HealBot_HealsIncCnt[xGUID]=HealBot_HealsIncCnt[xGUID]+HB_Timer3; 
                if HealBot_HealsIncCnt[xGUID]>2 and not HealBot_HealsIn[xGUID] then
                    HealBot_HealsIncCnt[xGUID]=nil
                else
                    if HealBot_Casters[xGUID] then
                        HealBot_HealsInUpdate(xGUID, HealBot_Casters[xGUID])
                    else
                        HealBot_HealsInUpdate(xGUID)
                    end
                end
            end
        elseif aSwitch==5 then
            HealBot_Action_RefreshButtons()
        else
            if Healbot_Config_Skins.ShowAggro[Healbot_Config_Skins.Current_Skin]==1 then HealBot_CheckAggro() end
            aSwitch=0
        end
        if HealBot_HelpCnt then
            HealBot_HelpCnt=HealBot_HelpCnt+1
            if HealBot_HelpCnt>#HEALBOT_HELP then
                HealBot_HelpCnt=nil
            else
                HealBot_AddChat(HEALBOT_HELP[HealBot_HelpCnt])
            end
        end
    end
end

function HealBot_RetVersion()
    return HEALBOT_VERSION
end

function HealBot_OnEvent(self, event, arg1,arg2,arg3,arg4)
    if (event=="CHAT_MSG_ADDON") then
        HealBot_OnEvent_AddonMsg(self,arg1,arg2,arg3,arg4);
    elseif (event=="UNIT_AURA") then
        HealBot_OnEvent_UnitAura(self,arg1);
    elseif (event=="UNIT_MANA") or (event=="UNIT_RAGE") or (event=="UNIT_ENERGY") or (event=="UNIT_RUNIC_POWER") or (event=="UNIT_MAXMANA") or (event=="UNIT_MAXRAGE") or (event=="UNIT_MAXENERGY") or (event=="UNIT_MAXRUNIC_POWER") then
        HealBot_OnEvent_UnitMana(self,arg1);
    elseif (event=="UNIT_HEALTH") or (event=="UNIT_MAXHEALTH") then
        HealBot_OnEvent_UnitHealth(self,arg1,UnitHealth(arg1),UnitHealthMax(arg1));
    elseif (event=="UnitHealthUpdated") then
        HealBot_OnEvent_UnitHealth(self,arg1,arg2,arg3);
    elseif (event=="UNIT_COMBAT") or (event=="UNIT_THREAT_LIST_UPDATE") or (event=="UNIT_THREAT_SITUATION_UPDATE") then
        if arg1 then HealBot_OnEvent_UnitCombat(self,arg1); end
    elseif (event=="UNIT_SPELLCAST_START") then
        HealBot_OnEvent_UnitSpellcastStart(self,arg1,arg2)
    elseif (event=="UNIT_SPELLCAST_STOP") or (event=="UNIT_SPELLCAST_SUCCEEDED") then
        HealBot_OnEvent_UnitSpellcastStop(self,arg1,arg2);
    elseif (event=="UNIT_SPELLCAST_FAILED") or (event=="UNIT_SPELLCAST_INTERRUPTED") then
        HealBot_OnEvent_UnitSpellcastFail(self,arg1,arg2);
    elseif (event=="UNIT_SPELLCAST_SENT") then
        HealBot_OnEvent_UnitSpellcastSent(self,arg1,arg2,arg3,arg4);  
    elseif (event=="PLAYER_REGEN_DISABLED") then
        HealBot_OnEvent_PlayerRegenDisabled(self);
    elseif (event=="PLAYER_REGEN_ENABLED") then
        HealBot_OnEvent_PlayerRegenEnabled(self);
    elseif (event=="UNIT_NAME_UPDATE") then
        HealBot_OnEvent_UnitNameUpdate(self,arg1)
    elseif (event=="CHAT_MSG_SYSTEM") then
        HealBot_OnEvent_SystemMsg(self,arg1);
    elseif (event=="PARTY_MEMBERS_CHANGED") then
        HealBot_OnEvent_PartyMembersChanged(self);
    elseif (event=="RAID_TARGET_UPDATE") then
        if Healbot_Config_Skins.ShowRaidIcon[Healbot_Config_Skins.Current_Skin]==1 then HealBot_OnEvent_RaidTargetUpdate(self); end
    elseif (event=="PLAYER_TARGET_CHANGED") then
        HealBot_OnEvent_PlayerTargetChanged(self);
    elseif (event=="PLAYER_FOCUS_CHANGED") then
        HealBot_OnEvent_FocusChanged(self);
    elseif (event=="MODIFIER_STATE_CHANGED") then
        HealBot_OnEvent_ModifierStateChange(self,arg1,arg2);
    elseif (event=="UNIT_INVENTORY_CHANGED") then
        HealBot_OnEvent_PlayerEquipmentChanged(self,arg1);
    elseif (event=="UNIT_PET") then
        HealBot_OnEvent_PartyPetChanged(self);
    elseif (event=="RAID_ROSTER_UPDATE") then
        HealBot_OnEvent_RaidRosterUpdate(self);
    elseif (event=="LEARNED_SPELL_IN_TAB") then
        HealBot_OnEvent_SpellsChanged(self,arg1);
    elseif (event=="INSPECT_TALENT_READY") then
        HealBot_GetTalentInfo(HealBot_UnitGUID("target"))
    elseif (event=="UNIT_ENTERED_VEHICLE") then
        HealBot_OnEvent_VehicleChange(self, arg1, true)
    elseif (event=="UNIT_EXITED_VEHICLE") then
        HealBot_OnEvent_VehicleChange(self, arg1, nil)
    elseif (event=="UNIT_EXITING_VEHICLE") then
        HealBot_OnEvent_LeavingVehicle(self, arg1)
    elseif (event=="PLAYER_ENTERING_WORLD") then
        HealBot_OnEvent_PlayerEnteringWorld(self);
    elseif (event=="PLAYER_LEAVING_WORLD") then
        HealBot_OnEvent_PlayerLeavingWorld(self);
    elseif (event=="CHARACTER_POINTS_CHANGED") then
        HealBot_OnEvent_TalentsChanged(self, arg1);
    elseif (event=="ZONE_CHANGED_NEW_AREA") then
        HealBot_OnEvent_ZoneChanged(self);
    elseif (event=="VARIABLES_LOADED") then
        HealBot_OnEvent_VariablesLoaded(self);
    else
        HealBot_AddDebug("OnEvent (" .. event .. ")");
    end
end

--
-- HealBot_Watch_HoT codes
--
-- A = All Casts by anyone
-- C = Cast by me on the target
-- AM = All my casts, multiple targets
-- CT = Cast by me on the target, cast can be delayed.
--
-- Order of preference based on CPU usage:
--                 C
--                 CT
--                 AM
--                 A
--

function HealBot_OnEvent_VariablesLoaded(self)
    table.foreach(HealBot_ConfigDefaults, function (key,val)
        if not HealBot_Config[key] then
            HealBot_Config[key] = val;
        end
    end);
    table.foreach(HealBot_Config_SkinsDefaults, function (key,val)
        if not Healbot_Config_Skins[key] then
            Healbot_Config_Skins[key] = val;
        end
    end);
    if not HealBot_Config.DisabledKeyCombo then HealBot_InitNewChar(HealBot_PlayerClassEN) end
    HealBot_Options_Set_Current_Skin()
    HealBot_Update_Skins()
    HealBot_Action_ResetSkin()
    HealBot_PlayerClass, HealBot_PlayerClassEN=UnitClass("player")
    HealBot_PlayerRace, HealBot_PlayerRaceEN=UnitRace("player")
    HealBot_PlayerName=UnitName("player")
    HealBot_Vers[HealBot_PlayerName]=HEALBOT_VERSION
    HealBot_Class_En[HEALBOT_DRUID]="DRUI"
    HealBot_Class_En[HEALBOT_HUNTER]="HUNT"
    HealBot_Class_En[HEALBOT_MAGE]="MAGE"
    HealBot_Class_En[HEALBOT_PALADIN]="PALA"
    HealBot_Class_En[HEALBOT_PRIEST]="PRIE"
    HealBot_Class_En[HEALBOT_ROGUE]="ROGU"
    HealBot_Class_En[HEALBOT_SHAMAN]="SHAM"
    HealBot_Class_En[HEALBOT_WARLOCK]="WARL"
    HealBot_Class_En[HEALBOT_WARRIOR]="WARR"
    HealBot_Class_En[HEALBOT_DEATHKNIGHT]="DEAT"
    if strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_PRIEST] then
        HealBot_ShortBuffs[HEALBOT_SHADOW_PROTECTION]=true
        HealBot_ShortBuffs[HEALBOT_TOUCH_OF_WEAKNESS]=true
        HealBot_Watch_HoT[HEALBOT_GUARDIAN_SPIRIT]="A"
        HealBot_Watch_HoT[HEALBOT_PAIN_SUPPRESSION]="A"
        HealBot_Watch_HoT[HEALBOT_POWER_INFUSION]="A"
        HealBot_Watch_HoT[HEALBOT_RENEW]="C"
        HealBot_Watch_HoT[HEALBOT_ABOLISH_DISEASE]="C"
        HealBot_Watch_HoT[HEALBOT_POWER_WORD_SHIELD]="A"
        HealBot_Watch_HoT[HEALBOT_PRAYER_OF_MENDING]="A"
        HealBot_HoT_Count[HEALBOT_PRAYER_OF_MENDING]={}
        HealBot_Watch_HoT[HEALBOT_GRACE]="A"
        HealBot_HoT_Count[HEALBOT_GRACE]={}
        HealBot_Watch_HoT[HEALBOT_DIVINE_AEGIS]="A"
        HealBot_BuffNameSwap = {[HEALBOT_POWER_WORD_FORTITUDE] = HEALBOT_PRAYER_OF_FORTITUDE,
                                [HEALBOT_PRAYER_OF_FORTITUDE] = HEALBOT_POWER_WORD_FORTITUDE,
                                [HEALBOT_SHADOW_PROTECTION] = HEALBOT_PRAYER_OF_SHADOW_PROTECTION,
                                [HEALBOT_PRAYER_OF_SHADOW_PROTECTION] = HEALBOT_SHADOW_PROTECTION,
                                [HEALBOT_DIVINE_SPIRIT] = HEALBOT_PRAYER_OF_SPIRIT,
                                [HEALBOT_PRAYER_OF_SPIRIT] = HEALBOT_DIVINE_SPIRIT}
        HealBot_Talents["InnerFocus"]=false
        HealBot_Talents["ImprovedRenew"]=0
        HealBot_Talents["TwinDisciplines"]=0
        HealBot_Talents["SpiritalHealing"]=0
        HealBot_Talents["EmpoweredPower"]=0
        HealBot_Talents["DivineProvidence"]=0
        HealBot_Talents["FocusedPower"]=0
    elseif strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_DRUID] then
        HealBot_ShortBuffs[HEALBOT_THORNS]=true
        HealBot_Watch_HoT[HEALBOT_REJUVENATION]="C"
        HealBot_Watch_HoT[HEALBOT_REGROWTH]="C"
        HealBot_Watch_HoT[HEALBOT_LIFEBLOOM]="C"
        HealBot_HoT_Count[HEALBOT_LIFEBLOOM]={}
        HealBot_Watch_HoT[HEALBOT_ABOLISH_POISON]="C"
        HealBot_Watch_HoT[HEALBOT_WILD_GROWTH]="AM"
        HealBot_Watch_HoT[HEALBOT_TRANQUILITY]="AM"
        HealBot_BuffNameSwap = {[HEALBOT_MARK_OF_THE_WILD] = HEALBOT_GIFT_OF_THE_WILD,
                                [HEALBOT_GIFT_OF_THE_WILD] = HEALBOT_MARK_OF_THE_WILD}
        HealBot_Talents["Genesis"]=0
        HealBot_Talents["NurturingInstinct"]=0
        HealBot_Talents["ImprovedRejuvenation"]=0
        HealBot_Talents["GiftOfNature"]=0
        HealBot_Talents["EmpoweredTouch"]=0
        HealBot_Talents["EmpoweredRejuvenation"]=0
    elseif strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_PALADIN] then
        HealBot_ShortBuffs[HEALBOT_BLESSING_OF_MIGHT]=true
        HealBot_ShortBuffs[HEALBOT_BLESSING_OF_WISDOM]=true
        HealBot_ShortBuffs[HEALBOT_BLESSING_OF_SALVATION]=true
        HealBot_ShortBuffs[HEALBOT_BLESSING_OF_SANCTUARY]=true
        HealBot_ShortBuffs[HEALBOT_BLESSING_OF_LIGHT]=true
        HealBot_ShortBuffs[HEALBOT_BLESSING_OF_PROTECTION]=true
        HealBot_ShortBuffs[HEALBOT_BLESSING_OF_FREEDOM]=true
        HealBot_ShortBuffs[HEALBOT_BLESSING_OF_SACRIFICE]=true
        HealBot_ShortBuffs[HEALBOT_BLESSING_OF_KINGS]=true
        HealBot_ShortBuffs[HEALBOT_BEACON_OF_LIGHT]=true
        HealBot_ShortBuffs[HEALBOT_SACRED_SHIELD]=true
        HealBot_ShortBuffs[HEALBOT_SEAL_OF_RIGHTEOUSNESS]=true
        HealBot_ShortBuffs[HEALBOT_SEAL_OF_BLOOD]=true
        HealBot_ShortBuffs[HEALBOT_SEAL_OF_CORRUPTION]=true
        HealBot_ShortBuffs[HEALBOT_SEAL_OF_JUSTICE]=true
        HealBot_ShortBuffs[HEALBOT_SEAL_OF_LIGHT]=true
        HealBot_ShortBuffs[HEALBOT_SEAL_OF_VENGEANCE]=true
        HealBot_ShortBuffs[HEALBOT_SEAL_OF_WISDOM]=true
        HealBot_ShortBuffs[HEALBOT_SEAL_OF_COMMAND]=true
        HealBot_ShortBuffs[HEALBOT_SEAL_OF_THE_MARTYR]=true
        HealBot_Watch_HoT[HEALBOT_FLASH_OF_LIGHT]="C"
        HealBot_Watch_HoT[HEALBOT_BEACON_OF_LIGHT]="CT"
        HealBot_Watch_HoT[HEALBOT_SACRED_SHIELD]="A"
        HealBot_Watch_HoT[HEALBOT_LIGHT_BEACON]="A"
        HealBot_BuffNameSwap = {[HEALBOT_BLESSING_OF_MIGHT] = HEALBOT_GREATER_BLESSING_OF_MIGHT,
                                [HEALBOT_GREATER_BLESSING_OF_MIGHT] = HEALBOT_BLESSING_OF_MIGHT,
                                [HEALBOT_BLESSING_OF_WISDOM] = HEALBOT_GREATER_BLESSING_OF_WISDOM,
                                [HEALBOT_GREATER_BLESSING_OF_WISDOM] = HEALBOT_BLESSING_OF_WISDOM,
                                [HEALBOT_BLESSING_OF_KINGS] = HEALBOT_GREATER_BLESSING_OF_KINGS,
                                [HEALBOT_GREATER_BLESSING_OF_KINGS] = HEALBOT_BLESSING_OF_KINGS,
                                [HEALBOT_BLESSING_OF_LIGHT] = HEALBOT_GREATER_BLESSING_OF_LIGHT,
                                [HEALBOT_GREATER_BLESSING_OF_LIGHT] = HEALBOT_BLESSING_OF_LIGHT,
                                [HEALBOT_BLESSING_OF_SALVATION] = HEALBOT_GREATER_BLESSING_OF_SALVATION,
                                [HEALBOT_GREATER_BLESSING_OF_SALVATION] = HEALBOT_BLESSING_OF_SALVATION,
                                [HEALBOT_BLESSING_OF_SANCTUARY] = HEALBOT_GREATER_BLESSING_OF_SANCTUARY,
                                [HEALBOT_GREATER_BLESSING_OF_SANCTUARY] = HEALBOT_BLESSING_OF_SANCTUARY}
        HealBot_Talents["HealingLight"]=0
    elseif strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_HUNTER] then
        HealBot_Watch_HoT[HEALBOT_MENDPET]="C"
    elseif strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_SHAMAN] then
        HealBot_Watch_HoT[HEALBOT_RIPTIDE]="C"
        HealBot_Watch_HoT[HEALBOT_EARTHLIVING_WEAPON]="C"
        HealBot_Watch_HoT[HEALBOT_EARTH_SHIELD]="A"
        HealBot_HoT_Count[HEALBOT_EARTH_SHIELD]={}
        HealBot_Watch_HoT[HEALBOT_WATER_SHIELD]="A"
        HealBot_HoT_Count[HEALBOT_WATER_SHIELD]={}
        HealBot_Watch_HoT[HEALBOT_HEALING_WAY]="C"
        HealBot_Watch_HoT[HEALBOT_LIGHTNING_SHIELD]="A"
        HealBot_HoT_Count[HEALBOT_LIGHTNING_SHIELD]={}
        HealBot_ShortBuffs[HEALBOT_ANCESTRAL_FORTITUDE]=true
        HealBot_Talents["Purification"]=0
        HealBot_Talents["ImprovedChainHeal"]=0
        HealBot_Talents["NatureBlessing"]=0
    elseif strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_WARRIOR] then
        HealBot_Watch_HoT[HEALBOT_VIGILANCE]="A"
        HealBot_HoT_Texture[HEALBOT_VIGILANCE] = "Interface\\Icons\\Ability_Warrior_Vigilance";
        HealBot_ShortBuffs[HEALBOT_BATTLE_SHOUT]=true
        HealBot_ShortBuffs[HEALBOT_COMMANDING_SHOUT]=true
    end
    if strsub(HealBot_PlayerRaceEN,1,3)=="Dra" then
        HealBot_Watch_HoT[HEALBOT_GIFT_OF_THE_NAARU]="A"
    end
    HealBot_CheckForDivineSpirit=true;
    if HealBot_Config.EnLibQuickHealth==1 then
        QuickHealth = LibStub("LibQuickHealth-2.0")
        QuickHealth.RegisterCallback(self, "UnitHealthUpdated", function(event, unitID, health, healthMax)
            HealBot_OnEvent(self, "UnitHealthUpdated", unitID, health, healthMax)
        end);
    end
    if HealBot_Config.ShowIncHeals==1 then
        HealComm.RegisterCallback(HealBot_LHC4, "HealComm_HealStarted", "HealStarted")
    end
    HealBot_Options_Init(9)
    HealBot_OptionsTab5:SetText(HEALBOT_OPTIONS_TAB_SKIN.." 1");
    HealBot_OptionsTab6:SetText(HEALBOT_OPTIONS_TAB_SKIN.." 2");
    HealBot_MMButton_Init();
    HealBot:RegisterEvent("PLAYER_ENTERING_WORLD");
    HealBot:RegisterEvent("PLAYER_LEAVING_WORLD");
    HealBot_Loaded=1;
end

function HealBot_Load()
    HealBot_InitSpells()
    HealBot_Init_SetSpec()
    HealBot_CheckFrame()
    HealBot_PlayerGUID=UnitGUID("player")
    HealBot_PlayerBuff[HealBot_PlayerGUID]={}
    HealBot_Buff_Spells_List=HealBot_Options_InitBuffList()
    HealBot_Options_EmergencyFilter_Reset()
    HealBot_Options_SetSkins();
    HealBot_Options_CheckCombos()
    HealBot_Options_Debuff_Reset()
    HealBot_Options_Buff_Reset()
    HealBot_CheckMyBuffs(HealBot_PlayerGUID)
    HealBot_Action_SetDebuffAggroCols()
    if HealBot_Config.AutoClose==0 then HealBot_Config.ActionVisible=1; end
    if HealBot_Config.DisableHealBot==0 and HealBot_Config.ActionVisible==1 then HealBot_Action:Show() end
    if not HealBot_IsFighting then
        HealBot_RecalcParty(nil);
    else
        HealBot_RecalcParty(true);
    end
--        HealBot_Comms_SendAddonMsg("HealBot", ">> SendVersion <<=>> "..HealBot_PlayerName.." <<=>> Version="..HEALBOT_VERSION, HealBot_AddonMsgType, HealBot_PlayerName)       
    HealBot_Comms_SendAddonMsg("HealBot", ">> RequestVersion <<=>> "..HealBot_PlayerName.." <<=>> nil <<", HealBot_AddonMsgType, HealBot_PlayerName)
    HealBot_CheckTalents=true
    if HealBot_AddonMsgType==2 then HealBot_Comms_SendAddonMsg("CTRA", "SR", HealBot_AddonMsgType, HealBot_PlayerName) end
    HealBot_AddChat("  "..HEALBOT_ADDON .. HEALBOT_LOADED);
    HealBot_AddChat(HEALBOT_HELP[1])
    HealBot_Panel_SetmaxHealDiv(UnitLevel("player"))
    if Healbot_Config_Skins.ShowRaidIcon[Healbot_Config_Skins.Current_Skin]==1 then 
        HealBot_RaidTargetToggle(true) 
    else
        HealBot_RaidTargetToggle(nil) 
    end
    HealBot_Loaded=true
    Delay_RecalcParty=3
end

function HealBot_Register_Events()
    if HealBot_Config.DisableHealBot==0 then
        HealBot:RegisterEvent("PLAYER_REGEN_DISABLED");
        HealBot:RegisterEvent("PLAYER_REGEN_ENABLED");
        HealBot:RegisterEvent("PLAYER_TARGET_CHANGED");
        HealBot:RegisterEvent("PARTY_MEMBERS_CHANGED");
        HealBot:RegisterEvent("PLAYER_FOCUS_CHANGED");
        HealBot:RegisterEvent("UNIT_ENTERED_VEHICLE");
        HealBot:RegisterEvent("UNIT_EXITED_VEHICLE");
        HealBot:RegisterEvent("UNIT_EXITING_VEHICLE");
        HealBot:RegisterEvent("UNIT_HEALTH");
        HealBot:RegisterEvent("UNIT_MAXHEALTH");
        if Healbot_Config_Skins.bar2size[Healbot_Config_Skins.Current_Skin]>0 then HealBot_Register_Mana() end
        HealBot:RegisterEvent("LEARNED_SPELL_IN_TAB");
        HealBot:RegisterEvent("UNIT_SPELLCAST_START");
        HealBot:RegisterEvent("UNIT_AURA");
        HealBot:RegisterEvent("CHARACTER_POINTS_CHANGED");
        HealBot:RegisterEvent("UNIT_INVENTORY_CHANGED");
        HealBot:RegisterEvent("CHAT_MSG_ADDON");
        HealBot:RegisterEvent("CHAT_MSG_SYSTEM");
        HealBot:RegisterEvent("MODIFIER_STATE_CHANGED");
        HealBot:RegisterEvent("UNIT_PET");
        HealBot:RegisterEvent("UNIT_NAME_UPDATE");
        if Healbot_Config_Skins.ShowAggro[Healbot_Config_Skins.Current_Skin]==1 then HealBot_Register_Aggro() end
        HealBot:RegisterEvent("ZONE_CHANGED_NEW_AREA");
        HealBot:RegisterEvent("RAID_ROSTER_UPDATE");
        if Healbot_Config_Skins.ShowRaidIcon[Healbot_Config_Skins.Current_Skin]==1 then HealBot:RegisterEvent("RAID_TARGET_UPDATE") end
        HealBot:RegisterEvent("INSPECT_TALENT_READY");
    --    HealBot:RegisterEvent("PARTY_MEMBER_DISABLE");
    --    HealBot:RegisterEvent("PARTY_MEMBER_ENABLE");
        if HealBot_Loaded and HealBot_AddonMsgType==2 then HealBot_Comms_SendAddonMsg("CTRA", "SR", HealBot_AddonMsgType, HealBot_PlayerName) end
    end
    HealBot:RegisterEvent("UNIT_SPELLCAST_SENT");
    HealBot:RegisterEvent("CHAT_MSG_ADDON");
    HealBot:RegisterEvent("UNIT_SPELLCAST_STOP");
    HealBot:RegisterEvent("UNIT_SPELLCAST_FAILED");
    HealBot:RegisterEvent("UNIT_SPELLCAST_INTERRUPTED");
    HealBot:RegisterEvent("UNIT_SPELLCAST_SUCCEEDED");
  
    HealBot_Set_Timers()
    HealBot_Action_Set_Timers()
end

function HealBot_Register_Aggro()
    HealBot:RegisterEvent("UNIT_COMBAT")
    HealBot:RegisterEvent("UNIT_THREAT_LIST_UPDATE")
    HealBot:RegisterEvent("UNIT_THREAT_SITUATION_UPDATE")
end

function HealBot_UnRegister_Aggro()
    HealBot:UnregisterEvent("UNIT_COMBAT")
    HealBot:UnregisterEvent("UNIT_THREAT_LIST_UPDATE")
    HealBot:UnregisterEvent("UNIT_THREAT_SITUATION_UPDATE")
end

function HealBot_Register_Mana()
    HealBot:RegisterEvent("UNIT_MANA")
    HealBot:RegisterEvent("UNIT_RAGE")
    HealBot:RegisterEvent("UNIT_ENERGY")
    HealBot:RegisterEvent("UNIT_RUNIC_POWER")
    HealBot:RegisterEvent("UNIT_MAXMANA")
    HealBot:RegisterEvent("UNIT_MAXRAGE")
    HealBot:RegisterEvent("UNIT_MAXENERGY")
    HealBot:RegisterEvent("UNIT_MAXRUNIC_POWER")
end

function HealBot_UnRegister_Mana()
    HealBot:UnregisterEvent("UNIT_MANA")
    HealBot:UnregisterEvent("UNIT_RAGE")
    HealBot:UnregisterEvent("UNIT_ENERGY")
    HealBot:UnregisterEvent("UNIT_RUNIC_POWER")
    HealBot:UnregisterEvent("UNIT_MAXMANA")
    HealBot:UnregisterEvent("UNIT_MAXRAGE")
    HealBot:UnregisterEvent("UNIT_MAXENERGY")
    HealBot:UnregisterEvent("UNIT_MAXRUNIC_POWER")
end

function HealBot_UnRegister_Events()

--    HealBot:UnregisterEvent("ZONE_CHANGED_NEW_AREA");
--    HealBot:UnregisterEvent("PLAYER_REGEN_DISABLED");
--    HealBot:UnregisterEvent("PLAYER_REGEN_ENABLED");
--    HealBot:UnregisterEvent("UNIT_ENTERED_VEHICLE");
--      HealBot:UnregisterEvent("UNIT_EXITED_VEHICLE");
--      HealBot:UnregisterEvent("UNIT_EXITING_VEHICLE");
--    HealBot:UnregisterEvent("PLAYER_TARGET_CHANGED");
--    HealBot:UnregisterEvent("PLAYER_FOCUS_CHANGED");
--    HealBot:UnregisterEvent("PARTY_MEMBERS_CHANGED");
--    HealBot:UnregisterEvent("UNIT_HEALTH");
--    HealBot_UnRegister_Mana()
--    HealBot:UnregisterEvent("LEARNED_SPELL_IN_TAB");
--    HealBot:UnregisterEvent("UNIT_SPELLCAST_SENT");
--    HealBot:UnregisterEvent("UNIT_SPELLCAST_START");
--    HealBot:UnregisterEvent("UNIT_SPELLCAST_STOP");
--    HealBot:UnregisterEvent("UNIT_SPELLCAST_FAILED");
--    HealBot:UnregisterEvent("UNIT_SPELLCAST_INTERRUPTED");
--    HealBot:UnregisterEvent("UNIT_SPELLCAST_SUCCEEDED");
--    HealBot:UnregisterEvent("UNIT_AURA");
--    HealBot:UnregisterEvent("CHARACTER_POINTS_CHANGED");
--    HealBot:UnregisterEvent("UNIT_INVENTORY_CHANGED");
--    HealBot:UnregisterEvent("CHAT_MSG_ADDON");
--    HealBot:UnregisterEvent("CHAT_MSG_SYSTEM");
--    HealBot:UnregisterEvent("MODIFIER_STATE_CHANGED");
--    HealBot:UnregisterEvent("UNIT_PET");
--    HealBot:UnregisterEvent("UNIT_NAME_UPDATE");
--    HealBot:UnregisterEvent("RAID_ROSTER_UPDATE");
--    HealBot:UnregisterEvent("INSPECT_TALENT_READY");
--    HealBot_UnRegister_Aggro()
    
    HB_Timer1=1
    HB_Timer2=5
    HB_Timer3=2
    HealBot_Action_Set_Timers(true)
    
--    HealBot:UnregisterEvent("PARTY_MEMBER_DISABLE");
--    HealBot:UnregisterEvent("PARTY_MEMBER_ENABLE");
end

local aUnit,oUnit=nil,nil
function HealBot_CheckAggro()
    if hbtestaggro then return end
    for aUnit,oUnit in pairs(HealBot_Aggro) do 
        _,z,_,_,_ = UnitThreatSituation(aUnit)
        if not z then z=0 end
        if z==0 then
            if UnitIsEnemy(aUnit, aUnit.."target") then
                uName=UnitName(aUnit.."targettarget")
                if uName~=UnitName(aUnit) then
                    if UnitIsEnemy(oUnit, oUnit.."target") then
                        uName=UnitName(oUnit.."targettarget")
                        if uName~=UnitName(aUnit) then
                            _,z,_,_,_ = UnitThreatSituation(oUnit)
                            if not z then z=0 end
                            HealBot_SetAggro(oUnit, z)
                            HealBot_Aggro[aUnit]=nil
                            HealBot_Action_UpdateAggro(aUnit,false,nil,HealBot_UnitGUID(aUnit))
                        end
                    else
                        HealBot_Aggro[aUnit]=nil
                        HealBot_Action_UpdateAggro(aUnit,false,nil,HealBot_UnitGUID(aUnit))
                    end
                end
            elseif UnitIsEnemy(oUnit, oUnit.."target") then
                uName=UnitName(oUnit.."targettarget")
                if uName~=UnitName(aUnit) then
                    _,z,_,_,_ = UnitThreatSituation(oUnit)
                    if not z then z=0 end
                    HealBot_SetAggro(oUnit, z)
                    HealBot_Aggro[aUnit]=nil
                    HealBot_Action_UpdateAggro(aUnit,false,nil,HealBot_UnitGUID(aUnit))
                end
            else
                HealBot_Aggro[aUnit]=nil
                HealBot_Action_UpdateAggro(aUnit,false,nil,HealBot_UnitGUID(aUnit))
            end
        elseif z~=HealBot_Action_RetUnitThreat(HealBot_UnitGUID(aUnit)) then
            HealBot_Action_UpdateAggro(aUnit,true,z,HealBot_UnitGUID(aUnit))
        end
    end
end

local aGUID=nil
function HealBot_SetAggro(unit, aggroStatus)
    uName=UnitName(unit.."targettarget")
    aGUID=HealBot_Derive_GUID_fuName(uName)
    xUnit=HealBot_UnitID[aGUID]
    if xUnit=="target" then return end
    if xUnit and (aggroStatus~=HealBot_Action_RetUnitThreat(aGUID) or not HealBot_Aggro[xUnit]) then
        HealBot_Aggro[xUnit]=unit
        HealBot_Action_UpdateAggro(xUnit,true,aggroStatus,aGUID)
    end
end

function HealBot_RetSetAggroSize()
    z=0
    for _,_ in pairs(HealBot_Aggro) do 
        z=z+1
    end
    return z
end

function HealBot_ClearAggro()
    for xUnit,_ in pairs(HealBot_Aggro) do
        HealBot_Aggro[xUnit]=nil
        if HealBot_Action_retAggro(HealBot_UnitGUID(xUnit)) then
            HealBot_Action_UpdateAggro(xUnit,false,nil,HealBot_UnitGUID(xUnit))
        end
    end
    HealBot_Action_EndAggro()
end

local HealBot_GUIDlist, HealBot_tempGUID, HealBot_casterName = nil,nil,nil
function HealBot_LHC4:HealStarted(event, casterGUID, spellID, spellType, endTime, ...)
    HealBot_casterName=nil
    if casterGUID then
        if HealBot_UnitName[casterGUID] then
            HealBot_casterName=HealBot_UnitName[casterGUID]
        else
            x=HealBot_RaidUnit("unknown",casterGUID)
            if UnitGUID(x)==casterGUID then
                HealBot_casterName=UnitName(x)
            end
        end
    end
    HealBot_GUIDlist=nil
    if HealBot_casterName then
        for i=1, select("#", ...) do
            HealBot_tempGUID = select(i, ...)
            if HealBot_UnitName[HealBot_tempGUID] then
                if HealBot_GUIDlist then
                    HealBot_GUIDlist = HealBot_GUIDlist .. ":" .. HealBot_tempGUID
                else
                    HealBot_GUIDlist = HealBot_tempGUID
                end
            end
        end
        if HealBot_GUIDlist then HealBot_OnEvent_AddonMsg(nil,HEALBOT_ADDON_ID, HealBot_GUIDlist.."|.|.|.|.", nil, HealBot_casterName, casterGUID) end
    else
        HealBot_AddDebug("Cast in from LHC4 - NO caster=")
        if casterGUID then HealBot_AddDebug("Cast in from LHC4 - casterGUID="..casterGUID) end
	end
end

local HealBotAddonSummary={}
local HealBotAddonIncHeals={}
local utGUID=nil
function HealBot_OnEvent_AddonMsg(self,addon_id,msg,distribution,sender_id,hbGUID)
--  inc_msg = gsub(msg, "%$", "s");
--  inc_msg = gsub(inc_msg, "§", "S");
    inc_msg=msg
    if HealBot_InBG then sender_id = string.match(sender_id, "^[^-]*") end
    utGUID=nil
    if self then
        if not HealBotAddonSummary[addon_id] then
            HealBotAddonSummary[addon_id]=1
        else
            HealBotAddonSummary[addon_id]=HealBotAddonSummary[addon_id]+1
        end
    end
    if HealBot_Config.ShowIncHeals==1 and (addon_id==HEALBOT_ADDON_ID or addon_id=="LHC40" or addon_id=="VisualHeal" or addon_id=="HealComm3" or addon_id=="CastCommLib" or addon_id=="X-PerlHeal") then
        if hbGUID then
            xGUID = hbGUID
        else
            xGUID = HealBot_Derive_GUID_fuName(sender_id)
        end
        if not xGUID then return end
        if addon_id==HEALBOT_ADDON_ID then
            utGUID, _, _, _, _ = string.split("|", inc_msg)
            if strfind(utGUID,":") then utGUID = HealBot_Split(utGUID, ":"); end
        elseif addon_id=="LHC40" then
            arr, _, _, _, _, _, _, _, _ = string.split(":", inc_msg)
            if arr=="D" or arr=="S" then
                _, _, _, _, utGUID, _, _, _, _ = string.split(":", inc_msg)
            elseif arr=="C" or arr=="U" then
                _, _, _, _, _, utGUID, _, _, _ = string.split(":", inc_msg)
            elseif arr=="H" then
                _, _, _, _, _, _, utGUID, _, _ = string.split(":", inc_msg)
            end
            if utGUID then
                if strfind(utGUID,",") then utGUID = HealBot_Split(utGUID, ","); end
                if type(utGUID)=="table" then
                    table.foreach(utGUID, function (index,uGUID)
                        utGUID[index]=HealComm.decompressGUID[uGUID]
                    end)
                else
                    utGUID=HealComm.decompressGUID[utGUID]
                end
            end
        elseif addon_id=="HealComm" then
            arr = tonumber(strsub(inc_msg, 1, 3))
            if arr==0 then
                uName = strsub(inc_msg, 9, -1)
                utGUID = HealBot_Derive_GUID_fuName(uName)
            elseif arr==2 then
                uName = HealBot_Split(strsub(inc_msg, 9, -1), ":");
                utGUID={}
                table.foreach(uName, function (index,nameu)
                    if HealBot_Derive_GUID_fuName(nameu) then
                        tinsert(utGUID, HealBot_Derive_GUID_fuName(nameu));
                    end
                end)
            end  
        elseif addon_id=="CastCommLib" then
            arr = strsub(inc_msg, 1, 2)
            if arr=="C " then
                spell, rank, _, _, _, z, _ = UnitCastingInfo(HealBot_UnitID[xGUID])
                if spell and rank and z and z/1000-GetTime()>=1 then 
                    uName = strsub(inc_msg, 3, -1)
                    utGUID = HealBot_Derive_GUID_fuName(uName)
                end
            end                
        elseif addon_id=="X-PerlHeal" then
            datatype, uName = strmatch(msg, "^(%a+) (%a+)$")
            utGUID = HealBot_Derive_GUID_fuName(uName)
        elseif addon_id=="VisualHeal" then
            _, _, uName, _ = strfind(inc_msg, "^%d+:(.+):(%d+):")
            utGUID = HealBot_Derive_GUID_fuName(uName)      
        end
        if utGUID then
            if (type(utGUID) == "table") then
                table.foreach(utGUID, function (index,uGUID)
                    tGUID=HealBot_PetGUID[uGUID] or uGUID
                    if self then
                        HealBot_HealsIncCnt[tGUID]=0.5
                    else
                        HealBot_HealsIncCnt[tGUID]=0
                    end
                    HealBot_HealsInUpdate(tGUID,xGUID)
                end)
            else
                tGUID=HealBot_PetGUID[utGUID] or utGUID
                if self then
                    HealBot_HealsIncCnt[tGUID]=0.5
                else
                    HealBot_HealsIncCnt[tGUID]=0
                end
                HealBot_HealsInUpdate(tGUID,xGUID)
            end 
            arr=addon_id.." : "..sender_id
            if not HealBotAddonIncHeals[arr] then
                HealBotAddonIncHeals[arr]=1
            else
                HealBotAddonIncHeals[arr]=HealBotAddonIncHeals[arr]+1
            end
        end
    elseif addon_id=="HealBot" then
        _,_, datatype, sender, datamsg = strfind(inc_msg, ">> (%a+) <<=>> (%a+) <<=>> (.+)");
        if datatype=="RequestVersion" then
            HealBot_RequestVer=sender;
        elseif datatype=="SendVersion" then
            if sender_id~=HealBot_PlayerName then HealBot_MsgOthers=true end
            HealBot_Vers[sender_id]=datamsg
            HealBot_AddDebug(sender_id..":  "..datamsg);
            HealBot_Comms_CheckVer(sender_id, strsub(datamsg,9,-1))
        end
    elseif addon_id=="CTRA" then
        if ( strfind(inc_msg, "#") ) then
            arr = HealBot_Split(inc_msg, "#");
            for k in pairs(arr) do
                HealBot_ParseCTRAMsg(sender_id, arr[k]);
            end
        else
            HealBot_ParseCTRAMsg(sender_id, inc_msg);
        end
    end
end

function HealBot_RetHealBotAddonSummary()
    return HealBotAddonSummary
end

function HealBot_RetHealBotAddonIncHeals()
    return HealBotAddonIncHeals
end

function HealBot_GetInfo()
    return HealBot_Vers
end

function HealBot_Split(msg, char)
    for x,_ in pairs(arrg) do
        arrg[x]=nil;
    end
    while (strfind(msg, char) ) do
        x, y = strfind(msg, char);
        tinsert(arrg, strsub(msg, 1, x-1));
        msg = strsub(msg, y+1, strlen(msg));
    end
    if ( strlen(msg) > 0 ) then
        tinsert(arrg, msg);
    end
    return arrg;
end

local HealBot_MT=nil
function HealBot_ParseCTRAMsg(sender_id, inc_msg)
    if ( strsub(inc_msg, 1, 3) == "RES" ) then
        if ( inc_msg == "RESNO" ) then
            for j in pairs(HealBot_Ressing) do
                if HealBot_Ressing[j]==sender_id then
                    HealBot_Ressing[j] = "_RESSED_";
                    break
                end
            end
        else
            _,_, uName = strfind(inc_msg, "^RES (.+)$");
            if ( uName ) then
                xGUID = HealBot_Derive_GUID_fuName(uName)
                if HealBot_UnitID[xGUID] then
                    HealBot_Ressing[xGUID] = sender_id;
                    HealBot_RecalcHeals(xGUID);
                end
            end
        end
    elseif ( strsub(inc_msg, 1, 4) == "SET " ) then
        _,_, x, uName = strfind(inc_msg, "^SET (%d+) (.+)$");
        if ( x and uName ) then
            xGUID = HealBot_Derive_GUID_fuName(uName)
            if HealBot_UnitID[xGUID] then
                for k in pairs(HealBot_MainTanks) do
                    if ( HealBot_MainTanks[k] == xGUID ) then
                        HealBot_MainTanks[k] = nil;
                    end
                end
            end
            HealBot_MainTanks[tonumber(x)] = xGUID;
            HealBot_MT=true
            if Delay_RecalcParty<2 then 
                Delay_RecalcParty=2; 
            end
        end
    elseif ( strsub(inc_msg, 1, 2) == "R " ) then
        _,_, uName = strfind(inc_msg, "^R (.+)$");
        if ( uName ) then
            xGUID = HealBot_Derive_GUID_fuName(uName)
            if HealBot_UnitID[xGUID] then
                for k in pairs(HealBot_MainTanks) do
                    if ( HealBot_MainTanks[k] == xGUID ) then
                        HealBot_MainTanks[k] = nil;
                        if Delay_RecalcParty<2 then 
                            Delay_RecalcParty=2; 
                        end
                    end
                end
            end
        end
    end
end

local dGUID,uGUID=nil,nil
function HealBot_Derive_GUID_fuName(unitName)
    dGUID=nil
    for uGUID,uName in pairs(HealBot_UnitName) do
        if uName==unitName then 
            dGUID=uGUID
            do break end
        end
    end
    return dGUID
end

function HealBot_OnEvent_RaidRosterUpdate(self)
    HealBot_OnEvent_PartyMembersChanged(self)
    if HealBot_MT then return end
    for x,_ in pairs(HealBot_MainTanks) do
        HealBot_MainTanks[x]=nil;
    end
    y = 0
    for index=1,GetNumRaidMembers() do
        xUnit = "raid"..index
            if UnitExists(xUnit) then
                _,_,_,_,_,_,_,_,_,z = GetRaidRosterInfo(index)
            if z == "MAINTANK" then
                y = y + 1
                HealBot_MainTanks[y] = HealBot_UnitGUID(xUnit)
            end
        end
    end
end

function HealBot_RetHealsIn(hbGUID)
    return HealBot_HealsIn[hbGUID] or 0;
end

function HealBot_OnEvent_UnitHealth(self,unit,health,healthMax)
    hGUID=HealBot_UnitGUID(unit)
    if hGUID and HealBot_VehicleUnit[unit] and not HealBot_UnitID[hGUID] then
        HealBot_UnitID[hGUID]=unit
    end
    if HealBot_Config.DisableHealBot==1 or not HealBot_UnitID[hGUID] then return end
    hUnit=HealBot_UnitID[hGUID]
    if HealBot_VehicleUnit[hUnit] then
		HBvUnits=HealBot_VehicleUnit[hUnit]
		for xUnit,_ in pairs(HBvUnits) do
			HealBot_Action_ResetUnitStatus(xUnit)
		end
        if not HealBot_Unit_Button[hUnit] then
            _,y,_,_,_ = UnitThreatSituation(hUnit)
            if not y then y=0 end
            if Healbot_Config_Skins.ShowAggro[Healbot_Config_Skins.Current_Skin]==1 and (UnitIsEnemy(hUnit, hUnit.."target") or y>0) then
                HealBot_Action_SetVAggro(hGUID, true)
            else
                HealBot_Action_SetVAggro(hGUID, nil)
            end
            HealBot_VehicleSetHealth(hUnit, health, healthMax)
			return
        end
    end
    if not HealBot_unitHealth[hGUID] then 
        HealBot_unitHealth[hGUID]=-1
        HealBot_unitHealthMax[hGUID]=-1
    end
    if HealBot_unitHealth[hGUID]~=health or HealBot_unitHealthMax[hGUID]~=healthMax then
        HealBot_unitHealth[hGUID]=health
        HealBot_unitHealthMax[hGUID]=healthMax
        HealBot_RecalcHeals(hGUID)
    end
    _,y,_,_,_ = UnitThreatSituation(hUnit)
    if not y then y=0 end
    if Healbot_Config_Skins.ShowAggro[Healbot_Config_Skins.Current_Skin]==1 and (UnitIsEnemy(hUnit, hUnit.."target") or y>0) then
        HealBot_SetAggro(hUnit, y)
    end
end

function HealBot_Reset_UnitHealth(hbGUID)
    if hbGUID and HealBot_UnitID[hbGUID] then
        HealBot_OnEvent_UnitHealth(nil,HealBot_UnitID[hbGUID],UnitHealth(HealBot_UnitID[hbGUID]),UnitHealthMax(HealBot_UnitID[hbGUID]))
    else
        for x,_ in pairs(HealBot_Unit_Button) do
            HealBot_OnEvent_UnitHealth(nil,x,UnitHealth(x),UnitHealthMax(x))
        end
    end
end

function HealBot_VehicleHealth(unit)
    vGUID=HealBot_UnitGUID(unit)
    if not vGUID then
	    HealBot_NoVehicle(unit)
        return 100,100
    end
    if not HealBot_unitHealth[vGUID] then 
        HealBot_unitHealth[vGUID]=UnitHealth(unit)
        HealBot_unitHealthMax[vGUID]=UnitHealthMax(unit)
    end
    return HealBot_unitHealth[vGUID], HealBot_unitHealthMax[vGUID]
end

function HealBot_NoVehicle(unit)
    HBvUnits=HealBot_VehicleUnit[unit]
    if not HBvUnits then 
        HealBot_AddDebug("HBvUnits is NIL in HealBot_NoVehicle")
    else
        for xUnit,_ in pairs(HBvUnits) do
            if HealBot_UnitInVehicle[xUnit] then HealBot_UnitInVehicle[xUnit]=nil end
        end
    end
	if HealBot_VehicleUnit[unit] then HealBot_VehicleUnit[unit]=nil end
    vGUID=HealBot_UnitGUID(unit)
    if vGUID then
		if HealBot_unitHealth[vGUID] then
			HealBot_unitHealth[vGUID]=nil
			HealBot_unitHealthMax[vGUID]=nil
		end
		if HealBot_UnitID[vGUID] then
			HealBot_UnitID[vGUID]=nil
		end
    end
    if Delay_RecalcParty<3 then 
        Delay_RecalcParty=3; 
    end
end

function HealBot_VehicleSetHealth(unit, health, healthMax)
    vGUID=HealBot_UnitGUID(unit)
    if not vGUID then
		HealBot_NoVehicle(unit)
    else
        HealBot_unitHealth[vGUID]=health
        HealBot_unitHealthMax[vGUID]=healthMax
    end
end

function HealBot_OnEvent_VehicleChange(self, unit, enterVehicle)
    xGUID=HealBot_UnitGUID(unit)
    if not HealBot_UnitID[xGUID] then return end 
    xUnit=HealBot_UnitID[xGUID]
    if enterVehicle then
        vUnit=HealBot_UnitPet(xUnit)
        if vUnit and UnitHasVehicleUI(xUnit) then
            if not HealBot_VehicleUnit[vUnit] then HealBot_VehicleUnit[vUnit]={} end
            HealBot_VehicleUnit[vUnit][xUnit]=true
            HealBot_UnitInVehicle[xUnit]=vUnit
            if HealBot_UnitGUID(vUnit) and not HealBot_UnitID[HealBot_UnitGUID(vUnit)] then 
                HealBot_UnitID[HealBot_UnitGUID(vUnit)]=vUnit 
            end
            HealBot_OnEvent_UnitHealth(self,vUnit,UnitHealth(vUnit),UnitHealthMax(vUnit))
            if Delay_RecalcParty<3 then 
                Delay_RecalcParty=3; 
            end
        elseif self then
            HealBot_VehicleCheck[xUnit]=true
        end
    elseif HealBot_UnitInVehicle[xUnit] then
        vUnit=HealBot_UnitInVehicle[xUnit]
        HealBot_NoVehicle(vUnit)
    end
    HealBot_Action_ResetUnitStatus(xUnit)
end

function HealBot_OnEvent_LeavingVehicle(self, unit)
    xGUID=HealBot_UnitGUID(unit)
    if not xGUID or not HealBot_UnitID[xGUID] then return end
    if HealBot_UnitInVehicle[HealBot_UnitID[xGUID]] then
        vUnit=HealBot_UnitInVehicle[HealBot_UnitID[xGUID]]
        HealBot_Action_SetVAggro(HealBot_UnitGUID(vUnit), nil)
    end
end

function HealBot_retIsInVehicle(unit)
    return HealBot_UnitInVehicle[unit]
end

function HealBot_CheckAllUnitVehicle(unit)
    if unit then
        HealBot_OnEvent_VehicleChange(nil, unit, true)
    else
        for xUnit,_ in pairs(HealBot_Unit_Button) do
            HealBot_VehicleCheck[xUnit]=true
        end
    end
end

function HealBot_OnEvent_UnitMana(self,unit)
    xGUID=HealBot_UnitGUID(unit)
    xUnit=HealBot_UnitID[xGUID]
    if not HealBot_UnitName[xGUID] or HealBot_Config.DisableHealBot==1 then return end
    HealBot_Action_RefreshBar3(xUnit)
end

function HealBot_OnEvent_UnitCombat(self,unit)
    xGUID=HealBot_UnitGUID(unit)
    xUnit=HealBot_UnitID[xGUID]
    if not xUnit or not UnitName(xUnit) then return end
    _,y,_,_,_ = UnitThreatSituation(xUnit)
    if not y then y=0 end
    if UnitIsEnemy(xUnit, xUnit.."target") or y>0 then
        HealBot_SetAggro(xUnit, y)
    end
end

function HealBot_OnEvent_ModifierStateChange(self,arg1,arg2)
    if HealBot_Action_TooltipUnit then
        HealBot_Action_RefreshTooltip(HealBot_Action_TooltipUnit,"Enabled");
    elseif HealBot_Action_DisableTooltipUnit then
        HealBot_Action_RefreshTooltip(HealBot_Action_DisableTooltipUnit,"Disabled");
    end
end

function HealBot_OnEvent_ZoneChanged(self)
    HealBot_CheckZoneFlag=true
end

function HealBot_CheckZone()
--   z = GetRealZoneText()
    _,z = IsInInstance()
--    if z==HEALBOT_ZONE_AB or z==HEALBOT_ZONE_WG  or z==HEALBOT_ZONE_AV or z==HEALBOT_ZONE_ES then
    if z=="pvp" or z == "arena" then
        HealBot_InBG=true;
    else
        HealBot_InBG=nil;
    end
    HealBot_Action_ResetUnitStatus()
    HealBot_SetAddonComms()
    HealBot_Queue_AllActiveMyBuffs()
end

local uaUnit=nil
local uaGUID=nil
function HealBot_OnEvent_UnitAura(self,unit)
    uaGUID=HealBot_UnitGUID(unit)
    if not uaGUID or not HealBot_UnitID[uaGUID] then return end
    uaUnit=HealBot_UnitID[uaGUID]
    if not HealBot_Unit_Button[uaUnit] then
        if UnitName("target")==UnitName(uaUnit) then
            uaUnit="target"
            uaGUID=HealBot_UnitGUID(uaUnit)
            if not uaGUID or not HealBot_UnitID[uaGUID] then return end
        else
            return;
        end
    end

    if HealBot_Config.DebuffWatch==1 then
        if HealBot_Config.DebuffWatchInCombat==0 and HealBot_IsFighting then
            HealBot_DelayDebuffCheck[uaGUID]=true;
        else
            if uaUnit then HealBot_CheckUnitDebuffs(uaGUID); end
        end
    elseif HealBot_TrackWS[uaGUID] then 
        HealBot_TrackDebuffWS(uaGUID)
    end  
  
    if uaGUID==HealBot_PlayerGUID and strsub(HealBot_PlayerClassEN,1,4)=="PRIE" then
        HealBot_CheckForDivineSpirit=true;
        if HealBot_InnerFocusTalent then HealBot_CheckForInnerFocus(); end
    end
  
    if HealBot_Config.BuffWatch==1 then 
        if HealBot_Config.BuffWatchInCombat==0 and HealBot_IsFighting then
            HealBot_DelayBuffCheck[uaGUID]=true;
        else
            HealBot_CheckUnitBuffs(uaGUID);
        end
    end

    if uaUnit==HealBot_Action_TooltipUnit then
        HealBot_Action_RefreshTooltip(HealBot_Action_TooltipUnit,"Enabled");
    elseif uaUnit==HealBot_Action_DisableTooltipUnit then
        HealBot_Action_RefreshTooltip(HealBot_Action_DisableTooltipUnit,"Disabled");
    end

    if Healbot_Config_Skins.ShowHoTicons[Healbot_Config_Skins.Current_Skin]==1 then 
        HealBot_DelayAuraCheck[uaGUID]=uaUnit
    end

end

function HealBot_SetUnitBuffTimer(hbGUID,buffName,endtime)

    if not HealBot_PlayerBuff[hbGUID] then
        HealBot_PlayerBuff[hbGUID]={}
    end

    if HealBot_ShortBuffs[buffName] then 
        HealBot_PlayerBuff[hbGUID][buffName] = endtime-HealBot_Config.ShortBuffTimer
    else
        HealBot_PlayerBuff[hbGUID][buffName] = endtime-HealBot_Config.LongBuffTimer
    end
--  HealBot_AddDebug("Set bufftimer.buffName="..buffName.."  hbGUID="..hbGUID.."  endtime="..endtime)
    if not HealBot_CheckBuffsTime or HealBot_PlayerBuff[hbGUID][buffName] < HealBot_CheckBuffsTime then
        HealBot_CheckBuffsTime=HealBot_PlayerBuff[hbGUID][buffName]
        HealBot_CheckBuffsTimehbGUID=hbGUID
    end
end

function HealBot_CheckForInnerFocus()
    HealBot_Talents["InnerFocus"]=HealBot_HasBuff(HEALBOT_INNER_FOCUS,"player")
end

function HealBot_HasBuff(buffName, unit)
    x,_,iTexture,bCount,_,_,expirationTime, isMine,_ = UnitBuff(unit,buffName)
    if x then
        if not HealBot_HoT_Texture[buffName] then HealBot_HoT_Texture[buffName]=iTexture end
        return true, expirationTime, isMine, bCount;
    end
    return false;
end

function HealBot_HasDebuff(debuffName, unit)
    x,_,_,_,_,_,expirationTime,_,_ = UnitDebuff(unit,debuffName)
    if x then
        return true, expirationTime;
    end
    return false;
end

function HealBot_HasMyBuffs(unit,hbGUID)
    for bName,y in pairs(HealBot_Watch_HoT) do
        if y=="A" then
            HoTActive, expirationTime, isMine, bCount=HealBot_HasBuff(bName, unit)
            if HoTActive then
                if not HealBot_Player_HoT[hbGUID] then HealBot_Player_HoT[hbGUID]={} end
                if not HealBot_Player_HoT_Icons[hbGUID] then HealBot_Player_HoT_Icons[hbGUID]={} end
                if not HealBot_Player_HoT_Icons[hbGUID][bName] then HealBot_Player_HoT_Icons[hbGUID][bName]=0 end
                if not HealBot_Player_HoT[hbGUID][bName] then HealBot_Player_HoT[hbGUID][bName]=GetTime()+50 end
                if HealBot_HoT_Count[bName] then
                    if isMine and isMine=="player" then
                        HealBot_HoT_Count[bName][hbGUID]=bCount
                    elseif HealBot_HoT_Count[bName][hbGUID] then
                        HealBot_HoT_Count[bName][hbGUID]=nil
                    end
                end    
                if HealBot_Player_HoT[hbGUID][bName]~=expirationTime then
                    HealBot_Player_HoT[hbGUID][bName]=expirationTime
                    HealBot_HoT_Update(hbGUID, bName)
                end
                if bName==HEALBOT_POWER_WORD_SHIELD and expirationTime-GetTime()>15 and not HealBot_TrackWS[hbGUID] then
                    if HealBot_HasDebuff(HEALBOT_DEBUFF_WEAKENED_SOUL, unit) then
                        HealBot_TrackWS[hbGUID]=true
                    end
                end
            elseif HealBot_Player_HoT_Icons[hbGUID] and HealBot_Player_HoT_Icons[hbGUID][bName] and HealBot_Player_HoT_Icons[hbGUID][bName]>0 then
                if bName==HEALBOT_POWER_WORD_SHIELD then
                    if not HealBot_TrackWS[hbGUID] then 
                        HealBot_Player_HoT[hbGUID][bName]=10
                        HealBot_HoT_Update(hbGUID, bName)
                    else
                        HoTActive, expirationTime = HealBot_HasDebuff(HEALBOT_DEBUFF_WEAKENED_SOUL, unit)
                        if HealBot_Player_HoT[hbGUID][bName]~=expirationTime then
                            HealBot_Player_HoT[hbGUID][bName]=expirationTime
                            HealBot_HoT_Update(hbGUID, bName)
                        end
                    end
                else
                    HealBot_Player_HoT[hbGUID][bName]=10
                    HealBot_HoT_Update(hbGUID, bName)
                end
            elseif bName==HEALBOT_POWER_WORD_SHIELD then
                HoTActive, expirationTime = HealBot_HasDebuff(HEALBOT_DEBUFF_WEAKENED_SOUL, unit)
                if HoTActive then
                    HealBot_TrackWS[hbGUID]=true
                    if not HealBot_Player_HoT[hbGUID] then HealBot_Player_HoT[hbGUID]={} end
                    if not HealBot_Player_HoT_Icons[hbGUID] then HealBot_Player_HoT_Icons[hbGUID]={} end
                    if not HealBot_Player_HoT_Icons[hbGUID][bName] then HealBot_Player_HoT_Icons[hbGUID][bName]=0 end
                    if not HealBot_Player_HoT[hbGUID][bName] then HealBot_Player_HoT[hbGUID][bName]=GetTime()+50 end
                    if HealBot_Player_HoT[hbGUID][bName]~=expirationTime then
                        HealBot_Player_HoT[hbGUID][bName]=expirationTime
                        HealBot_HoT_Update(hbGUID, bName)
                    end
                end
            end
        elseif y=="AM" and HealBot_Watch_AM_HoT>0 then
            HoTActive, expirationTime, bCount=HealBot_HasMyBuff(bName, unit)
            if HoTActive then
                if not HealBot_Player_HoT[hbGUID] then HealBot_Player_HoT[hbGUID]={} end
                if not HealBot_Player_HoT_Icons[hbGUID] then HealBot_Player_HoT_Icons[hbGUID]={} end
                if not HealBot_Player_HoT_Icons[hbGUID][bName] then HealBot_Player_HoT_Icons[hbGUID][bName]=0 end
                if not HealBot_Player_HoT[hbGUID][bName] then HealBot_Player_HoT[hbGUID][bName]=GetTime()+50 end
                if HealBot_Player_HoT[hbGUID][bName]~=expirationTime then
                    HealBot_Player_HoT[hbGUID][bName]=expirationTime
                    HealBot_HoT_Update(hbGUID, bName)
                end
            elseif HealBot_Player_HoT_Icons[hbGUID] and HealBot_Player_HoT_Icons[hbGUID][bName] and HealBot_Player_HoT_Icons[hbGUID][bName]>0 then
                HealBot_Player_HoT[hbGUID][bName]=10
                HealBot_HoT_Update(hbGUID, bName)
            end
        elseif y=="CT" and HealBot_Watch_Timed_HoT[hbGUID] then
            HoTActive, expirationTime, bCount=HealBot_HasMyBuff(bName, unit)
            if HoTActive then
                if not HealBot_Player_HoT[hbGUID] then HealBot_Player_HoT[hbGUID]={} end
                if not HealBot_Player_HoT_Icons[hbGUID] then HealBot_Player_HoT_Icons[hbGUID]={} end
                if not HealBot_Player_HoT_Icons[hbGUID][bName] then HealBot_Player_HoT_Icons[hbGUID][bName]=0 end
                if not HealBot_Player_HoT[hbGUID][bName] then HealBot_Player_HoT[hbGUID][bName]=GetTime()+50 end
                if HealBot_Player_HoT[hbGUID][bName]~=expirationTime then
                    HealBot_Player_HoT[hbGUID][bName]=expirationTime
                    HealBot_HoT_Update(hbGUID, bName)
                end
            elseif HealBot_Player_HoT_Icons[hbGUID] and HealBot_Player_HoT_Icons[hbGUID][bName] and HealBot_Player_HoT_Icons[hbGUID][bName]>0 then
                HealBot_Player_HoT[hbGUID][bName]=10
                HealBot_HoT_Update(hbGUID, bName)
            end
        elseif HealBot_Player_HoT[hbGUID] and HealBot_Player_HoT[hbGUID][bName] then
            HoTActive, expirationTime, bCount=HealBot_HasMyBuff(bName, unit)
            if HoTActive then
                if HealBot_HoT_Count[bName] then
                    HealBot_HoT_Count[bName][hbGUID]=bCount
                end    
                if HealBot_Player_HoT[hbGUID][bName]~=expirationTime then
                    HealBot_Player_HoT[hbGUID][bName]=expirationTime
                    HealBot_HoT_Update(hbGUID, bName)
                end
            elseif HealBot_Player_HoT_Icons[hbGUID][bName]>0 then
                HealBot_Player_HoT[hbGUID][bName]=10
                HealBot_HoT_Update(hbGUID, bName)
            end
        end
    end
end

function HealBot_HasMyBuff(buffName, unit)
    x,_,iTexture,bCount,_,_,expirationTime, isMine,_ = UnitBuff(unit,buffName)
    if x and isMine and isMine=="player" then
        if not HealBot_HoT_Texture[buffName] then HealBot_HoT_Texture[buffName]=iTexture end
        return true, expirationTime, bCount
    end
    return false;
end

function HealBot_CheckMyBuffs(hbGUID)
    xUnit=HealBot_UnitID[hbGUID]
    if not xUnit then return end
    for bName,_ in pairs(HealBot_CheckBuffs) do
        _,_,_,_,_,_,z,isMine,_ = UnitBuff(xUnit,bName)
        if z and isMine and isMine=="player" then
            HealBot_SetUnitBuffTimer(hbGUID,bName,z)
        elseif HealBot_PlayerBuff[hbGUID] and HealBot_PlayerBuff[hbGUID][bName] then
            if HealBot_PlayerBuff[hbGUID][bName]==HealBot_CheckBuffsTime then
                HealBot_PlayerBuff[hbGUID][bName]=nil
                HealBot_ResetCheckBuffsTime()
            else
                HealBot_PlayerBuff[hbGUID][bName]=nil
            end
        end
    end
end

function HealBot_CheckAllBuffs(hbGUID)
    if HealBot_Config.BuffWatch==1 then 
        if hbGUID then
            HealBot_DelayBuffCheck[hbGUID]=true
        else
            for xGUID,_  in pairs(HealBot_UnitID) do
                HealBot_DelayBuffCheck[xGUID]=true;
            end
        end
    end
end

function HealBot_ClearAllBuffs(hbGUID)
    if hbGUID then
        if HealBot_DelayBuffCheck[hbGUID] then 
            HealBot_DelayBuffCheck[hbGUID]=nil
            HealBot_Action_ResetUnitStatus(HealBot_UnitID[hbGUID])
        end
    else
        for x,_ in pairs(HealBot_DelayBuffCheck) do
            if HealBot_DelayBuffCheck[x] then 
                HealBot_DelayBuffCheck[x]=nil;
                HealBot_Action_ResetUnitStatus(HealBot_UnitID[x])
            end
        end
    end
end

function HealBot_CheckAllDebuffs(hbGUID)
    if HealBot_Config.DebuffWatch==1 then 
        if hbGUID then
            HealBot_DelayDebuffCheck[hbGUID]=true
        else
            for xGUID,_ in pairs(HealBot_UnitID) do
                HealBot_DelayDebuffCheck[xGUID]=true;
            end
        end
    end
end

function HealBot_ClearAllDebuffs(hbGUID)
    if hbGUID then
        if HealBot_DelayDebuffCheck[hbGUID] then 
            HealBot_DelayDebuffCheck[hbGUID]=nil 
            HealBot_Action_ResetUnitStatus(HealBot_UnitID[hbGUID])
        end
    else
        for x,_ in pairs(HealBot_DelayDebuffCheck) do
            if HealBot_DelayDebuffCheck[x] then 
                HealBot_DelayDebuffCheck[x]=nil;
                HealBot_Action_ResetUnitStatus(HealBot_UnitID[x])
            end
        end
    end
end

local DebuffIn=nil
local DebuffClass=nil
local myhTargets={}
local checkWS=nil
local inSpellRange = 0 -- added by Diacono
local udName=nil
local debuffDuration=nil
function HealBot_CheckUnitDebuffs(hbGUID)
    if not HealBot_UnitID[hbGUID] then return end
    xUnit=HealBot_UnitID[hbGUID]
    if not xUnit or not HealBot_Unit_Button[xUnit] then return end
    udName=UnitName(xUnit);
    _,DebuffClass=UnitClass(xUnit)
    if not DebuffClass then DebuffClass=HealBot_Class_En[HEALBOT_WARRIOR] end
    DebuffType=nil;
    y = 1;
    DebuffIn=HealBot_UnitDebuff[hbGUID] or "x"
    checkWS=nil
    while true do
        dName,_,_,_,debuff_type,debuffDuration,_,_,_ = UnitDebuff(xUnit,y)
        if dName then
            y = y + 1;
            if dName~=DebuffIn then
                checkthis=false;
                WatchTarget, WatchGUID=HealBot_Options_retDebuffWatchTarget(debuff_type,hbGUID);
                if HealBot_Config.HealBot_Custom_Debuffs[dName] then
                    debuff_type = HEALBOT_CUSTOM_en;
                    WatchTarget={["Raid"]=true,};
                end
      
                if (debuff_type == HEALBOT_POISON_en) and (HealBot_DebuffSpell[HEALBOT_DISEASE_en] == HEALBOT_ABOLISH_DISEASE) then
                    if (not HealBot_DebuffSpell[HEALBOT_POISON_en]) and ( HealBot_Talents[HEALBOT_BODY_AND_SOUL] > 0) then
                        WatchTarget={["Self"]=true,};
                    end
                end
                
                if dName==HEALBOT_DEBUFF_WEAKENED_SOUL then
                    HealBot_TrackWS[hbGUID]=true
                    checkWS=true
                end
      
                if WatchTarget then 
                    if WatchTarget["Raid"] then
                        checkthis=true;
                    elseif WatchTarget["Party"] and (UnitInParty(xUnit) or udName==HealBot_PlayerName) then
                        checkthis=true;
                    elseif WatchTarget["Self"] and udName==HealBot_PlayerName then
                        checkthis=true
                    elseif WatchTarget[strsub(DebuffClass,1,4)] then
                        checkthis=true;
                    elseif WatchTarget["PvP"] and UnitIsPVP("player") then
                        checkthis=true;
					elseif WatchTarget["Name"] and hbGUID==WatchGUID then
						checkthis=true;
					elseif WatchTarget["Focus"] and UnitIsUnit(xUnit, "focus") then
						checkthis=true;
                    elseif WatchTarget["MainTanks"] then
                        for i=1, #HealBot_MainTanks do
                            if hbGUID==HealBot_MainTanks[i] then
                                checkthis=true;
                                break;
                            end
                        end
                    elseif WatchTarget["MyTargets"] then
                        myhTargets=HealBot_GetMyHealTargets();
                        for i=1, #myhTargets do
                            if hbGUID==myhTargets[i] then
                                checkthis=true;
                                break;
                            end
                        end
                    end
       
                    if checkthis and (debuff_type ~= HEALBOT_CUSTOM_en) then
                        if HealBot_Config.IgnoreMovementDebuffs==1 and HealBot_Ignore_Movement_Debuffs[dName] then
                            checkthis=false;
                        elseif HealBot_Config.IgnoreFastDurDebuffs==1 and debuffDuration and debuffDuration<=HealBot_Config.IgnoreFastDurDebuffsSecs then
                            checkthis=false;
                        elseif HealBot_Config.IgnoreNonHarmfulDebuffs==1 and HealBot_Ignore_NonHarmful_Debuffs[dName] then
                            checkthis=false;
                        elseif HealBot_Config.IgnoreClassDebuffs==1 then
                            HealBot_Ignore_Debuffs_Class=HealBot_Ignore_Class_Debuffs[strsub(DebuffClass,1,4)];
                            if HealBot_Ignore_Debuffs_Class[dName] then
                                checkthis=false;
                            end
                        end
                    end
                end
            else
                checkthis=true
            end
            if checkthis then
                HealBot_UnitDebuff[hbGUID]=debuff_type
                HealBot_UnitDebuff[hbGUID.."_debuff_name"]=dName
                DebuffType=debuff_type;
                if HealBot_Options_retDebuffPriority()==debuff_type then
                    do break end
                end
            end
        else
            if not DebuffType then 
                if HealBot_Player_HoT[hbGUID] and HealBot_Player_HoT[hbGUID][HealBot_UnitDebuff[hbGUID.."_debuff_name"]] then
                    HealBot_Player_HoT[hbGUID][HealBot_UnitDebuff[hbGUID.."_debuff_name"]]=10
                    HealBot_HoT_Update(hbGUID, HealBot_UnitDebuff[hbGUID.."_debuff_name"])
                end
                if HealBot_UnitDebuff[hbGUID] then
                    HealBot_UnitDebuff[hbGUID] = nil;
                    if HealBot_ThrottleCnt>5 then
                        HealBot_Action_ResetUnitStatus(xUnit)
                    else
                        HealBot_RecalcHeals(hbGUID)
                        HealBot_ThrottleCnt=HealBot_ThrottleCnt+1
                    end
                    HealBot_UnitDebuff[hbGUID.."_debuff_name"] = nil;
                    if HealBot_Config.CDCshownAB==1 then
                        HealBot_Action_SetUnitDebuffStatus(hbGUID)
                        if not HealBot_Aggro[xUnit] then HealBot_Aggro[xUnit]=xUnit end
                    end
                end
            end
            do break end
        end 
    end

    if HealBot_UnitDebuff[hbGUID] then
        if HealBot_UnitDebuff[hbGUID]~=DebuffIn then
            inSpellRange = 0
            if HealBot_Config.CDCshownAB==1 then
                HealBot_Action_SetUnitDebuffStatus(hbGUID,debuffCodes[DebuffType])
                HealBot_Action_UpdateAggro(xUnit,"debuff",debuffCodes[DebuffType],hbGUID)
            end
            if (HealBot_UnitDebuff[hbGUID] ~= HEALBOT_CUSTOM_en) and (HealBot_DebuffSpell[HealBot_UnitDebuff[hbGUID]] ~= HEALBOT_STONEFORM) then
                inSpellRange = HealBot_UnitInRange(HealBot_DebuffSpell[HealBot_UnitDebuff[hbGUID]], xUnit)
            end
            if inSpellRange == 1 then
                if HealBot_Config.ShowDebuffWarning==1 then
                    UIErrorsFrame:AddMessage(udName.." suffers from "..HealBot_UnitDebuff[hbGUID.."_debuff_name"], 
                                             HealBot_Config.CDCBarColour[DebuffType].R,
                                             HealBot_Config.CDCBarColour[DebuffType].G,
                                             HealBot_Config.CDCBarColour[DebuffType].B,
                                             1, UIERRORS_HOLD_TIME);
                end
                if HealBot_Config.SoundDebuffWarning==1 then HealBot_PlaySound(HealBot_Config.SoundDebuffPlay); end
                if HealBot_ThrottleCnt>5 then
                    HealBot_Action_ResetUnitStatus(xUnit)
                else
                    HealBot_RecalcHeals(hbGUID)
                    HealBot_ThrottleCnt=HealBot_ThrottleCnt+1
                end
            else
                HealBot_Action_ResetUnitStatus(xUnit)
            end
        end
        if Healbot_Config_Skins.ShowDebuffIcon[Healbot_Config_Skins.Current_Skin]==1 and UnitIsVisible(xUnit) then
            _,_,iTexture,bCount,_,_,expirationTime,_,_ = UnitDebuff(xUnit,HealBot_UnitDebuff[hbGUID.."_debuff_name"])
            if bCount then
                if not HealBot_DeBuff_Texture[HealBot_UnitDebuff[hbGUID.."_debuff_name"]] then
                    HealBot_DeBuff_Texture[HealBot_UnitDebuff[hbGUID.."_debuff_name"]]=iTexture
                end
                if not HealBot_Player_HoT[hbGUID] then HealBot_Player_HoT[hbGUID]={} end
                if not HealBot_Player_HoT[hbGUID][HealBot_UnitDebuff[hbGUID.."_debuff_name"]] then HealBot_Player_HoT[hbGUID][HealBot_UnitDebuff[hbGUID.."_debuff_name"]]=GetTime()+31 end
                if not HealBot_Player_HoT_Icons[hbGUID] then HealBot_Player_HoT_Icons[hbGUID]={} end
                if not HealBot_Player_HoT_Icons[hbGUID][HealBot_UnitDebuff[hbGUID.."_debuff_name"]] then HealBot_Player_HoT_Icons[hbGUID][HealBot_UnitDebuff[hbGUID.."_debuff_name"]]=0 end
                if HealBot_Player_HoT[hbGUID][HealBot_UnitDebuff[hbGUID.."_debuff_name"]]~=expirationTime or DeBuff_Count[hbGUID]~=bCount then
                    DeBuff_Count[hbGUID]=bCount
                    HealBot_Player_HoT[hbGUID][HealBot_UnitDebuff[hbGUID.."_debuff_name"]]=expirationTime
                    HealBot_HoT_Update(hbGUID, HealBot_UnitDebuff[hbGUID.."_debuff_name"])
                end
            end
        end
    end
    if HealBot_TrackWS[hbGUID] and not checkWS then
        HealBot_TrackWS[hbGUID]=nil
        HealBot_HasMyBuffs(xUnit,hbGUID)
    end
end

function HealBot_TrackDebuffWS(hbGUID)
    xUnit=HealBot_UnitID[hbGUID]
    if xUnit then
        HoTActive, expirationTime = HealBot_HasDebuff(HEALBOT_DEBUFF_WEAKENED_SOUL, xUnit)
        if not HoTActive then
            HealBot_TrackWS[hbGUID]=nil
            HealBot_HasMyBuffs(xUnit,hbGUID)
        end
    end
end

function HealBot_CheckUnitBuffs(hbGUID)
    if not HealBot_UnitID[hbGUID] then return end
    xUnit=HealBot_UnitID[hbGUID]
    if not UnitName(xUnit) then return end
    if not xUnit or not HealBot_Unit_Button[xUnit] then return end
    uName=UnitName(xUnit);
    if not uName then return end
    _,BuffClass=UnitClass(xUnit)
    if not BuffClass then BuffClass=HealBot_Class_En[HEALBOT_WARRIOR] end
    y = 1;

    for x,_ in pairs(PlayerBuffs) do
        PlayerBuffs[x]=nil;
    end

    while true do
        bName,_,_,_,_,_,w,_ = UnitAura(xUnit,y,"HELPFUL") 
        if bName then
            PlayerBuffs[bName]=true
            y = y + 1;
            if HealBot_CheckBuffs[bName] then
                if w-GetTime()>0 then
                    HealBot_SetUnitBuffTimer(hbGUID,bName,w)
                elseif HealBot_PlayerBuff[hbGUID] and HealBot_PlayerBuff[hbGUID][bName] then
                    if HealBot_PlayerBuff[hbGUID][bName]==HealBot_CheckBuffsTime then
                        HealBot_PlayerBuff[hbGUID][bName]=nil
                        HealBot_ResetCheckBuffsTime()
                    else
                        HealBot_PlayerBuff[hbGUID][bName]=nil
                    end
            
--            HealBot_ResetCheckBuffsTime()
                end
            end
        else
            do break end
        end
    end 

    if HealBot_PlayerBuff[hbGUID] then
        PlayerBuffsGUID=HealBot_PlayerBuff[hbGUID]
        for z,_ in pairs (PlayerBuffsGUID) do
            if not PlayerBuffs[z] then
--              HealBot_AddDebug("Removed buff="..z)
                if PlayerBuffsGUID[z]==HealBot_CheckBuffsTime then
                    PlayerBuffsGUID[z]=nil
                    HealBot_ResetCheckBuffsTime()
                else
                    PlayerBuffsGUID[z]=nil
                end
            end
        end
        for x,_ in pairs(PlayerBuffs) do
            if HealBot_PlayerBuff[hbGUID][x] and HealBot_PlayerBuff[hbGUID][x] < GetTime() then
                PlayerBuffs[x]=nil
            end
        end
    end

    HasWeaponBuff=GetWeaponEnchantInfo()
    bName=nil;
    for k in pairs(HealBot_BuffWatch) do
        checkthis=false;
        WatchTarget, WatchGUID=HealBot_Options_retBuffWatchTarget(HealBot_BuffWatch[k], hbGUID);
        z, x, _ = GetSpellCooldown(HealBot_BuffWatch[k]);
        if not x then
            -- Spec change withing that last few secs - buff outdated so do nothing
        elseif x<2 then
            if WatchTarget["Raid"] then
                checkthis=true;
            elseif WatchTarget["Party"] and (UnitInParty(xUnit) or uName==HealBot_PlayerName) then
                checkthis=true;
            elseif WatchTarget["Self"] and uName==HealBot_PlayerName then 
                checkthis=true
            elseif WatchTarget[strsub(BuffClass,1,4)] then
                checkthis=true
            elseif WatchTarget["PvP"] and UnitIsPVP(xUnit) then
                checkthis=true;
            elseif WatchTarget["Name"] and hbGUID==WatchGUID then
                checkthis=true;
            elseif WatchTarget["Focus"] and UnitIsUnit(xUnit, "focus") then
                checkthis=true;
            elseif WatchTarget["MainTanks"] then
                for i=1, #HealBot_MainTanks do
                    if hbGUID==HealBot_MainTanks[i] then
                        checkthis=true;
                        break;
                    end
                end
            elseif WatchTarget["MyTargets"] then
                myhTargets=HealBot_GetMyHealTargets();
                for i=1, #myhTargets do
                    if hbGUID==myhTargets[i] then
                        checkthis=true;
                        break;
                    end
                end
            end
        elseif not HealBot_ReCheckBuffsTime or HealBot_ReCheckBuffsTime>z+x then
            HealBot_ReCheckBuffsTime=z+x
            HealBot_ReCheckBuffsTimed[HealBot_ReCheckBuffsTime]=hbGUID
        elseif HealBot_ReCheckBuffsTime<z+x then
            HealBot_ReCheckBuffsTimed[z+x]=hbGUID
        end
        if CheckWeaponBuffs[HealBot_BuffWatch[k]] and HasWeaponBuff then checkthis=false end
        if checkthis then
            if not PlayerBuffs[HealBot_BuffWatch[k]] then
                checkthis=false;
                if HealBot_BuffWatch[k]==HEALBOT_ARCANE_INTELLECT or HealBot_BuffWatch[k]==HEALBOT_ARCANE_BRILLIANCE or 
                   HealBot_BuffWatch[k]==HEALBOT_DALARAN_BRILLIANCE or HealBot_BuffWatch[k]==HEALBOT_DALARAN_INTELLECT then
                    if not PlayerBuffs[HEALBOT_ARCANE_INTELLECT] and not PlayerBuffs[HEALBOT_ARCANE_BRILLIANCE] and not
                       PlayerBuffs[HEALBOT_DALARAN_BRILLIANCE] and not PlayerBuffs[HEALBOT_DALARAN_INTELLECT] then
                        bName=HealBot_BuffWatch[k];
                        break
                    end
                elseif HealBot_BuffNameSwap[HealBot_BuffWatch[k]] then
                    checkthis=HealBot_BuffNameSwap[HealBot_BuffWatch[k]];
                    if not PlayerBuffs[checkthis] then
                        bName=HealBot_BuffWatch[k];
                        break
                    end
                else
                    bName=HealBot_BuffWatch[k];
                    break
                end
            end
        end
    end
    if bName then
        if HealBot_UnitBuff[hbGUID] and HealBot_UnitBuff[hbGUID]==bName then
            return
        else
            HealBot_UnitBuff[hbGUID]=bName;
            HealBot_Action_ResetUnitStatus(xUnit)
            if bName==HEALBOT_INNER_FIRE then HealBot_NeedEquipUpdate=true end
        end
    elseif HealBot_UnitBuff[hbGUID] then 
        HealBot_UnitBuff[hbGUID]=nil
        if HealBot_ThrottleCnt>3 then
            HealBot_Action_ResetUnitStatus(xUnit)
        else
            HealBot_RecalcHeals(hbGUID)
            HealBot_ThrottleCnt=HealBot_ThrottleCnt+1
        end
    end
end

local needReset=nil
function HealBot_OnEvent_PlayerRegenDisabled(self)
    if not HealBot_Loaded then return end
    if not HealBot_PlayerGUID then
        HealBot_OnEvent_PlayerEnteringWorld(self);     
        needReset=true
    elseif HealBot_Config.TargetHeals==1 and UnitExists("target") and not UnitIsEnemy("target", "player") then
        HealBot_RecalcParty(true);
    else
        HealBot_EnteringCombat()
    end
    if HealBot_Config.BuffWatch==1 and HealBot_Config.BuffWatchInCombat==0 then
        for xGUID,_ in pairs(HealBot_UnitBuff) do
            HealBot_UnitBuff[xGUID]=nil
            if HealBot_UnitID[xGUID] and HealBot_Unit_Button[HealBot_UnitID[xGUID]] then
                HealBot_RecalcHeals(xGUID)
                HealBot_DelayBuffCheck[xGUID]=true
            end
        end
        if HealBot_UnitID[HealBot_PlayerGUID] then HealBot_DelayBuffCheck[HealBot_PlayerGUID]=true; end
    end
    
    if HealBot_Config.DebuffWatch==1 and HealBot_Config.DebuffWatchInCombat==0 then
        for xGUID,_ in pairs(HealBot_UnitDebuff) do
            HealBot_UnitDebuff[xGUID]=nil
            if HealBot_UnitID[xGUID] and HealBot_Unit_Button[HealBot_UnitID[xGUID]] then
                HealBot_RecalcHeals(xGUID)
                HealBot_DelayDebuffCheck[xGUID]=true
            end
        end
        if HealBot_UnitID[HealBot_PlayerGUID] then HealBot_DelayDebuffCheck[HealBot_PlayerGUID]=true; end
    end
    if HealBot_Config.AutoClose==1 and HealBot_Config.ActionVisible==0 and HealBot_Config.DisableHealBot==0 then HealBot_TogglePanel(HealBot_Action) end
    if Healbot_Config_Skins.ShowAggro[Healbot_Config_Skins.Current_Skin]==1 then HealBot_OnEvent_UnitCombat(self,"player") end
end

function HealBot_OnEvent_PlayerRegenEnabled(self)
    if InCombatLockdown() then
        HealBot_IsReallyFightingFlag = true
    else
        HealBot_IsFighting = nil;
    end
    if HealBot_Config.TargetHeals==1 and UnitExists("target") and not UnitIsEnemy("target", "player") then
        HealBot_RecalcParty(nil);
    end
    if needReset then
        HealBot_Reset_flag=true 
        needReset=nil
    end
    if HealBot_Config.DisableToolTipInCombat==1 then
        if HealBot_Action_TooltipUnit then
            HealBot_Action_ShowTooltip(HealBot_Action_TooltipUnit)
        elseif HealBot_Action_DisableTooltipUnit then
            HealBot_Action_ShowDisabledTooltip(HealBot_Action_DisableTooltipUnit)
        end
    end
    HealBot_ClearAggro()
    if HealBot_InCombatUpdCntFlag then
        HealBot_InCombatUpdCntFlag=nil
        HealBot_Reset_UnitHealth()
    end
end

function HealBot_EnteringCombat()
    if HealBot_Config.DisableToolTipInCombat==1 and (HealBot_Action_TooltipUnit or HealBot_Action_DisableTooltipUnit) then
        HealBot_Action_HideTooltipFrame()
    end
    HealBot_IsFighting = true;
end

function HealBot_OnEvent_UnitNameUpdate(self,unit)
    xGUID=HealBot_UnitGUID(unit)
    if xGUID and HealBot_UnitID[xGUID] then
        if unit==HealBot_UnitID[xGUID] then
            HealBot_Action_ResetUnitStatus(unit)    
        elseif HealBot_IsFighting then 
            HealBot_InCombatUpdate=true
        else
            HealBot_UnitNameUpdate(unit,UnitGUID(unit))
        end
    end
end

function HealBot_UnitNameUpdate(unUnit,unGUID)
    if not UnitExists(unUnit) or not unGUID then
        if HealBot_UnitID[unGUID] then HealBot_UnitID[unGUID]=nil end
    elseif HealBot_Unit_Button[unUnit] then
        if unGUID==HealBot_PlayerGUID then unUnit="player" end
        HealBot_UnitName[unGUID]=UnitName(unUnit)
        HealBot_UnitID[unGUID]=unUnit
        HealBot_CheckAllDebuffs(unGUID)
        HealBot_CheckAllBuffs(unGUID)
        if HealBot_HoT_Active_Button[unGUID] then
            b=HealBot_Unit_Button[unUnit]
            if HealBot_HoT_Active_Button[unGUID]~=b then
                HealBot_HoT_MoveIcon(HealBot_HoT_Active_Button[unGUID], b, unGUID)
                HealBot_HoT_Active_Button[unGUID]=b
            end
        end    
        HealBot_OnEvent_UnitHealth(self,unUnit,UnitHealth(unUnit),UnitHealthMax(unUnit));
        HealBot_Action_ResetUnitStatus(unUnit)    
        HealBot_Action_UpdateAggro(unUnit,false,nil,unGUID)
        HealBot_CheckAllUnitVehicle(unUnit)
        HealBot_Queue_MyBuffsCheck(unGUID,unUnit)
    end
end

function HealBot_RaidUnit(unit,hbGUID)
    if hbGUID==HealBot_PlayerGUID then
        unit="player"
    elseif HealBot_Config.SetFocusBar==1 and (UnitGUID("focus")==hbGUID or HealBot_UnitGUID("focus")==hbGUID) then
        unit="focus"
    elseif unit and GetNumRaidMembers()>0 then
        if strsub(unit,1,5)=="party" or unit=="unknown" then
            if HealBot_UnitID[hbGUID] and HealBot_UnitGUID(HealBot_UnitID[hbGUID])==hbGUID then
                unit=HealBot_UnitID[hbGUID]
            else
                for j=1,40 do
                    xUnit = "raid"..j
                    if UnitGUID(xUnit)==hbGUID then
                        unit=xUnit
                        break
                    end
                    xUnit = "raidpet"..j
                    if UnitGUID(xUnit)==hbGUID or HealBot_UnitGUID(xUnit)==hbGUID then
                        unit=xUnit
                        break
                    end
                end
            end
        end
    elseif unit and unit=="unknown" and GetNumPartyMembers()>0 then
        for j=1,4 do
            xUnit = "party"..j
            if UnitGUID(xUnit)==hbGUID then
                unit=xUnit
                break
            end
            xUnit = "partypet"..j
            if UnitGUID(xUnit)==hbGUID or HealBot_UnitGUID(xUnit)==hbGUID then
                unit=xUnit
                break
            end
        end
    end
    return unit
end

function HealBot_UnitGUID(unit)
    if not unit or not UnitExists(unit) then
        xGUID=nil
    else
        s=string.gsub(UnitName(unit), " ", "")
        if unit=="pet" then
            xGUID=UnitGUID("player")..s
            HealBot_PetGUID[UnitGUID(unit)]=xGUID
        elseif strsub(unit,1,7)=="raidpet" then
            if strsub(unit,8) and UnitGUID("raid"..strsub(unit,8)) then
                xGUID=UnitGUID("raid"..strsub(unit,8))..s
                HealBot_PetGUID[UnitGUID(unit)]=xGUID
            else
                HealBot_AddDebug("No owner found for pet "..unit.." ("..s..")")
                xGUID=UnitGUID(unit)
            end
        elseif strsub(unit,1,8)=="partypet" then
            if strsub(unit,9) and UnitGUID("party"..strsub(unit,9)) then
                xGUID=UnitGUID("party"..strsub(unit,9))..s
                HealBot_PetGUID[UnitGUID(unit)]=xGUID
            else
                HealBot_AddDebug("No owner found for pet "..unit.." ("..s..")")
                xGUID=UnitGUID(unit)
            end
        else
            xGUID=UnitGUID(unit)
        end
    end
    return xGUID
end

function HealBot_UnitPet(unit)
    vUnit=nil
    if unit=="player" then
        vUnit="pet"
    elseif strsub(unit,1,4)=="raid" then
        vUnit="raidpet"..strsub(unit,5)
    elseif strsub(unit,1,5)=="party" then
        vUnit="partypet"..strsub(unit,6)
    end
    return vUnit
end

function HealBot_IC_PartyMembersChanged()
    z=false
    HealBot_InCombatUpdCnt=HealBot_InCombatUpdCnt+1
    if HealBot_InCombatUpdCnt<25 then
        for x,_ in pairs(HealBot_UpUnitInCombat) do
            HealBot_UpUnitInCombat[x]=nil
        end
        for xGUID,xUnit in pairs(HealBot_UnitID) do
            if HealBot_UnitGUID(xUnit) and HealBot_UnitGUID(xUnit)~=xGUID then
                HealBot_UpUnitInCombat[xGUID]=xUnit
            end
            if not UnitExists(xUnit) then HealBot_UnitID[xUnit]=nil end
       end
        for zGUID,zUnit in pairs(HealBot_UpUnitInCombat) do
            HealBot_UnitNameUpdate(HealBot_GetUnitID(zGUID),zGUID)
            HealBot_UnitNameUpdate(zUnit,HealBot_UnitGUID(zUnit))
            z=true
        end
    end
    if z then
        HealBot_InCombatUpdCnt=HealBot_InCombatUpdCnt+1
        HealBot_InCombatUpdCntFlag=true
    else
        HealBot_AddDebug("HealBot_InCombatUpdCnt="..HealBot_InCombatUpdCnt)
        HealBot_InCombatUpdate=false
        HealBot_InCombatUpdCnt=0
        if Healbot_Config_Skins.ShowRaidIcon[Healbot_Config_Skins.Current_Skin]==1 then HealBot_OnEvent_RaidTargetUpdate(nil) end
    end
end

function HealBot_GetUnitID(hbGUID)
    xUnit=nil
    for _,zUnit in pairs(HealBot_UnitID) do
        if HealBot_UnitGUID(zUnit)==hbGUID then
            xUnit=zUnit
            do break end
        end
    end
    return xUnit
end

function HealBot_OnEvent_PartyMembersChanged(self)
    if HealBot_IsFighting then HealBot_InCombatUpdate=true end
    if Delay_RecalcParty<3 then Delay_RecalcParty=3; end
    if GetNumPartyMembers()==0 or HealBot_AddonMsgType==4 then HealBot_CheckZoneFlag=true end
end

function HealBot_OnEvent_PlayerTargetChanged(self)
    if HealBot_Config.TargetHeals==1 then
        HealBot_RecalcParty(nil);
        if UnitExists("target") and not UnitIsEnemy("target", "player") then
            HealBot_OnEvent_UnitAura(nil,"target")
        end
    end
    if HealBot_UnitSpec[HealBot_UnitGUID("target")] then
        if HealBot_UnitSpec[HealBot_UnitGUID("target")] == " " then
            NotifyInspect("target")
        end
    end
end

function HealBot_OnEvent_RaidTargetUpdate(self)
    for _,xUnit in pairs(HealBot_UnitID) do
        if UnitExists(xUnit) then 
            x=GetRaidTargetIndex(xUnit)
            if x then
                HealBot_TargetIcons[xUnit]=x
                HealBot_RaidTargetUpdate(HealBot_Unit_Button[xUnit], xUnit, x)
            elseif HealBot_TargetIcons[xUnit] then
                HealBot_TargetIcons[xUnit]=nil
                HealBot_RaidTargetUpdate(HealBot_Unit_Button[xUnit], xUnit)
            end
        end
    end
end

local HealBot_TargetIconsTextures = {[1]=[[Interface\Addons\HealBot\Images\Star.tga]],
                                     [2]=[[Interface\Addons\HealBot\Images\Circle.tga]],
                                     [3]=[[Interface\Addons\HealBot\Images\Diamond.tga]],
                                     [4]=[[Interface\Addons\HealBot\Images\Triangle.tga]],
                                     [5]=[[Interface\Addons\HealBot\Images\Moon.tga]],
                                     [6]=[[Interface\Addons\HealBot\Images\Square.tga]],
                                     [7]=[[Interface\Addons\HealBot\Images\Cross.tga]],
                                     [8]=[[Interface\Addons\HealBot\Images\Skull.tga]],}
                                     
function HealBot_RaidTargetUpdate(button, unit, iconID)
    bar = HealBot_Action_HealthBar(button);
    if not bar then return end
    if Healbot_Config_Skins.ShowClassOnBar[Healbot_Config_Skins.Current_Skin]==1 and Healbot_Config_Skins.ShowClassType[Healbot_Config_Skins.Current_Skin]==1 then
        iconName = getglobal(bar:GetName().."Icon9");
    else
        iconName = getglobal(bar:GetName().."Icon8");
    end
    if iconID then
        iconName:SetTexture(HealBot_TargetIconsTextures[iconID])
        iconName:SetAlpha(1);
    else
        iconName:SetAlpha(0);
    end
end

function HealBot_RaidTargetToggle(switch)
    if switch then
        HealBot:RegisterEvent("RAID_TARGET_UPDATE")
        HealBot_OnEvent_RaidTargetUpdate(nil)
    else
        HealBot:UnregisterEvent("RAID_TARGET_UPDATE")
        for _,xUnit in pairs(HealBot_UnitID) do
            if HealBot_TargetIcons[xUnit] then
                HealBot_TargetIcons[xUnit]=nil
                HealBot_RaidTargetUpdate(HealBot_Unit_Button[xUnit], xUnit)
            end
        end
    end
end

function HealBot_OnEvent_FocusChanged(self)
    if HealBot_Config.SetFocusBar==1 and Delay_RecalcParty<3 then 
        Delay_RecalcParty=3; 
    end
end

function HealBot_GetTalentInfo(hbGUID)
    if HealBot_UnitSpec[hbGUID] then
        x,y,z=0,0,0
        if hbGUID==HealBot_PlayerGUID then
            _,_,x,_,_ = GetTalentTabInfo(1,false)
            _,_,y,_,_ = GetTalentTabInfo(2,false)
            _,_,z,_,_ = GetTalentTabInfo(3,false)
            uClass=HealBot_PlayerClassEN
        else
            _,_,x,_,_ = GetTalentTabInfo(1,true)
            _,_,y,_,_ = GetTalentTabInfo(2,true)
            _,_,z,_,_ = GetTalentTabInfo(3,true)
            _,uClass=UnitClass("target")
        end
      
        w=1
        if x+y+z>0 and uClass then
            uClass=strsub(uClass,1,4)
            if ((x > y) and (x > z)) then
                w = 1
            elseif (y > z) then
                w = 2
            else
                w = 3
            end
            s=HealBot_Init_retSpec(uClass,w)
            if s then HealBot_UnitSpec[hbGUID] = " "..s.." " end
        end
        x=w
        return w
    else
        return 1
    end
end

local HealBot_PrevComm=0
function HealBot_SetAddonComms()
    if not HealBot_InBG then
        if GetNumRaidMembers()>0 then
            HealBot_AddonMsgType=2;
        elseif GetNumPartyMembers()>0 then
            HealBot_AddonMsgType=3;
        else
            HealBot_AddonMsgType=4;
        end
    else
        HealBot_AddonMsgType=1;
    end
    if HealBot_PrevComm~=HealBot_AddonMsgType then
        HealBot_PrevComm=HealBot_AddonMsgType
        HealBot_Comms_SendAddonMsg("HealBot", ">> RequestVersion <<=>> "..HealBot_PlayerName.." <<=>> nil <<", HealBot_AddonMsgType, HealBot_PlayerName)
    end
end

function HealBot_OnEvent_PartyPetChanged(self)
    if HealBot_Config.PetHeals==1 and Delay_RecalcParty<2 then
        Delay_RecalcParty=2
    end
end

function HealBot_OnEvent_SystemMsg(self,msg)
    if type(msg)=="string" then
        if (string.find(msg, HB_ONLINE)) or (string.find(msg, HB_OFFLINE)) then
            msg = gsub(msg, "|Hplayer:([^%c^%d^%s^%p]+)|h(.+)|h", "%1")
            uName = msg:match("([^%c^%d^%s^%p]+)")
            xGUID=HealBot_Derive_GUID_fuName(uName)
            if HealBot_UnitID[xGUID] then
                if (string.find(msg, HB_ONLINE)) then
                    HealBot_Action_UnitIsOffline(xGUID,-1)
                else
                    HealBot_Action_UnitIsOffline(xGUID,time())
                end
                HealBot_Action_ResetUnitStatus(HealBot_UnitID[xGUID]);
            end
        end
    end
end

function HealBot_OnEvent_PlayerEquipmentChanged(self,unit)
    if UnitName(unit)==HealBot_PlayerName then
        HealBot_NeedEquipUpdate=true
    end
end

function HealBot_OnEvent_SpellsChanged(self, arg1)
    if arg1==0 then return; end
    HealBot_CheckSpells=true
    HealBot_OnEvent_TalentsChanged(self)
end

function HealBot_OnEvent_TalentsChanged(self, State)
    HealBot_CheckTalents=true
end

function HealBot_OnEvent_PlayerEnteringWorld(self)
    if not HealBot_Loaded then 
        return 
    elseif not HealBot_PlayerGUID then
        HealBot_Load()      
    end
    if HealBot_Config.HidePartyFrames==1 then
        HealBot_Options_DisablePartyFrame()
    end
    if HealBot_Config.HidePlayerTarget==1 then
        HealBot_Options_DisablePlayerFrame()
        HealBot_Options_DisablePetFrame()
        HealBot_Options_DisableTargetFrame()
    end
    HealBot_Register_Events()
    HealBot_CheckZoneFlag=true
    HealBot_CheckAllUnitVehicle()
end

function HealBot_OnEvent_PlayerLeavingWorld(self)
    if HealBot_Config.HidePartyFrames==1 then
        HealBot_Options_EnablePartyFrame()
    end
    if HealBot_Config.HidePlayerTarget==1 then
        HealBot_Options_EnablePlayerFrame()
        HealBot_Options_EnablePetFrame()
        HealBot_Options_EnableTargetFrame()
    end
    HealBot_UnRegister_Events();
end

local uscSpell,uscName,uscGUID=nil,nil,nil
function HealBot_OnEvent_UnitSpellcastSent(self,caster,spellName,spellRank,unitName)
    uscGUID=nil
    if HealBot_InBG then 
        uscName = string.match(unitName, "^[^-]*"); 
    else
        uscName = unitName
    end
    if uscName=="" then
        if spellName==HEALBOT_PRAYER_OF_HEALING or HEALBOT_INNER_FIRE or spellName==HEALBOT_WILD_GROWTH or spellName==HEALBOT_TRANQUILITY then 
            uscName=HealBot_PlayerName 
            uscGUID=HealBot_PlayerGUID
            if spellName==HEALBOT_INNER_FIRE then HealBot_NeedEquipUpdate=true end
        elseif spellName==HEALBOT_MENDPET then
            uscName=UnitName("pet")
            uscGUID=HealBot_UnitGUID("pet")
        end
    end
    if caster=="player" and uscName == HEALBOT_WORDS_UNKNOWN then
        uscName = HealBot_GetCorpseName(uscName)
    end
    if not uscGUID then
        if uscName==UnitName(HealBot_TargetUnitID) then
            uscGUID=HealBot_UnitGUID(HealBot_TargetUnitID)
        elseif HealBot_Derive_GUID_fuName(uscName) then
            uscGUID=HealBot_Derive_GUID_fuName(uscName)
        elseif UnitName("target") and UnitName("target")==uscName then
            xUnit="target"
            uscGUID=HealBot_UnitGUID("target")
        end
    end
    xUnit = HealBot_UnitID[uscGUID];
    if caster=="player" and uscGUID and xUnit then
        uscSpell=spellName.."("..spellRank..")"
        if spellName==HEALBOT_RESURRECTION or spellName==HEALBOT_ANCESTRALSPIRIT or spellName==HEALBOT_REBIRTH or spellName==HEALBOT_REDEMPTION or spellName==HEALBOT_REVIVE then
            HealBot_IamRessing = uscName;
            if HealBot_IamRessing then
                HealBot_Comms_SendAddonMsg("CTRA", "RES "..HealBot_IamRessing, HealBot_AddonMsgType, HealBot_PlayerName)
            end
            HealBot_CastingTarget = xUnit;
            if HealBot_Config.CastNotify>1 and HealBot_Config.CastNotifyResOnly==1 then
                HealBot_CastNotify(uscSpell,uscName,spellName)
            end
        elseif HealBot_Spells[uscSpell] then
            HealBot_IamHealing=nil
            if HealBot_Spells[uscSpell].CastTime>=1 then
                if spellName==HEALBOT_NOURISH then
                    if not HealBot_Player_HoT_Icons[uscGUID] then HealBot_Player_HoT_Icons[uscGUID]={} end
                    if HealBot_Player_HoT_Icons[uscGUID][HEALBOT_REJUVENATION] or HealBot_Player_HoT_Icons[uscGUID][HEALBOT_LIFEBLOOM] 
                    or HealBot_Player_HoT_Icons[uscGUID][HEALBOT_REGROWTH] or HealBot_Player_HoT_Icons[uscGUID][HEALBOT_WILD_GROWTH] then
                        HealBot_HealValue=floor(HealBot_Spells[uscSpell].HealsDur * 1.2);
                    else
                        HealBot_HealValue=HealBot_Spells[uscSpell].HealsDur;
                    end
                else
                    HealBot_HealValue=HealBot_Spells[uscSpell].HealsDur;
                end
                if spellName==HEALBOT_BINDING_HEAL then
                    HealBot_AddIamHealingList(HealBot_PlayerGUID)
                    HealBot_AddIamHealingList(uscGUID);
                elseif spellName==HEALBOT_PRAYER_OF_HEALING then
                    utGUID=HealBot_RetGroupGUIDs(uscGUID)
                    utGUID = HealBot_Split(utGUID, ":");
                    table.foreach(utGUID, function (index,xGUID)
                        if HealBot_UnitID[xGUID] and HealBot_UnitInRange(HEALBOT_PRAYER_OF_HEALING, HealBot_UnitID[xGUID])==1 then
                            HealBot_AddIamHealingList(xGUID);
                        end
                    end)
                elseif uscName then
                    HealBot_AddIamHealingList(uscGUID)
                end
            elseif uscName then
                HealBot_AddIamHealingList(uscGUID)
            end
            if HealBot_IamHealing and HealBot_Config.UseHbHeals<3 then 
                if HealBot_Config.UseHbHeals==1 or (HealBot_Config.UseHbHeals==2 and HealBot_AddonMsgType==4) then
                    HealBot_OnEvent_AddonMsg(nil,HEALBOT_ADDON_ID, HealBot_IamHealing.."|.|.|.|.", nil, HealBot_PlayerName, HealBot_PlayerGUID)
                    if HealBot_MsgOthers then
                        HealBot_Comms_SendAddonMsg(HEALBOT_ADDON_ID, HealBot_IamHealing.."|.|.|.|.", HealBot_AddonMsgType, HealBot_PlayerName)   
                    end
                end
            end
            HealBot_CastingTarget = xUnit;
            if HealBot_Spells[uscSpell].Duration and HealBot_Spells[uscSpell].Duration>0 and Healbot_Config_Skins.ShowHoTicons[Healbot_Config_Skins.Current_Skin]==1 and HealBot_Unit_Button[HealBot_UnitID[uscGUID]] then

                if not HealBot_Player_HoT[uscGUID] then HealBot_Player_HoT[uscGUID]={} end
                if not HealBot_Player_HoT_Icons[uscGUID] then HealBot_Player_HoT_Icons[uscGUID]={} end
                HealBot_Player_HoT[uscGUID][spellName]=9
                if not HealBot_Player_HoT_Icons[uscGUID][spellName] then HealBot_Player_HoT_Icons[uscGUID][spellName]=0 end
                if spellName==HEALBOT_REGROWTH or spellName==HEALBOT_FLASH_OF_LIGHT or spellName==HEALBOT_GIFT_OF_THE_NAARU then
                    if HealBot_Player_HoT[uscGUID][spellName]<17 then HealBot_Player_HoT[uscGUID][spellName]=17 end
                elseif spellName==HEALBOT_WILD_GROWTH or spellName==HEALBOT_TRANQUILITY then
                    HealBot_Watch_AM_HoT=3
                end
            end
        elseif spellName==HEALBOT_SACRED_SHIELD or spellName==HEALBOT_BEACON_OF_LIGHT or spellName==HEALBOT_LIGHT_BEACON then
            HealBot_Watch_Timed_HoT[uscGUID]=31
        elseif spellName==HEALBOT_ABOLISH_DISEASE or spellName==HEALBOT_ABOLISH_POISON or spellName==HEALBOT_EARTHLIVING_WEAPON or spellName==HEALBOT_EARTH_SHIELD then
            if not HealBot_Player_HoT[uscGUID] then HealBot_Player_HoT[uscGUID]={} end
            if not HealBot_Player_HoT_Icons[uscGUID] then HealBot_Player_HoT_Icons[uscGUID]={} end
            HealBot_Player_HoT[uscGUID][spellName]=9
            if not HealBot_Player_HoT_Icons[uscGUID][spellName] then HealBot_Player_HoT_Icons[uscGUID][spellName]=0 end
        end
        if HealBot_Spells[uscSpell] or HealBot_OtherSpells[uscSpell] then
            if HealBot_Config.CastNotify>1 and HealBot_Config.CastNotifyResOnly==0 then
                HealBot_CastNotify(uscSpell,uscName,spellName)
            end
        end
    end
end

function HealBot_GetCorpseName(cName)
    x = getglobal("GameTooltipTextLeft1"):GetText();
    if (x) then
        cName = string.gsub(x, HEALBOT_TOOLTIP_CORPSE, "")
    end
    return cName
end


function HealBot_ResetCheckBuffsTime()
    HealBot_CheckBuffsTime=GetTime()+10000200
    for z,_ in pairs(HealBot_PlayerBuff) do
        if HealBot_PlayerBuff[z] then
            PlayerBuffsGUID=HealBot_PlayerBuff[z]
            for y,_ in pairs (PlayerBuffsGUID) do
                if PlayerBuffsGUID[y]<0 then
                    PlayerBuffsGUID[y]=nil
                elseif PlayerBuffsGUID[y] < HealBot_CheckBuffsTime then
                    HealBot_CheckBuffsTime=PlayerBuffsGUID[y]
                    HealBot_CheckBuffsTimehbGUID=z
                end
            end
        end
    end
    if HealBot_CheckBuffsTime>GetTime()+10000000 then
        HealBot_CheckBuffsTime=nil
        HealBot_CheckBuffsTimehbGUID=nil
    end
end

function HealBot_AddIamHealingList(hbGUID)
    if (type(hbGUID) == "table") then
        HealBot_AddDebug("HealBot_AddIamHealingList has table for hbGUID")
    end  
    if HealBot_IamHealing then
        HealBot_IamHealing=HealBot_IamHealing..":"..hbGUID
    else
        HealBot_IamHealing=hbGUID
    end
    HealBot_unitHealth[hbGUID]=UnitHealth(HealBot_UnitID[hbGUID])
    HealBot_unitHealthMax[hbGUID]=UnitHealthMax(HealBot_UnitID[hbGUID])
end

local hbCin, hbDin, hbHin = 0, 0, 0
function HealBot_HealsInUpdate(hbGUID,hcGUID)
    if not HealBot_UnitID[hbGUID] then return end
    i=HealBot_HealsIn[hbGUID] or 0
    if HealBot_Config.incHealDur["C"]>0 then 
        hbCin=HealComm:GetHealAmount(hbGUID, HealComm.CHANNEL_HEALS, GetTime() + HealBot_Config.incHealDur["C"]) or 0
    else
        hbCin=0
    end
    if HealBot_Config.incHealDur["D"]>0 then 
        hbDin=HealComm:GetHealAmount(hbGUID, HealComm.DIRECT_HEALS, GetTime() + HealBot_Config.incHealDur["D"]) or 0
    else
        hbDin=0
    end
    if HealBot_Config.incHealDur["H"]>0 then 
        hbHin=HealComm:GetHealAmount(hbGUID, HealComm.HOT_HEALS, GetTime() + HealBot_Config.incHealDur["H"]) or 0
    else
        hbHin=0
    end
    x=0
    if hcGUID then 
        if (HealComm:GetHealAmount(hbGUID, HealComm.ALL_HEALS, GetTime() + 15, hcGUID) or 0)==0 then
            xUnit=HealBot_UnitID[hcGUID] or HealBot_RaidUnit("unknown", hcGUID)
            if xUnit then
                spell, rank, _, _, _, w, _ = UnitCastingInfo(xUnit)
                if spell and rank and HealBot_Spells[spell.."("..rank..")"] and w then 
                    if UnitClass(xUnit)==UnitClass("player") then
                        x=ceil((HealBot_Spells[spell.."("..rank..")"].HealsDur) * (1+(UnitLevel(xUnit)/225))) -- This is a patch for addons still using LHC3 - guess at healing bonuses based on level.
                    else
                        x=ceil((HealBot_Spells[spell.."("..rank..")"].HealsDur) * (1+(UnitLevel(xUnit)/75)))
                    end
                end
            end
        end
        if x>0 then
            HealBot_Casters[hbGUID]=hcGUID
        elseif HealBot_HealsIncCnt[hbGUID]>1.0 then
            HealBot_Casters[hbGUID]=nil
        end
    end
    y=ceil(hbCin+hbDin+hbHin+x)
    if y==0 then
        HealBot_HealsIn[hbGUID]=nil
    else
        HealBot_HealsIn[hbGUID]=y
    end
    if i~=(HealBot_HealsIn[hbGUID] or 0) then
        HealBot_RecalcHeals(hbGUID)
    end
end

function HealBot_CastNotify(spellrank,unitName,spell)
    z = HealBot_Config.CastNotify;
    if HealBot_Spells[spellrank] then
        if HealBot_Spells[spellrank].HealsDur>0 then
            s = gsub(HealBot_Config.NotifyHealMsg,"#s",spell)
            s = gsub(s,"#n",unitName)
            s = gsub(s,"#h",HealBot_Spells[spellrank].HealsDur)
        else
            s = gsub(HealBot_Config.NotifyOtherMsg,"#s",spell)
            s = gsub(s,"#n",unitName)
        end
    elseif HealBot_OtherSpells[spellrank] then
        if HealBot_OtherSpells[spellrank].HealsDur and HealBot_OtherSpells[spellrank].HealsDur>0 then
            s = gsub(HealBot_Config.NotifyHealMsg,"#s",spell)
            s = gsub(s,"#n",unitName)
            s = gsub(s,"#h",HealBot_Spells[spellrank].HealsDur)
        else
            s = gsub(HealBot_Config.NotifyOtherMsg,"#s",spell)
            s = gsub(s,"#n",unitName)
        end
    else
        s = gsub(HealBot_Config.NotifyOtherMsg,"#s",spell)
        s = gsub(s,"#n",unitName)
    end
    w=nil;
    if z==6 then
        w=HealBot_Comms_GetChan(HealBot_Config.NotifyChan) 
        if not w then z=2 end
    end
    if z==5 and GetNumRaidMembers()==0 then z = 4 end
    if z==4 and GetNumPartyMembers()==0 then z = 2 end
    if z==3 and not (UnitPlayerControlled(HealBot_CastingTarget) and HealBot_CastingTarget~='player' and HealBot_CastingTarget~='pet') then z = 2 end
    if z==3 then
        s = gsub(s,unitName,HEALBOT_WORDS_YOU)
        SendChatMessage(s,"WHISPER",nil,unitName);
    elseif z==4 then
        SendChatMessage(s,"PARTY",nil,nil);
    elseif z==5 then
        SendChatMessage(s,"RAID",nil,nil);
    elseif z==6 then
        SendChatMessage(s,"CHANNEL",nil,w);
    else
        HealBot_AddChat(s);
    end
end

-- HealBot_RetHealsIn(hbGUID)
function HealBot_Titan_Check()
    if UnitName(HealBot_CastingTarget) and HealBot_RetHealsIn(HealBot_UnitGUID(HealBot_CastingTarget))>0 then
        return UnitName(HealBot_CastingTarget), HealBot_RetHealsIn(HealBot_UnitGUID(HealBot_CastingTarget))
    else
        return nil, nil
    end
end

function HealBot_OnEvent_UnitSpellcastStart(self,unit,spellName)
    if not HealBot_UnitName[HealBot_UnitGUID(unit)] then return end
    if Healbot_Config_Skins.ShowAggro[Healbot_Config_Skins.Current_Skin]==1 then HealBot_OnEvent_UnitCombat(self,unit) end
end

function HealBot_OnEvent_UnitSpellcastStop(self,unit,spellName)
    if not HealBot_UnitName[HealBot_UnitGUID(unit)] then return end
    if UnitGUID("player")==HealBot_PlayerGUID and HealBot_IamRessing then
        HealBot_Comms_SendAddonMsg("CTRA", "RESNO", HealBot_AddonMsgType, HealBot_PlayerName)
        HealBot_IamRessing=nil;
    end
    if Healbot_Config_Skins.ShowAggro[Healbot_Config_Skins.Current_Skin]==1 then HealBot_OnEvent_UnitCombat(self,unit) end
end

function HealBot_OnEvent_UnitSpellcastFail(self,unit,spellName)
    if not HealBot_UnitName[HealBot_UnitGUID(unit)] then return end
    if UnitGUID("player")==HealBot_PlayerGUID and HealBot_IamRessing then
        HealBot_Comms_SendAddonMsg("CTRA", "RESNO", HealBot_AddonMsgType, HealBot_PlayerName)
        HealBot_IamRessing=nil;
    end
    if Healbot_Config_Skins.ShowAggro[Healbot_Config_Skins.Current_Skin]==1 then HealBot_OnEvent_UnitCombat(self,unit) end
end

local HoTtxt2=nil
function HealBot_HoT_Update(hbGUID, hotName)
    huUnit=HealBot_UnitID[hbGUID]
    huHoTtime=HealBot_Player_HoT[hbGUID]
    huHoTicon=HealBot_Player_HoT_Icons[hbGUID]
  
    if not huHoTtime[hotName] then
        HealBot_AddDebug("huHoTtime[hotName]==Nil")
        HealBot_AddDebug("hbGUID="..hbGUID.."  hotName="..hotName)
        return
    end
    if HealBot_HoT_Count[hotName] and HealBot_HoT_Count[hotName][hbGUID] then
        HoTtxt2=HealBot_HoT_Count[hotName][hbGUID]
    elseif hotName==HEALBOT_POWER_WORD_SHIELD and HealBot_TrackWS[hbGUID] then
        HoTtxt2="+"
    elseif HealBot_DeBuff_Texture[hotName] then
        if DeBuff_Count[hbGUID]>0 then
            HoTtxt2=DeBuff_Count[hbGUID]
        else
            HoTtxt2=nil
        end
    else
        HoTtxt2=nil
    end
    iTexture=HealBot_Icon_Texture(hotName)
    secLeft=floor(huHoTtime[hotName]-GetTime())

    if huHoTicon[hotName]>0 then
        if secLeft<0 then
            HealBot_HoT_UpdateIcon(HealBot_Unit_Button[huUnit], huHoTicon[hotName], 0)
--            if HealBot_DeBuff_Texture[hotName] then
--                huHoTtime[hotName]=nil
--            else
                huHoTtime[hotName]=9
--            end
            huHoTicon[hotName]=0
            HealBot_HoT_RefreshIcons(hbGUID,HealBot_Unit_Button[huUnit])
            if HealBot_HoT_Count[hotName] and HealBot_HoT_Count[hotName][hbGUID] then
                HealBot_HoT_Count[hotName][hbGUID]=nil
            end
        else
            HealBot_HoT_UpdateIcon(HealBot_Unit_Button[huUnit], huHoTicon[hotName], HealBot_HoT_AlphaValue(secLeft+1),iTexture,secLeft, HoTtxt2)
        end
    else
        i=0
        for k,z in pairs(huHoTicon) do 
            if z>0 then 
                if HealBot_DeBuff_Texture[k] then
                    if not HealBot_DeBuff_Texture[hotName] then
                        if (i+2)<8 then
                            huHoTicon[k]=i+2
                            HealBot_HoT_UpdateIcon(HealBot_Unit_Button[huUnit], i+2, HealBot_HoT_AlphaValue(secLeft),HealBot_DeBuff_Texture[k], secLeft, HoTtxt2)
                        else
                            i=8
                        end
                    end
                else
                    i=i+1
                end
            end 
        end    
        i=i+1
        if i<8 then 
            huHoTicon[hotName]=i
            HealBot_HoT_UpdateIcon(HealBot_Unit_Button[huUnit], i, HealBot_HoT_AlphaValue(secLeft),iTexture, secLeft, HoTtxt2)
            HealBot_HoT_Active_Button[hbGUID]=HealBot_Unit_Button[huUnit]
        end
    end
end

local temp_icons={}
function HealBot_HoT_RefreshIcons(hbGUID,button)
    huUnit=HealBot_UnitID[hbGUID]
    huHoTtime=HealBot_Player_HoT[hbGUID]
    huHoTicon=HealBot_Player_HoT_Icons[hbGUID]
    if not huHoTtime then 
        HealBot_HoT_RemoveIcon(hbGUID)
    else
        z=0
        for k,i in pairs(huHoTicon) do
            if i>0 then 
                temp_icons[i]=k
                z=z+1
            end
        end
        if z>0 then
            for i=1,7 do
                if not temp_icons[i] then
                    if temp_icons[i+1] then
                        HealBot_HoT_UpdateIcon(button, i+1, 0)
                        huHoTicon[temp_icons[i+1]]=i
                        secLeft=floor(huHoTtime[temp_icons[i+1]]-GetTime())
                        iTexture=HealBot_Icon_Texture(temp_icons[i+1])
                        HealBot_HoT_UpdateIcon(button, i, HealBot_HoT_AlphaValue(secLeft), iTexture, secLeft)
                        -- HealBot_HoT_Update(hbGUID, temp_icons[i+1])
                        huHoTicon[temp_icons[i+1]]=i
                        temp_icons[i+1]=nil
                    end
                end
                temp_icons[i]=nil
            end
        else
            HealBot_HoT_Active_Button[hbGUID]=nil
        end
    end
end

function HealBot_HoT_MoveIcon(oldButton, newButton, hbGUID)
    huUnit=HealBot_UnitID[hbGUID]
    huHoTtime=HealBot_Player_HoT[hbGUID]
    huHoTicon=HealBot_Player_HoT_Icons[hbGUID]
    if not huHoTicon then 
        -- HealBot_AddDebug("huHoTicon is NIL in HealBot_HoT_MoveIcon")
        return 
    end
    for k,i in pairs(huHoTicon) do
        if i>0 then
            HealBot_HoT_UpdateIcon(oldButton, huHoTicon[k], 0)
            if huHoTtime[k] then
                secLeft=floor(huHoTtime[k]-GetTime())
            else
                secLeft=2
            end
            iTexture=HealBot_Icon_Texture(k)
            HealBot_HoT_UpdateIcon(newButton, i, HealBot_HoT_AlphaValue(secLeft), iTexture, secLeft)
        end
    end
end

function HealBot_HoT_RemoveIcon(hbGUID)
    xButton=HealBot_HoT_Active_Button[hbGUID];
    huHoTicon=HealBot_Player_HoT_Icons[hbGUID]
    if not huHoTicon then 
        HealBot_AddDebug("huHoTicon is NIL in HealBot_HoT_RemoveIcon")
        return 
    end
    for _,i in pairs(huHoTicon) do
        if i>0 then
            HealBot_HoT_UpdateIcon(xButton, i, 0)
        end
    end
    HealBot_HoT_Active_Button[hbGUID]=nil;
end

function HealBot_HoT_RemoveIconButton(button)
    HealBot_HoT_UpdateIcon(button, 1, 0)
    HealBot_HoT_UpdateIcon(button, 2, 0)
    HealBot_HoT_UpdateIcon(button, 3, 0)
    HealBot_HoT_UpdateIcon(button, 4, 0)
    HealBot_HoT_UpdateIcon(button, 5, 0)
    HealBot_HoT_UpdateIcon(button, 6, 0)
    HealBot_HoT_UpdateIcon(button, 7, 0)
end

local Texture=nil
local hbiconcount=nil
local hbiconcount2=nil

function HealBot_HoT_UpdateIcon(button, index, a, Texture, txt1, txt2)
    if not button then return; end;
    if not txt1 or Healbot_Config_Skins.ShowIconTextDuration[Healbot_Config_Skins.Current_Skin]==0 then txt1=10 end;
    bar = HealBot_Action_HealthBar(button);
    iconName = getglobal(bar:GetName().."Icon"..index);
    if not iconName then
        HealBot_AddDebug("iconName is nil index="..index)
        return
    end
    iconName:SetAlpha(a);
    if Texture then iconName:SetTexture(Texture); end
    hbiconcount = getglobal(bar:GetName().."Count"..index);
    hbiconcount2 = getglobal(bar:GetName().."Count"..index.."a");
    hbiconcount:SetText(txt1);
    if txt2 and Healbot_Config_Skins.ShowIconTextCount[Healbot_Config_Skins.Current_Skin]==1 then
        hbiconcount2:SetText(txt2);
        hbiconcount2:SetTextColor(1,1,1,1);
    else
        hbiconcount2:SetText(" ");
        hbiconcount2:SetTextColor(1,1,1,0);
    end
    if txt1<0 or txt1>9 then
        hbiconcount:SetTextColor(1,1,1,0);
    elseif txt1<4 then
        if (Texture==HealBot_HoT_Texture[HEALBOT_REJUVENATION] or Texture==HealBot_HoT_Texture[HEALBOT_REGROWTH]) then
            y, x, _ = GetSpellCooldown(HEALBOT_SWIFTMEND);
            if x and y and (x+y)==0 then
                hbiconcount:SetTextColor(0,1,0,1);
            else
                hbiconcount:SetTextColor(1,0,0,1);        
            end
        else
            hbiconcount:SetTextColor(1,0,0,1);           
        end
    else
        hbiconcount:SetTextColor(1,1,1,1);
    end    
end 

function HealBot_HoT_AlphaValue(secLeft)
    if secLeft>0 and secLeft<6 then
        return (secLeft/8)+.25
    else
        return 1
    end
end

function HealBot_Icon_Texture(spellName)
    if HealBot_HoT_Texture[spellName] then
        return HealBot_HoT_Texture[spellName]
    elseif HealBot_DeBuff_Texture[spellName] then
        return HealBot_DeBuff_Texture[spellName]
    else
        return nil
    end
end

function HealBot_PlaySound(id)
    if HealBot_Loaded then
        PlaySoundFile(LSM:Fetch('sound',id));
    end
end

function HealBot_InitSpells()
  
    for x in pairs(HealBot_CurrentSpells) do
        HealBot_CurrentSpells[x]=nil;
    end

    for x,_ in pairs(HealBot_SmartCast_Spells) do
        HealBot_SmartCast_Spells[x]=nil;
    end
  
    HealBot_Init_Spells_Defaults(HealBot_PlayerClassEN);
  
    for x in pairs(HealBot_Spells) do
        if not HealBot_Spells[x].HealsExt then
            HealBot_Spells[x].HealsExt=0;
        end
        if not HealBot_Spells[x].RealHealing then
            HealBot_Spells[x].RealHealing=0;
        end
        if not HealBot_Spells[x].HealsDur then
            if HealBot_Spells[x].HealsMax then
                HealBot_Spells[x].HealsDur=HealBot_Spells[x].HealsMax;
            else
                HealBot_Spells[x].HealsDur=0;
            end
        end
        HealBot_InitClearSpellNils(x)
    end

    id = 1
    z = 0;  
    local lsName,lsRank,iSpell = nil,nil,nil
    while true do
        lsName, lsRank = HealBot_GetSpellName(id);
        iSpell=nil;
        if not lsName then
            break
        end
        if lsRank then
            iSpell=lsName .. "(" .. lsRank .. ")";
        end
        if (HealBot_Spells[iSpell]) then
            HealBot_Spells[iSpell].id = id;
            HealBot_InitGetSpellData(iSpell, id, HealBot_PlayerClassEN, lsName);
            table.insert(HealBot_CurrentSpells,iSpell);
            z = z + 1;
        end
        id = id + 1;
    end
    if strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_PRIEST] then
        if UnitLevel("player") < 20 then
            sName,sRank= HealBot_GetSpellName(HealBot_GetSpellId(HEALBOT_LESSER_HEAL))
            if sName and sRank then
                HealBot_SmartCast_Spells[HEALBOT_LESSER_HEAL]=sName .. "(" .. sRank .. ")"
            elseif sName then
                HealBot_SmartCast_Spells[HEALBOT_LESSER_HEAL]=sName
            end
        end
        if UnitLevel("player") < 40 then
            sName,sRank= HealBot_GetSpellName(HealBot_GetSpellId(HEALBOT_HEAL))
            if sName and sRank then
                HealBot_SmartCast_Spells[HEALBOT_HEAL]=sName .. "(" .. sRank .. ")"
            elseif sName then
                HealBot_SmartCast_Spells[HEALBOT_HEAL]=sName
            end
        end
        sName,sRank= HealBot_GetSpellName(HealBot_GetSpellId(HEALBOT_GREATER_HEAL))
        if sName and sRank then
            HealBot_SmartCast_Spells[HEALBOT_GREATER_HEAL]=sName .. "(" .. sRank .. ")"
        elseif sName then
            HealBot_SmartCast_Spells[HEALBOT_GREATER_HEAL]=sName
        end
        sName,sRank= HealBot_GetSpellName(HealBot_GetSpellId(HEALBOT_RENEW))
        if sName and sRank then
            HealBot_SmartCast_Spells[HEALBOT_RENEW]=sName .. "(" .. sRank .. ")"
        elseif sName then
            HealBot_SmartCast_Spells[HEALBOT_RENEW]=sName
        end
        sName,sRank= HealBot_GetSpellName(HealBot_GetSpellId(HEALBOT_FLASH_HEAL))
        if sName and sRank then
            HealBot_SmartCast_Spells[HEALBOT_FLASH_HEAL]=sName .. "(" .. sRank .. ")"
        elseif sName then
            HealBot_SmartCast_Spells[HEALBOT_FLASH_HEAL]=sName
        end
    elseif strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_DRUID] then
        sName,sRank= HealBot_GetSpellName(HealBot_GetSpellId(HEALBOT_REGROWTH))
        if sName and sRank then
            HealBot_SmartCast_Spells[HEALBOT_REGROWTH]=sName .. "(" .. sRank .. ")"
        elseif sName then
            HealBot_SmartCast_Spells[HEALBOT_REGROWTH]=sName
        end
        sName,sRank= HealBot_GetSpellName(HealBot_GetSpellId(HEALBOT_HEALING_TOUCH))
        if sName and sRank then
            HealBot_SmartCast_Spells[HEALBOT_HEALING_TOUCH]=sName .. "(" .. sRank .. ")"
        elseif sName then
            HealBot_SmartCast_Spells[HEALBOT_HEALING_TOUCH]=sName
        end
        sName,sRank= HealBot_GetSpellName(HealBot_GetSpellId(HEALBOT_REJUVENATION))
        if sName and sRank then
            HealBot_SmartCast_Spells[HEALBOT_REJUVENATION]=sName .. "(" .. sRank .. ")"
        elseif sName then
            HealBot_SmartCast_Spells[HEALBOT_REJUVENATION]=sName
        end
    elseif strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_PALADIN] then
        sName,sRank= HealBot_GetSpellName(HealBot_GetSpellId(HEALBOT_HOLY_LIGHT))
        if sName and sRank then
            HealBot_SmartCast_Spells[HEALBOT_HOLY_LIGHT]=sName .. "(" .. sRank .. ")"
        elseif sName then
            HealBot_SmartCast_Spells[HEALBOT_HOLY_LIGHT]=sName
        end
        sName,sRank= HealBot_GetSpellName(HealBot_GetSpellId(HEALBOT_FLASH_OF_LIGHT))
        if sName and sRank then
            HealBot_SmartCast_Spells[HEALBOT_FLASH_OF_LIGHT]=sName .. "(" .. sRank .. ")"
        elseif sName then
            HealBot_SmartCast_Spells[HEALBOT_FLASH_OF_LIGHT]=sName
        end
    elseif strsub(HealBot_PlayerClassEN,1,4)==HealBot_Class_En[HEALBOT_SHAMAN] then
        sName,sRank= HealBot_GetSpellName(HealBot_GetSpellId(HEALBOT_HEALING_WAVE))
        if sName and sRank then
            HealBot_SmartCast_Spells[HEALBOT_HEALING_WAVE]=sName .. "(" .. sRank .. ")"
        elseif sName then
            HealBot_SmartCast_Spells[HEALBOT_HEALING_WAVE]=sName
        end
        sName,sRank= HealBot_GetSpellName(HealBot_GetSpellId(HEALBOT_LESSER_HEALING_WAVE))
        if sName and sRank then
            HealBot_SmartCast_Spells[HEALBOT_LESSER_HEALING_WAVE]=sName .. "(" .. sRank .. ")"
        elseif sName then
            HealBot_SmartCast_Spells[HEALBOT_LESSER_HEALING_WAVE]=sName
        end
    end
    HealBot_Action_SetrSpell()
    HealBot_AddDebug("Initiated HealBot_CurrentSpells with ".. z .." Spells");
    HealBot_Options_CheckCombos();
    HealBot_Init_SmartCast();
end

function HealBot_InitNewChar(PlayerClassEN)
    HealBot_Config.EnabledKeyCombo = {}
    HealBot_Config.DisabledKeyCombo = {}
    HealBot_Config.HealBotBuffText = {[1]=HEALBOT_WORDS_NONE,[2]=HEALBOT_WORDS_NONE,[3]=HEALBOT_WORDS_NONE,[4]=HEALBOT_WORDS_NONE,
                                      [5]=HEALBOT_WORDS_NONE,[6]=HEALBOT_WORDS_NONE,[7]=HEALBOT_WORDS_NONE,[8]=HEALBOT_WORDS_NONE,[9]=HEALBOT_WORDS_NONE}
    HealBot_Config.HealBotDebuffText = {[1]=HEALBOT_WORDS_NONE,[2]=HEALBOT_WORDS_NONE,[3]=HEALBOT_WORDS_NONE}
    HealBot_Config.HealBotBuffDropDown = {[1]=4,[2]=4,[3]=4,[4]=4,[5]=4,[6]=4,[7]=4,[8]=4,[9]=4,[10]=4}
    HealBot_Config.HealBotDebuffDropDown = {[1]=4,[2]=4,[3]=4}
    if strsub(PlayerClassEN,1,4)=="DRUI" then
        HealBot_Config.EnabledKeyCombo = {
          ["Left"] = HEALBOT_REGROWTH,
          ["ShiftLeft"] = HEALBOT_DISABLED_TARGET,
          ["AltLeft"] =  HEALBOT_ABOLISH_POISON,
          ["Right"] = HEALBOT_HEALING_TOUCH,
          ["ShiftRight"] = HEALBOT_ASSIST,
          ["AltRight"] =  HEALBOT_REMOVE_CURSE,
          ["Middle"] = HEALBOT_REJUVENATION,
          ["ShiftMiddle"] = HEALBOT_HEAVY_RUNECLOTH_BANDAGE,
          ["AltMiddle"] = HEALBOT_REBIRTH,
          ["Button4"] = HEALBOT_MARK_OF_THE_WILD,
          ["Button5"] = HEALBOT_THORNS,
          ["CtrlLeft"] = HEALBOT_MAINTANK,
          ["CtrlRight"] = HEALBOT_MAINASSIST,
          ["CtrlMiddle"] = HEALBOT_MENU,
                                         }
        HealBot_Config.DisabledKeyCombo = {
          ["Left"] = HEALBOT_DISABLED_TARGET,
          ["ShiftLeft"] = HEALBOT_MARK_OF_THE_WILD,
          ["ShiftRight"] = HEALBOT_ASSIST,
          ["AltRight"] = HEALBOT_THORNS,
          ["Middle"] = HEALBOT_REJUVENATION,
          ["CtrlLeft"] = HEALBOT_MAINTANK,
          ["CtrlRight"] = HEALBOT_MAINASSIST,
          ["Right"] = HEALBOT_MENU,
                                         }
          HealBot_Config.HealBotDebuffText = {[1]=HEALBOT_CURE_POISON,[2]=HEALBOT_REMOVE_CURSE,[3]=HEALBOT_WORDS_NONE}
          HealBot_Config.HealBotBuffText = {[1]=HEALBOT_MARK_OF_THE_WILD,[2]=HEALBOT_THORNS,[3]=HEALBOT_WORDS_NONE,[4]=HEALBOT_WORDS_NONE,
                                            [5]=HEALBOT_WORDS_NONE,[6]=HEALBOT_WORDS_NONE,[7]=HEALBOT_WORDS_NONE,[8]=HEALBOT_WORDS_NONE,[9]=HEALBOT_WORDS_NONE}
    elseif strsub(PlayerClassEN,1,4)=="PALA" then
        HealBot_Config.EnabledKeyCombo = {
          ["Left"] = HEALBOT_FLASH_OF_LIGHT,
          ["ShiftLeft"] = HEALBOT_DISABLED_TARGET,
          ["AltLeft"] =  HEALBOT_CLEANSE,
          ["Right"] = HEALBOT_HOLY_LIGHT,
          ["ShiftRight"] = HEALBOT_ASSIST,
          ["Middle"] =  HEALBOT_HAND_OF_SALVATION,
          ["ShiftMiddle"] = HEALBOT_HEAVY_RUNECLOTH_BANDAGE,
          ["CtrlLeft"] = HEALBOT_MAINTANK,
          ["CtrlRight"] = HEALBOT_MAINASSIST,
          ["CtrlMiddle"] = HEALBOT_MENU,
                                         }
        HealBot_Config.DisabledKeyCombo = {
          ["Left"] = HEALBOT_DISABLED_TARGET,
          ["ShiftRight"] = HEALBOT_ASSIST,
          ["Middle"] =  HEALBOT_HAND_OF_SALVATION,
          ["CtrlLeft"] = HEALBOT_MAINTANK,
          ["CtrlRight"] = HEALBOT_MAINASSIST,
          ["Right"] = HEALBOT_MENU,
                                         }
          HealBot_Config.HealBotDebuffText = {[1]=HEALBOT_PURIFY,[2]=HEALBOT_CLEANSE,[3]=HEALBOT_WORDS_NONE}
          HealBot_Config.HealBotBuffText = {[1]=HEALBOT_BLESSING_OF_MIGHT,[2]=HEALBOT_DEVOTION_AURA,[3]=HEALBOT_SEAL_OF_RIGHTEOUSNESS,[4]=HEALBOT_WORDS_NONE,
                                            [5]=HEALBOT_WORDS_NONE,[6]=HEALBOT_WORDS_NONE,[7]=HEALBOT_WORDS_NONE,[8]=HEALBOT_WORDS_NONE,[9]=HEALBOT_WORDS_NONE}
          HealBot_Config.HealBotBuffDropDown = {[1]=4,[2]=2,[3]=2,[4]=4,[5]=4,[6]=4,[7]=4,[8]=4,[9]=4,[10]=4}
    elseif strsub(PlayerClassEN,1,4)=="PRIE" then
        HealBot_Config.EnabledKeyCombo = {
          ["Left"] = HEALBOT_FLASH_HEAL,
          ["ShiftLeft"] = HEALBOT_BINDING_HEAL,
          ["CtrlLeft"] = HEALBOT_MAINTANK,
          ["AltLeft"] =  HEALBOT_ABOLISH_DISEASE,
          ["Right"] = HEALBOT_GREATER_HEAL,
          ["ShiftRight"] = HEALBOT_POWER_WORD_SHIELD,
          ["CtrlRight"] = HEALBOT_MAINASSIST,
          ["AltRight"] =  HEALBOT_DISPEL_MAGIC,
          ["Middle"] = HEALBOT_RENEW,
          ["ShiftMiddle"] = HEALBOT_PRAYER_OF_MENDING,
          ["AltMiddle"] = HEALBOT_PRAYER_OF_HEALING,
          ["CtrlMiddle"] = HEALBOT_MENU,
          ["Button4"] = HEALBOT_POWER_WORD_FORTITUDE,
          ["ShiftButton4"] = HEALBOT_DISABLED_TARGET,
          ["Button5"] = HEALBOT_DIVINE_SPIRIT,
          ["ShiftButton5"] = HEALBOT_ASSIST,
                                         }
        HealBot_Config.DisabledKeyCombo = {
          ["Left"] = HEALBOT_DISABLED_TARGET,
          ["ShiftLeft"] = HEALBOT_ASSIST,
          ["AltLeft"] = HEALBOT_RESURRECTION,
          ["ShiftRight"] = HEALBOT_POWER_WORD_SHIELD,
          ["Middle"] = HEALBOT_RENEW,
          ["Button4"] = HEALBOT_POWER_WORD_FORTITUDE,
          ["Button5"] = HEALBOT_DIVINE_SPIRIT,
          ["CtrlLeft"] = HEALBOT_MAINTANK,
          ["CtrlRight"] = HEALBOT_MAINASSIST,
          ["Right"] = HEALBOT_MENU,
                                         }
          HealBot_Config.HealBotDebuffText = {[1]=HEALBOT_CURE_DISEASE,[2]=HEALBOT_DISPEL_MAGIC,[3]=HEALBOT_WORDS_NONE}
          HealBot_Config.HealBotBuffText = {[1]=HEALBOT_POWER_WORD_FORTITUDE,[2]=HEALBOT_INNER_FIRE,[3]=HEALBOT_DIVINE_SPIRIT,[4]=HEALBOT_SHADOW_PROTECTION,
                                            [5]=HEALBOT_WORDS_NONE,[6]=HEALBOT_WORDS_NONE,[7]=HEALBOT_WORDS_NONE,[8]=HEALBOT_WORDS_NONE,[9]=HEALBOT_WORDS_NONE}
          HealBot_Config.HealBotBuffDropDown = {[1]=4,[2]=2,[3]=4,[4]=4,[5]=4,[6]=4,[7]=4,[8]=4,[9]=4,[10]=4}
    elseif strsub(PlayerClassEN,1,4)=="SHAM" then
        HealBot_Config.EnabledKeyCombo = {
          ["Left"] = HEALBOT_LESSER_HEALING_WAVE,
          ["ShiftLeft"] = HEALBOT_DISABLED_TARGET,
          ["AltLeft"] =  HEALBOT_CURE_TOXINS,
          ["CtrlLeft"] = HEALBOT_MAINTANK,
          ["Right"] = HEALBOT_HEALING_WAVE,
          ["ShiftRight"] = HEALBOT_ASSIST,
          ["AltRight"] =  HEALBOT_CURE_TOXINS,
          ["CtrlRight"] = HEALBOT_MAINASSIST,
          ["Middle"] = HEALBOT_CHAIN_HEAL,
          ["ShiftMiddle"] = HEALBOT_HEAVY_RUNECLOTH_BANDAGE,
          ["AltMiddle"] = HEALBOT_CLEANSE_SPIRIT,
          ["CtrlMiddle"] = HEALBOT_MENU,
          ["Button4"] = HEALBOT_EARTH_SHIELD,
                                         }
        HealBot_Config.DisabledKeyCombo = {
          ["Left"] = HEALBOT_DISABLED_TARGET,
          ["ShiftLeft"] = HEALBOT_ASSIST,
          ["CtrlLeft"] = HEALBOT_MAINTANK,
          ["Right"] = HEALBOT_MENU,
          ["CtrlRight"] = HEALBOT_MAINASSIST,
          ["ShiftRight"] = HEALBOT_ANCESTRALSPIRIT,
                                         }
          HealBot_Config.HealBotDebuffText = {[1]=HEALBOT_CURE_TOXINS,[2]=HEALBOT_WORDS_NONE,[3]=HEALBOT_WORDS_NONE}
          HealBot_Config.HealBotBuffText = {[1]=HEALBOT_WATER_SHIELD,[2]=HEALBOT_ROCKBITER_WEAPON,[3]=HEALBOT_WORDS_NONE,[4]=HEALBOT_WORDS_NONE,
                                            [5]=HEALBOT_WORDS_NONE,[6]=HEALBOT_WORDS_NONE,[7]=HEALBOT_WORDS_NONE,[8]=HEALBOT_WORDS_NONE,[9]=HEALBOT_WORDS_NONE}
          HealBot_Config.HealBotBuffDropDown = {[1]=2,[2]=2,[3]=4,[4]=4,[5]=4,[6]=4,[7]=4,[8]=4,[9]=4,[10]=4}
    elseif strsub(PlayerClassEN,1,4)=="MAGE" then
        HealBot_Config.EnabledKeyCombo = {
          ["Left"] = HEALBOT_REMOVE_LESSER_CURSE,
          ["CtrlLeft"] = HEALBOT_DISABLED_TARGET,
          ["ShiftLeft"] = HEALBOT_HEAVY_RUNECLOTH_BANDAGE,
          ["Right"] = HEALBOT_ASSIST,
          ["Middle"] = HEALBOT_MENU,
          ["Button4"] = HEALBOT_MAINTANK,
          ["Button5"] = HEALBOT_MAINASSIST,
                                         }
        HealBot_Config.DisabledKeyCombo = {
          ["Left"] = HEALBOT_REMOVE_LESSER_CURSE,
          ["CtrlLeft"] = HEALBOT_DISABLED_TARGET,
          ["ShiftLeft"] = HEALBOT_HEAVY_RUNECLOTH_BANDAGE,
          ["Right"] = HEALBOT_ASSIST,
          ["Middle"] = HEALBOT_MENU,
          ["Button4"] = HEALBOT_MAINTANK,
          ["Button5"] = HEALBOT_MAINASSIST,
                                         }
          HealBot_Config.HealBotDebuffText = {[1]=HEALBOT_REMOVE_CURSE,[2]=HEALBOT_WORDS_NONE,[3]=HEALBOT_WORDS_NONE}
          HealBot_Config.HealBotBuffText = {[1]=HEALBOT_ARCANE_INTELLECT,[2]=HEALBOT_WORDS_NONE,[3]=HEALBOT_WORDS_NONE,[4]=HEALBOT_WORDS_NONE,
                                            [5]=HEALBOT_WORDS_NONE,[6]=HEALBOT_WORDS_NONE,[7]=HEALBOT_WORDS_NONE,[8]=HEALBOT_WORDS_NONE,[9]=HEALBOT_WORDS_NONE}
    else
        HealBot_Config.EnabledKeyCombo = {
          ["Left"] = HEALBOT_DISABLED_TARGET,
          ["ShiftLeft"] = HEALBOT_HEAVY_RUNECLOTH_BANDAGE,
          ["Middle"] = HEALBOT_ASSIST,
          ["Right"] = HEALBOT_MENU,
          ["Button4"] = HEALBOT_MAINTANK,
          ["Button5"] = HEALBOT_MAINASSIST,
                                         }
        HealBot_Config.DisabledKeyCombo = {
          ["Left"] = HEALBOT_DISABLED_TARGET,
          ["ShiftLeft"] = HEALBOT_HEAVY_RUNECLOTH_BANDAGE,
          ["Middle"] = HEALBOT_ASSIST,
          ["Right"] = HEALBOT_MENU,
          ["Button4"] = HEALBOT_MAINTANK,
          ["Button5"] = HEALBOT_MAINASSIST,
                                         }
    end
    HealBot_Config.HealBotBuffColR = {[1]=1,[2]=1,[3]=1,[4]=1,[5]=1,[6]=1,[7]=1,[8]=1,[9]=1,[10]=1}
    HealBot_Config.HealBotBuffColG = {[1]=1,[2]=1,[3]=1,[4]=1,[5]=1,[6]=1,[7]=1,[8]=1,[9]=1,[10]=1}
    HealBot_Config.HealBotBuffColB = {[1]=1,[2]=1,[3]=1,[4]=1,[5]=1,[6]=1,[7]=1,[8]=1,[9]=1,[10]=1}
    HealBot_Update_SpellCombos()
    HealBot_Action:SetPoint("CENTER","UIParent","CENTER",0,0);
    HealBot_CheckActionFrame()
end

function HealBot_ToggleOptions()
    HealBot_TogglePanel(HealBot_Options)
end

function HealBot_HasTalent(tab,icon,talentName)
    s,_,_,_,z,_ = GetTalentInfo(tab,icon);
    if s then
        if s~=talentName then
            --      HealBot_Report_Error( "================================" );
            --      HealBot_Report_Error( "ERROR: in function HealBot_HasTalent" );
            --      HealBot_Report_Error( "found talent "..s.." when expecting "..talentName );
            HealBot_AddDebug("ERROR: in function HealBot_HasTalent");
            HealBot_AddDebug("found talent "..s.." when expecting "..talentName);
            z=0
        end
    else
        z=0
    end
    return z
end

function HealBot_MMButton_UpdatePosition()
    HealBot_ButtonFrame:SetPoint(
        "TOPLEFT",
        "Minimap",
        "TOPLEFT",
        54 - (HealBot_Config.HealBot_ButtonRadius * cos(HealBot_Config.HealBot_ButtonPosition)),
        (HealBot_Config.HealBot_ButtonRadius * sin(HealBot_Config.HealBot_ButtonPosition)) - 55
    );
end

function HealBot_MMButton_Init()
    if HealBot_Config.ButtonShown==1 then
        HealBot_ButtonFrame:Show();
        HealBot_MMButton_UpdatePosition()
    else
        HealBot_ButtonFrame:Hide();
    end
end

function HealBot_MMButton_OnEnter(self)
    GameTooltip:SetOwner(self, "ANCHOR_LEFT");
    GameTooltip:SetText(HEALBOT_BUTTON_TOOLTIP);
    GameTooltipTextLeft1:SetTextColor(1, 1, 1);
    GameTooltip:Show();
end

function HealBot_MMButton_OnClick(self,button)
    if button~="RightButton" then
        HealBot_ToggleOptions()
    else
        HealBot_AddDebug("right click")
    end
end

function HealBot_MMButton_BeingDragged()
    w,x = GetCursorPosition() 
    y,z = Minimap:GetLeft(), Minimap:GetBottom() 
    w = y-w/UIParent:GetScale()+70 
    x = x/UIParent:GetScale()-z-70 
    HealBot_MMButton_SetPosition(math.deg(math.atan2(x,w)));
end

function HealBot_MMButton_SetPosition(c)
    if(c < 0) then
        c = c + 360;
    end

    HealBot_Config.HealBot_ButtonPosition = c;
    HealBot_MMButton_UpdatePosition();
end

function HealBot_SmartCast(hbGUID,hlthDelta)
    w=nil;
    x=0;
    y=0;
    z=false;
    for sName,sNameRank in pairs(HealBot_SmartCast_Spells) do
        if (HealBot_Spells[sNameRank]) then
            if HealBot_Spells[sNameRank].HealsDur<(hlthDelta*2) then
                if HealBot_Spells[sNameRank].Buff then
                    if HealBot_HasBuff(sName,HealBot_UnitID[hbGUID]) then 
                        z=false;  
                    else
                        z=true;
                    end;  
                else
                    z=true
                end
                if z then
                    x=(HealBot_Spells[sNameRank].HealsDur/hlthDelta)/5;
                    x=x-(HealBot_Spells[sNameRank].Mana/2);
                    x=x/(HealBot_Spells[sNameRank].CastTime+0.5);
                    if x>y then
                        y=x;
                        w=sName;
                    end
                end
            end
        end
    end
    return w;
end

local uRange=0
function HealBot_UnitInRange(spellName, unit) -- added by Diacono of Ursin
    if UnitName(unit)==HealBot_PlayerName then
        uRange = 1
    elseif not spellName then
        if UnitInRange(unit) == 1 then
            uRange = 1
        else
            uRange = 0
        end
    elseif IsSpellInRange(spellName, unit) ~= nil then
        uRange = IsSpellInRange(spellName, unit)
    elseif IsItemInRange(spellName, unit) ~= nil then
        uRange = IsItemInRange(spellName, unit)
    elseif UnitInRange(unit) == 1 then
        uRange = 1
    else
        uRange=0
    end
    if uRange==0 and not UnitIsVisible(unit) then 
        uRange=-1 
    end
    return uRange
end

function HealBot_ClearLocalArr(hbGUID)
    if HealBot_PlayerBuff[hbGUID] then HealBot_PlayerBuff[hbGUID]=nil end
    if HealBot_Player_HoT[hbGUID] then HealBot_Player_HoT[hbGUID]=nil end
    if HealBot_Player_HoT_Icons[hbGUID] then HealBot_Player_HoT_Icons[hbGUID]=nil end
    if DeBuff_Count[hbGUID] then DeBuff_Count[hbGUID]=nil end
    if HealBot_unitHealth[hbGUID] then
        HealBot_unitHealth[hbGUID]=nil
        HealBot_unitHealthMax[hbGUID]=nil
    end
    for k in pairs(HealBot_MainTanks) do
        if ( HealBot_MainTanks[k] == hbGUID ) then
            HealBot_MainTanks[k] = nil;
        end
    end
    if HealBot_DelayBuffCheck[hbGUID] then HealBot_DelayBuffCheck[hbGUID]=nil end
    HealBot_ClearAllDebuffs(hbGUID)
    HealBot_UnitSpec[hbGUID]=nil
    HealBot_UnitBuff[hbGUID]=nil
    HealBot_UnitDebuff[hbGUID]=nil
    HealBot_UnitName[hbGUID]=nil
    if HealBot_UnitID[hbGUID] then
        if HealBot_Unit_Button[HealBot_UnitID[hbGUID]] then
            if not UnitName(HealBot_UnitID[hbGUID]) then
                HealBot_Unit_Button[HealBot_UnitID[hbGUID]]=nil
            end
        end
        HealBot_UnitID[hbGUID]=nil
    end
    for k in pairs(HealBot_PetGUID) do
        if ( HealBot_PetGUID[k] == hbGUID ) then
            HealBot_PetGUID[k] = nil;
        end
    end
    if HealBot_PetGUID[hbGUID] then HealBot_PetGUID[hbGUID]=nil end
end

function HealBot_Update_Skins()

    if HealBot_Config.Skin_Version then
        if HealBot_Config.Skin_Version>Healbot_Config_Skins.Skin_Version then
            Healbot_Config_Skins.Skin_Version=HealBot_Config.Skin_Version
        end
        HealBot_Config.Skin_Version=nil
    end
  
    if HealBot_Config.Current_Skin then
        if Healbot_Config_Skins.Current_Skin == HEALBOT_SKINS_STD then
            Healbot_Config_Skins.Current_Skin = HealBot_Config.Current_Skin
        end
        HealBot_Config.Current_Skin = nil
        for x in pairs (Healbot_Config_Skins.Skins) do
            if Healbot_Config_Skins.btexture[Healbot_Config_Skins.Skins[x]] and Healbot_Config_Skins.btexture[Healbot_Config_Skins.Skins[x]] == "Empty" then
                Healbot_Config_Skins.btexture[Healbot_Config_Skins.Skins[x]]="Smooth"
            end
        end
    end
  
    for x in pairs (Healbot_Config_Skins.Skins) do
        if not Healbot_Config_Skins.DoubleText[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.Skin_Version = 1 end
    end

    if Healbot_Config_Skins.Skin_Version<2 then
        HealBot_Config_Skins={}            --
        HealBot_Options_SetDefaults()      --  So now we are forcing a wipe of WTF for those users upgrading from an old version
        HealBot_AddDebug("SkinVer Updated to 2")
        Healbot_Config_Skins.Skin_Version=2
    end
  
    if Healbot_Config_Skins.Skin_Version<3 then
        if HealBot_Config.RangeCheckFreq<0.2 then HealBot_Config.RangeCheckFreq=0.2 end
        for x,y in pairs(Healbot_Config_Skins.headtexture) do
            y = tonumber(y) or 0
            if y <= 15 and y > 0 then
                Healbot_Config_Skins.headtexture[x]=HealBot_Default_Textures[y].name
            end
        end
        for x,y in pairs(Healbot_Config_Skins.btexture) do
            y = tonumber(y) or 0
            if y <= 15  and y > 0 then
                Healbot_Config_Skins.btexture[x]=HealBot_Default_Textures[y].name
            end
        end
        if tonumber(HealBot_Config.SoundDebuffPlay) then
            HealBot_Config.SoundDebuffPlay=HealBot_Default_Sounds[HealBot_Config.SoundDebuffPlay].name;
        end
        HealBot_AddDebug("SkinVer Updated to 3")
    end
  
    if Healbot_Config_Skins.Skin_Version<4 then
        for x in pairs (Healbot_Config_Skins.Skins) do
            if not Healbot_Config_Skins.AggroBarSize[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.AggroBarSize[Healbot_Config_Skins.Skins[x]] = 3 end
            if not Healbot_Config_Skins.btextfont[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.btextfont[Healbot_Config_Skins.Skins[x]] = HealBot_Default_Font end
            if not Healbot_Config_Skins.headtextfont[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.headtextfont[Healbot_Config_Skins.Skins[x]] = HealBot_Default_Font end
            if not Healbot_Config_Skins.headtextheight[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.headtextheight[Healbot_Config_Skins.Skins[x]] = 10 end
        end
        HealBot_AddDebug("SkinVer Updated to 4")
    end
  
    if Healbot_Config_Skins.Skin_Version<5 then
        HealBot_AddDebug("SkinVer Updated to 5")
    end
  
    if Healbot_Config_Skins.Skin_Version<6 then
        for x in pairs (Healbot_Config_Skins.Skins) do
            if not Healbot_Config_Skins.numcols[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.numcols[Healbot_Config_Skins.Skins[x]] = 2 end
            if not Healbot_Config_Skins.btexture[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.btexture[Healbot_Config_Skins.Skins[x]] = HealBot_Default_Textures[8].name end
            if not Healbot_Config_Skins.bcspace[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.bcspace[Healbot_Config_Skins.Skins[x]] = 4 end
            if not Healbot_Config_Skins.brspace[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.brspace[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.bwidth[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.bwidth[Healbot_Config_Skins.Skins[x]] = 144 end
            if not Healbot_Config_Skins.bheight[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.bheight[Healbot_Config_Skins.Skins[x]] = 22 end
            if not Healbot_Config_Skins.btextenabledcolr[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.btextenabledcolr[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.btextenabledcolg[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.btextenabledcolg[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.btextenabledcolb[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.btextenabledcolb[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.btextenabledcola[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.btextenabledcola[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.btextdisbledcolr[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.btextdisbledcolr[Healbot_Config_Skins.Skins[x]] = 0.5 end
            if not Healbot_Config_Skins.btextdisbledcolg[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.btextdisbledcolg[Healbot_Config_Skins.Skins[x]] = 0.5 end
            if not Healbot_Config_Skins.btextdisbledcolb[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.btextdisbledcolb[Healbot_Config_Skins.Skins[x]] = 0.5 end
            if not Healbot_Config_Skins.btextdisbledcola[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.btextdisbledcola[Healbot_Config_Skins.Skins[x]] = 0.5 end
            if not Healbot_Config_Skins.btextcursecolr[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.btextcursecolr[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.btextcursecolg[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.btextcursecolg[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.btextcursecolb[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.btextcursecolb[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.btextcursecola[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.btextcursecola[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.backcola[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.backcola[Healbot_Config_Skins.Skins[x]] = 0.02 end
            if not Healbot_Config_Skins.Barcola[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.Barcola[Healbot_Config_Skins.Skins[x]] = 0.9 end
            if not Healbot_Config_Skins.BarcolaInHeal[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.BarcolaInHeal[Healbot_Config_Skins.Skins[x]] = 0.45 end
            if not Healbot_Config_Skins.backcolr[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.backcolr[Healbot_Config_Skins.Skins[x]] = 0 end
            if not Healbot_Config_Skins.backcolg[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.backcolg[Healbot_Config_Skins.Skins[x]] = 0 end
            if not Healbot_Config_Skins.backcolb[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.backcolb[Healbot_Config_Skins.Skins[x]] = 0.8 end
            if not Healbot_Config_Skins.borcolr[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.borcolr[Healbot_Config_Skins.Skins[x]] = 0.4    end  
            if not Healbot_Config_Skins.borcolg[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.borcolg[Healbot_Config_Skins.Skins[x]] = 0.4    end 
            if not Healbot_Config_Skins.borcolb[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.borcolb[Healbot_Config_Skins.Skins[x]] = 0.4    end
            if not Healbot_Config_Skins.borcola[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.borcola[Healbot_Config_Skins.Skins[x]] = 0.2 end
            if not Healbot_Config_Skins.btextheight[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.btextheight[Healbot_Config_Skins.Skins[x]] = 10 end
            if not Healbot_Config_Skins.bardisa[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.bardisa[Healbot_Config_Skins.Skins[x]] = 0.28 end
            if not Healbot_Config_Skins.bareora[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.bareora[Healbot_Config_Skins.Skins[x]] = 0.45 end
            if not Healbot_Config_Skins.bar2size[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.bar2size[Healbot_Config_Skins.Skins[x]] = 0 end
            if not Healbot_Config_Skins.ShowHeader[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.ShowHeader[Healbot_Config_Skins.Skins[x]] = 0 end
            if not Healbot_Config_Skins.headbarcolr[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.headbarcolr[Healbot_Config_Skins.Skins[x]] = 0.1 end
            if not Healbot_Config_Skins.headbarcolg[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.headbarcolg[Healbot_Config_Skins.Skins[x]] = 0.1 end
            if not Healbot_Config_Skins.headbarcolb[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.headbarcolb[Healbot_Config_Skins.Skins[x]] = 0.4 end
            if not Healbot_Config_Skins.headbarcola[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.headbarcola[Healbot_Config_Skins.Skins[x]] = 0.25 end
            if not Healbot_Config_Skins.headtxtcolr[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.headtxtcolr[Healbot_Config_Skins.Skins[x]] = 0.8 end
            if not Healbot_Config_Skins.headtxtcolg[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.headtxtcolg[Healbot_Config_Skins.Skins[x]] = 0.8 end
            if not Healbot_Config_Skins.headtxtcolb[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.headtxtcolb[Healbot_Config_Skins.Skins[x]] = 0.4 end
            if not Healbot_Config_Skins.headtxtcola[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.headtxtcola[Healbot_Config_Skins.Skins[x]] = 0.8 end
            if not Healbot_Config_Skins.headtexture[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.headtexture[Healbot_Config_Skins.Skins[x]] = HealBot_Default_Textures[6].name end
            if not Healbot_Config_Skins.headwidth[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.headwidth[Healbot_Config_Skins.Skins[x]] = 0.72 end
            if not Healbot_Config_Skins.ShowAggro[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.ShowAggro[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.ShowAggroBars[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.ShowAggroBars[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.ShowAggroText[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.ShowAggroText[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.UseFluidBars[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.UseFluidBars[Healbot_Config_Skins.Skins[x]] = 0 end
            if not Healbot_Config_Skins.BarFreq[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.BarFreq[Healbot_Config_Skins.Skins[x]] = 5 end
            if not Healbot_Config_Skins.ShowHoTicons[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.ShowHoTicons[Healbot_Config_Skins.Skins[x]] = 1  end
            if not Healbot_Config_Skins.HoTonBar[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.HoTonBar[Healbot_Config_Skins.Skins[x]] = 1  end
            if not Healbot_Config_Skins.HoTposBar[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.HoTposBar[Healbot_Config_Skins.Skins[x]] = 1  end
            if not Healbot_Config_Skins.ShowClassOnBar[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.ShowClassOnBar[Healbot_Config_Skins.Skins[x]] = 0 end
            if not Healbot_Config_Skins.ShowNameOnBar[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.ShowNameOnBar[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.ShowHealthOnBar[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.ShowHealthOnBar[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.BarHealthIncHeals[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.BarHealthIncHeals[Healbot_Config_Skins.Skins[x]] = 1  end
            if not Healbot_Config_Skins.BarHealthType[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.BarHealthType[Healbot_Config_Skins.Skins[x]] = 1  end
            if not Healbot_Config_Skins.SetClassColourText[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.SetClassColourText[Healbot_Config_Skins.Skins[x]] = 1  end
            if not Healbot_Config_Skins.ShowDebuffIcon[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.ShowDebuffIcon[Healbot_Config_Skins.Skins[x]] = 1  end
            if not Healbot_Config_Skins.ShowIconTextCount[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.ShowIconTextCount[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.ShowIconTextDuration[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.ShowIconTextDuration[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.IconScale[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.IconScale[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.IconTextScale[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.IconTextScale[Healbot_Config_Skins.Skins[x]] = 0.55 end
        end
        HealBot_AddDebug("SkinVer Updated to 6")
    end
  
    if Healbot_Config_Skins.Skin_Version<7 then
        for x in pairs (Healbot_Config_Skins.Skins) do
            if not Healbot_Config_Skins.DoubleText[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.DoubleText[Healbot_Config_Skins.Skins[x]] = 0 end
            if not Healbot_Config_Skins.TextAlignment[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.TextAlignment[Healbot_Config_Skins.Skins[x]] = 2 end
        end
        HealBot_AddDebug("SkinVer Updated to 7")
    end
  
    if Healbot_Config_Skins.Skin_Version<8 then
        HealBot_AddDebug("SkinVer Updated to 8")
    end  
    
    if Healbot_Config_Skins.Skin_Version<9 then
        for x in pairs (Healbot_Config_Skins.Skins) do
            if not Healbot_Config_Skins.ShowRaidIcon[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.ShowRaidIcon[Healbot_Config_Skins.Skins[x]] = 1 end
        end
        HealBot_AddDebug("SkinVer Updated to 9")
    end  
   
    if Healbot_Config_Skins.Skin_Version<10 then
        HealBot_Config.HealBotBuffColR[10]=1
        HealBot_Config.HealBotBuffColG[10]=1
        HealBot_Config.HealBotBuffColB[10]=1
        HealBot_AddDebug("SkinVer Updated to 10")
    elseif not HealBot_Config.HealBotBuffColB[10] then
        HealBot_Config.HealBotBuffColR[10]=1
        HealBot_Config.HealBotBuffColG[10]=1
        HealBot_Config.HealBotBuffColB[10]=1
    end  
    
    if Healbot_Config_Skins.Skin_Version<11 or HealBot_Config.CurrentSpec==4 then
        HealBot_Config.CurrentSpec=1
        HealBot_Update_SpellCombos()
        HealBot_Update_BuffsForSpec()
    end
    
    if Healbot_Config_Skins.Skin_Version<12 then
        for x in pairs (Healbot_Config_Skins.Skins) do
            if not Healbot_Config_Skins.SetBarClassColour[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.SetBarClassColour[Healbot_Config_Skins.Skins[x]] = 0 end
            if not Healbot_Config_Skins.SetBarCustomColour[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.SetBarCustomColour[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.barcolr[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.barcolr[Healbot_Config_Skins.Skins[x]] = 0.4 end
            if not Healbot_Config_Skins.barcolg[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.barcolg[Healbot_Config_Skins.Skins[x]] = 0.7 end
            if not Healbot_Config_Skins.barcolb[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.barcolb[Healbot_Config_Skins.Skins[x]] = 0.7 end
        end
    end
    
    if Healbot_Config_Skins.Skin_Version<13 then
        for x in pairs (Healbot_Config_Skins.Skins) do
            if not Healbot_Config_Skins.ShowClassType[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.ShowClassType[Healbot_Config_Skins.Skins[x]] = 1 end
            if not Healbot_Config_Skins.BarHealthSepHeals[Healbot_Config_Skins.Skins[x]] then Healbot_Config_Skins.BarHealthSepHeals[Healbot_Config_Skins.Skins[x]] = 0 end
        end
    end
    
    Healbot_Config_Skins.Skin_Version=HealBotSkinVersion
end

function HealBot_Update_SpellCombos()
    local combo=nil
    local button=nil

    for x=1,2 do
        if x==1 then
            combo = HealBot_Config.EnabledKeyCombo;
        else
            combo = HealBot_Config.DisabledKeyCombo;
        end
        for y=1,5 do
            button = HealBot_Options_ComboClass_Button(y)
            for z=1,3 do
                if combo then
                    combo[button..z] = combo[button]
                    combo["Shift"..button..z] = combo["Shift"..button]
                    combo["Ctrl"..button..z] = combo["Ctrl"..button]
                    combo["Alt"..button..z] = combo["Alt"..button]
                end
            end
        end
    end
end

function HealBot_Update_BuffsForSpec()
    for x=1,3 do
        HealBot_Update_BuffsForSpecDD(x,"Debuff")
    end
    for x=1,10 do
        HealBot_Update_BuffsForSpecDD(x,"Buff")
    end
end

function HealBot_Update_BuffsForSpecDD(ddId,bType)
    if bType=="Debuff" then
        for z=1,3 do
            if HealBot_Config.HealBotDebuffDropDown[ddId] and not HealBot_Config.HealBotDebuffDropDown[z..ddId] then 
                HealBot_Config.HealBotDebuffDropDown[z..ddId]=HealBot_Config.HealBotDebuffDropDown[ddId] 
            elseif not HealBot_Config.HealBotDebuffDropDown[z..ddId] then 
                HealBot_Config.HealBotDebuffDropDown[z..ddId]=4
            end
            if HealBot_Config.HealBotDebuffText[ddId] and not HealBot_Config.HealBotDebuffText[z..ddId] then 
                HealBot_Config.HealBotDebuffText[z..ddId]=HealBot_Config.HealBotDebuffText[ddId]
            elseif not not HealBot_Config.HealBotDebuffText[z..ddId] then 
                HealBot_Config.HealBotDebuffText[z..ddId]=HEALBOT_WORDS_NONE
            end
        end
    else
        for z=1,3 do
            if HealBot_Config.HealBotBuffDropDown[ddId] and not HealBot_Config.HealBotBuffDropDown[z..ddId] then 
                HealBot_Config.HealBotBuffDropDown[z..ddId]=HealBot_Config.HealBotBuffDropDown[ddId]
            elseif not HealBot_Config.HealBotBuffDropDown[z..ddId] then 
                HealBot_Config.HealBotBuffDropDown[z..ddId]=4
            end
            if HealBot_Config.HealBotBuffText[ddId] and not HealBot_Config.HealBotBuffText[z..ddId] then 
                HealBot_Config.HealBotBuffText[z..ddId]=HealBot_Config.HealBotBuffText[ddId]
            elseif not HealBot_Config.HealBotBuffText[z..ddId] then 
                HealBot_Config.HealBotBuffText[z..ddId]=HEALBOT_WORDS_NONE
            end
        end
    end
end
