using Snxxz.UI;
using TableConfig;
using UnityEngine;
using UnityEngine.Events;

public class GA_Hero : GActorPlayerBase, ICtrlGA
{
    public static Vector3 MapOffset;
    public static bool s_MapSwitching = false;
    //public static bool s_MapSwitching
    //{
    //    get
    //    {
    //        return _s_MapSwitching;
    //    }
    //    set
    //    {
    //        _s_MapSwitching = value;
    //        Debug.Log("---------- MapSwitching: " + value);
    //    }
    //}

    /// <summary>
    /// 当切换锁定目标的时候, 为空的时候id=0
    /// </summary>
    public static event UnityAction<uint> OnLockTargetChanged;
    /// <summary>
    /// 当用户点击了技能按钮, 并切技能可以释放的时候调用
    /// </summary>
    public static event UnityAction<int> OnUserClickSkill;
    public static event UnityAction<uint, string> OnKillPlayer;

    private GameObject m_Light;
    public static bool forceAutoFight;
    /// <summary>
    /// 锁定目标对象
    /// 用户点击锁定, 被攻击锁定攻击者...
    /// </summary>
    private GActor m_LockTarget;
    public GActor LockTarget
    {
        get { return m_LockTarget; }
        set
        {
            if (m_LockTarget == value)
            {
                return;
            }
            m_LockTarget = value;

            if (OnLockTargetChanged != null)
            {
                if (m_LockTarget != null)
                {
                    OnLockTargetChanged(m_LockTarget.ServerInstID);
                }
                else
                {
                    OnLockTargetChanged(0);
                }
            }
        }
    }

    public MapArea currentBossArea;

    private uint _atkBossID;
    public uint atkBossID
    {
        get
        {
            return _atkBossID;
        }
        set
        {
            if (_atkBossID != value)
            {
                _atkBossID = value;
                //if (_atkBossID != 0)
                //{
                //    Debug.LogFormat("设置攻击的bossID: {0}", atkBossID);
                //}
                //else
                //{
                //    Debug.LogFormat("清空bossID");
                //}
            }
        }
    }

    public sealed override int NextAction
    {
        get
        {
            return base.NextAction;
        }

        set
        {
            base.NextAction = value;
        }
    }

    public sealed override GActor SelectTarget
    {
        get
        {
            return base.SelectTarget;
        }

        set
        {
            if (base.SelectTarget == value)
            {
                return;
            }

            IOtherSelectable _selectable = base.SelectTarget as IOtherSelectable;
            if (_selectable != null)
            {
                _selectable.OnUnSelect();
            }

            _selectable = value as IOtherSelectable;

            if (_selectable != null)
            {
                _selectable.OnSelect();
            }

            base.SelectTarget = value;
        }
    }

    public HeroBehaviour Behaviour;
    public HeroAIHandler aiHandler;
    private Bhv_FindEnemy m_BhvFindEnemy;
    private float m_LastSyncTickTime = 0;

    protected sealed override void OnInit(GameNetPackBasic package)
    {
        CharacterController _charCtrl = Root.AddMissingComponent<CharacterController>();
        _charCtrl.height = 1.2f;
        _charCtrl.center = new Vector3(0, .6f, 0);
        _charCtrl.radius = .4f;

        Root.gameObject.layer = LayerUtility.Hero;

        m_BhvFindEnemy = Root.AddMissingComponent<Bhv_FindEnemy>();

        JobSetup = ConfigManager.Instance.GetTemplate<JobSetupConfig>(PlayerDatas.Instance.baseData.Job);
        Behaviour = new HeroBehaviour(this);
        aiHandler = new HeroAIHandler();

        base.OnInit(package);

        ActorInfo.familyID = PlayerDatas.Instance.baseData.Family;

        OnPathFinding += MapTransferUtility.Instance.OnHeroPathFinding;

        UserInputHandler.OnCirclePanelTouched += OnCirclePanelTouched;
        UserInputHandler.OnClickedFloor += OnClickedFloor;
        HeroBehaviour.OnStopHandupAI += OnStopHandupAI;

        m_CalculAutoFightTime = Time.realtimeSinceStartup;

        m_LastSyncTickTime = Time.realtimeSinceStartup;
    }

