using UnityEngine;
using TableConfig;

public abstract class GActorNpcNoFight : GActor, IOtherSelectable
{
    protected GameObject m_Model;
    protected Animator m_Animator;
    private UnityEngine.AI.NavMeshObstacle m_Dig;
    private SFXController m_Shadow;
    //protected AudioSource m_AudioSource = null;
    public NPCConfig NpcConfig { get; protected set; }
    public SFXController m_AppearEffect;
    protected bool m_LoadDefaultRes = false;

    public override int NextAction
    {
        get
        {
            return m_Animator.GetInteger(GAStaticDefine.Param_Action);
        }

        set
        {
            m_Animator.SetInteger(GAStaticDefine.Param_Action, value);
        }
    }

    public void Init(uint serverInstID, uint clientInstID, uint npcID, E_ActorGroup group, GameNetPackBasic package)
    {
        m_LoadDefaultRes = false;

        NpcConfig = Config.Instance.Get<NPCConfig>((int)npcID);

        if (NpcConfig == null)
        {
            // 报错
            return;
        }

        //        if (!m_AudioSource)
        //        {
        //            // 创建音源
        //            GameObject _audioSourceNode = Object.Instantiate(Resources.Load<GameObject>("Prefabs/AudioSource3D")) as GameObject;
        //#if UNITY_EDITOR
        //            _audioSourceNode.name = "AudioSource";
        //#endif
        //            _audioSourceNode.transform.SetParent(m_Root);
        //            _audioSourceNode.transform.localPosition = new Vector3(0, 0.5f, 0);
        //            m_AudioSource = _audioSourceNode.GetComponent<AudioSource>();
        //        }


        ActorType = GameObjType.gotNPC;

        // 初始化表现层
        InitPerformance(clientInstID, (int)npcID);

        // 执行父类的初始化
        Init(serverInstID, clientInstID, group, package);

        Root.gameObject.layer = LayerUtility.Monster;

        if (m_Model)
        {
            m_Model.transform.SetParent(m_Root.transform);
            m_Model.transform.localPosition = Vector3.zero;
            m_Model.transform.localRotation = Quaternion.identity;
        }

        if (NpcConfig.ModeProportion != 1)
        {
            Root.localScale = Vector3.one * NpcConfig.ModeProportion;
        }

        if (CanBeSelected())
        {
            CapsuleCollider _collider = Root.AddMissingComponent<CapsuleCollider>();
            _collider.center = new Vector3(0, NpcConfig.ModleHeight * .5f, 0);
            _collider.radius = NpcConfig.ModelRadius;
            _collider.height = NpcConfig.ModleHeight;
        }

        RequestShadow();
        RequestName();

        // 这里针对指定的NPC特殊矫正位置
        if (GeneralConfig.Instance.NpcPosOffset.ContainsKey(NpcConfig.NPCID))
        {
            Pos = GeneralConfig.Instance.NpcPosOffset[NpcConfig.NPCID];
        }

        // 执行挖洞逻辑
        if (NpcConfig.Dig == 1)
        {
            m_Dig = SoMap.CreateImpasse.GeneralCircle(Pos, NpcConfig.ModelRadius);
        }

        if (NpcConfig.NPCEffect != 0)
        {
            m_AppearEffect = SFXPlayUtility.Instance.PlayBattleEffect(NpcConfig.NPCEffect, this);
            //EffectConfig _effectConfig = ConfigManager.Instance.GetTemplate<EffectConfig>(NpcConfig.NPCEffect);
            //if (_effectConfig != null)
            //{
            //    SoundPlayer.Instance.PlayAudio(m_AudioSource, _effectConfig.audio);
            //}
        }
    }

    protected override void OnUnit()
    {
        if (m_LoadDefaultRes)
        {
            GameObjectPoolManager.Instance.ReleaseDefaultFuncNPC(m_Model);
        }
        else
        {
            GameObject _prefab = InstanceResourcesLoader.LoadNpc(NpcConfig.NPCID);
            GameObjectPoolManager.Instance.ReleaseGameObject(_prefab, m_Model);
        }

        if (m_AppearEffect)
        {
            SFXPlayUtility.Instance.Release(m_AppearEffect);
            m_AppearEffect = null;
        }

        m_Model = null;

        if (m_Animator)
        {
            m_Animator.enabled = false;
            m_Animator = null;
        }

        ReleaseName();
        ReleaseShadow();

        if (m_Dig)
        {
            Object.Destroy(m_Dig.gameObject);
            m_Dig = null;
        }
    }

    public override void Destroy()
    {
    }

