/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#include "ScriptMgr.h"
#include "baradin_hold.h"
#include "InstanceScript.h"
#include "MotionMaster.h"
#include "ObjectAccessor.h"
#include "Player.h"
#include "ScriptedCreature.h"

enum Texts
{
    SAY_INTRO               = 1,
    SAY_AGGRO               = 2,
    SAY_HATE                = 3,
    SAY_SKEWER              = 4,
    SAY_SKEWER_ANNOUNCE     = 5,
    SAY_BLADE_STORM         = 6,
    SAY_SLAY                = 10,
    SAY_DEATH               = 12
};

enum Spells
{
    SPELL_BLADE_DANCE       = 105784,
    SPELL_BLADE_DANCE_DUMMY = 105828,
    SPELL_SEETHING_HATE     = 105067,
    SPELL_SKEWER            = 104936,
    SPELL_BERSERK           = 47008
};

enum Actions
{
    ACTION_INTRO            = 1
};

enum Points
{
    POINT_STORM             = 1
};

enum Events
{
    EVENT_RANDOM_CAST       = 1,
    EVENT_STOP_STORM        = 2,
    EVENT_MOVE_STORM        = 3,
    EVENT_CAST_STORM        = 4
};

class at_alizabal_intro : public AreaTriggerScript
{
    public:
        at_alizabal_intro() : AreaTriggerScript("at_alizabal_intro") { }

        bool OnTrigger(Player* player, AreaTriggerEntry const* /*areaTrigger*/) override
        {
            if (InstanceScript* instance = player->GetInstanceScript())
                if (Creature* alizabal = instance->GetCreature(BOSS_ALIZABAL))
                    alizabal->AI()->DoAction(ACTION_INTRO);
            return true;
        }
};

class boss_alizabal : public CreatureScript
{
    public:
        boss_alizabal() : CreatureScript("boss_alizabal") { }

        struct boss_alizabalAI : public BossAI
        {
            boss_alizabalAI(Creature* creature) : BossAI(creature, BOSS_ALIZABAL) { }

            void Reset() override
            {
                _Reset();
                _hate = false;
                _skewer = false;
            }

            void JustEngagedWith(Unit* who) override
            {
                BossAI::JustEngagedWith(who);
                Talk(SAY_AGGRO);
                instance->SendEncounterUnit(ENCOUNTER_FRAME_ENGAGE, me);
                events.ScheduleEvent(EVENT_RANDOM_CAST, 10s);
            }

            void JustDied(Unit* /*killer*/) override
            {
                _JustDied();
                Talk(SAY_DEATH);
                instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
            }

            void KilledUnit(Unit* who) override
            {
                if (who->GetTypeId() == TYPEID_PLAYER)
                    Talk(SAY_SLAY);
            }

            void EnterEvadeMode(EvadeReason /*why*/) override
            {
                instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
                me->GetMotionMaster()->MoveTargetedHome();
                _DespawnAtEvade();
            }

            void DoAction(int32 action) override
            {
                switch (action)
                {
                    case ACTION_INTRO:
                        if (!_intro)
                        {
                            Talk(SAY_INTRO);
                            _intro = true;
                        }
                        break;
                }
            }

            void MovementInform(uint32 /*type*/, uint32 pointId) override
            {
                switch (pointId)
                {
                    case POINT_STORM:
                        events.ScheduleEvent(EVENT_CAST_STORM, 1ms);
                        break;
                }
            }