    protected sealed override void OnUnit()
    {
        Object.Destroy(m_BhvFindEnemy);
        m_BhvFindEnemy = null;

        OnPathFinding -= MapTransferUtility.Instance.OnHeroPathFinding;
        OnPathFindStop -= MapTransferUtility.Instance.OnHeroStopPathFind;

        Behaviour = null;
        m_LockTarget = null;

        MaterialUtility.SwitchXrayShader(m_Material, false);
        MaterialUtility.SwitchXrayShader(m_WingMaterial, false);
        MaterialUtility.SwitchXrayShader(m_HorseMaterial, false);
        MaterialUtility.SwitchXrayShader(m_WeaponMaterial, false);
        MaterialUtility.SwitchXrayShader(m_SecondaryMaterial, false);

        m_WingMaterial = null;
        m_HorseMaterial = null;
        m_WeaponMaterial = null;
        m_SecondaryMaterial = null;

        ReleaseLight();

        base.OnUnit();
    }

    public sealed override void Destroy()
    {
    }

    public float forceAutoFightTime;

    protected sealed override void OnUpdate()
    {
        base.OnUpdate();

        if (forceAutoFight
#if UNITY_EDITOR
            && RuntimeLogUtility.s_forceAutoFight
#endif
            )
        {
            if (!aiHandler.IsAuto() && !BossShowModel.Instance.BossShowing)
            {
                if (Time.realtimeSinceStartup - forceAutoFightTime > 3)
                {
                    Behaviour.StartHandupAI();
                }
            }
        }

        aiHandler.Update();

        bool _isCastSkill = false;

        if (SkillMgr.CurCastSkill != null)
        {
            _isCastSkill = !SkillMgr.CurCastSkill.SkillCompelete;
        }

        // 每隔1分钟同步一次tick
        if (Time.realtimeSinceStartup - m_LastSyncTickTime > 60)
        {
            PlayerDatas.Instance.RequestWorldTick();
            m_LastSyncTickTime = Time.realtimeSinceStartup;
        }

        if ((IsRun() || IsIdle() || UserInputHandler.isTouched) && UserInputHandler.IsMoveValid())
        {
            float _distance = MathUtility.DistanceSqrtXZ(PrevPos, Pos);
            if (_distance > 0.25f)
            {
                PrevPos = Pos;
                UserInputHandler.Send_CB409_tagCMPyMove();
            }
        }

        if (PlayerDatas.Instance.extersion.bossState == 1)
        {
            GA_Player _player = SelectTarget as GA_Player;
            if (_player != null)
            {
                foreach (var _key in DungeonStage.s_MapAreaDict.Keys)
                {
                    if ((int)_key >= 3000)
                    {
                        var _areaList = DungeonStage.s_MapAreaDict[_key];
                        if (_areaList != null)
                        {
                            MapArea _area = null;
                            for (int i = 0; i < _areaList.Count; ++i)
                            {
                                _area = _areaList[i];
                                if (_area == currentBossArea)
                                {
                                    if (_area.IsPosOut(_player.Pos))
                                    {
                                        LockTarget = SelectTarget = null;
                                        if (atkBossID != 0)
                                        {
                                            MapTransferUtility.Instance.MoveToNPC((int)atkBossID);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

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

    protected sealed override void OnLateUpdate()
    {
        base.OnLateUpdate();

        UpdateAutoStartFight();
    }

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

        SkinnedMeshRenderer _renderer = clothed.GetComponentInChildren<SkinnedMeshRenderer>();
        _renderer.gameObject.SetLayer(LayerUtility.Hero, false);
        MaterialUtility.SwitchXrayShader(m_Material, true);
        GameObjectPoolManager.Instance.AddDontDestroyGoInstID(clothed.GetInstanceID());

        StopRush();

        Behaviour.StopKillUntilDieAI();

    }

    protected sealed override void OnPutonSecondary(uint secondaryItemID, GameObject secondary)
    {
        Renderer _renderer = secondary.GetComponent<Renderer>();
        if (_renderer)
        {
            _renderer.gameObject.SetLayer(LayerUtility.Hero, false);
            m_SecondaryMaterial = _renderer.material;
            MaterialUtility.SwitchXrayShader(m_SecondaryMaterial, true);
        }
        GameObjectPoolManager.Instance.AddDontDestroyGoInstID(secondary.GetInstanceID());
    }

    protected sealed override void OnPutonWeapon(uint weaponItemID, GameObject weapon)
    {
        Renderer _renderer = weapon.GetComponent<Renderer>();
        if (_renderer)
        {
            _renderer.gameObject.SetLayer(LayerUtility.Hero, false);
            m_WeaponMaterial = _renderer.material;
            MaterialUtility.SwitchXrayShader(m_WeaponMaterial, true);
        }
        GameObjectPoolManager.Instance.AddDontDestroyGoInstID(weapon.GetInstanceID());
    }

    protected sealed override void OnPutonWing(uint wingItemID, GameObject wing)
    {
        wing.gameObject.layer = LayerUtility.Hero;

        SkinnedMeshRenderer _renderer = wing.GetComponentInChildren<SkinnedMeshRenderer>();
        _renderer.gameObject.SetLayer(LayerUtility.Hero, false);
        m_WingMaterial = _renderer.material;
        MaterialUtility.SwitchXrayShader(m_WingMaterial, true);

        GameObjectPoolManager.Instance.AddDontDestroyGoInstID(wing.GetInstanceID());
    }

    protected sealed override void OnSwitchHorse(uint horseID, GameObject horse)
    {
        horse.layer = LayerUtility.Hero;

        SkinnedMeshRenderer _renderer = horse.GetComponentInChildren<SkinnedMeshRenderer>();
        _renderer.gameObject.SetLayer(LayerUtility.Hero, false);
        m_HorseMaterial = _renderer.material;
        MaterialUtility.SwitchXrayShader(m_HorseMaterial, true);

        GameObjectPoolManager.Instance.AddDontDestroyGoInstID(horse.GetInstanceID());
    }

    public override void OnHorse(byte upOrDown)
    {
        if (upOrDown == 1)
        {
            PlayerPackModel _packModel = ModelCenter.Instance.GetModel<PlayerPackModel>();
            SinglePackModel _horsePackModel = _packModel.GetSinglePackModel(PackType.rptEquip);
            if (_horsePackModel != null)
            {
                ItemModel _horseItem = _horsePackModel.GetItemModelByIndex((int)RoleEquipType.mount);
                SwitchHorse((uint)_horseItem.itemInfo.ItemID);
            }
        }
        else
        {
            SwitchHorse(0);
        }
    }

    public sealed override void RefreshLifeBar(uint value) { }

    public override void RequestName()
    {
        ReleaseName();

        if (MovingState == E_MovingState.Ride)
        {
            m_HeadUpName = HeadUpName.RequireHeadUpName(HeadUpName.Pattern.Hero, MP_Name1, 0, CameraController.Instance.CameraObject);
        }
        else
        {
            m_HeadUpName = HeadUpName.RequireHeadUpName(HeadUpName.Pattern.Hero, MP_Name, 0, CameraController.Instance.CameraObject);
        }

        // 称号
        var titleModel = ModelCenter.Instance.GetModel<TitleModel>();
        var _title = titleModel.GetTitleEquip();
        uint _titleID = 0;
        if (_title != null && titleModel.IsTitleGain(_title.id))
        {
            _titleID = (uint)_title.id;
        }

        var _familyName = string.Empty;
        // 仙盟
        if (PlayerDatas.Instance.baseData.Family != 0)
        {
            _familyName = PlayerDatas.Instance.baseData.FamilyName;
        }

        m_HeadUpName.SetPlayerInfo(PlayerDatas.Instance.baseData.realmLevel, _titleID, PlayerDatas.Instance.baseData.PlayerName, _familyName, false);

        if (StatusMgr.Instance.IsExist(ServerInstID, StatusMgr.Instance.bossBelongBuffID))
        {
            m_HeadUpName.SetBossDropout(true);
        }

        base.SetFairyLeagueHeadUp(PlayerDatas.Instance.baseData.MapID == FairyLeagueModel.FAIRY_LEAGUE_DUNGEON);
    }

    public sealed override void SwitchRedName(bool on)
    {
        if (PlayerDatas.Instance.baseData.MapID == FairyLeagueModel.FAIRY_LEAGUE_DUNGEON)
        {
            return;
        }
        base.SwitchRedName(on);
    }

    public sealed override void SwitchYellowName(bool on)
    {
        if (PlayerDatas.Instance.baseData.MapID == FairyLeagueModel.FAIRY_LEAGUE_DUNGEON)
        {
            return;
        }
        base.SwitchYellowName(on);
    }

    public sealed override void Die()
    {
        LockTarget = null;
        SelectTarget = null;

        base.Die();
    }

    public sealed override void Collect()
    {
        if (ActorInfo.serverDie)
        {
            return;
        }

        base.Collect();

        Behaviour.StopKillUntilDieAI();
        Behaviour.StopHandupAI();
    }

    public bool CanMove()
    {
        if (IsHurt()
         || IsRushing
         || ActorInfo.serverDie
         || State == E_ActorState.Mocked
         || IsDaZuo()
         || BossShowModel.Instance.BossShowing
         || heavenBattleModel.IsBattlePrepare)
        {
            return false;
        }

        if (StatusMgr.IsValid()
        && !StatusMgr.Instance.CanMove(ServerInstID))
        {
            return false;
        }

        if (State == E_ActorState.Idle
         || State == E_ActorState.AutoRun
         || State == E_ActorState.CtrlRun)
        {
            return true;
        }

        return false;
    }

    public bool CanRotate()
    {
        return State != E_ActorState.Mocked
            && !IsDaZuo();
    }

    private HeavenBattleModel m_HeavenBattleModel = null;
    public HeavenBattleModel heavenBattleModel
    {
        get
        {
            return m_HeavenBattleModel ?? (m_HeavenBattleModel = ModelCenter.Instance.GetModel<HeavenBattleModel>());
        }
    }

    public bool CanCommonAtk()
    {
        return !MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.Safe)
            && !MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.RebornSafe)
            && !IsStun()
            && !IsHurt()
            && !IsDaZuo()
            && State != E_ActorState.Roll
            && !s_MapSwitching
            && !heavenBattleModel.IsBattlePrepare
            && !m_Beating;
    }

    public bool CanCastSkill()
    {
        return !MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.Safe)
            && !MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.RebornSafe)
            && !IsStun()
            && !IsHurt()
            && !IsDaZuo()
            && State != E_ActorState.Roll
            && State != E_ActorState.Mocked
            && !s_MapSwitching
            && !heavenBattleModel.IsBattlePrepare
            && !m_Beating;
    }

    public void StopAll()
    {
        Behaviour.StopHandupAI();
        Behaviour.StopKillUntilDieAI();

        if (State == E_ActorState.AutoRun
         || PathFindStatus == E_PathFindStatus.Moving)
        {
            StopPathFind();
        }

        if (!ActorInfo.serverDie)
        {
            IdleImmediate();
        }
    }

    public void SwitchTarget()
    {
        if (m_BhvFindEnemy)
        {
            m_BhvFindEnemy.SwitchTarget();
        }
    }

    public void RequestLight()
    {
        ReleaseLight();
        if (PlayerDatas.Instance.baseData.MapID == 31160)
        {
            m_Light = Object.Instantiate(Resources.Load<GameObject>("Prefabs/Zhujiao_Pointlight"));
            m_Light.transform.SetParent(MP_Name);
            m_Light.transform.localPosition = Vector3.zero;
            m_Light.transform.localScale = Vector3.one;
            m_Light.transform.localRotation = Quaternion.identity;
        }
    }

    public void ReleaseLight()
    {
        if (m_Light)
        {
            Object.Destroy(m_Light);
            m_Light = null;
        }
    }

    public void KillPlayer(uint sid, string name)
    {
#if UNITY_EDITOR
        Debug.LogFormat("杀死了玩家: {0}, {1}", sid, name);
#endif
        if (OnKillPlayer != null)
        {
            OnKillPlayer(sid, name);
        }
    }

    #region 地图区域相关处理

    private int m_CurMapArea = 1 << (int)MapArea.E_Type.Normal;
    public int CurMapArea
    {
        get
        {
            return m_CurMapArea;
        }
        set
        {
            m_CurMapArea = value;
        }
    }

    public static UnityAction<MapArea.E_Type, bool> OnEnterOrExitArea;

    public void EnterArea(int type)
    {
        if (type < 3000)
        {
            CurMapArea |= type;
            if (OnEnterOrExitArea != null)
            {
                OnEnterOrExitArea((MapArea.E_Type)type, true);
            }

            if (type == (int)MapArea.E_Type.RebornSafe
             || type == (int)MapArea.E_Type.Safe)
            {
                if (aiHandler.IsAuto())
                {
                    Behaviour.StopKillUntilDieAI();
                    Behaviour.StopHandupAI();
                }
            }
        }
    }

    public void ExitArea(int type)
    {
        if (type < 3000)
        {
            CurMapArea &= ~type;
            if (OnEnterOrExitArea != null)
            {
                OnEnterOrExitArea((MapArea.E_Type)type, false);
            }
        }
    }

    #endregion

    #region 站前冲锋相关逻辑

    public bool IsNeedRush(float distanceSqrt)
    {
        if (IsRushing)
        {
            return false;
        }

        if (PreFightMission.Instance.IsFinished())
        {
            if (Time.time - m_LastRushTime <= JobSetup.RushInterval * Constants.F_DELTA)
            {
                return false;
            }
        }

        if (JobSetup.RushTargetType == 0
        || (JobSetup.RushTargetType == 2 && SelectTarget is GActorNpcFight)
        || (JobSetup.RushTargetType == 1 && SelectTarget is GA_Player))
        {
            float _minDistSqrt = JobSetup.RushMinDist * Constants.F_DELTA;
            _minDistSqrt *= _minDistSqrt;

            float _maxDistSqrt = JobSetup.RushMaxDist * Constants.F_DELTA;
            _maxDistSqrt *= _maxDistSqrt;

            if (PreFightMission.Instance.IsFinished() == false)
            {
                _minDistSqrt = 1f;
                _maxDistSqrt = 100f;
            }

            if (distanceSqrt > _minDistSqrt && distanceSqrt < _maxDistSqrt)
            {
                return true;
            }
        }

        return false;
    }

    #endregion

    #region 攻击相关逻辑

    public void ComAtk()
    {
        if (MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.Safe)
         || MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.RebornSafe))
        {
            SysNotifyMgr.Instance.ShowTip("NoFighting");
            return;
        }

        if (!CanCommonAtk())
        {
            return;
        }

        if (!PreFightMission.Instance.IsFinished())
        {
            if (SelectTarget != null)
            {
                if (!PathFinder.WalkAble(Pos, SelectTarget.Pos))
                {
                    SelectTarget = GAMgr.Instance.FindAtkTarget(Pos, 10, 360);
                }
            }
        }

        if (UserInputHandler.isTouched)
        {
            int _index = nextComAtkIndex == -1 ? 0 : nextComAtkIndex;
            int _skillID = GetCommonSkillID(_index);
            Skill _skill = SkillMgr.Get(_skillID);
            float _skillDist = _skill.skillInfo.config.AtkDist * .5f;
            GActor _dirTarget = GAMgr.Instance.FindAtkTarget(Pos, _skillDist, 90);
            if (_dirTarget != null)
            {
                LockTarget = _dirTarget;
                SelectTarget = _dirTarget;
            }
        }

        Behaviour.StartKillUntilDieAI();

        if (OnUserClickSkill != null)
        {
            OnUserClickSkill(0);
        }
    }

    public void CastSkill(int skillID)
    {
        if (!PreFightMission.Instance.IsFinished())
        {
            if (SelectTarget != null)
            {
                destForward = -SelectTarget.Forward;
                Forward = destForward;
            }
        }

        if (MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.Safe)
         || MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.RebornSafe))
        {
            SysNotifyMgr.Instance.ShowTip("NoFighting");
            return;
        }

        if (!CanCastSkill())
        {
            return;
        }

        Skill _skill = SkillMgr.Get(skillID);
        if (!_skill.IsValid())
        {
            return;
        }

        if (!PreFightMission.Instance.IsFinished())
        {
            if (skillID == 190)
            {
                if (State != E_ActorState.Roll)
                {
                    if (SkillMgr.CurCastSkill != null)
                    {
                        SkillMgr.CurCastSkill.SkillCompelete = true;
                    }

                    aiHandler.currentType = E_HeroAIType.None;
                    Behaviour.DoAttack(_skill);
                    return;
                }
            }
            else
            {
                if (!PreFightMission.Instance.IsHeroCanCastSkill)
                {
                    return;
                }
            }
        }

        if (MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.Safe)
         || MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.RebornSafe))
        {
            SysNotifyMgr.Instance.ShowTip("NoFighting");
            return;
        }

