local TempMaxH=0;
local TempMaxHinit=0;
local bwidth=nil
local bheight=nil
local bcspace=nil
local brspace=nil
local left=nil
local right=nil
local bottom=nil
local top=nil
local hheight=nil
local hrspace=nil
local hwidth=nil
local hwidthadj=nil
local cols=nil
local nraid=nil
local tBars=nil
local b=nil
local bar=nil
local hdr=nil
local HealBot_TrackNames={};
local i=nil
local h=nil
local j=nil
local k=nil
local z=nil
local t=nil
local x=nil
local xButton=nil
local curcol=nil
local xUnit=nil
local tUnit=nil
local sUnit=nil
local getUnitID=nil
local pUnit=nil
local header=nil
local order = {};
local units = {};
local subunits = {};
local HealBot_CheckedTargets={};
local name=nil
local subgroup=nil
local online=nil
local class=nil
local TempSort=nil
local MyGroup=0
local numHeaders = 0
local HealBot_headerno=0
local GroupValid=nil
local TargetValid=nil
local HeaderPos={}
local OffsetY = 10;
local OffsetX = 10;
local MaxOffsetY=0;
local HealBot_HeadX={};
local HealBot_HeadY={};
local HealBot_BarX={};
local HealBot_BarY={};
local HealBot_MultiColHoToffset=0;
local HealBot_TrackUnitNames={};
local HealBot_TrackButtons={};
local HealBot_TrackHButtons={};
local HealBot_TrackButtonsH={};
local HealBot_Panel_BlackList={};
local format=format
local ceil=ceil;
local strsub=strsub
local HealBot_AddHeight=4
local HealBot_MyHealTargets={}
local MyHealTargets=nil
local mti=0
local classEN=nil
local TempGrp=99
local TempUnitMaxH=1
local SubSort=nil
local uName=nil
local HealBot_MainTanks={};
local HealBot_TempTanks={};
local HealBot_GroupGUID={}
local xGUID = nil
local sGUID = nil
local maxHealDiv=2500
local showCI = false
local HealBot_TestBars={}
local hbincSort=nil
local hbSortsecno = 0

local HealBot_Action_HealGroup = {
    "player",
    "party1",
    "party2",
    "party3",
    "party4",
};

local HealBot_Action_HealButtons = {};

function HealBot_GetMyHealTargets()
    return HealBot_MyHealTargets;
end

function HealBot_Panel_SetBarArrays(bx)
    HealBot_BarX[bx]=0;
    HealBot_BarY[bx]=0;
end

function HealBot_Panel_SetHeadArrays(bx)
    HealBot_HeadX[bx]=0;
    HealBot_HeadY[bx]=0;
end

function HealBot_Panel_SetmaxHealDiv(lvl)
    maxHealDiv=500
    if lvl>76 then
        maxHealDiv=5000
    elseif lvl>70 then
        maxHealDiv=4000
    elseif lvl>60 then
        maxHealDiv=2500
    elseif lvl>45 then
        maxHealDiv=2000
    elseif lvl>30 then
        maxHealDiv=1000
    end
end

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

function HealBot_Panel_AddBlackList(hbGUID)
    HealBot_Panel_BlackList[hbGUID]=true;
end

function HealBot_Panel_ClearHealTarget()
    HealBot_MyHealTargets = {}
end

local myGUID=nil
function HealBot_Panel_ToggelHealTarget(hbGUID)
    mti=0
    table.foreach(HealBot_MyHealTargets, function (i,myGUID)
        if myGUID==hbGUID then
            mti=i
        end  
    end)
    if mti>0 then
        table.remove(HealBot_MyHealTargets,mti)
    else
        table.insert(HealBot_MyHealTargets,hbGUID)
    end
end

function HealBot_Panel_RetMyHealTarget(hbGUID)
    mti=0
    table.foreach(HealBot_MyHealTargets, function (i,myGUID)
        if myGUID==hbGUID then
            mti=i
        end  
    end)
    if mti>0 then
        return true
    else
        return false
    end
end
  
function HealBot_Panel_SetMultiColHoToffset(nx)
    HealBot_MultiColHoToffset=nx
end


local HealBot_ClassIconCoord = {
    WARRIOR = {1,1},
    MAGE = {1,2},
    ROGUE = {1,3},
    DRUID = {1,4},
    HUNTER = {2,1},
    SHAMAN = {2,2},
    PRIEST = {2,3},
    WARLOCK = {2,4},
    PALADIN = {3,1},
    DEATHKNIGHT = {3,2},
    DEFAULT = {4,4}};
    
local ciCol,ciRow=nil,nil
function HealBot_Action_SetClassIcon(button, unit)
    bar = HealBot_Action_HealthBar(button);
    if not bar then return end
    iconName = getglobal(bar:GetName().."Icon8");
    _,class = UnitClass(unit)
    ciCol, ciRow = HealBot_ClassIconCoord[class or "DEFAULT"][1],HealBot_ClassIconCoord[class or "DEFAULT"][2];
    left, top = (ciRow-1)*0.25,(ciCol-1)*0.25;
    iconName:SetTexCoord(left,left+0.25,top,top+0.25);
end

function HealBot_Action_SetClassIconTexture(button, unit)
    bar = HealBot_Action_HealthBar(button);
    if not bar then return end
    iconName = getglobal(bar:GetName().."Icon8");
    _,class = UnitClass(unit)
    ciCol, ciRow = HealBot_ClassIconCoord[class or "DEFAULT"][1],HealBot_ClassIconCoord[class or "DEFAULT"][2];
    left, top = (ciRow-1)*0.25,(ciCol-1)*0.25;
    iconName:SetTexture([[Interface\AddOns\HealBot\Images\icon_class.tga]]);
    iconName:SetTexCoord(left,left+0.25,top,top+0.25);
end

local thisX=nil
local HealBot_ResetHeaderSkinDone={}
function HealBot_Panel_clearResetHeaderSkinDone()
    for x,_ in pairs(HealBot_ResetHeaderSkinDone) do
        HealBot_ResetHeaderSkinDone[x]=nil;
    end
end