    public virtual void InitPerformance(uint clientInstID, int npcID)
    {
        GameObject _prefab = InstanceResourcesLoader.LoadNpcPrefab(npcID);

        if (_prefab == null)
        {
            _prefab = InstanceResourcesLoader.LoadDefaultFuncNPC();

            if (_prefab)
            {
                m_LoadDefaultRes = true;
            }
        }

        if (_prefab != null)
        {
            if (PreFightMission.Instance.IsFinished())
            {
                GAMgr.Instance.AddNeedDestroyPrefab(_prefab);
            }
            if (this is GA_Guard)
            {
                GAMgr.Instance.RemoveNeedDestroyPrefab(_prefab);
            }

            if (m_LoadDefaultRes)
            {
                m_Model = GameObjectPoolManager.Instance.RequestDefaultFuncNpc();
            }
            else
            {
                m_Model = GameObjectPoolManager.Instance.RequestNpcGameObject(npcID);
            }

            if (m_Model)
            {
                m_Animator = m_Model.GetComponent<Animator>();
                if (m_Animator)
                {
                    m_Animator.enabled = true;
                    m_Animator.SetInteger(GAStaticDefine.Param_ActorInstID, (int)clientInstID);
                }

                SetupBindNode(m_Model.transform);
            }
        }
    }

    public sealed override void SetAnimatorSpeed(float speed)
    {
        if (m_Animator)
        {
            m_Animator.speed = speed;
        }
    }

    public sealed override void Play(int stateNameHash, float normalizeTime = 0)
    {
        if (m_Animator)
        {
            m_Animator.Play(stateNameHash, 0, normalizeTime);
        }
    }

    public override void Idle()
    {
        NextAction = GAStaticDefine.Act_Idle;
    }

    public override void IdleImmediate()
    {
        if (m_Animator)
        {
            Idle();
            m_Animator.Play(GAStaticDefine.State_IdleHash);
        }
    }

    public override void Run()
    {
        NextAction = GAStaticDefine.Act_Run;
    }

    public override void RunImmediate()
    {
        if (m_Animator)
        {
            Run();
            m_Animator.Play(GAStaticDefine.State_RunHash);
        }
    }

    public override bool IsIdle()
    {
        AnimatorStateInfo _stateInfo = m_Animator.GetCurrentAnimatorStateInfo(0);
        return _stateInfo.shortNameHash == GAStaticDefine.State_IdleHash;
    }

    public override bool IsRun()
    {
        AnimatorStateInfo _stateInfo = m_Animator.GetCurrentAnimatorStateInfo(0);
        return _stateInfo.shortNameHash == GAStaticDefine.State_RunHash;
    }

    public override bool IsHurt()
    {
        AnimatorStateInfo _stateInfo = m_Animator.GetCurrentAnimatorStateInfo(0);
        return _stateInfo.shortNameHash == GAStaticDefine.State_HurtHash;
    }

    public sealed override bool IsStun()
    {
        AnimatorStateInfo _stateInfo = m_Animator.GetCurrentAnimatorStateInfo(0);

        return _stateInfo.shortNameHash == GAStaticDefine.State_StunHash;
    }

    public sealed override bool HasState(int stateHash)
    {
        if (m_Animator)
        {
            return m_Animator.HasState(0, stateHash);
        }
        return false;
    }

    public override void RequestShadow()
    {
        ReleaseShadow();
        m_Shadow = SFXPlayUtility.Instance.PlayBattleEffect(999999, m_Root);
        m_Shadow.duration = 0;
        if (Root.transform.localScale == Vector3.zero)
        {
            Root.transform.localScale = Vector3.one;
        }
        m_Shadow.transform.localScale = new Vector3((NpcConfig.ModelRadius * 2) / Root.transform.localScale.x,
                                                    1,
                                                    (NpcConfig.ModelRadius * 2) / Root.transform.localScale.z);
    }

    public sealed override void ReleaseShadow()
    {
        if (m_Shadow)
        {
            SFXPlayUtility.Instance.Release(m_Shadow);
            m_Shadow = null;
        }
    }

    public sealed override void ShowOrHideModel(bool showOrHide)
    {
        if (ShowOrHide == showOrHide)
        {
            return;
        }

        if (showOrHide)
        {
            if (m_Model)
            {
                m_Model.transform.localPosition = Vector3.zero;
                m_Model.transform.localRotation = Quaternion.identity;
            }

            RequestName();
            RequestShadow();
        }
        else
        {
            if (m_Model)
            {
                m_Model.transform.localPosition = Constants.Special_Hide_Position;
            }

            if (PlayerDatas.Instance.hero.SelectTarget == this)
            {
                PlayerDatas.Instance.hero.SelectTarget = null;
            }

            if (PlayerDatas.Instance.hero.LockTarget == this)
            {
                PlayerDatas.Instance.hero.LockTarget = null;
            }

            ReleaseName();
            ReleaseShadow();
        }

        ShowOrHide = showOrHide;
    }

    public override abstract void RequestName();
    public override abstract void RequestLifeBar();

    public abstract void OnSelect();
    public abstract void OnUnSelect();
    public abstract bool CanBeSelected();
    public abstract void OnClick();
}