return IconAura("HELPFUL|PLAYER", "player", "Lichtenergie")

-- don't load if class is wrong
local _, class = UnitClass("player")
if class ~= "WARRIOR" then return end

local GetTime = GetTime
local version = 1


-- mod name in lower case
local modName = "_prot"

local defaults = {
    version = version,
    priorityList = {},
}

-- create a module in the main addon
local mod = clcInfo:RegisterClassModule(modName)
local db
-- functions visible to exec should be attached to this
local emod = clcInfo.env

-- any error sets this to false
local enabled = true

-- spells used
local spellGCD	= 94009	-- Rend for gcd

local spellHeS	= 78	-- Heroic Strike
local spellShS	= 23922	-- Shield Slam
local spellRev	= 6572	-- Revenge
local spellCoS	= 469	-- Commanding Shout
local spellRen	= 772	-- Rend
local spellShW	= 46968	-- Shockwave
local spellCoB	= 12809	-- Concussion Blow
local spellThC	= 6343	-- Thunder Clap
local spellDeS	= 1160	-- Demoralizing Shout
local spellDev	= 20243	-- Devastate
-- buff
local buffThunderStruck	= GetSpellInfo(80980)	-- Thunderstruck
-- debuff
local debuffSunder	= GetSpellInfo(spellDev)	-- Sunder Armor
local debuffDemo	= GetSpellInfo(spellDeS)	-- Demoralizing Shout
local debuffRend	= GetSpellInfo(spellRen)	-- Rend
local debuffThunderClap	= GetSpellInfo(spellThC)	-- Thunder Clap


-- list of actions available for the priority list
-- it's a list of functions that return cooldowns based on current status values
local actions = {}
-- when an action is selected, return is spell with the id from this table
local listActionId = {
    HeS	= spellHeS,
    ShS	= spellShS,
    Rev	= spellRev,
    CoS	= spellCoS,
    Ren	= spellRen,
    ShW	= spellShW,
    CoB	= spellCoB,
    ThC	= spellThC,
    DeS	= spellDeS,
    Dev	= spellDev,
}
-- names to display in option screen
local listActionName = {
    HeS	= GetSpellInfo(spellHeS),
    ShS	= GetSpellInfo(spellShS),
    Rev	= GetSpellInfo(spellRev),
    CoS	= GetSpellInfo(spellCoS),
    Ren	= GetSpellInfo(spellRen),
    ShW	= GetSpellInfo(spellShW),
    CoB	= GetSpellInfo(spellCoB),
    ThC	= GetSpellInfo(spellThC),
    DeS	= GetSpellInfo(spellDeS),
    Dev	= GetSpellInfo(spellDev),
}

-- status values
--------------------------------------------------------------------------------
local _gcd		= 0	-- current gcd value
local _ctime		= 0	-- current GetTime value
local _rage		= 0	-- amount of rage :p
local _ragehs		= 0	-- rage needed before we hs
local _thunderstruck	= 0	-- thunderstruck duration
local _thunderstruckc	= 0	-- thunderstruck count
local _sunder		= 0	-- sunder armor duration
local _sunderc		= 0	-- sunder armor count
local _demo		= 0	-- demoralizing shout duration
local _rend		= 0	-- rend duration
local _thunderclap	= 0	-- thunder clap duration
--------------------------------------------------------------------------------

local pq, dq1, dq2
local debug = ""
local mode = "single"

-- this function, if it exists, will be called at init
function mod.OnInitialize()
    db = clcInfo:RegisterClassModuleDB(modName, defaults)
    db.priorityList = { "HeS", "CoS", "ShS", "Rev", "Ren", "ThC", "DeS", "ShW", "CoB", "Dev" } 
    mod.UpdatePriorityList()
end