function HealBot_Action_PositionButton(button,OsetX,OsetY,bWidth,bHeight,xHeader)
    brspace=Healbot_Config_Skins.brspace[Healbot_Config_Skins.Current_Skin];
    if xHeader then
        HealBot_headerno=HealBot_headerno+1;
        hheight = ceil(bHeight*Healbot_Config_Skins.headhight[Healbot_Config_Skins.Current_Skin])
        hrspace = ceil(brspace*1.4)+3
        hdr=getglobal("HealBot_Action_Header"..HealBot_headerno);
        if not HealBot_ResetHeaderSkinDone[HealBot_headerno] then
            HealBot_Action_ResetSkin("header",hdr)
            HealBot_ResetHeaderSkinDone[HealBot_headerno]=true
        end
        bar = HealBot_Action_HealthBar(hdr);
        hwidth = bWidth*Healbot_Config_Skins.headwidth[Healbot_Config_Skins.Current_Skin]
        hwidthadj = ceil((bWidth-hwidth)/2);
        thisX=OsetX+hwidthadj+(HealBot_MultiColHoToffset*curcol)
        if HealBot_HeadX[hdr]~=thisX or HealBot_HeadY[hdr]~=format("%s",OsetY)..xHeader then
            HealBot_HeadX[hdr]=thisX
            HealBot_HeadY[hdr]=format("%s",OsetY)..xHeader;
            hdr:ClearAllPoints();
            if Healbot_Config_Skins.Panel_Anchor[Healbot_Config_Skins.Current_Skin]<3 then
                hdr:SetPoint("TOPLEFT","HealBot_Action","TOPLEFT",thisX,-OsetY);
            else
                hdr:SetPoint("TOPRIGHT","HealBot_Action","TOPRIGHT",-thisX,-OsetY);
            end
            bar.txt = getglobal(bar:GetName().."_text");
            bar.txt:SetText(xHeader);
            hdr:Show();
        end
        HealBot_TrackButtonsH[hdr]=nil;
        HealBot_TrackHButtons[hdr]=true;
        OsetY = OsetY+hheight+hrspace;
    else
        thisX=OsetX+(HealBot_MultiColHoToffset*curcol)
        if HealBot_BarX[button]~=thisX or HealBot_BarY[button]~=OsetY then
            HealBot_BarX[button]=thisX
            HealBot_BarY[button]=OsetY;
            button:ClearAllPoints();
            button:SetWidth(bWidth);
            if Healbot_Config_Skins.Panel_Anchor[Healbot_Config_Skins.Current_Skin]<3 then
                button:SetPoint("TOPLEFT","HealBot_Action","TOPLEFT",thisX,-OsetY)
            else
                button:SetPoint("TOPRIGHT","HealBot_Action","TOPRIGHT",-thisX,-OsetY)
            end
            button:Show();
        end
        OsetY = OsetY+bHeight+brspace+HealBot_AddHeight
        if showCI then HealBot_Action_SetClassIcon(button, button.unit) end
    end
    return OsetY;
end

local HealBot_AggroBarSize=0
function HealBot_Action_SetAddHeight()
    if Healbot_Config_Skins.ShowAggro[Healbot_Config_Skins.Current_Skin]==0 and Healbot_Config_Skins.HighLightActiveBar[Healbot_Config_Skins.Current_Skin]==0 then 
        HealBot_AggroBarSize=0
    else
        HealBot_AggroBarSize=Healbot_Config_Skins.AggroBarSize[Healbot_Config_Skins.Current_Skin]
    end
    if Healbot_Config_Skins.bar2size[Healbot_Config_Skins.Current_Skin]==0 then
        if Healbot_Config_Skins.ShowAggroBars[Healbot_Config_Skins.Current_Skin]==0 then
            HealBot_AddHeight=0
        else
            HealBot_AddHeight=(HealBot_AggroBarSize*2)
        end
    else
        if Healbot_Config_Skins.ShowAggroBars[Healbot_Config_Skins.Current_Skin]==0 and Healbot_Config_Skins.HighLightActiveBar[Healbot_Config_Skins.Current_Skin]==0 then
            HealBot_AddHeight=Healbot_Config_Skins.bar2size[Healbot_Config_Skins.Current_Skin]
        else
            HealBot_AddHeight=Healbot_Config_Skins.bar2size[Healbot_Config_Skins.Current_Skin]+(HealBot_AggroBarSize*2)
        end
    end
end

function HealBot_Action_SetHeightWidth(width,height,bWidth, numBars)
    HealBot_Action:SetHeight(height);
    if (Healbot_Config_Skins.Panel_Anchor[Healbot_Config_Skins.Current_Skin]<3 and Healbot_Config_Skins.HoTposBar[Healbot_Config_Skins.Current_Skin]==2) or (Healbot_Config_Skins.Panel_Anchor[Healbot_Config_Skins.Current_Skin]>2 and Healbot_Config_Skins.HoTposBar[Healbot_Config_Skins.Current_Skin]==1) then curcol=curcol+1; end;
    HealBot_Action:SetWidth(width+bWidth+10+(HealBot_MultiColHoToffset*curcol))
    HealBot_Action_setPoint()
end

local HealBot_noBars=25
function HealBot_Panel_SetNumBars(numBars)
    HealBot_noBars=numBars
end

local HealBot_setTestBars=false
local HealBot_setTestCols=false
function HealBot_Panel_ToggleTestBars()
    if HealBot_setTestBars then
        HealBot_setTestBars=false
        HealBot_Options_TestBarsButton:SetText(HEALBOT_OPTIONS_TESTBARS.." "..HEALBOT_WORD_OFF)
    else
        HealBot_setTestBars=true
        HealBot_Options_TestBarsButton:SetText(HEALBOT_OPTIONS_TESTBARS.." "..HEALBOT_WORD_ON)
        HealBot_setTestCols=false
    end
    HealBot_Action_Set_Timers()
end

function HealBot_Panel_retTestBars()
    return HealBot_setTestBars
end

local HealBot_noTestPets=0
function HealBot_Panel_TestBarsOn(showHeaders)
    noBars=HealBot_noBars
    i=0
    if Healbot_Config_Skins.SelfHeals[Healbot_Config_Skins.Current_Skin]==1 then
        j=i
        b=HealBot_Action_SetTestButton(j)
        if b then
            HealBot_Panel_TestBarShow(j,b)
            HeaderPos[j+1] = HEALBOT_OPTIONS_SELFHEALS 
            noBars=noBars-1
            i=i+1
        end
    end
    if Healbot_Config_Skins.TankHeals[Healbot_Config_Skins.Current_Skin]==1 and HealBot_Config.noTestTanks>0 and HealBot_Config.noTestTanks<noBars then
        HeaderPos[i+1] = HEALBOT_OPTIONS_TANKHEALS 
        for j=1+i,HealBot_Config.noTestTanks+i do
            b=HealBot_Action_SetTestButton(j)
            if b then
                HealBot_Panel_TestBarShow(j,b)
                noBars=noBars-1
                i=i+1
            end
        end
    end
    if noBars>0 then
        if noBars>5 then
            z=5
        else
            z=noBars
        end
        HeaderPos[i+1] = HEALBOT_OPTIONS_GROUPHEALS 
        for j=1+i,z+i do
            b=HealBot_Action_SetTestButton(j)
            if b then
                HealBot_Panel_TestBarShow(j,b)
                noBars=noBars-1
                i=i+1
            end
        end
    end
    if HealBot_Config.noTestTargets>0 and HealBot_Config.noTestTargets<noBars then
        HeaderPos[i+1] = HEALBOT_OPTIONS_MYTARGET 
        for j=1+i,HealBot_Config.noTestTargets+i  do
            b=HealBot_Action_SetTestButton(j)
            if b then
                HealBot_Panel_TestBarShow(j,b)
                noBars=noBars-1
                i=i+1
            end
        end
    end
    HealBot_noTestPets=HealBot_Config.noTestPets
    if HealBot_Config.noTestPets<=noBars then
        noBars=noBars-HealBot_Config.noTestPets
    else
        HealBot_noTestPets=0
    end
    for t=1,7 do
        if noBars>0 then
            if noBars>5 then
                z=5
            else
                z=noBars
            end
            HeaderPos[i+1] = HEALBOT_OPTIONS_GROUPHEALS 
            for j=1+i,z+i do
                b=HealBot_Action_SetTestButton(j)
                if b then
                    HealBot_Panel_TestBarShow(j,b)
                    noBars=noBars-1
                    i=i+1
                end
            end
        end
    end
    if HealBot_noTestPets>0 then
        HeaderPos[i+1] = HEALBOT_OPTIONS_PETHEALS
        for j=1+i,HealBot_noTestPets+i  do
            b=HealBot_Action_SetTestButton(j)
            if b then
                HealBot_Panel_TestBarShow(j,b)
            end
        end
    end
    HealBot_Panel_SetupBars(showHeaders)
    for j,xButton in pairs(HealBot_TestBars) do
        HealBot_TrackButtons[xButton]=true;
    end
    for unit,button in pairs(HealBot_Unit_Button) do
        HealBot_Unit_Button[unit]=nil
    end
    HealBot_setTestCols=true