            void UpdateAI(uint32 diff) override
            {
                if (!UpdateVictim())
                    return;

                events.Update(diff);

                while (uint32 eventId = events.ExecuteEvent())
                {
                    switch (eventId)
                    {
                        case EVENT_RANDOM_CAST:
                            switch (urand(0, 1))
                            {
                                case 0:
                                    if (!_skewer)
                                    {
                                        if (Unit* target = SelectTarget(SelectTargetMethod::MaxThreat, 0))
                                        {
                                            DoCast(target, SPELL_SKEWER, true);
                                            Talk(SAY_SKEWER);
                                            Talk(SAY_SKEWER_ANNOUNCE, target);
                                        }
                                        _skewer = true;
                                        events.ScheduleEvent(EVENT_RANDOM_CAST, 7s, 10s);
                                    }
                                    else if (!_hate)
                                    {
                                        if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, NonTankTargetSelector(me)))
                                        {
                                            DoCast(target, SPELL_SEETHING_HATE, true);
                                            Talk(SAY_HATE);
                                        }
                                        _hate = true;
                                        events.ScheduleEvent(EVENT_RANDOM_CAST, 7s, 10s);
                                    }
                                    else if (_hate && _skewer)
                                    {
                                        Talk(SAY_BLADE_STORM);
                                        DoCastAOE(SPELL_BLADE_DANCE_DUMMY);
                                        DoCastAOE(SPELL_BLADE_DANCE);
                                        events.ScheduleEvent(EVENT_RANDOM_CAST, 21s);
                                        events.ScheduleEvent(EVENT_MOVE_STORM, 4050ms);
                                        events.ScheduleEvent(EVENT_STOP_STORM, 13s);
                                    }
                                    break;
                                case 1:
                                    if (!_hate)
                                    {
                                        if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, NonTankTargetSelector(me)))
                                        {
                                            DoCast(target, SPELL_SEETHING_HATE, true);
                                            Talk(SAY_HATE);
                                        }
                                        _hate = true;
                                        events.ScheduleEvent(EVENT_RANDOM_CAST, 7s, 10s);
                                    }
                                    else if (!_skewer)
                                    {
                                        if (Unit* target = SelectTarget(SelectTargetMethod::MaxThreat, 0))
                                        {
                                            DoCast(target, SPELL_SKEWER, true);
                                            Talk(SAY_SKEWER);
                                            Talk(SAY_SKEWER_ANNOUNCE, target);
                                        }
                                        _skewer = true;
                                        events.ScheduleEvent(EVENT_RANDOM_CAST, 7s, 10s);
                                    }
                                    else if (_hate && _skewer)
                                    {
                                        Talk(SAY_BLADE_STORM);
                                        DoCastAOE(SPELL_BLADE_DANCE_DUMMY);
                                        DoCastAOE(SPELL_BLADE_DANCE);
                                        events.ScheduleEvent(EVENT_RANDOM_CAST, 21s);
                                        events.ScheduleEvent(EVENT_MOVE_STORM, 4050ms);
                                        events.ScheduleEvent(EVENT_STOP_STORM, 13s);
                                    }
                                    break;
                            }
                            break;
                        case EVENT_MOVE_STORM:
                            me->SetSpeedRate(MOVE_RUN, 4.0f);
                            me->SetSpeedRate(MOVE_WALK, 4.0f);
                            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, NonTankTargetSelector(me)))
                                me->GetMotionMaster()->MovePoint(POINT_STORM, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ());
                            events.ScheduleEvent(EVENT_MOVE_STORM, 4050ms);
                            break;
                        case EVENT_STOP_STORM:
                            me->RemoveAura(SPELL_BLADE_DANCE);
                            me->RemoveAura(SPELL_BLADE_DANCE_DUMMY);
                            me->SetSpeedRate(MOVE_WALK, 1.0f);
                            me->SetSpeedRate(MOVE_RUN, 1.14f);
                            me->GetMotionMaster()->MoveChase(me->GetVictim());
                            _hate = false;
                            _skewer = false;
                            break;
                        case EVENT_CAST_STORM:
                            DoCastAOE(SPELL_BLADE_DANCE);
                            break;
                    }
                }
            }

        private:
            bool _intro = false;
            bool _hate = false;
            bool _skewer = false;
        };

        CreatureAI* GetAI(Creature* creature) const override
        {
            return GetBaradinHoldAI<boss_alizabalAI>(creature);
        }
};

void AddSC_boss_alizabal()
{
    new boss_alizabal();
    new at_alizabal_intro();
}