function mod.UpdatePriorityList()
    pq = {}
    local check = {} -- used to check for duplicates
    for k, v in ipairs(db.priorityList) do
	if not check[v] then
	    if v ~= "none" and listActionId[v] then
		pq[#pq + 1] = { alias = v, id = listActionId[v] }
		check[v] = true
	    end
	end
    end
end

-- action functions
-- if a function can be selected, then the function must be here
--------------------------------------------------------------------------------
function actions.ShS()
    local start, duration = GetSpellCooldown(spellShS)
    local cd = start + duration - _ctime - _gcd
    return max(0, cd)
end

function actions.Rev()
    if IsUsableSpell(spellRev) then
	local start, duration = GetSpellCooldown(spellRev)
	local cd = start + duration - _ctime - _gcd
	return max(0, cd)
    else
	return 100
    end
end

function actions.CoS()
    local start, duration = GetSpellCooldown(spellCoS)
    local cd = start + duration - _ctime - _gcd
    cd = max(0, cd)

    if cd <= _gcd * 2 and _rage > 80 then cd = 100 end  -- rage check

    return cd
end

function actions.HeS()
    local start, duration = GetSpellCooldown(spellHeS)
    local cd = start + duration - _ctime
    return max(0, cd)
end

function actions.Ren()
    local start, duration = GetSpellCooldown(spellRen)
    local cd = start + duration - _ctime - _gcd
    cd = max(0, cd)

    if _rend <= _gcd then
	cd = max(0, cd)
    else
	cd = 100
    end

    return cd
end

function actions.ShW()
    local start, duration = GetSpellCooldown(spellShW)
    local ShWcd = start + duration - _ctime - _gcd
    ShWcd = max(0, ShWcd)
    local cd = ShWcd

    if _thunderstruckc > 0 and _thunderstruckc < 3 then
	start, duration = GetSpellCooldown(spellThC)
	local ThCcd = start + duration - _ctime - _gcd
	ThCcd = max(0, ThCcd)

	local thundertimeleft = _thunderstruck - _gcd

	if thundertimeleft < ThCcd then
	    cd = ShWcd
	else
	    if _thunderstruckc < 2 then
		cd = ThCcd + 30
	    else
		cd = max(ShWcd, ThCcd + _gcd)
	    end
	end
    end

    return cd
end

function actions.CoB()
    local start, duration = GetSpellCooldown(spellCoB)
    local cd = start + duration - _ctime - _gcd
    return max(0, cd)
end

function actions.ThC()
    local start, duration = GetSpellCooldown(spellThC)
    local ThCcd = start + duration - _ctime - _gcd
    ThCcd = max(0, ThCcd)
    local cd = ThCcd

    if _thunderstruckc > 2 then
	local thundertimeleft = _thunderstruck - _gcd
	if thundertimeleft > cd then cd = cd + _gcd end
    end

    --if have the Blood and Thunder talent
	local rendtimeleft = _rend - _gcd
	if rendtimeleft > cd then cd = cd + _gcd end
    --end

    local thunderclaptimeleft = _thunderclap - _gcd
    if thunderclaptimeleft < cd then cd = 0 end
    
    return max(cd, ThCcd)
end

function actions.DeS()
    local start, duration = GetSpellCooldown(spellDeS)
    local cd = start + duration - _ctime - _gcd

    local timeleft = _demo - 2 * _gcd

    return max(0, cd, timeleft)
end

function actions.Dev()
    local start, duration = GetSpellCooldown(spellDev)
    local cd = start + duration - _ctime - _gcd
    return max(0, cd)
end
--------------------------------------------------------------------------------

local function sortByCDs(t)
    local sorted = {}
    local check = {} -- used to check for duplicates

    for i = 1, #t do
        local j = 0
	for k, v in ipairs(t) do
	    if not check[v.alias] then
		if j == 0 or v.cd < t[j].cd then
		    j = k
		end
	    end
	end
	sorted[#sorted + 1] = t[j] -- { alias = t[j].alias, cd = t[j].cd }
	check[t[j].alias] = true
    end

    return sorted
end

mod.Rotation = {}
function mod.Rotation.single(ragehs)
    _ctime = GetTime()

    -- gcd
    local start, duration = GetSpellCooldown(spellGCD)
    _gcd = start + duration - _ctime
    if _gcd < 0 then _gcd = 0 end

    -- thunderstruck
    local _, _, _, count, _, _, expires = UnitBuff("player", buffThunderStruck)
    if count then _thunderstruckc = count else _thunderstruckc = 0 end
    if expires then _thunderstruck = expires - _ctime - _gcd else _thunderstruck = 0 end

    -- sunder armor
    local _, _, _, count, _, _, expires = UnitDebuff("target", debuffSunder)
    if count then _sunderc = count else _sunderc = 0 end
    if expires then _sunder = expires - _ctime - _gcd else _sunder = 0 end

    -- demoralizing shout
    local _, _, _, _, _, _, expires = UnitDebuff("target", debuffDemo)
    if expires then _demo = expires - _ctime - _gcd else _demo = 0 end

    -- rend
    local _, _, _, _, _, _, expires = UnitDebuff("target", debuffRend)
    if expires then _rend = expires - _ctime - _gcd else _rend = 0 end

    -- thunderclap
    local _, _, _, _, _, _, expires = UnitDebuff("target", debuffThunderClap)
    if expires then _thunderclap = expires - _ctime - _gcd else _thunderclap = 0 end

    for i, v in ipairs(pq) do
	v.cd = actions[v.alias]()

	if v.alias == "HeS" then
	    if  UnitPower("player") < (ragehs or 65) then
		v.cd = 100
	    end
	end
    end

    debug = ""
    local sortedpq = sortByCDs(pq)
    for i, v in ipairs(sortedpq) do
	if i > 1 then
	    debug = debug .. "\n"
	end
	debug = format("%s%s: %4d", debug, v.alias, v.cd)
	--if v.alias == pq[sel].alias then
	if i == 1 then
	    debug = debug .. "  1*"
	--elseif v.alias == pq[sel2].alias then
	elseif i == 2 then
	    debug = debug .. "  2-"
	end
    end

    dq1 = sortedpq[1].id
    dq2 = sortedpq[2].id

    return true
end

--------------------------------------------------------------------------------
-- function to be executed when OnUpdate is called manually
local function S2Exec()
    if not enabled then return end
    if dq2 ~= 0 then
	return emod.IconSpell(dq2, true)
    end
    return false
end

-- cleanup function for when exec changes
local function ExecCleanup()
    s2 = nil
end

function emod.IconProt1(...)
    local gotskill = false
    if enabled then
	gotskill = mod.Rotation[mode](...)
    end

    if s2 then UpdateS2(s2, 100) end    -- update with a big "elapsed" so it's updated on call
    if gotskill then
	return emod.IconSpell(dq1, true)
    end
end

function emod.IconProt2()
    -- remove this button's OnUpdate
    s2 = emod.___e
    UpdateS2 = s2:GetScript("OnUpdate")
    s2:SetScript("OnUpdate", nil)
    s2.exec = S2Exec
    s2.ExecCleanup = ExecCleanup
end

function emod.DebugTextProt(...)
    local gotskill = false
    if enabled then
	gotskill = mod.Rotation[mode](...)
    end

    if gotskill then
	return debug
    end
end

function emod.ProtMode() return mode end

-- protection
--------------------------------------------------------------------------------
mod:Add("icons", defs.CLASS_3, "Protection Rotation Skill 1", "return IconProt1(50)")
mod:Add("icons", defs.CLASS_3, "Protection Rotation Skill 2", "IconProt2()")