end

local HealBot_keepClass=false
local HealBot_colIndex= {}

function HealBot_Panel_resetTestCols()
    if HealBot_setTestBars then
        HealBot_setTestCols=false
        if Delay_RecalcParty<2 then 
            Delay_RecalcParty=2; 
        end
    end
end

function HealBot_Panel_TestBarShow(index,button)
    table.insert(HealBot_Action_HealButtons,button)
    HealBot_TestBars[index]=button
    bar=HealBot_Action_HealthBar(button)
    HealBot_keepClass=false
    if not HealBot_setTestCols then
        if (Healbot_Config_Skins.SetBarClassColour[Healbot_Config_Skins.Current_Skin] == 1) then
            if (Healbot_Config_Skins.SetBarCustomColour[Healbot_Config_Skins.Current_Skin] == 1) then
                if index==1 then
                    HealBot_colIndex["hcr"..index],HealBot_colIndex["hcg"..index],HealBot_colIndex["hcb"..index] = HealBot_Action_ClassColour(HealBot_PlayerGUID, "player")
                else
                    HealBot_colIndex["hcr"..index],HealBot_colIndex["hcg"..index],HealBot_colIndex["hcb"..index] = HealBot_Panel_RandomClassColour()
                end
                if Healbot_Config_Skins.SetClassColourText[Healbot_Config_Skins.Current_Skin]==1 then
                    HealBot_keepClass=true
                end
            else
                HealBot_colIndex["hcr"..index]=Healbot_Config_Skins.barcolr[Healbot_Config_Skins.Current_Skin]
                HealBot_colIndex["hcg"..index]=Healbot_Config_Skins.barcolg[Healbot_Config_Skins.Current_Skin]
                HealBot_colIndex["hcb"..index]=Healbot_Config_Skins.barcolb[Healbot_Config_Skins.Current_Skin]
            end
        else
            HealBot_colIndex["hcr"..index],HealBot_colIndex["hcg"..index],HealBot_colIndex["hcb"..index] = 0,1,0
        end
        if HealBot_keepClass then
            HealBot_colIndex["hctr"..index],HealBot_colIndex["hctg"..index],HealBot_colIndex["hctb"..index] = HealBot_colIndex["hcr"..index],HealBot_colIndex["hcg"..index],HealBot_colIndex["hcb"..index]
        else
            if Healbot_Config_Skins.SetClassColourText[Healbot_Config_Skins.Current_Skin]==1 then
                if index==1 then
                    HealBot_colIndex["hctr"..index],HealBot_colIndex["hctg"..index],HealBot_colIndex["hctb"..index] = HealBot_Action_ClassColour(HealBot_PlayerGUID, "player")
                else
                    HealBot_colIndex["hctr"..index],HealBot_colIndex["hctg"..index],HealBot_colIndex["hctb"..index] = HealBot_Panel_RandomClassColour()
                end
            else
                HealBot_colIndex["hctr"..index] = Healbot_Config_Skins.btextenabledcolr[Healbot_Config_Skins.Current_Skin]
                HealBot_colIndex["hctg"..index] = Healbot_Config_Skins.btextenabledcolg[Healbot_Config_Skins.Current_Skin]
                HealBot_colIndex["hctb"..index] = Healbot_Config_Skins.btextenabledcolb[Healbot_Config_Skins.Current_Skin]
            end
        end
        HealBot_initTestBar(bar)
        bar:SetValue(0)
    end
    bar:SetStatusBarColor(HealBot_colIndex["hcr"..index],HealBot_colIndex["hcg"..index],HealBot_colIndex["hcb"..index],Healbot_Config_Skins.Barcola[Healbot_Config_Skins.Current_Skin]);
    bar.txt = getglobal(bar:GetName().."_text");
    if Healbot_Config_Skins.ShowHealthOnBar[Healbot_Config_Skins.Current_Skin]==1 then
        if Healbot_Config_Skins.DoubleText[Healbot_Config_Skins.Current_Skin]==0 then
            if Healbot_Config_Skins.BarHealthType[Healbot_Config_Skins.Current_Skin]==1 then
                bar.txt:SetText(button.unit.." (0)");
            else
                bar.txt:SetText(button.unit.." (100%)");
            end
        else
            if Healbot_Config_Skins.BarHealthType[Healbot_Config_Skins.Current_Skin]==1 then
                bar.txt:SetText(button.unit.."\n(0)");
            else
                bar.txt:SetText(button.unit.."\n(100%)");
            end
        end
    else
        bar.txt:SetText(button.unit)
    end
    bar.txt:SetTextColor(HealBot_colIndex["hctr"..index],HealBot_colIndex["hctg"..index],HealBot_colIndex["hctb"..index],Healbot_Config_Skins.btextenabledcola[Healbot_Config_Skins.Current_Skin]);
    bar:Show()
    HealBot_TrackButtons[button]=nil
end

local HealBot_randomN=1
local HealBot_randomClCol = { [1] = { [1] = 1.0, [2] = 0.49, [3] = 0.04, },
                             [2] = { [1] = 0.67, [2] = 0.83, [3] = 0.45, },
                             [3] = { [1] = 0.41, [2] = 0.8, [3] = 0.94, },
                             [4] = { [1] = 0.96, [2] = 0.55, [3] = 0.73, },
                             [5] = { [1] = 1.0, [2] = 1.0, [3] = 1.0, },
                             [6] = { [1] = 1.0, [2] = 0.96, [3] = 0.41, },
                             [7] = { [1] = 0.14, [2] = 0.25, [3] = 1.0, },
                             [8] = { [1] = 0.58, [2] = 0.51, [3] = 0.79, },
                             [9] = { [1] = 0.78, [2] = 0.04, [3] = 0.04, },
                             [10] = { [1] = 0.78, [2] = 0.61, [3] = 0.43, },
                            }
function HealBot_Panel_RandomClassColour()
    HealBot_randomN=random(1, 10)
    return HealBot_randomClCol[HealBot_randomN][1],HealBot_randomClCol[HealBot_randomN][2],HealBot_randomClCol[HealBot_randomN][3]
end

function HealBot_Panel_TestBarsOff()
    for x,b in pairs(HealBot_TestBars) do
        HealBot_Action_InsButtonStore(b)
        HealBot_TestBars[x]=nil
    end
    for x,_ in pairs(HealBot_Action_HealButtons) do
        HealBot_Action_HealButtons[x]=nil;
    end
    for x,_ in pairs(HeaderPos) do
        HeaderPos[x]=nil;
    end
    HealBot_headerno=0;
end

function HealBot_Panel_PartyChanged(showHeaders)
    HealBot_Panel_TestBarsOff()
    if HealBot_setTestBars then
        if not HealBot_IsFighting then
            HealBot_Panel_TestBarsOn(showHeaders)
        else
            HealBot_Panel_PanelChanged(showHeaders)
            Delay_RecalcParty=1
        end
    else
        HealBot_Panel_PanelChanged(showHeaders)
    end
end

