using UnityEngine;

public class Warn_300 : SMB_Base
{
    public int nextSkillID = -1;

    protected override void OnEnter(GActor owner, Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        base.OnEnter(owner, animator, stateInfo, layerIndex);
    }

    protected override void OnUpdate(GActor owner, Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        base.OnUpdate(owner, animator, stateInfo, layerIndex);

        if (owner is GA_NpcClientFightNorm)
        {
            GA_NpcClientFightNorm _owner = owner as GA_NpcClientFightNorm;

            if (stateInfo.normalizedTime > 1f)
            {
                if (nextSkillID != -1)
                {
                    Skill _skill = _owner.SkillMgr.Get(nextSkillID);
                    float length = 7.5f;
                    SkillHelper.EffectValue _effectValue;
                    if (_skill.skillInfo.effectValue.TryGetValue(2100, out _effectValue))
                    {
                        length = _effectValue.value1 * .5f;
                        Vector3 _end = owner.Pos + owner.Forward * length;

                        Vector3 _position = owner.Pos;
                        _position.y = 0;
                        _end.y = 0;
                        UnityEngine.AI.NavMeshHit _hit;
                        if (UnityEngine.AI.NavMesh.Raycast(_position, _end, out _hit, -1))
                        {
                            _end = _hit.position;
                        }
                        _end.y = owner.Pos.y;
                        _skill.targetPosition = _end;
                    }

                    if (_skill.skillInfo.config.Skillactmark != 0)
                    {
                        owner.SetAnimatorSpeed(1);
                        owner.NextAction = _skill.skillInfo.config.Skillactmark;
                        _owner.SkillMgr.CastSkill(_owner.ServerInstID, nextSkillID, true);

                        bool _canAttacked = false;

                        int _type = _skill.skillInfo.config.WarnInfo / 1000000;
                        if (_type > 200)
                        {
                            if (CollisionUtility.IsPointInRectangle(owner.Pos, owner.Forward, 4, length, PlayerDatas.Instance.hero.Pos)
                                && PlayerDatas.Instance.hero.State != E_ActorState.Roll)
                            {
                                _canAttacked = true;
                            }
                        }
                        else if (_type >= 100 && _type < 200)
                        {
                            float _distSqrt = MathUtility.DistanceSqrtXZ(owner.Pos, PlayerDatas.Instance.hero.Pos);
                            if (_distSqrt < _skill.skillInfo.config.AtkDist * _skill.skillInfo.config.AtkDist)
                            {
                                _canAttacked = true;
                            }
                        }
                        //Debug.LogFormat("=====================: {0}", PlayerDatas.Instance.hero.State);
                        if (_canAttacked)
                        {
                            uint hurtValue = 0;
                            byte attackType = 0;

                            AttackHandler.CalculateDamage(_owner, PlayerDatas.Instance.hero, _skill, 0, ref hurtValue, ref attackType);
                            AttackHandler.HurtObjs _hurtObject = new AttackHandler.HurtObjs
                            {
                                AttackType = attackType,
                                clientInstID = PlayerDatas.Instance.hero.ClientInstID,
                                CurHP = PlayerDatas.Instance.hero.ActorInfo.Hp,
                                CurHPEx = 0,
                                HurtHP = hurtValue,
                                ObjID = (uint)PlayerDatas.Instance.hero.ServerInstID,
                                ObjType = (byte)GameObjType.gotPlayer
                            };

                            _skill.hurtClientList.Add(_hurtObject);
                        }
                    }
                    _skill.SkillPreparing = false;
                }
            }
        }
    }

    protected override void OnExit(GActor owner, Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        base.OnExit(owner, animator, stateInfo, layerIndex);
        owner.SetAnimatorSpeed(1);
    }
}