using UnityEngine;
using System.Collections.Generic;
using Snxxz.UI;

public class GA_PVPClientPlayer : GActorPlayerBase, IOtherSelectable
{
    public static UnityEngine.Events.UnityAction<bool> OnPVPResult;

    private PlayerInfo info;

    private static bool doAILogic = false;

    public static void AutoAI(bool startOrStop)
    {
        doAILogic = startOrStop;
    }

    public void Init(uint serverInstID, uint clientInstID, PlayerInfo playerInfo, E_ActorGroup group)
    {
        info = playerInfo;

        Init(serverInstID, clientInstID, group, null);
    }

    public static void Result(bool winOrLose)
    {
#if UNITY_EDITOR
        Debug.Log(winOrLose ? "============ 赢了" : "============ 输了");
#endif

        if (OnPVPResult != null)
        {
            OnPVPResult(winOrLose);
        }
    }

    public static void Reset()
    {
        var _list = GAMgr.Instance.GetTypeList(E_ActorClassType.PVPClientPlayer);
        if (_list != null)
        {
            _list[0].ActorInfo.ResetHp((int)_list[0].ActorInfo.MaxHp);
            _list[0].ActorInfo.serverDie = false;
            _list[0].IdleImmediate();
        }

        PlayerDatas.Instance.FightRefreshPlayerHp((uint)PlayerDatas.Instance.extersion.MaxHP);
        PlayerDatas.Instance.hero.ActorInfo.ResetHp((int)PlayerDatas.Instance.extersion.MaxHP);
        PlayerDatas.Instance.hero.IdleImmediate();
    }

    int[] m_Skills1 = { 50000, 50100, 50200, 50300, 50400 };
    int[] m_Skills2 = { 55100, 55400, 55200, 55300, 55000 };

    protected override void OnInit(GameNetPackBasic package)
    {
        base.OnInit(package);

        CapsuleCollider _capCollider = Root.AddMissingComponent<CapsuleCollider>();
        _capCollider.height = 1.2f;
        _capCollider.center = new Vector3(0, .6f, 0);
        _capCollider.radius = .4f;

        Evt_PlayerClick _evtClick = Root.AddMissingComponent<Evt_PlayerClick>();
        _evtClick.ownerSID = ServerInstID;

        // 初始化坐标
        AdjustPos(PlayerDatas.Instance.baseData.PosX, PlayerDatas.Instance.baseData.PosY);

        ActorInfo.moveSpeed = 500f / 150;
        ActorInfo.atkSpeed = 1;

        JobSetup = JobSetupConfig.Get(info.job);
        CEquipInfo _itemInfo;
        if (info.itemDatas != null)
        {
            // 因为衣服是所有装备的父节点, 需要预先处理衣服
            for (int i = 0; i < info.itemDatas.Length; ++i)
            {
                _itemInfo = info.itemDatas[i];

                if (_itemInfo.place == (int)RoleEquipType.Clothes)
                {
                    SwitchClothes((uint)_itemInfo.id);
                    break;
                }
            }
        }

        // 如果没有任何衣服, 则穿上默认装备
        if (ClothesItemID == 0 || ClothesItemID == uint.MaxValue)
        {
            SwitchClothes(0);
        }

        if (info.itemDatas != null)
        {
            for (int i = 0; i < info.itemDatas.Length; ++i)
            {
                _itemInfo = info.itemDatas[i];

                if (_itemInfo.place == (int)RoleEquipType.Weapon)
                {
                    SwitchWeapon((uint)_itemInfo.id);
                }
                else if (_itemInfo.place == (int)RoleEquipType.Weapon2)
                {
                    SwitchSecondary((uint)_itemInfo.id);
                }
                else if (_itemInfo.place == (int)RoleEquipType.Wing)
                {
                    SwitchWing((uint)_itemInfo.id);
                }
            }
        }

        if (WeaponItemID == 0 || WeaponItemID == uint.MaxValue)
        {
            SwitchWeapon(0);
        }

        var _funcOpenLv = FuncOpenLVConfig.Get((int)FuncOpenEnum.CrossServer);

        int _ranVal = Random.Range(10, 101);
        int _lv = PlayerDatas.Instance.baseData.LV - _ranVal;
        int _limitLv = _funcOpenLv.LimitLV;
        ActorInfo.LV = (ushort)(_lv < _limitLv ? _limitLv : _lv);

        ActorInfo.Job = (byte)JobSetup.Job;
        ActorInfo.PlayerName = info.name;
        ActorInfo.MaxHp = info.hp;
        ActorInfo.Hp = info.maxHp;

        _ranVal = Random.Range(3, 6);
        int _realm = PlayerDatas.Instance.baseData.realmLevel - _ranVal;
        int _limitRealm = _funcOpenLv.LimiRealmLV;
        ActorInfo.realm = (uint)(_realm < _limitRealm ? _limitRealm : _realm);

        RequestName();

        IdleImmediate();
    }

    public override void Destroy()
    {
    }