function HealBot_Panel_PanelChanged(showHeaders)
    if Healbot_Config_Skins.ShowClassOnBar[Healbot_Config_Skins.Current_Skin]==1 and Healbot_Config_Skins.ShowClassType[Healbot_Config_Skins.Current_Skin]==1 then
        showCI=true
    else
        showCI=false
    end
    nraid=GetNumRaidMembers();
    MyHealTargets=nil
    numHeaders = 0
    TempMaxH=0;
    hbSortsecno = 0
  
    for x,_ in pairs(HealBot_TrackNames) do
        HealBot_TrackNames[x]=nil;
    end
  
    for x,_ in pairs(HealBot_MainTanks) do
        HealBot_MainTanks[x]=nil;
    end
  
    for x,_ in pairs(HealBot_TempTanks) do
        HealBot_TempTanks[x]=nil;
    end
  
    for xGUID,_ in pairs(HealBot_Panel_BlackList) do
        HealBot_TrackNames[xGUID]=true
    end 
  
    table.foreach(HealBot_MyHealTargets, function (i,xGUID)
        HealBot_TrackNames[xGUID]=true
        MyHealTargets=true
    end)
  
    i=0;
    h=1;
    z=1;
    
    if Healbot_Config_Skins.SelfHeals[Healbot_Config_Skins.Current_Skin]==1 then
        HeaderPos[i+1] = HEALBOT_OPTIONS_SELFHEALS 
        GroupValid=i
        xUnit="player";
        uName=UnitName(xUnit);
        if not HealBot_TrackNames[HealBot_PlayerGUID] and uName and uName~=HEALBOT_WORDS_UNKNOWN then
            i = i+1;
            HealBot_UnitName[HealBot_PlayerGUID] = uName;
            HealBot_TrackNames[HealBot_PlayerGUID]=true;
            b=HealBot_Action_SetHealButton(i,xUnit,HealBot_PlayerGUID);
            if b then
                HealBot_TrackButtons[b]=nil
                HealBot_TrackUnitNames[HealBot_PlayerGUID]=nil
                table.insert(HealBot_Action_HealButtons,b)
            end
        end
        if Healbot_Config_Skins.SelfPet[Healbot_Config_Skins.Current_Skin]==1 then
            xUnit="pet";
            xGUID=HealBot_UnitGUID(xUnit)
            uName=UnitName(xUnit);
            if xGUID and not HealBot_TrackNames[xGUID] and uName and not HealBot_retIsInVehicle("player") and uName~=HEALBOT_WORDS_UNKNOWN then
                i = i+1;
                HealBot_UnitName[xGUID] = uName;
                HealBot_TrackNames[xGUID]=true;
                b=HealBot_Action_SetHealButton(i,xUnit,xGUID);
                if b then
                    HealBot_TrackButtons[b]=nil
                    HealBot_TrackUnitNames[xGUID]=nil
                    table.insert(HealBot_Action_HealButtons,b)
                end
            end
        end
        if i>GroupValid then numHeaders=numHeaders+1 end
    end
    
    if Healbot_Config_Skins.TankHeals[Healbot_Config_Skins.Current_Skin]==1 and nraid>0 then
        HeaderPos[i+1] = HEALBOT_OPTIONS_TANKHEALS 
        GroupValid=i
        if Healbot_Config_Skins.SubSortIncTanks[Healbot_Config_Skins.Current_Skin]==1 then 
            hbincSort=true
        else
            hbincSort=nil
        end
        for j=1,10 do
            xGUID = HealBot_retHealBot_MainTanks(j);
            if xGUID and not HealBot_TrackNames[xGUID] then 
                HealBot_MainTanks[xGUID]=true 
                HealBot_TempTanks[xGUID]=true 
            end
        end
        for k=1,40 do
            xGUID=HealBot_UnitGUID("raid"..k);
            if xGUID and HealBot_MainTanks[xGUID] then
                HealBot_MainTanks[xGUID]="raid"..k
                HealBot_TempTanks[xGUID]=nil 
            end
        end
        for xGUID,_ in pairs(HealBot_TempTanks) do
            HealBot_MainTanks[xGUID]=nil
        end
        for xGUID,xUnit in pairs(HealBot_MainTanks) do
            i = i+1;
            HealBot_UnitName[xGUID] = UnitName(xUnit);
            HealBot_TrackNames[xGUID]=true;
            HealBot_Panel_insSubSort(xUnit, xGUID, hbincSort)
        end
        if i>GroupValid then 
            HealBot_Panel_SubSort()
            numHeaders=numHeaders+1 
        end
    end
    
    MyGroup=0
    if Healbot_Config_Skins.GroupHeals[Healbot_Config_Skins.Current_Skin]==1 then
        MyGroup=i+1
        HeaderPos[MyGroup] = HEALBOT_OPTIONS_GROUPHEALS 
        GroupValid=i
        if Healbot_Config_Skins.SubSortIncGroup[Healbot_Config_Skins.Current_Skin]==1 then 
            hbincSort=true
        else
            hbincSort=nil
        end
        for _,xUnit in ipairs(HealBot_Action_HealGroup) do
            uName=UnitName(xUnit);
            xGUID=HealBot_UnitGUID(xUnit)
            if xGUID and uName and not HealBot_TrackNames[xGUID] and uName~=HEALBOT_WORDS_UNKNOWN then
                if nraid>0 and uName~=HealBot_PlayerName then 
                    xUnit=HealBot_RaidUnit(xUnit,xGUID) 
                end
                i = i+1;
                HealBot_UnitName[xGUID] = uName;
                HealBot_TrackNames[xGUID]=true;
                HealBot_Panel_insSubSort(xUnit, xGUID, hbincSort)
            end
        end
        if Healbot_Config_Skins.SelfPet[Healbot_Config_Skins.Current_Skin]==1 then
            xUnit="pet";
            xGUID=HealBot_UnitGUID(xUnit)
            uName=UnitName(xUnit);
            if xGUID and not HealBot_TrackNames[xGUID] and uName and not HealBot_retIsInVehicle("player") and uName~=HEALBOT_WORDS_UNKNOWN then
                i = i+1;
                HealBot_UnitName[xGUID] = uName;
                HealBot_TrackNames[xGUID]=true;
                HealBot_Panel_insSubSort(xUnit, xGUID, hbincSort)
            end
        end
        if i>GroupValid then 
            numHeaders=numHeaders+1
            HealBot_Panel_SubSort()
        else
            MyGroup=0
        end
    end
    
    if Healbot_Config_Skins.SetFocusBar[Healbot_Config_Skins.Current_Skin]==1 and UnitExists("focus") and not UnitIsEnemy("focus", "player") then
        xGUID=HealBot_UnitGUID("focus")
        if xGUID and not HealBot_Panel_RetMyHealTarget(xGUID) and not HealBot_TrackNames[xGUID] then 
            HealBot_TrackNames[xGUID]=true;
            table.insert(HealBot_MyHealTargets,xGUID)
            MyHealTargets=true
        end
    end
  
    if MyHealTargets then
        if (Healbot_Config_Skins.ShowMyTargetsList[Healbot_Config_Skins.Current_Skin]==1 or MyGroup==0) then 
            HeaderPos[i+1] = HEALBOT_OPTIONS_MYTARGET 
            GroupValid=i
        end
        if Healbot_Config_Skins.SubSortIncMyTargets[Healbot_Config_Skins.Current_Skin]==1 then 
            hbincSort=true
        else
            hbincSort=nil
        end
        table.foreach(HealBot_MyHealTargets, function (index,xGUID)
        --  HealBot_AddDebug("In MyHealTargets - uName="..uName)
            xUnit=HealBot_RaidUnit("unknown",xGUID) 
            if UnitExists(xUnit) then
                i = i+1;
                HealBot_UnitName[xGUID] = UnitName(xUnit);
                HealBot_Panel_insSubSort(xUnit, xGUID, hbincSort)
            else
                HealBot_Panel_ToggelHealTarget(xGUID)
            end
        end)
        if i>GroupValid then 
            HealBot_Panel_SubSort()
            numHeaders=numHeaders+1 
        end
    end

    if Healbot_Config_Skins.EmergencyHeals[Healbot_Config_Skins.Current_Skin]==1 then
        for x,_ in pairs(order) do
            order[x]=nil;
        end
        for x,_ in pairs(units) do
            units[x]=nil;
        end
        for x,_ in pairs(subunits) do
            subunits[x]=nil;
        end
        GroupValid=i
        if Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==1 then
            HeaderPos[i+1] = HEALBOT_OPTIONS_EMERGENCYHEALS
            numHeaders=numHeaders+1;
        end
        if Healbot_Config_Skins.EmergIncMonitor[Healbot_Config_Skins.Current_Skin]==1 then
            if nraid>0 then
                for j=1,40 do
                    xUnit = "raid"..j;
                    xGUID=UnitGUID(xUnit)
                    uName=UnitName(xUnit);
                    name, _, subgroup, _, class, _, _, online, _, _, _ = GetRaidRosterInfo(j);
                    if xGUID then
                        HealBot_GroupGUID[xGUID]=subgroup
                        if (not online and not HealBot_Action_retUnitOffline(xGUID)) or HealBot_Action_retUnitOffline(xGUID) then
                            HealBot_Action_UnitIsOffline(xGUID)
                        end
                        if uName==HealBot_PlayerName then
                            xUnit="player"
                            if MyGroup>0 then
                                HeaderPos[MyGroup] = HEALBOT_OPTIONS_GROUPHEALS.." "..subgroup;
                            end
                        end
                    end
                    if xGUID and uName and not HealBot_TrackNames[xGUID] and uName~=HEALBOT_WORDS_UNKNOWN then
                        if Healbot_Config_Skins.ExtraIncGroup[Healbot_Config_Skins.Current_Skin][subgroup] and class then
                            if Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==1 then
                                order[xUnit] = name;
                            elseif Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==2 then
                                order[xUnit] = class;
                            elseif Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==3 then
                                order[xUnit] = subgroup;
                            else
                                order[xUnit] = 0-UnitHealthMax(xUnit);
                                if UnitHealthMax(xUnit)>TempMaxH then TempMaxH=UnitHealthMax(xUnit); end
                            end
                            table.insert(units,xUnit);
                            HealBot_UnitName[xGUID] = uName;
                            HealBot_TrackNames[xGUID]=true;
                        end
                    end
                end
            else
                for _,xUnit in ipairs(HealBot_Action_HealGroup) do
                    uName=UnitName(xUnit);
                    xGUID=HealBot_UnitGUID(xUnit)
                    if xGUID then
                        HealBot_GroupGUID[xGUID]=1
                        if (not UnitIsConnected(xUnit) and not HealBot_Action_retUnitOffline(xGUID)) or HealBot_Action_retUnitOffline(xGUID) then
                            HealBot_Action_UnitIsOffline(xGUID)
                        end
                    end
                    if xGUID and uName and not HealBot_TrackNames[xGUID] and uName~=HEALBOT_WORDS_UNKNOWN then
                        class,_=UnitClass(xUnit)
                        name = uName;
                        subgroup = 1
                        if Healbot_Config_Skins.ExtraIncGroup[Healbot_Config_Skins.Current_Skin][subgroup] and class then
                            if Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==1 then
                                order[xUnit] = name;
                            elseif Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==2 then
                                order[xUnit] = class;
                            elseif Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==3 then
                                order[xUnit] = subgroup;
                            else
                                order[xUnit] = 0-UnitHealthMax(xUnit);
                                if UnitHealthMax(xUnit)>TempMaxH then TempMaxH=UnitHealthMax(xUnit); end
                            end
                            table.insert(units,xUnit);
                            HealBot_UnitName[xGUID] = uName;
                            HealBot_TrackNames[xGUID]=true;
                        end
                    end
                end
            end
        else
            if nraid>0 then
                for j=1,40 do
                    xUnit = "raid"..j;
                    xGUID=UnitGUID(xUnit)
                    uName=UnitName(xUnit);
                    name, _, subgroup, _, class, _, _, online, _, _, _ = GetRaidRosterInfo(j);
                    if xGUID then
                        HealBot_GroupGUID[xGUID]=subgroup
                        if (not online and not HealBot_Action_retUnitOffline(xGUID)) or HealBot_Action_retUnitOffline(xGUID) then
                            HealBot_Action_UnitIsOffline(xGUID)
                        end
                        if uName==HealBot_PlayerName then
                            xUnit="player"
                            if MyGroup>0 then
                                HeaderPos[MyGroup] = HEALBOT_OPTIONS_GROUPHEALS.." "..subgroup;
                            end
                        end
                    end
                    if xGUID and uName and not HealBot_TrackNames[xGUID] and uName~=HEALBOT_WORDS_UNKNOWN then
                        _,classEN=UnitClass(xUnit)
                        if Healbot_Config_Skins.ExtraIncGroup[Healbot_Config_Skins.Current_Skin][subgroup] and class and HealBot_EmergInc[strsub(classEN,1,4)]==1 then
                            if Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==1 then
                                order[xUnit] = name;
                            elseif Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==2 then
                                order[xUnit] = class;
                            elseif Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==3 then
                                order[xUnit] = subgroup;
                            else
                                order[xUnit] = 0-UnitHealthMax(xUnit);
                                if UnitHealthMax(xUnit)>TempMaxH then TempMaxH=UnitHealthMax(xUnit); end
                            end
                            table.insert(units,xUnit);
                            HealBot_UnitName[xGUID] = uName;
                            HealBot_TrackNames[xGUID]=true;
                        end
                    end
                end
            else
                for _,xUnit in ipairs(HealBot_Action_HealGroup) do
                    class,classEN = UnitClass(xUnit);
                    xGUID=HealBot_UnitGUID(xUnit)
                    uName=UnitName(xUnit);
                    if xGUID then
                        HealBot_GroupGUID[xGUID]=1
                        if (not UnitIsConnected(xUnit) and not HealBot_Action_retUnitOffline(xGUID)) or HealBot_Action_retUnitOffline(xGUID) then
                            HealBot_Action_UnitIsOffline(xGUID)
                        end
                    end
                    if xGUID and uName and class and not HealBot_TrackNames[xGUID] and uName~=HEALBOT_WORDS_UNKNOWN then
                        name = uName;
                        subgroup = 1;
                        if Healbot_Config_Skins.ExtraIncGroup[Healbot_Config_Skins.Current_Skin][subgroup] and HealBot_EmergInc[strsub(classEN,1,4)]==1 then
                            if Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==1 then
                                order[xUnit] = name;
                            elseif Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==2 then
                                order[xUnit] = class;
                            elseif Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==3 then
                                order[xUnit] = subgroup;
                            else
                                order[xUnit] = 0-UnitHealthMax(xUnit);
                                if UnitHealthMax(xUnit)>TempMaxH then TempMaxH=UnitHealthMax(xUnit); end
                            end
                            table.insert(units,xUnit);
                            HealBot_UnitName[xGUID] = uName;
                            HealBot_TrackNames[xGUID]=true;
                        end
                    end
                end
            end
        end
        table.sort(units,function (a,b)
            if order[a]<order[b] then return true end
            if order[a]>order[b] then return false end
            return a<b
        end)
        TempMaxH=ceil(TempMaxH/maxHealDiv)*maxHealDiv;
        TempMaxHinit=TempMaxH
        TempSort="init"
        for x,_ in pairs(order) do
            order[x]=nil;
        end
        
        for j=1,41 do
            if not units[j] then 
                classEN="end"
                TempGrp=99
                TempUnitMaxH=1
            else
                xUnit=units[j];
                class,classEN = UnitClass(xUnit);
                xGUID=UnitGUID(xUnit)
                TempGrp=HealBot_GroupGUID[xGUID]
                TempUnitMaxH=UnitHealthMax(xUnit)
                i = i+1;
            end
            if Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==2 and TempSort~=classEN then 
                if TempSort=="init" then SubSort=classEN end
                TempSort=classEN
                if units[j] then 
                    HeaderPos[i] = classEN
                    numHeaders=numHeaders+1;
                end
                if TempSort~=SubSort then
                    HealBot_Panel_SubSort()
                    SubSort=TempSort
                end
            end
            if Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==3 and TempSort~=TempGrp then
                if TempSort=="init" then SubSort=TempGrp end
                TempSort=TempGrp
                if units[j] then 
                    HeaderPos[i] = HEALBOT_OPTIONS_GROUPHEALS.." "..TempSort
                    numHeaders=numHeaders+1;
                end
                if TempSort~=SubSort then
                    HealBot_Panel_SubSort()
                    SubSort=TempSort
                end
            end
            if Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==4 and TempMaxH>TempUnitMaxH then
                if TempMaxHinit==TempMaxH then SubSort=TempMaxH-maxHealDiv end
                TempMaxH=TempMaxH-maxHealDiv
                if units[j] then 
                    HeaderPos[i] = ">"..format("%s",(TempMaxH/1000)).."k"
                    numHeaders=numHeaders+1;
                end
                if TempMaxH~=SubSort then
                    HealBot_Panel_SubSort()
                    SubSort=TempMaxH
                end
            end
            if Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==5 and not units[j] then
                HealBot_Panel_SubSort()
            elseif Healbot_Config_Skins.ExtraOrder[Healbot_Config_Skins.Current_Skin]==1 and units[j] then
                b=HealBot_Action_SetHealButton(i,xUnit,xGUID);
                if b then
                    HealBot_TrackButtons[b]=nil
                    HealBot_TrackUnitNames[xGUID]=nil
                    table.insert(HealBot_Action_HealButtons,b)
                end
            elseif units[j] then
                HealBot_Panel_insSubSort(xUnit, xGUID, true)
            else
                do break end
            end
        end
        if i==GroupValid+1 then HeaderPos[i+1] = nil end
    else
        if nraid>0 then
            for j=1,40 do
                xUnit = "raid"..j;
                xGUID=UnitGUID(xUnit)
                if xGUID then
                    _, _, subgroup, _, _, _, _, online, _, _, _ = GetRaidRosterInfo(j);
                    HealBot_GroupGUID[xGUID]=subgroup
                    if (not online and not HealBot_Action_retUnitOffline(xGUID)) or HealBot_Action_retUnitOffline(xGUID) then
                        HealBot_Action_UnitIsOffline(xGUID)
                    end
                end
            end
        else
            for _,xUnit in ipairs(HealBot_Action_HealGroup) do
                xGUID=HealBot_UnitGUID(xUnit)
                if xGUID then
                    if (not UnitIsConnected(xUnit) and not HealBot_Action_retUnitOffline(xGUID)) or HealBot_Action_retUnitOffline(xGUID) then
                        HealBot_Action_UnitIsOffline(xGUID)
                    end
                    HealBot_GroupGUID[xGUID]=1
                end
            end
        end
    end
    
    if Healbot_Config_Skins.PetHeals[Healbot_Config_Skins.Current_Skin]==1 then
        for x,_ in pairs(HealBot_CheckedTargets) do
            HealBot_CheckedTargets[x]=nil;
        end
        HeaderPos[i+1] = HEALBOT_OPTIONS_PETHEALS 
        GroupValid=i
        xUnit="pet"
        pUnit="player"
        xGUID=HealBot_UnitGUID(xUnit)
        uName=UnitName(xUnit);
        if Healbot_Config_Skins.SubSortIncPet[Healbot_Config_Skins.Current_Skin]==1 then 
            hbincSort=true
        else
            hbincSort=nil
        end
        if xGUID and not HealBot_TrackNames[xGUID] and not HealBot_CheckedTargets[xGUID] and not HealBot_retIsInVehicle(pUnit) and uName and uName~=HEALBOT_WORDS_UNKNOWN then
            i = i+1;
            HealBot_UnitName[xGUID] = uName;
            HealBot_GroupGUID[xGUID]=HealBot_GroupGUID[UnitGUID(pUnit)]
            HealBot_Panel_insSubSort(xUnit, xGUID, hbincSort)
            HealBot_CheckedTargets[xGUID]=true;
        end
        if nraid>0 then
            for j=1,40 do
                xUnit="raidpet"..j;
                xGUID=HealBot_UnitGUID(xUnit)
                pUnit="raid"..j;
                uName=UnitName(xUnit);
                if xGUID and not HealBot_TrackNames[xGUID] and not HealBot_CheckedTargets[xGUID] and HealBot_TrackNames[UnitGUID(pUnit)] and not HealBot_retIsInVehicle(pUnit) and uName and uName~=HEALBOT_WORDS_UNKNOWN then
                    i = i+1;
                    HealBot_UnitName[xGUID] = uName;
                    HealBot_GroupGUID[xGUID]=HealBot_GroupGUID[UnitGUID(pUnit)]
                    HealBot_Panel_insSubSort(xUnit, xGUID, hbincSort)
                    HealBot_CheckedTargets[xGUID]=true;
                end
                if i>56 then break end
            end
        else
            for j=1,4 do
                xUnit="partypet"..j;
                xGUID=HealBot_UnitGUID(xUnit)
                pUnit="party"..j;
                uName=UnitName(xUnit);
                if xGUID and not HealBot_TrackNames[xGUID] and not HealBot_CheckedTargets[xGUID] and HealBot_TrackNames[UnitGUID(pUnit)] and not HealBot_retIsInVehicle(pUnit) and uName and uName~=HEALBOT_WORDS_UNKNOWN then
                    i = i+1;
                    HealBot_UnitName[xGUID] = uName;
                    HealBot_GroupGUID[xGUID]=HealBot_GroupGUID[UnitGUID(pUnit)]
                    HealBot_Panel_insSubSort(xUnit, xGUID, hbincSort)
                    HealBot_CheckedTargets[xGUID]=true;
                end
            end
        end
        if i>GroupValid then
            HealBot_Panel_SubSort()        
            numHeaders=numHeaders+1 
        end
    end

    
    if Healbot_Config_Skins.VehicleHeals[Healbot_Config_Skins.Current_Skin]==1 then
        for x,_ in pairs(HealBot_CheckedTargets) do
            HealBot_CheckedTargets[x]=nil;
        end
        if Healbot_Config_Skins.SubSortIncVehicle[Healbot_Config_Skins.Current_Skin]==1 then 
            hbincSort=true
        else
            hbincSort=nil
        end
        HeaderPos[i+1] = HEALBOT_VEHICLE 
        GroupValid=i
        xUnit="pet"
        pUnit="player"
        xGUID=HealBot_UnitGUID(xUnit)
        uName=UnitName(xUnit);
        if xGUID and not HealBot_TrackNames[xGUID] and not HealBot_CheckedTargets[xGUID] and HealBot_retIsInVehicle(pUnit) and uName and uName~=HEALBOT_WORDS_UNKNOWN then
            i = i+1;
            HealBot_UnitName[xGUID] = uName;
            HealBot_GroupGUID[xGUID]=HealBot_GroupGUID[UnitGUID(pUnit)]
            HealBot_Panel_insSubSort(xUnit, xGUID, hbincSort)
            HealBot_CheckedTargets[xGUID]=true;
        end
        if nraid>0 then
            for j=1,40 do
                xUnit="raidpet"..j;
                xGUID=HealBot_UnitGUID(xUnit)
                pUnit="raid"..j;
                uName=UnitName(xUnit);
                if xGUID and not HealBot_TrackNames[xGUID] and not HealBot_CheckedTargets[xGUID] and HealBot_TrackNames[UnitGUID(pUnit)] and HealBot_retIsInVehicle(pUnit) and uName and uName~=HEALBOT_WORDS_UNKNOWN then
                    i = i+1;
                    HealBot_UnitName[xGUID] = uName;
                    HealBot_GroupGUID[xGUID]=HealBot_GroupGUID[UnitGUID(pUnit)]
                    HealBot_Panel_insSubSort(xUnit, xGUID, hbincSort)
                    HealBot_CheckedTargets[xGUID]=true;
                end
                if i>56 then break end
            end
        else
            for j=1,4 do
                xUnit="partypet"..j;
                xGUID=HealBot_UnitGUID(xUnit)
                pUnit="party"..j;
                uName=UnitName(xUnit);
                if xGUID and not HealBot_TrackNames[xGUID] and not HealBot_CheckedTargets[xGUID] and HealBot_TrackNames[UnitGUID(pUnit)] and HealBot_retIsInVehicle(pUnit) and uName and uName~=HEALBOT_WORDS_UNKNOWN then
                    i = i+1;
                    HealBot_UnitName[xGUID] = uName;
                    HealBot_GroupGUID[xGUID]=HealBot_GroupGUID[UnitGUID(pUnit)]
                    HealBot_Panel_insSubSort(xUnit, xGUID, hbincSort)
                    HealBot_CheckedTargets[xGUID]=true;
                end
            end
        end
        if i>GroupValid then 
            HealBot_Panel_SubSort()    
            numHeaders=numHeaders+1 
        end
    end
    
    
    if Healbot_Config_Skins.TargetHeals[Healbot_Config_Skins.Current_Skin]==1 and not HealBot_IsFighting then
        if (UnitCanAssist("player","target")) then
            uName=UnitName("target")
            TargetValid=false
            if uName==HealBot_PlayerName then 
                if Healbot_Config_Skins.TargetIncSelf[Healbot_Config_Skins.Current_Skin]==1 then TargetValid=true end
            elseif UnitInParty("target") then
                if Healbot_Config_Skins.TargetIncGroup[Healbot_Config_Skins.Current_Skin]==1 then TargetValid=true end
            elseif UnitInRaid("target") then 
                if Healbot_Config_Skins.TargetIncRaid[Healbot_Config_Skins.Current_Skin]==1 then TargetValid=true end
            elseif UnitPlayerOrPetInParty("target") or UnitPlayerOrPetInRaid("target") then
                if Healbot_Config_Skins.TargetIncPet[Healbot_Config_Skins.Current_Skin]==1 then TargetValid=true end
            else
                TargetValid=true
            end
            if TargetValid and not HealBot_Panel_BlackList[HealBot_UnitGUID("target")] then

                HeaderPos[i+1] = HEALBOT_OPTIONS_TARGETHEALS
                xUnit="target";
                xGUID=HealBot_UnitGUID(xUnit)
                if xGUID and HealBot_MayHeal(xUnit, uName) then
                    HealBot_UnitName[xGUID] = uName;    
                    b=HealBot_Action_SetTargetHealButton(xUnit,xGUID);
                    if b then
                        HealBot_TrackButtons[b]=nil
                        HealBot_TrackUnitNames[HealBot_UnitGUID("target")]=nil
                        table.insert(HealBot_Action_HealButtons,b)
                        numHeaders=numHeaders+1
                    end
                end
            end
        end
    end
    
    for xGUID,xUnit in pairs(HealBot_TrackUnitNames) do
        if HealBot_Action_retAggro(xGUID) then HealBot_Action_UpdateAggro(xUnit,false,nil,xGUID) end
        HealBot_TrackUnitNames[xGUID]=nil
        HealBot_Action_RemoveMember(xGUID)
    end

    HealBot_Panel_SetupBars(showHeaders)

    for xUnit,xButton in pairs(HealBot_Unit_Button) do
        if UnitExists(xUnit) then
            xGUID=HealBot_UnitGUID(xUnit)
            HealBot_TrackButtons[xButton]=true;
            HealBot_TrackUnitNames[xGUID]=xUnit;
            if HealBot_HoT_Active_Button[xGUID] then
                if HealBot_HoT_Active_Button[xGUID]~=xButton then
                    HealBot_HoT_MoveIcon(HealBot_HoT_Active_Button[xGUID], xButton, xGUID)
                    HealBot_HoT_Active_Button[xGUID]=xButton  
                end
            end
        else
            HealBot_Unit_Button[xUnit]=nil
        end
    end

    HealBot_Action_RefreshButtons();
    if Healbot_Config_Skins.ShowRaidIcon[Healbot_Config_Skins.Current_Skin]==1 then HealBot_OnEvent_RaidTargetUpdate(nil) end
  
