void UpdateAI(const uint32 uiDiff) override
    {
        if (m_uiEventTimer)
        {
            if (m_uiEventTimer <= uiDiff)
            {
                switch (m_uiPhase)
                {
                    case 0:
                        DoSummonWave(NPC_SCOURGE_ARCHER);
                        m_uiEventTimer = 5000;
                        break;
                    case 1:
                        DoSummonWave();
                        m_uiEventTimer = urand(60000, 80000);
                        break;
                    default:
                        // The summoning timer of the soldiers isn't very clear
                        DoSummonWave(NPC_SCOURGE_FOOTSOLDIER);
                        m_uiEventTimer = urand(5000, 30000);
                        break;
                }
                ++m_uiPhase;
            }
            else
                m_uiEventTimer -= uiDiff;
        }

        // Handle event end in case of fail
        if (m_uiSadEndTimer)
        {
            if (m_uiSadEndTimer <= uiDiff)
            {
                DoScriptText(SAY_EVENT_FAIL_2, m_creature);
                m_creature->ForcedDespawn(5000);
                DoDespawnSummons();
                m_uiSadEndTimer = 0;
            }
            else
                m_uiSadEndTimer -= uiDiff;
        }
    }
    void DoHandlePhaseEnd()
    {
        if (Player* pPlayer = m_creature->GetMap()->GetPlayer(m_playerGuid))
            pPlayer->CastSpell(pPlayer, SPELL_BLESSING_OF_NORDRASSIL, true);

        DoScriptText(SAY_PHASE_HEAL, m_creature);

        // Send next wave
        if (m_uiCurrentWave < 5)
            DoSummonWave();
    }
    void UpdateFightAI(const uint32 uiDiff) override
    {
        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        // Berserk - both phases
        if (m_uiBerserkTimer <= uiDiff)
        {
            if (DoCastSpellIfCan(m_creature, SPELL_BERSERK) == CAST_OK)
            {
                DoScriptText(SAY_BERSERK, m_creature);
                m_uiBerserkTimer = 10 * MINUTE * IN_MILLISECONDS;
            }
        }
        else
            m_uiBerserkTimer -= uiDiff;

        // Death and Decay - both phases
        if (m_uiDeathAndDecayTimer <= uiDiff)
        {
            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 1))
            {
                if (DoCastSpellIfCan(pTarget, SPELL_DEATH_AND_DECAY) == CAST_OK)
                    m_uiDeathAndDecayTimer = 30000;
            }
        }
        else
            m_uiDeathAndDecayTimer -= uiDiff;

        // Dominate Mind - both phases
        if (m_uiMindControlCount)
        {
            if (m_uiDominateMindTimer <= uiDiff)
            {
                /* uncomment when spell implemented in core
                for (int i = 0; i < m_uiMindControlCount; ++i)
                {
                    if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 1))
                        DoCastSpellIfCan(pTarget, SPELL_DOMINATE_MIND, CAST_TRIGGERED);
                }*/

                DoScriptText(SAY_DOMINATE_MIND, m_creature);
                m_uiDominateMindTimer = 45000;
            }
            else
                m_uiDominateMindTimer -= uiDiff;
        }


         // PHASE ONE
        if (m_bIsPhaseOne)
        {
            // Mana Barrier check
            if (m_uiManaBarrierCheckTimer <= uiDiff)
            {
                // phase ends when Mana Barrier wears off
                if (!m_creature->HasAura(SPELL_MANA_BARRIER))
                {
                    DoScriptText(SAY_PHASE_TWO, m_creature);
                    SetCombatMovement(true);
                    m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim());
                    m_bIsPhaseOne = false;
                    return;
                }

                m_uiManaBarrierCheckTimer = 1000;
            }
            else
                m_uiManaBarrierCheckTimer -= uiDiff;

            // Summon wave
            if (m_uiSummonWaveTimer <= uiDiff)
            {
                DoSummonWave();
                m_uiSummonWaveTimer = 60000;
                DoScriptText(SAY_ANIMATE_DEAD, m_creature);
            }
            else
                m_uiSummonWaveTimer -= uiDiff;

            // Shadow Bolt
            if (m_uiShadowBoltTimer <= uiDiff)
            {
                if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
                {
                    if (DoCastSpellIfCan(pTarget, SPELL_SHADOW_BOLT) == CAST_OK)
                        m_uiShadowBoltTimer = 2000;
                }
            }
            else
                m_uiShadowBoltTimer -= uiDiff;
        }
        else // PHASE TWO
        {
            if (m_bIsHeroic)
            {
                // Summon wave
                if (m_uiSummonWaveTimer <= uiDiff)
                {
                    DoSummonWave();
                    m_uiSummonWaveTimer = 60000;
                    DoScriptText(SAY_ANIMATE_DEAD, m_creature);
                }
                else
                    m_uiSummonWaveTimer -= uiDiff;
            }

            // Touch of Insignificance
            if (m_uiTouchOfInsignificanceTimer <= uiDiff)
            {
                if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_INSIGNIFICANCE) == CAST_OK)
                    m_uiTouchOfInsignificanceTimer = urand(7000, 10000);
            }
            else
                m_uiTouchOfInsignificanceTimer -= uiDiff;

            // Frostbolt
            if (m_uiFrostboltTimer <= uiDiff)
            {
                if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
                {
                    if (DoCastSpellIfCan(pTarget, SPELL_FROSTBOLT) == CAST_OK)
                        m_uiFrostboltTimer = urand(5000, 10000);
                }
            }
            else
                m_uiFrostboltTimer -= uiDiff;

            // Frostbolt Volley
            if (m_uiFrostboltVolleyTimer <= uiDiff)
            {
                if (DoCastSpellIfCan(m_creature, SPELL_FROSTBOLT_VOLLEY) == CAST_OK)
                    m_uiFrostboltVolleyTimer = urand(15000, 20000);
            }
            else
                m_uiFrostboltVolleyTimer -= uiDiff;

            // Vengeful Shade
            if (m_uiVengefulShadeTimer <= uiDiff)
            {
                DoSummonShade();
                m_uiVengefulShadeTimer = 10000;
            }
            else
                m_uiVengefulShadeTimer -= uiDiff;

            // melee attack in 2nd phase only
            DoMeleeAttackIfReady();
        }
    }