    protected sealed override void OnUpdate()
    {
        if (ActorInfo.serverDie)
        {
            return;
        }

        base.OnUpdate();

        UpdateAI();

        if (ActorInfo.RealHp <= 0)
        {
            ActorInfo.serverDie = true;
            Result(true);
        }
    }

    protected sealed override void OnUnit()
    {
        base.OnUnit();
    }

    public sealed override void OnHorse(byte upOrDown) { }

    public sealed override void RefreshLifeBar(ulong value)
    {
        GA_Hero _hero = PlayerDatas.Instance.hero;
        if (_hero != null && _hero.SelectTarget == this)
        {
            if (GA_Player.s_OnRefreshLife != null)
            {
                GA_Player.s_OnRefreshLife(ServerInstID, ActorInfo.RealHp, ActorInfo.RealMaxHp);
            }
        }
    }

    public sealed override void RequestName()
    {
        ReleaseName();
        if (MovingState == E_MovingState.Ride)
        {
            m_HeadUpName = HeadUpName.RequireHeadUpName(HeadUpName.Pattern.Player, MP_Name1, 0, CameraController.Instance.CameraObject);
        }
        else
        {
            m_HeadUpName = HeadUpName.RequireHeadUpName(HeadUpName.Pattern.Player, MP_Name, 0, CameraController.Instance.CameraObject);
        }

        m_HeadUpName.SetPlayerInfo((int)ActorInfo.realm, ActorInfo.titleID, ActorInfo.PlayerName, ActorInfo.familyName, false);
    }

    protected sealed override void OnPutonClothes(uint clothesItemID, GameObject clothed)
    {
        clothed.layer = LayerUtility.Player;

        SkinnedMeshRenderer _renderer = clothed.GetComponentInChildren<SkinnedMeshRenderer>();
        _renderer.gameObject.SetLayer(LayerUtility.Player, false);
    }

    protected sealed override void OnPutonSecondary(uint secondaryItemID, GameObject secondary)
    {
        Renderer _renderer = secondary.GetComponentInChildren<Renderer>();
        _renderer.gameObject.SetLayer(LayerUtility.Player, false);
    }

    protected sealed override void OnPutonWeapon(uint weaponItemID, GameObject weapon)
    {
        Renderer _renderer = weapon.GetComponentInChildren<Renderer>();
        _renderer.gameObject.SetLayer(LayerUtility.Player, false);
    }

    protected sealed override void OnPutonWing(uint wingItemID, GameObject wing)
    {
        SkinnedMeshRenderer _renderer = wing.GetComponentInChildren<SkinnedMeshRenderer>();
        _renderer.gameObject.SetLayer(LayerUtility.Player, false);
    }

    protected sealed override void OnSwitchHorse(uint horseID, GameObject horse)
    {
    }

    public sealed override bool CanAtked() { return !ActorInfo.serverDie; }

    public bool CanBeSelected()
    {
        if (ActorInfo.serverDie)
        {
            return false;
        }

        return true;
    }

    public void OnClick()
    {
        if (ActorInfo.serverDie)
        {
            return;
        }

        GA_Hero _hero = PlayerDatas.Instance.hero;
        if (_hero == null)
        {
            return;
        }

        _hero.LockTarget = this;
        _hero.SelectTarget = this;
    }

    public void OnSelect()
    {
        if (CanAtked())
        {
            SelectionManager.Request(SelectionManager.E_Type.Red, this);
        }
        else
        {
            SelectionManager.Request(SelectionManager.E_Type.Green, this);
        }

        if (GA_Player.s_OnSelected != null)
        {
            GA_Player.s_OnSelected(ServerInstID, true);
        }
    }

    public void OnUnSelect()
    {
        SelectionManager.Release(SelectionManager.E_Type.Green);
        SelectionManager.Release(SelectionManager.E_Type.Red);

        if (GA_Player.s_OnSelected != null)
        {
            GA_Player.s_OnSelected(ServerInstID, false);
        }
    }

    public sealed override void SyncSuitEffect(bool onOrOff = true) { }

    private float m_LastAttackTime;
    private int m_ComAtkIndex;

    DungeonModel m_DungeonModel;
    DungeonModel dungeonModel
    {
        get
        {
            return m_DungeonModel ?? (m_DungeonModel = ModelCenter.Instance.GetModel<DungeonModel>());
        }
    }