end

local hbIncSort=false
function HealBot_Panel_insSubSort(unit, hbGUID, incSort)
    hbIncSort=false
    if Healbot_Config_Skins.ExtraSubOrder[Healbot_Config_Skins.Current_Skin]==1 and incSort then
        if HealBot_UnitName[hbGUID] then
            order[unit] = HealBot_UnitName[hbGUID];
            hbIncSort=true
        end
    elseif Healbot_Config_Skins.ExtraSubOrder[Healbot_Config_Skins.Current_Skin]==2 and incSort then
        class,classEN = UnitClass(unit);
        if classEN then
            order[unit] = classEN
            hbIncSort=true
        end
    elseif Healbot_Config_Skins.ExtraSubOrder[Healbot_Config_Skins.Current_Skin]==3 and incSort then
        if HealBot_GroupGUID[hbGUID] then
            order[unit] = HealBot_GroupGUID[hbGUID];
            hbIncSort=true
        end
    elseif Healbot_Config_Skins.ExtraSubOrder[Healbot_Config_Skins.Current_Skin]==4 and incSort then
        if UnitHealthMax(unit) then
            order[unit] = 0-UnitHealthMax(unit);
            hbIncSort=true
        end
    else
        hbSortsecno = hbSortsecno + 1
        order[unit] = hbSortsecno
        hbIncSort=true
    end
    if hbIncSort then table.insert(subunits,unit) end
