using System;
using System.Collections;
using System.Collections.Generic;
using TableConfig;
using UnityEngine;
namespace Snxxz.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 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;
        private Transform treasure;
        private SkinnedMeshRenderer treasureSkin;
        private Transform bottom;
        private Transform name;
        private TextMesh condition;

        #region 红点
        private Transform potentialRed;
        private Transform achievementRed;
        private Transform stageUpRed;

        static GameObjectPoolManager.GameObjectPool m_PotentialRedpool;
        static GameObjectPoolManager.GameObjectPool m_AchievementRedpool;
        static GameObjectPoolManager.GameObjectPool m_StageUpRedpool;
        #endregion

        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 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();
                RequestRedpoint();
                UpdateTreasureState();
                UpdateParam();
                RedpointCenter.Instance.redpointValueChangeEvent -= RedpointValueChangeEvent;
                RedpointCenter.Instance.redpointValueChangeEvent += RedpointValueChangeEvent;
            }
            else
            {
                RecycleName();
                RecycleBottom();
                RecycleTreasure();
                RecycleBackLight();
                RecycleLockEffect();
                RecycleCollectingSfx();
                RecycleRedpoint();
                RecycleCondition();
                RedpointCenter.Instance.redpointValueChangeEvent -= RedpointValueChangeEvent;
            }
            interactProcessor.SetActive(_active);
        }

        public void RequestName()
        {
            if (name == null)
            {
                if (paramConfig != null && !paramConfig.treasureNamePrefab.Equals(string.Empty))
                {
                    var _instance = UILoader.LoadPrefab(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.gameObject.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.LoadPrefab(StringUtility.Contact("TreasureBottom_", category));
                m_CacheBottomScale = _bottomPrefab.transform.localScale;
                _pool = GameObjectPoolManager.Instance.RequestPool(_bottomPrefab);
                m_BottomPoolDict.Add(category, _pool);
            }
            bottom = _pool.Request().transform;
            bottom.gameObject.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.gameObject.SetActive(true);

            Treasure _treasure;
            if (!model.TryGetTreasure(treasureId, out _treasure))
            {
                return;
            }
            treasureSkin = treasure.GetComponentInChildren<SkinnedMeshRenderer>();
            if (treasureSkin != null)
            {
                bool _unlock = _treasure.state == TreasureState.Collected
                    || _treasure.state == TreasureState.Collecting;
                treasureSkin.material.SetFloat("_Gray", _unlock ? 0 : 1);
            }
        }

        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.gameObject.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;
                }
                var count = 0;
                if (stageUpRed != null)
                {
                    var _param = UI3DTreasureSelectStage.Instance.stageUpParam;
                    count++;
                    stageUpRed.transform.localPosition = GetRedpointPosition(count);
                    stageUpRed.transform.localScale = _param.scale;
                }
                if (achievementRed != null)
                {
                    var _param = UI3DTreasureSelectStage.Instance.achievementParam;
                    count++;
                    achievementRed.transform.localPosition = GetRedpointPosition(count);
                    achievementRed.transform.localScale = _param.scale;
                }
                if (potentialRed != null)
                {
                    var _param = UI3DTreasureSelectStage.Instance.potentialParam;
                    count++;
                    potentialRed.transform.localPosition = GetRedpointPosition(count);
                    potentialRed.transform.localScale = _param.scale;
                }
            }
        }

        public void RequestTreasureEffect()
        {
            RecycleTreasureEffect();
            if (treasure == null)
            {
                return;
            }
            var config = Config.Instance.Get<TreasureConfig>(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()
        {
            Treasure _treasure;
            if (!model.TryGetTreasure(treasureId, out _treasure))
            {
                return;
            }
            if (treasure == null)
            {
                return;
            }

            if (treasureSkin != null)
            {
                treasureSkin.material.SetFloat("_Gray", _treasure.state == TreasureState.Collected
                    || _treasure.state == TreasureState.Collecting ? 0 : 1);
                if (model.GetTreasureUnlockShow(UI3DTreasureSelectStage.Instance.currentCategory) == _treasure.id
                    && !UI3DTreasureSelectStage.Instance.CloserComplete)
                {
                    treasureSkin.material.SetFloat("_Gray", 1);
                }
            }
            RequestBackLight();
            switch (_treasure.state)
            {
                case TreasureState.Collected:
                    RecycleCollectingSfx();
                    RequestTreasureEffect();
                    RecycleLockEffect();
                    RecycleCondition();
                    break;
                case TreasureState.Collecting:
                    RequestTreasureEffect();
                    RequestCollectingSfx();
                    RecycleLockEffect();
                    RecycleCondition();
                    break;
                case TreasureState.Locked:
                    RecycleCollectingSfx();
                    RecycleTreasureEffect();
                    RequestLockEffect();
                    RequestCondition();
                    break;
            }
            if (model.GetTreasureUnlockShow(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.GetTreasureUnlockShow(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();
            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 RequestRedpoint()
        {
            RecycleRedpoint();
            Treasure _treasure;
            model.TryGetTreasure(treasureId, out _treasure);
            if (_treasure == null || category != TreasureCategory.Human)
            {
                return;
            }
            var _human = _treasure as HumanTreasure;
            var count = 0;
            if (_human.castSoulRedpoint.state == RedPointState.Simple)
            {
                if (m_StageUpRedpool == null)
                {
                    var _prefab = UILoader.LoadPrefab("Dian_JueXing");
                    m_StageUpRedpool = GameObjectPoolManager.Instance.RequestPool(_prefab);
                }
                stageUpRed = m_StageUpRedpool.Request().transform;
                stageUpRed.gameObject.SetActive(true);
                stageUpRed.SetParent(root);
                stageUpRed.transform.localPosition = Vector3.zero;
                stageUpRed.LookAt(UI3DTreasureSelectStage.Instance.center);
                if (stageUpRed != null)
                {
                    var _param = UI3DTreasureSelectStage.Instance.stageUpParam;
                    count++;
                    stageUpRed.transform.localPosition = GetRedpointPosition(count);
                    stageUpRed.transform.localScale = _param.scale;
                }
                LayerUtility.SetLayer(stageUpRed.gameObject, LayerUtility.UILayer, true);
            }
            if (_human.achievementRedpoint.state == RedPointState.Simple)
            {
                if (m_AchievementRedpool == null)
                {
                    var _prefab = UILoader.LoadPrefab("Dian_JiHun");
                    m_AchievementRedpool = GameObjectPoolManager.Instance.RequestPool(_prefab);
                }
                achievementRed = m_AchievementRedpool.Request().transform;
                achievementRed.gameObject.SetActive(true);
                achievementRed.SetParent(root);
                achievementRed.transform.localPosition = Vector3.zero;
                achievementRed.LookAt(UI3DTreasureSelectStage.Instance.center);
                if (achievementRed != null)
                {
                    var _param = UI3DTreasureSelectStage.Instance.achievementParam;
                    count++;
                    achievementRed.transform.localPosition = GetRedpointPosition(count);
                    achievementRed.transform.localScale = _param.scale;
                }
                LayerUtility.SetLayer(achievementRed.gameObject, LayerUtility.UILayer, true);
            }
            if (_human.skillLevelUpRedpoint.state == RedPointState.Simple)
            {
                if (m_PotentialRedpool == null)
                {
                    var _prefab = UILoader.LoadPrefab("Dian_Gong");
                    m_PotentialRedpool = GameObjectPoolManager.Instance.RequestPool(_prefab);
                }
                potentialRed = m_PotentialRedpool.Request().transform;
                potentialRed.gameObject.SetActive(true);
                potentialRed.SetParent(root);
                potentialRed.transform.localPosition = Vector3.zero;
                potentialRed.LookAt(UI3DTreasureSelectStage.Instance.center);
                if (potentialRed != null)
                {
                    var _param = UI3DTreasureSelectStage.Instance.potentialParam;
                    count++;
                    potentialRed.transform.localPosition = GetRedpointPosition(count);
                    potentialRed.transform.localScale = _param.scale;
                }
                LayerUtility.SetLayer(potentialRed.gameObject, LayerUtility.UILayer, true);
            }
        }

        public Vector3 GetRedpointPosition(int _count)
        {
            if (_count == 1)
            {
                return UI3DTreasureSelectStage.Instance.achievementParam.position;
            }
            else if (_count == 2)
            {
                return UI3DTreasureSelectStage.Instance.potentialParam.position;
            }
            else
            {
                return UI3DTreasureSelectStage.Instance.stageUpParam.position;
            }
        }

        private void RedpointValueChangeEvent(int _id)
        {
            if (UI3DTreasureSelectStage.Instance.IsCloser)
            {
                return;
            }
            Treasure _treasure;
            model.TryGetTreasure(treasureId, out _treasure);
            if (_treasure == null || category != TreasureCategory.Human)
            {
                return;
            }
            bool _update = false;
            if(_treasure.skillLevelUpRedpoint.id==_id
                || _treasure.achievementRedpoint.id == _id)
            {
                _update = true;
            }
            if(_treasure is HumanTreasure)
            {
                var _human = _treasure as HumanTreasure;
                if(_human.castSoulRedpoint.id==_id)
                {
                    _update = true;
                }
            }
            if (_update)
            {
                RequestRedpoint();
            }
        }

        public void RecycleRedpoint()
        {
            if (m_PotentialRedpool != null && potentialRed != null)
            {
                m_PotentialRedpool.Release(potentialRed.gameObject);
                potentialRed = null;
            }
            if (m_AchievementRedpool != null && achievementRed != null)
            {
                m_AchievementRedpool.Release(achievementRed.gameObject);
                achievementRed = null;
            }
            if (m_StageUpRedpool != null && stageUpRed != null)
            {
                m_StageUpRedpool.Release(stageUpRed.gameObject);
                stageUpRed = 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 = Config.Instance.Get<SuccessConfig>(achievementId);
                            var _missionId = _achievementConfig.Condition[0];
                            var _taskConfig = Config.Instance.Get<PyTaskConfig>(_missionId);
                            if (_taskConfig == null)
                            {
                                return;
                            }
                            if (_achievementConfig.Type == 3)
                            {
                                displayStr = StringUtility.Contact(_taskConfig.lv, "+");
                            }
                        }
                    }
                    break;
                case TreasureCategory.Demon:
                    var config = Config.Instance.Get<TreasureConfig>(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.LoadPrefab(StringUtility.Contact(category, "TreasureCondition"));
                pool = GameObjectPoolManager.Instance.RequestPool(_prefab);
                m_ConditionPoolDict.Add(category, pool);
            }
            condition = pool.Request().GetComponent<TextMesh>();
            condition.gameObject.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;
            }
        }

        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 CloserState()
        {
            RecycleBottom();
            RecycleCollectingSfx();
            RecycleName();
            RecycleBackLight();
            RecycleLockEffect();
            RecycleRedpoint();
            RecycleCondition();
            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);
        }

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

        public void PlayUnlockShow()
        {
            RecycleLockEffect();
            RecycleCondition();
            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.SetTreasureUnlockShow(UI3DTreasureSelectStage.Instance.currentCategory, 0);
            if (display)
            {
                UpdateTreasureState();
            }
            if (model.treasureGotoId != 0 && model.treasureGotoId != 101)
            {
                model.openFromTreasureUnlockShow = true;
                UI3DTreasureSelectStage.Instance.OnPointDownTreasure(model.treasureGotoId);
                model.treasureGotoId = 0;
            }
            UI3DTreasureSelectStage.Instance.CompleteUnlock();
            model.treasureGotoId = 0;
        }
    }
}