        Behaviour.StartKillUntilDieAI(skillID);

        if (OnUserClickSkill != null)
        {
            OnUserClickSkill(skillID);
        }
    }

    #endregion

    #region 自动开启自动战斗逻辑

    private float m_CalculAutoFightTime;

    private void UpdateAutoStartFight()
    {
        if (DTCB105_tagMCPlayerWallow.forceOffLine)
        {
            return;
        }

        if (ActorInfo.serverDie)
        {
            return;
        }

        if (MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.Safe)
         || MapArea.IsInMapArea(CurMapArea, MapArea.E_Type.RebornSafe))
        {
            return;
        }

        // 打坐状态下不自动开始战斗
        if (IsDaZuo())
        {
            return;
        }

        if (!aiHandler.IsAuto())
        {
            if (HangUpSetModel.Instance.GetBool(HangUpAutoBoolType.isAutoHangUp))
            {
                if (Time.realtimeSinceStartup - m_CalculAutoFightTime > 60
                 && !NewBieCenter.Instance.inGuiding
                 && PlayerTaskDatas.IsOPenAutoResolve())
                {
                    MapTransferUtility.Instance.Clear();
                    Behaviour.StartHandupAI();
                }
            }
        }
    }

    private SFXController m_ArrowEffect;

    public void ShowArrow(bool showOrHide)
    {
        if (showOrHide)
        {
            if (!m_ArrowEffect)
            {
                m_ArrowEffect = SFXPlayUtility.Instance.PlayBattleEffect(1052, this);
                if (PlayerDatas.Instance.baseData.MapID == 31230)
                {
                    FaceTargetXZ _f = m_ArrowEffect.gameObject.AddComponent<FaceTargetXZ>();
                    _f.targetPos = new Vector3(5.877f, 7.73f, 20.243f);
                }
            }
        }
        else
        {
            if (m_ArrowEffect)
            {
                FaceTargetXZ _f = m_ArrowEffect.GetComponent<FaceTargetXZ>();
                Object.Destroy(_f);
                SFXPlayUtility.Instance.Release(m_ArrowEffect);
                m_ArrowEffect = null;
            }
        }
    }

    private void OnClickedFloor(Vector3 dest)
    {
        m_CalculAutoFightTime = Time.realtimeSinceStartup;
    }

    private void OnCirclePanelTouched()
    {
        m_CalculAutoFightTime = Time.realtimeSinceStartup;
    }

    private void OnStopHandupAI()
    {
        m_CalculAutoFightTime = Time.realtimeSinceStartup;
    }

    #endregion
}