end

function HealBot_Panel_SubSort()
    table.sort(subunits,function (a,b)
        if not order[a] or not order[b] then
            if not order[a] or not order[b] then
                HealBot_AddDebug("Nil in SubSort for order[b] - b="..b)
                HealBot_AddDebug("order[a]="..order[a].." - a="..a)
            elseif order[b] and not order[a] then
                HealBot_AddDebug("Nil in SubSort for order[a] - a="..a)
                HealBot_AddDebug("order[b]="..order[b].." - b="..b)
            elseif not order[a] and not order[b] then
                HealBot_AddDebug("Nil in SubSort for order[a] and order[b]")
                HealBot_AddDebug("a="..a.." - b="..b)
            end
            return false
        else
            if order[a]<order[b] then return true end
            if order[a]>order[b] then return false end
            return a<b
        end
    end)
    for k=1,#subunits do
        sUnit=subunits[k];
        sGUID=HealBot_UnitGUID(sUnit)
        b=HealBot_Action_SetHealButton(i,sUnit,sGUID);
        if b then
            HealBot_TrackButtons[b]=nil
            HealBot_TrackUnitNames[sGUID]=nil
            table.insert(HealBot_Action_HealButtons,b)
        end
    end
    for x,_ in pairs(order) do
        order[x]=nil;
    end
    for x,_ in pairs(subunits) do
        subunits[x]=nil;
    end
