using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace vnxbqy.UI
{
    
    public class TreasureComponent
    {
        const string EFFECT_BONE = "Bone_effect";
        const string HUMAN_LOCKSFX_STATE_1 = "Effcet_FaBao_FengYin";
        const string HUMAN_LOCKSFX_STATE_2 = "Effcet_FaBao_FengYin_02";
        const string DEMON_LOCKSFX_STATE_1 = "Effcet_FaBao_FengYin2_01";
        const string DEMON_LOCKSFX_STATE_2 = "Effcet_FaBao_FengYin2_02";
        const string HUMAN_HIGHEST_STAGE_1 = "Effect_FaBao_QuanJueXing";
        const string HUMAN_HIGHEST_STAGE_2 = "Effect_FaBao_QuanJueXing_2";
        const int HUMAN_BACKLIGHT_EFFECT = 5115;
        const int DEMON_BACKLIGHT_EFFECT = 5116;
        const int FAIRY_BACKLIGHT_EFFECT = 5117;
        const int UNGET_BACKLIGHT_EFFECT = 5125;

        public int treasureId = 0;
        public bool display = false;
        public TreasureCategory category;

        public Transform root;
        public Transform treasureRoot;
        public TreasureInteractProcessor interactProcessor;
        Transform treasure;
        SkinnedMeshRenderer treasureSkin;
        Transform bottom;
        Transform name;
        TextMesh condition;
        DemonDungeonLabel treasureLabel;
        TreasureThreeDimensionsBehaviour m_ThreeDimensionsBehaviour;
        HumanThreeDimensionsBehaviour m_HumanThreeDimensions;

        SFXController treasureEffect;
        SFXController backLightEffect;
        SFXController lockEffect;
        SFXController challengeSfx;
        SFXController specialSfx;

        public Treasure3DConfig paramConfig { get; set; }

        static Dictionary<TreasureCategory, GameObjectPoolManager.GameObjectPool> m_BottomPoolDict
            = new Dictionary<TreasureCategory, GameObjectPoolManager.GameObjectPool>();
        static Dictionary<TreasureState, GameObjectPoolManager.GameObjectPool> m_StatePoolDict
            = new Dictionary<TreasureState, GameObjectPoolManager.GameObjectPool>();
        static Dictionary<TreasureCategory, GameObjectPoolManager.GameObjectPool> m_ConditionPoolDict
            = new Dictionary<TreasureCategory, GameObjectPoolManager.GameObjectPool>();
        static Dictionary<TreasureCategory, GameObjectPoolManager.GameObjectPool> m_LabelPoolDict
            = new Dictionary<TreasureCategory, GameObjectPoolManager.GameObjectPool>();
        static Dictionary<TreasureCategory, GameObjectPoolManager.GameObjectPool> m_TreasureCanvaPool
            = new Dictionary<TreasureCategory, GameObjectPoolManager.GameObjectPool>();
        static Vector3 m_CacheBottomScale = Vector3.zero;

        TreasureModel m_Model;
        TreasureModel model
        {
            get
            {
                return m_Model ?? (m_Model = ModelCenter.Instance.GetModel<TreasureModel>());
            }
        }

        AchievementModel achievementModel { get { return ModelCenter.Instance.GetModel<AchievementModel>(); } }

        public void SetActive(bool _active)
        {
            display = _active;
            if (_active)
            {
                RequestName();
                RequestTreasure();
                RequestBottom();
                RequestBackLight();
                RequestTreasureCanva();
                UpdateTreasureState();
                UpdateParam();
                model.demonTreasureDungeonUpdate -= DemonTreasureDungeonUpdate;
                model.demonTreasureDungeonUpdate += DemonTreasureDungeonUpdate;
            }
            else
            {
                RecycleName();
                RecycleBottom();
                RecycleTreasure();
                RecycleBackLight();
                RecycleLockEffect();
                RecycleCollectingSfx();
                RecycleCondition();
                RecycleTreasureLabel();
                RecycleTreasureCanva();
                model.demonTreasureDungeonUpdate -= DemonTreasureDungeonUpdate;
            }
            interactProcessor.SetActive(_active);
        }

        public void RequestName()
        {
            RecycleName();
            if (category == TreasureCategory.King)
            {
                return;
            }
            if (name == null)
            {
                if (paramConfig != null && !paramConfig.treasureNamePrefab.Equals(string.Empty))
                {
                    var _instance = UILoader.LoadTreasure("Misc", paramConfig.treasureNamePrefab);
                    if (_instance != null)
                    {
                        _instance = GameObject.Instantiate(_instance);
                        name = _instance.transform;
                        name.SetParent(root);
                        name.localPosition = Vector3.zero;
                        name.localScale = Vector3.one;
                        name.LookAt(UI3DTreasureSelectStage.Instance.center);
                        LayerUtility.SetLayer(name.gameObject, LayerUtility.UILayer, true);
                    }
                }
            }
            if (name != null)
            {
                name.SetActive(true);
                LayerUtility.SetLayer(name.gameObject, LayerUtility.UILayer, true);
            }
        }

        public void RequestBottom()
        {
            RecycleBottom();
            GameObjectPoolManager.GameObjectPool _pool = null;
            if (!m_BottomPoolDict.TryGetValue(category, out _pool))
            {
                var _bottomPrefab = UILoader.LoadTreasure("Misc", StringUtility.Contact("TreasureBottom_", category));
                m_CacheBottomScale = _bottomPrefab.transform.localScale;
                _pool = GameObjectPoolManager.Instance.RequestPool(_bottomPrefab);
                m_BottomPoolDict.Add(category, _pool);
            }
            bottom = _pool.Request().transform;
            bottom.SetActive(true);
            bottom.SetParent(root);
            bottom.transform.localPosition = Vector3.zero;
            bottom.transform.localScale = m_CacheBottomScale;
            bottom.LookAt(UI3DTreasureSelectStage.Instance.center);
            LayerUtility.SetLayer(bottom.gameObject, LayerUtility.UILayer, true);
        }

        public void RecycleBottom()
        {
            if (m_BottomPoolDict.ContainsKey(category) && bottom != null)
            {
                m_BottomPoolDict[category].Release(bottom.gameObject);
                bottom = null;
            }
        }

        public void RequestTreasure()
        {
            RecycleTreasure();
            var instance = UI3DModelFactory.LoadUITreasure(treasureId);
            if (instance == null)
            {
                return;
            }
            treasure = instance.transform;
            treasure.SetParent(treasureRoot);
            treasure.localPosition = Vector3.zero;
            treasure.LookAt(UI3DTreasureSelectStage.Instance.showCamera.transform);
            treasure.SetActive(true);

            bool requireGraySkin = RequireGrayTreasureSkin();
            treasureSkin = treasure.GetComponentInChildren<SkinnedMeshRenderer>();
            if (treasureSkin != null)
            {
                treasureSkin.material.SetFloat("_Gray", requireGraySkin ? 1 : 0);
            }
        }

        public void RecycleTreasure()
        {
            if (treasure != null)
            {
                if (treasureSkin != null)
                {
                    treasureSkin.material.SetFloat("_Gray", 0);
                    treasureSkin = null;
                }
                UI3DModelFactory.ReleaseUITreasure(treasureId, treasure.gameObject);
                treasure = null;
            }
        }

        public void RecycleName()
        {
            if (name != null)
            {
                name.SetActive(false);
            }
        }

        public void UpdateParam()
        {
            if (paramConfig != null)
            {
                if (treasure != null)
                {
                    treasure.localPosition = paramConfig.modelParam.position;
                    treasure.localScale = paramConfig.modelParam.scale;
                }
                if (name != null)
                {
                    name.localPosition = paramConfig.nameParam.position;
                    name.localEulerAngles = paramConfig.nameParam.rotation;
                    name.localScale = paramConfig.nameParam.scale;
                }
                if (bottom != null)
                {
                    bottom.localPosition = paramConfig.bottomParam.position;
                    bottom.localScale = paramConfig.bottomParam.scale;
                }
                if (challengeSfx != null)
                {
                    var _param = UI3DTreasureSelectStage.Instance.challengeSfxParam;
                    challengeSfx.transform.localPosition = _param.position;
                    challengeSfx.transform.localScale = _param.scale;
                }
                if (lockEffect != null)
                {
                    lockEffect.transform.localPosition = paramConfig.lockSfxParam.position;
                }
            }
        }

        public void RequestTreasureEffect()
        {
            RecycleTreasureEffect();
            if (treasure == null)
            {
                return;
            }
            var config = TreasureConfig.Get(treasureId);
            var mountPoint = treasure.GetChildTransformDeeply(EFFECT_BONE);
            if (mountPoint == null)
            {
                mountPoint = treasure.transform;
            }
            treasureEffect = SFXPlayUtility.Instance.Play(config.EffectID, mountPoint);
            if (treasureEffect != null)
            {
                LayerUtility.SetLayer(treasureEffect.gameObject, LayerUtility.UILayer, true);
            }
        }

        public void RecycleTreasureEffect()
        {
            if (treasureEffect != null)
            {
                SFXPlayUtility.Instance.Release(treasureEffect);
                treasureEffect = null;
            }
        }

        public void UpdateTreasureState()
        {
            if (treasure == null)
            {
                return;
            }

            Treasure _treasure;
            if (!model.TryGetTreasure(treasureId, out _treasure))
            {
                return;
            }

            bool requireGraySkin = RequireGrayTreasureSkin();
            if (treasureSkin != null)
            {
                treasureSkin.material.SetFloat("_Gray", requireGraySkin ? 1 : 0);
                if (model.IsRequireUnlockAnim(UI3DTreasureSelectStage.Instance.currentCategory) == _treasure.id
                    && !UI3DTreasureSelectStage.Instance.CloserComplete)
                {
                    treasureSkin.material.SetFloat("_Gray", 1);
                }
            }
            RequestBackLight();
            switch (_treasure.state)
            {
                case TreasureState.Collected:
                    RecycleCollectingSfx();
                    RequestTreasureEffect();
                    RecycleLockEffect();
                    RecycleCondition();
                    RequestTreasureLabel();
                    break;
                case TreasureState.Collecting:
                    RequestTreasureEffect();
                    RequestCollectingSfx();
                    RecycleLockEffect();
                    RecycleCondition();
                    RequestTreasureLabel();
                    break;
                case TreasureState.Locked:
                    RecycleCollectingSfx();
                    RecycleTreasureEffect();
                    RequestLockEffect();
                    RequestCondition();
                    RecycleTreasureLabel();
                    break;
            }
            if (model.IsRequireUnlockAnim(UI3DTreasureSelectStage.Instance.currentCategory) == _treasure.id)
            {
                RecycleCollectingSfx();
                RecycleTreasureEffect();
                RequestLockEffect();
            }
            if (UI3DTreasureSelectStage.Instance.CloserComplete
                && UI3DTreasureSelectStage.Instance.selectTreasure == treasureId)
            {
                CloserState();
            }
            UpdateParam();
        }

        private void RequestBackLight()
        {
            RecycleBackLight();
            Treasure _treasure;
            model.TryGetTreasure(treasureId, out _treasure);
            if (treasure != null && _treasure != null)
            {
                var _effectId = 0;
                if (_treasure.state == TreasureState.Collected)
                {
                    _effectId = category == TreasureCategory.Human ? HUMAN_BACKLIGHT_EFFECT :
                    category == TreasureCategory.Demon ? DEMON_BACKLIGHT_EFFECT : FAIRY_BACKLIGHT_EFFECT;
                }
                else
                {
                    _effectId = UNGET_BACKLIGHT_EFFECT;
                }
                if (model.IsRequireUnlockAnim(UI3DTreasureSelectStage.Instance.currentCategory) == treasureId)
                {
                    _effectId = UNGET_BACKLIGHT_EFFECT;
                }
                backLightEffect = SFXPlayUtility.Instance.Play(_effectId, root);
                if (backLightEffect != null)
                {
                    backLightEffect.duration = 0;
                }
            }
        }

        private void RecycleBackLight()
        {
            if (backLightEffect != null)
            {
                SFXPlayUtility.Instance.Release(backLightEffect);
                backLightEffect = null;
            }
        }

        private void RequestCollectingSfx()
        {
            RecycleCollectingSfx();
            challengeSfx = SFXPlayUtility.Instance.Play(category == TreasureCategory.Demon ? 5155 : 5145, root);
            if (challengeSfx != null)
            {
                challengeSfx.gameObject.SetActive(true);
                LayerUtility.SetLayer(challengeSfx.gameObject, LayerUtility.UILayer, true);
                challengeSfx.transform.LookAt(UI3DTreasureSelectStage.Instance.center);
                challengeSfx.duration = 0;
            }
        }

        private void RecycleCollectingSfx()
        {
            if (challengeSfx != null)
            {
                challengeSfx.gameObject.SetActive(false);
                SFXPlayUtility.Instance.Release(challengeSfx);
                challengeSfx = null;
            }
        }

        private void RequestLockEffect()
        {
            RecycleLockEffect();
            if (category == TreasureCategory.King)
            {
                return;
            }
            var _id = category == TreasureCategory.Human ? 5132 : 5157;
            lockEffect = SFXPlayUtility.Instance.Play(_id, treasureRoot);
            if (lockEffect != null)
            {
                LayerUtility.SetLayer(lockEffect.gameObject, LayerUtility.UILayer, true);
                lockEffect.transform.LookAt(UI3DTreasureSelectStage.Instance.center);
                lockEffect.duration = 0;
                var _animator = lockEffect.transform.GetComponentInChildren<Animator>();
                if (_animator != null)
                {
                    var _state = category == TreasureCategory.Human ? HUMAN_LOCKSFX_STATE_1 : DEMON_LOCKSFX_STATE_1;
                    _animator.Play(_state, 0, 0);
                }
            }
        }

        public void RecycleLockEffect()
        {
            if (lockEffect != null)
            {
                SFXPlayUtility.Instance.Release(lockEffect);
                lockEffect = null;
            }
        }

        public void RequestSpecialEffect()
        {
            RecycleSpecialEffect();
            if (treasureId == 301)
            {
                specialSfx = SFXPlayUtility.Instance.Play(5159, root);
                if (specialSfx != null)
                {
                    specialSfx.duration = 0;
                    if (paramConfig != null)
                    {

                        specialSfx.transform.localPosition = GetAdaptiveDistance(paramConfig.specialSfxParam.position);
                        specialSfx.transform.localScale = paramConfig.specialSfxParam.scale;
                    }
                    LayerUtility.SetLayer(specialSfx.gameObject, LayerUtility.DefaultLayer, true);
                }
            }
        }

        void RequestCondition()
        {
            RecycleCondition();

            if (category != TreasureCategory.Human && category != TreasureCategory.Demon)
            {
                return;
            }

            string displayStr = string.Empty;
            switch (category)
            {
                case TreasureCategory.Human:
                    //if (model.IsVersionUnOpenTreasure(treasureId))
                    //{
                    //    displayStr = "=";
                    //}
                    //else
                    //{
                    //    Achievement achievement = null;
                    //    var achievementId = 0;
                    //    var unlock = false;
                    //    if (model.TryGetTreasureUnlockAchievement(treasureId, out achievementId))
                    //    {
                    //        if (achievementModel.TryGetAchievement(achievementId, out achievement))
                    //        {
                    //            unlock = true;
                    //        }
                    //    }
                    //    if (unlock && !achievement.completed)
                    //    {
                    //        var _achievementConfig = SuccessConfig.Get(achievementId);
                    //        var _missionId = _achievementConfig.Condition[0];
                    //        var _taskConfig = PyTaskConfig.Get(_missionId);
                    //        if (_taskConfig == null)
                    //        {
                    //            return;
                    //        }
                    //        if (_achievementConfig.Type == 3)
                    //        {
                    //            displayStr = StringUtility.Contact(_taskConfig.lv, "+");
                    //        }
                    //    }
                    //}
                    break;
                case TreasureCategory.Demon:
                    var config = TreasureConfig.Get(treasureId);
                    if (config != null)
                    {
                        displayStr = StringUtility.Contact(config.ChallengeLevel, "+");
                    }
                    break;
            }

            if (string.IsNullOrEmpty(displayStr))
            {
                return;
            }

            GameObjectPoolManager.GameObjectPool pool;
            if (m_ConditionPoolDict.TryGetValue(category, out pool) == false)
            {
                var _prefab = UILoader.LoadTreasure("Misc", StringUtility.Contact(category, "TreasureCondition"));
                pool = GameObjectPoolManager.Instance.RequestPool(_prefab);
                m_ConditionPoolDict.Add(category, pool);
            }
            condition = pool.Request().GetComponent<TextMesh>();
            condition.SetActive(true);
            condition.transform.SetParent(root);
            condition.transform.localPosition = Vector3.zero;
            condition.transform.LookAt(UI3DTreasureSelectStage.Instance.center);
            condition.transform.localPosition = new Vector3(0, -1.75f, 0f);
            condition.transform.localScale = new Vector3(-1, 1, 1);
            condition.text = displayStr;
            LayerUtility.SetLayer(condition.gameObject, LayerUtility.UILayer, true);
        }

        void RecycleCondition()
        {
            if (m_ConditionPoolDict.ContainsKey(category) && condition != null)
            {
                var pool = m_ConditionPoolDict[category];
                pool.Release(condition.gameObject);
                condition = null;
            }
        }

        void RequestTreasureLabel()
        {
            RecycleTreasureLabel();

            if (category != TreasureCategory.Demon)
            {
                return;
            }

            string label1 = string.Empty;
            string label2 = string.Empty;
            switch (category)
            {
                case TreasureCategory.Demon:
                    Treasure _treasure;
                    if (model.TryGetTreasure(treasureId, out _treasure))
                    {
                        switch (_treasure.state)
                        {
                            case TreasureState.Collected:
                                label1 = ":";
                                break;
                            case TreasureState.Collecting:
                                TreasureDungeon treasureDungeon;
                                if (model.TryGetTreasureDungeon(treasureId, out treasureDungeon))
                                {
                                    label1 = "+";
                                    label2 = StringUtility.Contact("(", treasureDungeon.currentLevel,
                                        "/", treasureDungeon.maxLevel, ")");
                                }
                                break;
                            case TreasureState.Locked:
                                return;
                        }
                    }
                    break;
            }

            if (string.IsNullOrEmpty(label1))
            {
                return;
            }

            GameObjectPoolManager.GameObjectPool pool;
            if (m_LabelPoolDict.TryGetValue(category, out pool) == false)
            {
                var _prefab = UILoader.LoadTreasure("Misc", StringUtility.Contact(category, "TreasureLabel"));
                pool = GameObjectPoolManager.Instance.RequestPool(_prefab);
                m_LabelPoolDict.Add(category, pool);
            }
            treasureLabel = pool.Request().GetComponent<DemonDungeonLabel>();
            treasureLabel.SetActive(true);
            treasureLabel.transform.SetParent(root);
            treasureLabel.transform.localPosition = Vector3.zero;
            treasureLabel.transform.LookAt(UI3DTreasureSelectStage.Instance.center);
            treasureLabel.transform.localPosition = new Vector3(0, -1.73f, 0f);
            treasureLabel.transform.localScale = new Vector3(-1, 1, 1);
            treasureLabel.Display(label1, label2);
            LayerUtility.SetLayer(treasureLabel.gameObject, LayerUtility.UILayer, true);
        }

        private void DemonTreasureDungeonUpdate(int id)
        {
            if (id == treasureId)
            {
                DisplayTreasureLabel();
            }
        }

        void DisplayTreasureLabel()
        {
            if (category == TreasureCategory.Demon)
            {
                if (treasureLabel != null)
                {
                    Treasure _treasure;
                    if (model.TryGetTreasure(treasureId, out _treasure))
                    {
                        switch (_treasure.state)
                        {
                            case TreasureState.Collected:
                                treasureLabel.Display(":", string.Empty);
                                break;
                            case TreasureState.Collecting:
                                TreasureDungeon treasureDungeon;
                                if (model.TryGetTreasureDungeon(treasureId, out treasureDungeon))
                                {
                                    treasureLabel.Display("+", StringUtility.Contact("(", treasureDungeon.currentLevel,
                                        "/", treasureDungeon.maxLevel, ")"));
                                }
                                break;
                        }
                    }
                }
            }
        }

        void RecycleTreasureLabel()
        {
            if (m_LabelPoolDict.ContainsKey(category) && treasureLabel != null)
            {
                var pool = m_LabelPoolDict[category];
                pool.Release(treasureLabel.gameObject);
                treasureLabel = null;
            }
        }

        public Vector3 GetAdaptiveDistance(Vector3 _distance)
        {
            var normal = Constants.DESIGN_RESOLUTION.x / Constants.DESIGN_RESOLUTION.y;
            var now = (float)Screen.width / (float)Screen.height;
            if (now < normal)
            {
                return _distance * (now / normal);
            }
            else
            {
                return _distance;
            }
        }

        public void RecycleSpecialEffect()
        {
            if (specialSfx != null)
            {
                specialSfx.gameObject.SetActive(false);
                SFXPlayUtility.Instance.Release(specialSfx);
                specialSfx = null;
            }
        }

        public void RequestTreasureCanva()
        {
            RecycleTreasureCanva();
            if (category != TreasureCategory.King
                && category != TreasureCategory.Human)
            {
                return;
            }
            if (UI3DTreasureSelectStage.Instance.UnlockShowing
                && model.IsRequireUnlockAnim(category) == treasureId)
            {
                return;
            }
            if (!m_TreasureCanvaPool.ContainsKey(category))
            {
                var prefab = UILoader.LoadTreasure("Misc", "TreasureCanva_" + category.ToString());
                if (prefab)
                {
                    m_TreasureCanvaPool.Add(category, GameObjectPoolManager.Instance.RequestPool(prefab));
                }
            }
            if (m_TreasureCanvaPool.ContainsKey(category))
            {
                var pool = m_TreasureCanvaPool[category];
                var go = pool.Request();
                go.SetActive(true);
                go.transform.SetParent(root);
                go.transform.localPosition = Vector3.zero;
                go.transform.localEulerAngles = new Vector3(0, -180, 0);
                go.transform.localScale = Vector3.one * 0.01f;
                LayerUtility.SetLayer(go, LayerUtility.DevisableUI, true);

                switch (category)
                {
                    case TreasureCategory.Human:
                        m_HumanThreeDimensions = go.GetComponent<HumanThreeDimensionsBehaviour>();
                        m_HumanThreeDimensions.SetCamera(UI3DTreasureSelectStage.Instance.treasureUICamera);
                        m_HumanThreeDimensions.Display(treasureId); break;
                    case TreasureCategory.King:
                        m_ThreeDimensionsBehaviour = go.GetComponent<TreasureThreeDimensionsBehaviour>();
                        m_ThreeDimensionsBehaviour.SetCamera(UI3DTreasureSelectStage.Instance.treasureUICamera);
                        m_ThreeDimensionsBehaviour.Display(treasureId);
                        break;
                }
            }
        }

        public void RecycleTreasureCanva()
        {
            if (m_ThreeDimensionsBehaviour != null)
            {
                m_ThreeDimensionsBehaviour.SetActive(false);
                m_TreasureCanvaPool[TreasureCategory.King].Release(m_ThreeDimensionsBehaviour.gameObject);
                m_ThreeDimensionsBehaviour = null;
            }
            if (m_HumanThreeDimensions != null)
            {
                m_HumanThreeDimensions.SetActive(false);
                m_TreasureCanvaPool[TreasureCategory.Human].Release(m_HumanThreeDimensions.gameObject);
                m_HumanThreeDimensions = null;
            }
        }

        public void CloserState()
        {
            RecycleBottom();
            RecycleCollectingSfx();
            RecycleName();
            RecycleBackLight();
            RecycleLockEffect();
            RecycleCondition();
            RecycleTreasureLabel();
            RecycleTreasureCanva();
            RequestSpecialEffect();

            Treasure _treasure;
            if (!model.TryGetTreasure(treasureId, out _treasure))
            {
                return;
            }
            if (_treasure.state != TreasureState.Locked)
            {
                RequestTreasureEffect();
            }
            else
            {
                RecycleTreasureEffect();
            }
        }

        public void SetLayer(int _layer)
        {
            LayerUtility.SetLayer(root.gameObject, _layer, true);
            LayerUtility.SetLayer(treasureRoot.gameObject, _layer, true);

            if (m_ThreeDimensionsBehaviour != null)
            {
                LayerUtility.SetLayer(m_ThreeDimensionsBehaviour.gameObject, LayerUtility.DevisableUI, true);
            }
        }

        public void OutCloserState()
        {
            RequestBottom();
            RequestName();
            RequestTreasureCanva();
            UpdateTreasureState();
            RecycleSpecialEffect();
            UpdateParam();
        }

        public void PlayUnlockShow()
        {
            RecycleLockEffect();
            RecycleCondition();
            RecycleTreasureLabel();
            RecycleTreasureCanva();
            try
            {
                var _effect = SFXPlayUtility.Instance.Play(category == TreasureCategory.Demon ? 5157 : 5132, treasureRoot);
                if (_effect != null)
                {
                    SoundPlayer.Instance.PlayUIAudio(category == TreasureCategory.Demon ? 51 : 52);
                    LayerUtility.SetLayer(_effect.gameObject, LayerUtility.UILayer, true);
                    _effect.transform.LookAt(UI3DTreasureSelectStage.Instance.center);
                    _effect.transform.localPosition = paramConfig.lockSfxParam.position;
                    _effect.duration = 3.0f;
                    var _animator = _effect.transform.GetComponentInChildren<Animator>();
                    if (_animator != null)
                    {
                        _animator.Play(category == TreasureCategory.Demon ? DEMON_LOCKSFX_STATE_2 : HUMAN_LOCKSFX_STATE_2, 0, 0);
                    }
                }
            }
            catch (System.Exception e)
            {
                Debug.Log(e.Message);
            }

            SnxxzGame.Instance.StartCoroutine(Co_UnlockShow());
        }

        IEnumerator Co_UnlockShow()
        {
            yield return WaitingForSecondConst.GetWaitForSeconds(2.2f);
            UI3DTreasureSelectStage.Instance.UnlockShowing = false;
            model.SetUnlockAnim(UI3DTreasureSelectStage.Instance.currentCategory, 0);
            if (display)
            {
                UpdateTreasureState();
            }
            if (model.treasureGotoId != 0)
            {
                UI3DTreasureSelectStage.Instance.OnPointDownTreasure(model.treasureGotoId);
                model.treasureGotoId = 0;
            }
            UI3DTreasureSelectStage.Instance.CompleteUnlock();
            model.treasureGotoId = 0;
        }

        bool RequireGrayTreasureSkin()
        {
            Treasure _treasure;
            if (!model.TryGetTreasure(treasureId, out _treasure))
            {
                return true;
            }
            return _treasure.state != TreasureState.Collected
                    && _treasure.state != TreasureState.Collecting;
        }
    }
}