    private void UpdateAI()
    {
#if UNITY_EDITOR
        if (!RuntimeLogUtility.TEST_CLIENT_PVP_AI)
        {
            return;
        }
#endif

        if (dungeonModel.dungeonFightStage != DungeonFightStage.Normal
        || !doAILogic)
        {
            return;
        }

        SelectTarget = PlayerDatas.Instance.hero;

        if (SelectTarget == null || SelectTarget.ActorInfo.serverDie)
        {
            return;
        }

        // 攻击间隔中
        if (Time.time - m_LastAttackTime
          < (1f / ActorInfo.atkSpeed) * .8f)
        {
            return;
        }

        Skill _skill = SkillMgr.CurCastSkill;

        // 判断主角当前是否有技能尚未释放完毕
        if (_skill != null)
        {
            if (!_skill.SkillCompelete)
            {
                return;
            }

            if (SkillMgr.DoingPrepareSkill)
            {
                return;
            }
        }

        int[] _skills = JobSetup.Job == 1 ? m_Skills1 : m_Skills2;

        for (int i = 0; i < _skills.Length; ++i)
        {
            _skill = SkillMgr.Get(_skills[i]);
            if (_skill.IsValid())
            {
                break;
            }
            else
            {
                _skill = null;
            }
        }

        if (_skill == null)
        {
            if (m_ComAtkIndex > JobSetup.ComAtkIdList.Length - 1)
            {
                m_ComAtkIndex = 0;
            }
            int _comSkillId = JobSetup.ComAtkIdList[m_ComAtkIndex];
            _skill = SkillMgr.Get(_comSkillId);
            m_ComAtkIndex += 1;
        }

        // 判断技能范围, 不在可释放范围需要移动至目标
        float _compareDist = _skill.skillInfo.config.AtkDist * .5f;
        float _compareDistSqrt = _compareDist * _compareDist;

        // 计算当前和目标的距离
        float _currentDistSqrt = MathUtility.DistanceSqrtXZ(Pos, SelectTarget.Pos);
        // 比较距离
        if (_currentDistSqrt >= _compareDistSqrt)
        {
            // 移动至目标
            MoveToTarget(SelectTarget, _compareDist, true);

            return;
        }

        Vector3 _forward = MathUtility.ForwardXZ(SelectTarget.Pos, Pos);
        destForward = Forward = _forward;

        Vector3 _targetPosition = Pos + Forward * (_skill.skillInfo.config.AtkDist * .5f);
        _targetPosition.y = 0;
        UnityEngine.AI.NavMeshHit _navMeshHit;
        if (UnityEngine.AI.NavMesh.Raycast(Pos, _targetPosition, out _navMeshHit, -1))
        {
            _targetPosition = _navMeshHit.position;
        }
        _targetPosition.y = Pos.y;
        _skill.targetPosition = _targetPosition;

        E_SkillCastType _castType = (E_SkillCastType)(_skill.skillInfo.config.Tag % 10);
        if (_castType == E_SkillCastType.NeedTarget)
        {
            _skill.targetPosition = SelectTarget.Pos;
            _skill.mainTarget = SelectTarget as GActorFight;
        }

        SkillMgr.CastSkill(ServerInstID, _skill.id);

        if (_skill.skillInfo.config.Skillactmark > 0
                     && _skill.skillInfo.config.Skillactmark < 20)
        {
            switch (_skill.skillInfo.config.Skillactmark)
            {
                case 10:
                    Play(GAStaticDefine.State_Attack1Hash, 0);
                    break;
                case 11:
                    Play(GAStaticDefine.State_Attack2Hash, 0);
                    break;
                case 12:
                    Play(GAStaticDefine.State_Attack3Hash, 0);
                    break;
                case 13:
                    Play(GAStaticDefine.State_Attack4Hash, 0);
                    break;
            }

        }
        else
        {
            switch (_skill.skillInfo.config.Skillactmark)
            {
                case 21:
                    Play(GAStaticDefine.State_Skill21, 0);
                    break;
                case 22:
                    Play(GAStaticDefine.State_Skill22, 0);
                    break;
                case 23:
                    Play(GAStaticDefine.State_Skill23, 0);
                    break;
                case 24:
                    Play(GAStaticDefine.State_Skill24, 0);
                    break;
                case 25:
                    Play(GAStaticDefine.State_Skill25, 0);
                    break;
                case 26:
                    Play(GAStaticDefine.State_Skill26, 0);
                    break;
                case 27:
                    Play(GAStaticDefine.State_Skill27, 0);
                    break;
                case 28:
                    Play(GAStaticDefine.State_Skill28, 0);
                    break;
                case 29:
                    Play(GAStaticDefine.State_Skill29, 0);
                    break;
                case 99:
                    Play(GAStaticDefine.State_RollHash, 0);
                    break;
            }
        }

        uint hurtValue = 0;
        byte attackType = 0;

        AttackHandler.CalculateDamage(this, SelectTarget as GActorFight,
                                      _skill,
                                      0,
                                      ref hurtValue, ref attackType);

        AttackHandler.HurtObjs _hurtObject = new AttackHandler.HurtObjs
        {
            AttackType = attackType,
            clientInstID = SelectTarget.ClientInstID,
            CurHP = SelectTarget.ActorInfo.Hp,
            CurHPEx = SelectTarget.ActorInfo.HpEx,
            HurtHP = hurtValue,
            ObjID = SelectTarget.ServerInstID,
            ObjType = (byte)SelectTarget.ActorType
        };

        _skill.hurtClientList.Add(_hurtObject);

        m_LastAttackTime = Time.time;
    }
}