end

function HealBot_Panel_SetupBars(showHeaders)
    bwidth = Healbot_Config_Skins.bwidth[Healbot_Config_Skins.Current_Skin];
    bheight=Healbot_Config_Skins.bheight[Healbot_Config_Skins.Current_Skin];
    bcspace=Healbot_Config_Skins.bcspace[Healbot_Config_Skins.Current_Skin];
    cols=Healbot_Config_Skins.numcols[Healbot_Config_Skins.Current_Skin];
    i=0
    if Healbot_Config_Skins.Panel_Anchor[Healbot_Config_Skins.Current_Skin]<3 then
        curcol=2-Healbot_Config_Skins.HoTposBar[Healbot_Config_Skins.Current_Skin]
    else
        curcol=2-(3-Healbot_Config_Skins.HoTposBar[Healbot_Config_Skins.Current_Skin])
    end
    z=1;
    OffsetY = 7 + HealBot_AggroBarSize;
    OffsetX = 10;
    MaxOffsetY=0;
  
    if showHeaders then 
        h=0
        table.foreach(HealBot_Action_HealButtons, function (x,xButton)
            if strsub(xButton.unit,1,4)=="Test" then
                uName=xButton.unit
            else
                uName=UnitName(xButton.unit);
            end
            if uName and not HealBot_TrackButtons[xButton] then
                i=i+1
                if HeaderPos[i] then
                    h=h+1;
                    header=HeaderPos[i];
                    if h>cols then
                        if MaxOffsetY<OffsetY then MaxOffsetY = OffsetY; end
                        OffsetY = 7 + HealBot_AggroBarSize;
                        OffsetX = OffsetX + bwidth+bcspace; 
                        h=1;
                        curcol=curcol+1
                    end
                    OffsetY = HealBot_Action_PositionButton(nil,OffsetX,OffsetY,bwidth,bheight,header,curcol);
                end
                OffsetY = HealBot_Action_PositionButton(xButton,OffsetX,OffsetY,bwidth,bheight,nil,curcol);
            end
        end)
    elseif Healbot_Config_Skins.GroupsPerCol[Healbot_Config_Skins.Current_Skin]==1 then
        h=0
        table.foreach(HealBot_Action_HealButtons, function (x,xButton)
            if strsub(xButton.unit,1,4)=="Test" then
                uName=xButton.unit
            else
                uName=UnitName(xButton.unit);
            end
            if uName and not HealBot_TrackButtons[xButton] then
                i=i+1
                if HeaderPos[i] then
                    h=h+1;
                    if h>cols then
                        if MaxOffsetY<OffsetY then MaxOffsetY = OffsetY; end
                        OffsetY = 7 + HealBot_AggroBarSize;
                        OffsetX = OffsetX + bwidth+bcspace; 
                        h=1;
                        curcol=curcol+1
                    end
                end
                OffsetY = HealBot_Action_PositionButton(xButton,OffsetX,OffsetY,bwidth,bheight,nil,curcol);
            end
        end)
    else
        h=1
            tBars=table.getn(HealBot_Action_HealButtons)
            table.foreach(HealBot_Action_HealButtons, function (x,xButton)
            if strsub(xButton.unit,1,4)=="Test" then
                uName=xButton.unit
            else
                uName=UnitName(xButton.unit);
            end
            if uName and not HealBot_TrackButtons[xButton] then
                i=i+1
                OffsetY = HealBot_Action_PositionButton(xButton,OffsetX,OffsetY,bwidth,bheight,nil,curcol)
                if h==ceil((tBars)/cols) and z<tBars then
                    h=0;
                    if MaxOffsetY<OffsetY then MaxOffsetY = OffsetY; end
                    OffsetY = 7 + HealBot_AggroBarSize;
                    OffsetX = OffsetX + bwidth+bcspace; 
                    curcol=curcol+1;
                end
        
                z=z+1
                h=h+1;
            end
        end)
    end
     
    for xButton,_ in pairs(HealBot_TrackButtonsH) do
        xButton:Hide();
        HealBot_HeadY[xButton]="0"
        HealBot_TrackButtonsH[xButton]=nil;
    end
    
    for xButton,_ in pairs(HealBot_TrackButtons) do
        xButton:Hide();
        HealBot_Panel_SetBarArrays(xButton)
        HealBot_TrackButtons[xButton]=nil;
    end
    
    for xButton,_ in pairs(HealBot_TrackHButtons) do
        HealBot_TrackButtonsH[xButton]=true;
    end

    if MaxOffsetY<OffsetY then MaxOffsetY = OffsetY; end

    if HealBot_Config.HideOptions==1 then
        HealBot_Action_OptionsButton:Hide();
    else
        HealBot_Action_OptionsButton:SetPoint("BOTTOM","HealBot_Action","BOTTOM",0,10);
        HealBot_Action_OptionsButton:Show();
        MaxOffsetY = MaxOffsetY+30;
    end  
    if Healbot_Config_Skins.ShowAggroBars[Healbot_Config_Skins.Current_Skin]==0 and Healbot_Config_Skins.HighLightActiveBar[Healbot_Config_Skins.Current_Skin]==0 then
        HealBot_Action_SetHeightWidth(OffsetX, MaxOffsetY+5, bwidth,curcol, i);
    else
        HealBot_Action_SetHeightWidth(OffsetX, (MaxOffsetY+5)-(HealBot_AggroBarSize-2), bwidth,curcol, i);
    end
    
end

function HealBot_Action_RemoveMember(hbGUID)
    if HealBot_Unit_Button["target"] and HealBot_UnitName[hbGUID]=="target" then
        HealBot_Unit_Button["target"]=nil
    end
    HealBot_setClearLocalArr(hbGUID)
    if HealBot_GroupGUID[hbGUID] then HealBot_GroupGUID[hbGUID]=nil end
    HealBot_Action_immediateClearLocalArr(hbGUID)
    HealBot_immediateClearLocalArr(hbGUID)
end

function HealBot_RetGroupGUIDs(hbGUID)
    if not HealBot_GroupGUID[hbGUID] then 
        z=1
    else
        z=HealBot_GroupGUID[hbGUID]
    end
    y=hbGUID
    for xGUID,group in pairs(HealBot_GroupGUID) do
        if group==z and xGUID~=hbGUID then
            y=y..":"..xGUID
        end
    end
    return y
end
