//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Thursday, May 03, 2018
//--------------------------------------------------------

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using TableConfig;
using UnityEngine;
using UnityEngine.UI;

namespace Snxxz.UI {

    public class TreasureLevelUpWin : Window
    {
        [SerializeField] TreasureAnimation m_TreasureAnimation;
        [SerializeField] RectTransform m_DisplayContainer;
        [SerializeField] Image m_TreasureTitle;
        [SerializeField] DragSelectComponent m_DragSelect;

        [SerializeField] RectTransform m_ContainerUnGet;
        [SerializeField] RectTransform m_ContainerLockDetail;
        [SerializeField] PositionTween m_LockDetailPosTween;
        [SerializeField] ScrollerController m_Controller;
        [SerializeField] Button m_GetTreasureBtn;
        [SerializeField] RectTransform m_ContainerLimit;
        [SerializeField] Text m_TreasureChallengeLimit;
        [SerializeField] Text m_TreasureStory;

        [SerializeField] RectTransform m_ContainerTip;
        [SerializeField] Text m_NewStageTip;

        [SerializeField] RectTransform m_ContainerLevelUp;
        [SerializeField] RectTransform m_ContainerMeridian;
        [SerializeField] TreasureCyclicScroll m_AchievementScroll;
        [SerializeField] TreasureProperty m_TreasureProperty;
        [SerializeField] TreasureMeridianBehaviour[] m_TreasureMeridians;
        [Header("Progress")]
        [SerializeField] RectTransform m_ContainerPropgress;
        [SerializeField] Image m_CurrentStageIcon;
        [SerializeField] Text m_TreasureLevelProgress;
        [SerializeField] Text m_TreasureStageDesc;
        [SerializeField] AchievementAwardEffectResponse m_AwardEffectResponse;
        [SerializeField] SmoothSlider m_Slider;
        [SerializeField] Button m_LevelUpBtn;
        [SerializeField] Text m_LevelUpTxt;
        [SerializeField] UIEffect m_LevelUpSfx;
        [SerializeField] RectTransform m_ContainerSkillShow;
        [SerializeField] Image m_HeroShowSkill;
        [SerializeField] Image m_HeroShowSkillName;

        [SerializeField] RectTransform m_ContainerPotential;
        [SerializeField] TreasurePotentialPanel m_TreasurePotential;

        [SerializeField] TreasureDemonBehaviour m_TreasureDemonBehaviour;
        [SerializeField] FairyTreasureCollectPanel m_TreasureFairyBehaviour;

        [SerializeField] RectTransform m_ContainerSelect;
        [SerializeField] Button m_LeftBtn;
        [SerializeField] Button m_RightBtn;
        [SerializeField] Button m_BackBtn;

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

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

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

        PlayerTaskDatas task { get { return ModelCenter.Instance.GetModel<PlayerTaskDatas>(); } }

        Treasure m_Treasure;

        bool m_CorrectClose = false;
        bool m_OnLevelUpStage = false;
        bool m_Init = false;
        bool m_NewBieGuide = false;

        int mainTaskId = 0;

        int cacheTreasureExp = 0;

        float timer = 0;

        public event Action OnLineStepComplete;

        int beforePlayerLv = 0;

        #region Built-in
        protected override void BindController()
        {

        }

        protected override void AddListeners()
        {
            m_BackBtn.onClick.AddListener(OnBack);
            m_GetTreasureBtn.onClick.AddListener(OnGetTreasure);
            m_LevelUpBtn.onClick.AddListener(OnLevelUp);
            m_LeftBtn.onClick.AddListener(OnLeftBtn);
            m_RightBtn.onClick.AddListener(OnRightBtn);
            m_Controller.OnRefreshCell += OnRefreshCell;
        }

        protected override void OnPreOpen()
        {
            m_Init = false;
            if (UI3DTreasureSelectStage.Instance.IsOpen)
            {
                if (UI3DTreasureSelectStage.Instance.jumpTreasure != 0)
                {
                    model.selectedTreasure = UI3DTreasureSelectStage.Instance.jumpTreasure;
                }
                else
                {
                    model.selectedTreasure = UI3DTreasureSelectStage.Instance.selectTreasure;
                }
            }
            m_DisplayContainer.gameObject.SetActive(false);
            m_ContainerSkillShow.gameObject.SetActive(false);
            m_ContainerTip.gameObject.SetActive(false);
            m_CorrectClose = false;
            m_OnLevelUpStage = false;
            m_NewBieGuide = false;
            model.treasureStepUpShow = false;
            m_TreasureAnimation.stepComplete = true;
            beforePlayerLv = PlayerDatas.Instance.baseData.LV;
            model.SetTreasureUnlockShow(TreasureCategory.Human, 0);
        }

        protected override void OnAfterOpen()
        {
            UI3DTreasureSelectStage.Instance.OnCameraCloserComplete += OnCameraCloserComplete;
            UI3DTreasureSelectStage.Instance.OnCameraBackComplete += OnCameraBackComplete;
            PlayerTaskDatas.CardLevelChange += CardLevelChange;
            model.treasureLevelProgressUpdateEvent += TreasureLevelProgressUpdateEvent;
            model.treasureSelectedEvent += TreasureSelectedEvent;
            model.treasureStageUpEvent += TreasureStageUpEvent;
            m_TreasureAnimation.OnStepComplete += OnStepComplete;
            RedpointCenter.Instance.redpointValueChangeEvent += RedpointValueChangeEvent;
            achievementModel.achievementCompletedEvent += AchievementCompletedEvent;
            m_TreasureAnimation.OnAchievementSfxComplete += OnAchievementSfxComplete;
            m_TreasureAnimation.OnAchievementTweenComplete += OnAchievementTweenComplete;
            WindowCenter.Instance.windowAfterCloseEvent += WindowAfterCloseEvent;
            m_Slider.slider.onValueChanged.AddListener(OnSliderValueUpdate);
            NewBieCenter.Instance.guideCompletedEvent += GuideCompletedEvent;
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
            m_DragSelect.onDragComplete += onDragComplete;

            CameraManager.uiCamera.enabled = true;
            if (!UI3DTreasureSelectStage.Instance.IsOpen)
            {
                UI3DTreasureSelectStage.Instance.Open(true, model.currentCategory);
                var _list = model.GetTreasureCategory(model.currentCategory);
                var _index = _list.FindIndex((x) =>
                {
                    return x == model.selectedTreasure;
                });
                UI3DTreasureSelectStage.Instance.GotoImmediatly(_index);
                OnCameraCloserComplete();
            }
            else if (UI3DTreasureSelectStage.Instance.CloserComplete && !m_Init)
            {
                OnCameraCloserComplete();
            }
            model.treasureStateChangeEvent += TreasureStateChangeEvent;

            mainTaskId = 0;
        }

        protected override void OnActived()
        {
            base.OnActived();
        }

        protected override void OnPreClose()
        {
            UI3DTreasureSelectStage.Instance.OnCameraCloserComplete -= OnCameraCloserComplete;
            UI3DTreasureSelectStage.Instance.OnCameraBackComplete -= OnCameraBackComplete;
            model.treasureLevelProgressUpdateEvent -= TreasureLevelProgressUpdateEvent;
            PlayerTaskDatas.CardLevelChange -= CardLevelChange;
            model.treasureSelectedEvent -= TreasureSelectedEvent;
            model.treasureStageUpEvent -= TreasureStageUpEvent;
            m_TreasureAnimation.OnStepComplete -= OnStepComplete;
            RedpointCenter.Instance.redpointValueChangeEvent -= RedpointValueChangeEvent;
            achievementModel.achievementCompletedEvent -= AchievementCompletedEvent;
            m_TreasureAnimation.OnAchievementSfxComplete -= OnAchievementSfxComplete;
            m_TreasureAnimation.OnAchievementTweenComplete -= OnAchievementTweenComplete;
            WindowCenter.Instance.windowAfterCloseEvent -= WindowAfterCloseEvent;
            NewBieCenter.Instance.guideCompletedEvent -= GuideCompletedEvent;
            model.treasureStateChangeEvent -= TreasureStateChangeEvent;
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
            m_DragSelect.onDragComplete -= onDragComplete;
            m_Slider.slider.onValueChanged.RemoveAllListeners();
            m_TreasurePotential.Dispose();
            m_AchievementScroll.Dispose();
            m_TreasureFairyBehaviour.Dispose();
            FunctionalGuideCenter.Instance.RemoveGuide(65);
            if (!m_CorrectClose)
            {
                UI3DTreasureSelectStage.Instance.Close();
            }
            if (m_TreasureAnimation.step == TreasureAnimation.TreasureShowStep.FirstUnLock)
            {
                model.treasureEntranceShowId = 0;
            }
            m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.None;
            model.treasureStepUpShow = false;
            model.openFromTreasureSoul = false;
            model.openFromTreasureUnlockShow = false;
            m_TreasureAnimation.stepComplete = true;
            model.openFromTaskId = 0;
            model.SetTreasureUnlockShow(TreasureCategory.Human, 0);
        }

        protected override void OnAfterClose()
        {
        }
        #endregion

        private void OnRefreshCell(ScrollerDataType type, CellView cell)
        {
            TreasureUnlockCell treasureUnlockCell = cell as TreasureUnlockCell;
            treasureUnlockCell.Display(model.selectedTreasure, cell.index);
        }

        private void TreasureStateChangeEvent(int _id)
        {
            Treasure _treasure;
            model.TryGetTreasure(_id, out _treasure);
            if (_id == model.selectedTreasure && _treasure != null
                && _treasure.state == TreasureState.Collecting && model.serverInited)
            {
                UpdateStage();
                if (WindowCenter.Instance.CheckOpen<EffectToFaBaoWin>())
                {
                    WindowCenter.Instance.CloseImmediately<EffectToFaBaoWin>();
                }
            }
        }

        private void OnCameraCloserComplete()
        {
            m_Init = true;
            m_DisplayContainer.gameObject.SetActive(true);
            UpdateStage();
            if (WindowCenter.Instance.CheckOpen<EffectToFaBaoWin>())
            {
                WindowCenter.Instance.CloseImmediately<EffectToFaBaoWin>();
            }
        }

        private void OnCameraBackComplete()
        {
            m_CorrectClose = true;
            CloseImmediately();
        }

        private void UpdateStage(int _state = 0)
        {
            m_TreasureAnimation.selectTreasureId = model.selectedTreasure;
            model.TryGetTreasure(model.selectedTreasure, out m_Treasure);
            m_TreasureProperty.SetActive(false);
            m_TreasureProperty.Display(model.selectedTreasure);
            model.cacheGotAchievements.Clear();
            var _config = Config.Instance.Get<TreasureConfig>(m_Treasure.id);
            m_TreasureProperty.treasureNameTween.SetEndState();
            switch (model.currentCategory)
            {
                case TreasureCategory.Human:
                    beforePlayerLv = PlayerDatas.Instance.baseData.LV;
                    m_TreasureDemonBehaviour.gameObject.SetActive(false);
                    m_TreasureFairyBehaviour.gameObject.SetActive(false);
                    model.treasureStepUpShow = false;
                    SelectHumanTreasure(_state);
                    m_TreasureTitle.SetSprite("XT_FB_45");
                    m_LeftBtn.image.SetSprite("XT_FB_33");
                    m_RightBtn.image.SetSprite("XT_FB_34");
                    break;
                case TreasureCategory.Demon:
                    HideHuman();
                    m_TreasureAnimation.SetDisplayEnd();
                    m_TreasureAnimation.TreasureTween();
                    m_TreasureAnimation.stepComplete = true;
                    model.treasureStepUpShow = false;
                    m_TreasureProperty.containerName.gameObject.SetActive(true);
                    m_TreasureDemonBehaviour.gameObject.SetActive(true);
                    m_TreasureFairyBehaviour.gameObject.SetActive(false);
                    m_TreasureDemonBehaviour.Display(m_Treasure.id, _state == 0);
                    if (_state == 0)
                    {
                        m_TreasureProperty.treasureNameTween.Play();
                    }
                    m_TreasureTitle.SetSprite("XT_FB_46");
                    m_LeftBtn.image.SetSprite("XT_FB_35");
                    m_RightBtn.image.SetSprite("XT_FB_36");
                    break;
                case TreasureCategory.Fairy:
                    HideHuman();
                    m_TreasureAnimation.SetDisplayEnd();
                    m_TreasureAnimation.TreasureTween();
                    m_TreasureAnimation.stepComplete = true;
                    model.treasureStepUpShow = false;
                    m_TreasureDemonBehaviour.gameObject.SetActive(false);
                    m_TreasureProperty.containerName.gameObject.SetActive(true);
                    m_TreasureFairyBehaviour.gameObject.SetActive(true);
                    m_TreasureFairyBehaviour.Dispose();
                    m_TreasureFairyBehaviour.Display(m_Treasure.id, _state == 0);
                    if (_state == 0)
                    {
                        m_TreasureProperty.treasureNameTween.Play();
                    }
                    m_TreasureTitle.SetSprite("XT_FB_47");
                    m_LeftBtn.image.SetSprite("XT_FB_33");
                    m_RightBtn.image.SetSprite("XT_FB_34");
                    break;
            }

            var _leftRifht = Config.Instance.Get<TreasureConfig>(model.selectedTreasure + 1);
            m_RightBtn.gameObject.SetActive(_leftRifht != null);
            _leftRifht = Config.Instance.Get<TreasureConfig>(model.selectedTreasure - 1);
            m_LeftBtn.gameObject.SetActive(_leftRifht != null);
        }

        private void HideHuman()
        {
            m_ContainerUnGet.gameObject.SetActive(false);
            m_ContainerPotential.gameObject.SetActive(false);
            m_ContainerLevelUp.gameObject.SetActive(false);
        }

        private void SelectHumanTreasure(int _state = 0)
        {
            m_AchievementScroll.Dispose();
            m_TreasurePotential.Dispose();
            if (m_Treasure == null || m_Treasure.state != TreasureState.Collected)
            {
                m_ContainerUnGet.gameObject.SetActive(true);
                m_ContainerPotential.gameObject.SetActive(false);
                m_ContainerLevelUp.gameObject.SetActive(false);
                UpdateTreasureUnlockDetail();
                m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.Lock;
                m_TreasureProperty.containerName.gameObject.SetActive(true);

                if (model.openFromTreasureUnlockShow)
                {
                    if(m_Treasure.id == TreasureModel.TREASURE_GUIDE_ID)
                    {
                        NewBieCenter.Instance.StartNewBieGuide(13);
                    }
                    else if (model.guideTreasures.Contains(m_Treasure.id))
                    {
                        FunctionalGuideCenter.Instance.StartGuide(62);
                    }
                }
            }
            else
            {
                m_ContainerUnGet.gameObject.SetActive(false);

                if ((m_Treasure.IsHighestStage && FuncOpen.Instance.IsFuncOpen(82) 
                    && model.GetSpAnim(m_Treasure.id)) || _state == 2)
                {
                    if (_state != 2)
                    {
                        m_ContainerLevelUp.gameObject.SetActive(false);
                        m_ContainerPotential.gameObject.SetActive(true);
                        m_TreasureAnimation.stepComplete = true;
                    }
                    else
                    {
                        m_TreasureProperty.SetActive(true);
                        model.SetSpAnim(m_Treasure.id);
                    }
                    m_TreasurePotential.Display(m_Treasure, _state);
                }
                else
                {
                    m_ContainerLevelUp.gameObject.SetActive(true);
                    m_ContainerPropgress.gameObject.SetActive(!m_Treasure.IsHighestStage);
                    m_ContainerPotential.gameObject.SetActive(false);
                    if (model.treasureEntranceShowId == model.selectedTreasure)
                    {
                        UpdateLevelUp(true);
                        m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.FirstUnLock;
                        return;
                    }
                    UpdateLevelUp();
                }
                if (_state != 2)
                {
                    if (m_TreasureAnimation.step == TreasureAnimation.TreasureShowStep.UnLock)
                    {
                        RequestMeridianLine();
                        if (model.GetTreasureStageShow(m_Treasure.id) != -1)
                        {
                            model.SetTreasureStageShow(m_Treasure.id, -1);
                            m_TreasureAnimation.OnStageLock(m_Treasure.GetStageIndex(m_Treasure.stage));
                        }
                        m_TreasureProperty.SetActive(m_Treasure.state == TreasureState.Collected);
                        if (_state == 1 && m_Treasure.IsHighestStage
                            && FuncOpen.Instance.IsFuncOpen(82) && !model.GetSpAnim(m_Treasure.id))
                        {
                            m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.FirstPotential;
                            UpdateStage(2);
                            return;
                        }
                    }
                    m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.UnLock;
                }
            }
        }

        private void OnFuncStateChangeEvent(int _id)
        {
            if (_id == 82 && FuncOpen.Instance.IsFuncOpen(_id) && model.serverInited)
            {
                if (m_TreasureAnimation.stepComplete && m_Treasure.IsHighestStage
                    && !model.GetSpAnim(m_Treasure.id))
                {
                    m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.FirstPotential;
                    UpdateStage(2);
                }
            }
        }

        private void UpdateTreasureUnlockDetail()
        {
            var _cfg = Config.Instance.Get<TreasureConfig>(model.selectedTreasure);
            m_TreasureStory.text = _cfg.Story;

            m_Controller.Refresh();
            for (int i = 0; i < m_Treasure.treasureStages.Count; i++)
            {
                var stage = m_Treasure.treasureStages[i];
                switch (stage.unlockType)
                {
                    case TreasureStageUnlock.Skill:
                    case TreasureStageUnlock.Func:
                    case TreasureStageUnlock.Treasure:
                    case TreasureStageUnlock.TreasureSoul:
                        m_Controller.AddCell(ScrollerDataType.Header, stage.stage);
                        break;
                }
            }
            m_Controller.Restart();

            Achievement achievement = null;
            int _achievementId = 0;
            bool _unlockAchievement = false;
            if (model.TryGetTreasureUnlockAchievement(m_Treasure.id, out _achievementId))
            {
                if (achievementModel.TryGetAchievement(_achievementId, out achievement))
                {
                    _unlockAchievement = true;
                }
            }
            m_GetTreasureBtn.gameObject.SetActive(!_unlockAchievement || achievement.completed);
            m_ContainerLimit.gameObject.SetActive(_unlockAchievement && !achievement.completed);

            if (model.IsVersionUnOpenTreasure(m_Treasure.id))
            {
                m_TreasureChallengeLimit.text = Language.Get("TreasureNoOpen");
                return;
            }

            if (_unlockAchievement && !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;
                }
                switch (_achievementConfig.Type)
                {
                    case 1:
                        m_TreasureChallengeLimit.text = Language.Get("TreasureChallengeLv", _achievementConfig.Condition[0]);
                        break;
                    case 3:
                        m_TreasureChallengeLimit.text = Language.Get("TreasureGetRequire", _taskConfig.lv);
                        break;
                }
            }
        }

        private void TreasureSelectedEvent(int _id)
        {
            if (!m_TreasureAnimation.stepComplete)
            {
                return;
            }
            var _list = model.GetTreasureCategory(model.currentCategory);
            var _index = _list.FindIndex((x) =>
            {
                return x == _id;
            });
            if (_index != -1)
            {
                m_OnLevelUpStage = false;
                UI3DTreasureSelectStage.Instance.GotoImmediatly(_index);
                UpdateStage(1);
            }
        }

        private void onDragComplete(int _value)
        {
            if (_value > 0)
            {
                OnRightBtn();
            }
            else if (_value < 0)
            {
                OnLeftBtn();
            }
        }

        private void OnLeftBtn()
        {
            if (CheckSelectTreasureFunc(model.selectedTreasure - 1))
            {
                model.openFromTaskId = 0;
                FunctionalGuideCenter.Instance.RemoveGuide(65);
                model.selectedTreasure = model.selectedTreasure - 1;
            }
        }

        private void OnRightBtn()
        {
            if (CheckSelectTreasureFunc(model.selectedTreasure + 1))
            {
                model.openFromTaskId = 0;
                FunctionalGuideCenter.Instance.RemoveGuide(65);
                model.selectedTreasure = model.selectedTreasure + 1;
            }
        }

        private bool CheckSelectTreasureFunc(int _id)
        {
            Treasure _treasure;
            if (!model.TryGetTreasure(_id, out _treasure))
            {
                return false;
            }
            if (model.TreasureStageUpLimit(model.selectedTreasure))
            {
                return false;
            }
            return m_TreasureAnimation.stepComplete && !model.treasureStepUpShow && !m_NewBieGuide;
        }

        private void OnBack()
        {
            if (!m_TreasureAnimation.stepComplete || model.treasureStepUpShow || m_NewBieGuide)
            {
                return;
            }
            if (model.TreasureStageUpLimit(model.selectedTreasure))
            {
                return;
            }
            if (PlayerDatas.Instance.baseData.LV < model.treasureBackLvLimit
                && !WindowJumpMgr.Instance.IsJumpState)
            {
                StartBack();
                return;
            }
            if (!WindowJumpMgr.Instance.IsJumpState && model.openFromTreasureList)
            {
                StartBack();
                return;
            }
            if (!WindowJumpMgr.Instance.IsJumpState && model.exitRecord >= 4)
            {
                StartBack();
                model.exitRecord = 0;
                return;
            }
            model.openFromTreasureList = false;
            CloseImmediately();
            if (!WindowJumpMgr.Instance.IsJumpState)
            {
                model.exitRecord++;
                WindowCenter.Instance.Open<MainInterfaceWin>();
            }
        }

        void StartBack()
        {
            model.SetTreasureUnlockShow(TreasureCategory.Human, 0);
            model.openFromTreasureList = false;
            m_DisplayContainer.gameObject.SetActive(false);
            WindowCenter.Instance.Open<TreasureSelectWin>(true);
            UI3DTreasureSelectStage.Instance.StartBack();
        }

        private void OnGetTreasure()
        {
            var _cfg = Config.Instance.Get<TreasureConfig>(model.selectedTreasure);
            if (_cfg != null)
            {
                if (PlayerDatas.Instance.baseData.LV >= _cfg.ChallengeLevel)
                {
                    model.collectingHuman = model.selectedTreasure;
                    dungeonModel.SingleChallenge(TreasureModel.TREASURE_DATAMAPID, _cfg.LineId);
                }
            }
        }

        private void UpdateLevelUp(bool _firstUnlock = false)
        {
            DisplayAchievements(true, !_firstUnlock);
            UpdateTreasureMeridian();
            UpdateTreasureProgress(true);
            UpdateLevelUpSfx(m_TreasureAnimation.step != TreasureAnimation.TreasureShowStep.UnLock);
        }

        private void OnAchievementTweenComplete()
        {
            DisplayAchievements(true, true);
            if (m_Treasure.id == TreasureModel.TREASURE_GUIDE_ID
                && !NewBieCenter.Instance.completeGuidesBuf.Contains(15) && NewBieCenter.Instance.completeGuidesBuf.Contains(14)
                && IsComplete15GuidAchivement())
            {
                m_NewBieGuide = true;
                m_AchievementScroll.ResetScrollItemName();
                NewBieCenter.Instance.StartNewBieGuide(15);
            }
            else
            {
                CheckGuide65();
            }
        }

        private bool IsComplete15GuidAchivement()
        {
            Achievement achievement;
            if (achievementModel.TryGetAchievement(11, out achievement))
            {
                if (!Achievement.IsReach(11, achievement.progress) || achievement.completed)
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
            if (achievementModel.TryGetAchievement(12, out achievement))
            {
                if (!Achievement.IsReach(12, achievement.progress) || achievement.completed)
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
            return true;
        }

        private void CheckGuide65()
        {
            if (model.openFromTreasureCollect)
            {
                model.openFromTreasureCollect = false;
                foreach (var value in task.MainTaskDic.Values)
                {
                    if (task.GetTaskStatus(value.ID) == PlayerTaskDatas.TaskStatus.TreasureCardLevel)
                    {
                        model.openFromTaskId = value.ID;
                        break;
                    }
                }
            }
            if (model.openFromTaskId != 0
                && model.castSoulGuideTaskIds.Contains(model.openFromTaskId)
                && task.GetTaskStatus(model.openFromTaskId) == PlayerTaskDatas.TaskStatus.TreasureCardLevel
                && m_Treasure.achievementRedpoint.state == RedPointState.None
                && m_Treasure is HumanTreasure
                && (m_Treasure as HumanTreasure).castSoulRedpoint.state == RedPointState.None)
            {
                m_AchievementScroll.ResetScrollItemName();
                FunctionalGuideCenter.Instance.StartGuide(65);
            }
        }

        private void DisplayAchievements(bool _stepByStep, bool _show = true)
        {
            if (m_Treasure.achievementGroups != null)
            {
                m_AchievementScroll.HideAll();
                m_AchievementScroll.gameObject.SetActive(true);
                if (_show)
                {
                    var achievementGroups = new List<AchievementGroup>(m_Treasure.achievementGroups.Values);
                    m_AchievementScroll.ShowTreasures(achievementGroups, _stepByStep);
                }
            }
            else
            {
                m_AchievementScroll.gameObject.SetActive(false);
            }
        }

        private void AchievementCompletedEvent(int _id)
        {
            var config = Config.Instance.Get<TreasureConfig>(model.selectedTreasure);
            if (!m_Init || config == null || (TreasureCategory)config.Category != TreasureCategory.Human
                || m_Treasure.state != TreasureState.Collected || m_Treasure.IsHighestStage)
            {
                return;
            }
            TreasureAchievement treasureAchievement;
            m_AchievementScroll.TryGetTreasureAchievement(_id, out treasureAchievement);
            if (treasureAchievement != null)
            {
                m_TreasureAnimation.ShowAchievementCompleteSfx(treasureAchievement.rectTransform, _id);
            }
        }

        private void OnAchievementSfxComplete(int _id)
        {
            if (model.cacheGotAchievements.Contains(_id))
            {
                model.cacheGotAchievements.Remove(_id);
                UpdateTreasureProgress(false, _id);
                CheckGuide65();
            }
        }

        private void UpdateTreasureMeridian()
        {
            TreasureMeridianConfig _config = ScriptableObjectLoader.LoadSoTreasureMeridian(model.selectedTreasure);
            if (m_Treasure != null)
            {
                var _index = 0;
                for (int i = 0; i < m_Treasure.treasureStages.Count; i++)
                {
                    m_TreasureMeridians[_index].StopSfx();
                    if (i == 0 && m_Treasure.treasureStages[0].unlockType == TreasureStageUnlock.None)
                    {
                        continue;
                    }
                    if (_index < m_TreasureMeridians.Length)
                    {
                        m_TreasureMeridians[_index].gameObject.SetActive(true);
                        m_TreasureMeridians[_index].Display(i, _index, this);
                        if (_config != null)
                        {
                            m_TreasureMeridians[_index].scaleTween.to = Vector3.one;
                            m_TreasureMeridians[_index].scaleTween.SetEndState();
                            m_TreasureMeridians[_index].transform.localPosition = _config[_index].position;
                            //m_TreasureMeridians[_index].icon.transform.localScale = _config[_index].scale * Vector3.one;
                            m_TreasureMeridians[_index].SetScale(_config[_index].scale);
                            m_TreasureMeridians[_index].scaleTween.delay = _config[_index].scaleTweenDelay;
                            m_TreasureMeridians[_index].scaleTween.from = _config[_index].scaleTweenTo * Vector3.one;
                        }
                        _index++;
                    }
                }
                for (int i = _index; i < m_TreasureMeridians.Length; i++)
                {
                    m_TreasureMeridians[i].gameObject.SetActive(false);
                    m_TreasureMeridians[_index].StopSfx();
                }
            }
        }

        private void OnStepComplete(TreasureAnimation.TreasureShowStep _step)
        {
            switch (_step)
            {
                case TreasureAnimation.TreasureShowStep.UnLock:
                    RequestMeridianLine();
                    UpdateLevelUpSfx(false);
                    m_TreasureProperty.SetActive(m_Treasure.state == TreasureState.Collected);
                    if (model.openFromTreasureSoul)
                    {
                        var config = ScriptableObjectLoader.LoadSoTreasureMeridian(model.selectedTreasure);
                        m_TreasureMeridians[config.stagePointNum - 1].StartSoulTween();
                    }
                    if (model.GetTreasureStageShow(m_Treasure.id) != -1)
                    {
                        model.SetTreasureStageShow(m_Treasure.id, -1);
                        m_TreasureAnimation.OnStageLock(m_Treasure.GetStageIndex(m_Treasure.stage));
                    }
                    if (!m_Treasure.IsHighestStage)
                    {
                        CheckGuide65();
                    }
                    else if (FuncOpen.Instance.IsFuncOpen(82) && !model.GetSpAnim(m_Treasure.id))
                    {
                        m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.FirstPotential;
                        UpdateStage(2);
                    }
                    break;
                case TreasureAnimation.TreasureShowStep.FirstUnLock:
                    UpdateLevelUpSfx(false);
                    m_TreasureProperty.SetActive(m_Treasure.state == TreasureState.Collected);
                    var _config = ScriptableObjectLoader.LoadSoTreasureMeridian(model.selectedTreasure);
                    for (int i = 0; i < _config.stagePointNum; i++)
                    {
                        m_TreasureMeridians[i].RequestStateSfx();
                    }
                    if (m_Treasure.treasureStages[0].unlockType != TreasureStageUnlock.None)
                    {
                        model.SetTreasureStageShow(m_Treasure.id, m_Treasure.stage);
                    }
                    break;
                case TreasureAnimation.TreasureShowStep.FirstPotential:
                    break;
            }
        }

        private void WindowAfterCloseEvent(Window _win)
        {
            if (_win is TreasureNewStageWin || _win is TreasureSoulActiveWin)
            {
                if (m_Treasure.IsHighestStage && FuncOpen.Instance.IsFuncOpen(82))
                {
                    m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.FirstPotential;
                    UpdateStage(2);
                }
                else
                {
                    if (mainTaskId != 0)
                    {
                        CloseImmediately();
                        WindowCenter.Instance.Open<MainInterfaceWin>();
                        task.AutomaticTripToTask(mainTaskId);
                    }
                    else
                    {
                        var stage = m_Treasure.treasureStages[m_Treasure.stage];
                        model.SetTreasureStageShow(m_Treasure.id, -1);
                        m_TreasureAnimation.OnStageLock(m_Treasure.GetStageIndex(stage.stage));
                    }
                }
            }
        }

        private void RequestMeridianLine()
        {
            if (m_Treasure.IsHighestStage && FuncOpen.Instance.IsFuncOpen(82))
            {
                return;
            }
            var _config = ScriptableObjectLoader.LoadSoTreasureMeridian(model.selectedTreasure);
            for (int i = 0; i < _config.stagePointNum; i++)
            {
                m_TreasureMeridians[i].RequestSfx();
            }
        }

        private void TreasureLevelProgressUpdateEvent(int _treasureId)
        {
            if (_treasureId != model.selectedTreasure)
            {
                return;
            }
            if (model.cacheGotAchievements.Count == 0 || m_OnLevelUpStage)
            {
                UpdateTreasureProgress();
            }
        }

        private void TreasureStageUpEvent(int _treasureId)
        {
            if (_treasureId != model.selectedTreasure)
            {
                return;
            }
            m_TreasureProperty.Display(_treasureId, true);
            if (m_OnLevelUpStage)
            {
                var stage = m_Treasure.treasureStages[m_Treasure.stage];
                var _index = stage.stage;
                if (m_Treasure.treasureStages[0].unlockType == TreasureStageUnlock.None)
                {
                    _index -= 1;
                }
                m_TreasureAnimation.OnStageUpLineComplete -= OnStageUpLineComplete;
                m_TreasureAnimation.OnStageUpLineComplete += OnStageUpLineComplete;
                timer = 0f;
                model.treasureStepUpShow = true;
                m_TreasureAnimation.OnStageUp(_index);
                model.cacheGotAchievements.Clear();
            }
        }

        private void OnStageUpLineComplete()
        {
            if (OnLineStepComplete != null)
            {
                OnLineStepComplete();
            }

            m_OnLevelUpStage = false;

            m_TreasureAnimation.OnStageUpLineComplete -= OnStageUpLineComplete;
            var stage = m_Treasure.treasureStages[m_Treasure.stage];
            switch (stage.unlockType)
            {
                case TreasureStageUnlock.Func:
                    m_ContainerTip.gameObject.SetActive(true);
                    var _funcConfig = Config.Instance.Get<FuncOpenLVConfig>(stage.func);
                    m_NewStageTip.text = StringUtility.Contact(Language.Get("TreasureGetNewFunc"),
                        UIHelper.GetTextColorByItemColor(TextColType.Green, _funcConfig.Remark));
                    break;
            }
            StartCoroutine(Co_StepUpComplete());
        }

        IEnumerator Co_StepUpComplete()
        {
            var _selectTreasure = model.selectedTreasure;
            yield return WaitingForSecondConst.WaitMS1000;
            m_ContainerTip.gameObject.SetActive(false);
            if (_selectTreasure != model.selectedTreasure)
            {
                yield break;
            }
            model.treasureStepUpShow = false;
            var stage = m_Treasure.treasureStages[m_Treasure.stage];
            var _index = m_Treasure.GetStageIndex(stage.stage);
            model.SetTreasureStageShow(m_Treasure.id, stage.stage);

            if (WindowCenter.Instance.CheckOpen<TreasureStageTipWin>())
            {
                WindowCenter.Instance.CloseImmediately<TreasureStageTipWin>();
            }

            switch (stage.unlockType)
            {
                case TreasureStageUnlock.Skill:
                    var _config = Config.Instance.Get<SkillConfig>(m_Treasure.unLockSkill);
                    m_ContainerSkillShow.gameObject.SetActive(true);
                    m_HeroShowSkill.SetSprite(_config.IconName);
                    m_HeroShowSkillName.SetSprite(StringUtility.Contact("SkillName_", _config.SkillID));
                    m_HeroShowSkillName.SetNativeSize();
                    m_TreasureAnimation.OnHeroSkillShow(_index);
                    PlaySkillShow();
                    break;
                case TreasureStageUnlock.Func:
                    StartScreenShot();
                    break;
                case TreasureStageUnlock.Item:
                case TreasureStageUnlock.Property:
                    WindowCenter.Instance.Open<TreasureNewStageWin>(true);
                    break;
                case TreasureStageUnlock.Treasure:
                    WindowJumpMgr.Instance.ClearJumpData();
                    WindowCenter.Instance.Open<MainInterfaceWin>();
                    CloseImmediately();
                    break;
                case TreasureStageUnlock.TreasureSoul:
                    TreasureSoulActiveWin.treasureSoulId = stage.treasureSoul;
                    WindowCenter.Instance.Open<TreasureSoulActiveWin>(true);
                    break;
            }
        }

        private void CardLevelChange(int _id)
        {
            if (task.MainTaskDic.ContainsKey(_id))
            {
                mainTaskId = _id;
            }
        }

        private void StartScreenShot()
        {
            CameraUtility.ScreenShotCut((Texture2D _tex) =>
            {
                TreasureStageUpTriggerWin.screenShotCut = _tex;
                WindowJumpMgr.Instance.ClearJumpData();
                CloseImmediately();
                WindowCenter.Instance.Open<TreasureStageUpTriggerWin>(true);
                WindowCenter.Instance.Open<MainInterfaceWin>();
                if (WindowCenter.Instance.CheckOpen<DialogueDuidanceWin>())
                {
                    WindowCenter.Instance.CloseImmediately<DialogueDuidanceWin>();
                }
                if (WindowCenter.Instance.CheckOpen<TaskBoxBGMWin>())
                {
                    WindowCenter.Instance.CloseImmediately<TaskBoxBGMWin>();
                }
                m_ContainerSkillShow.gameObject.SetActive(false);
            });
        }

        private void PlaySkillShow()
        {
            m_DisplayContainer.gameObject.SetActive(false);
            UI3DTreasureSelectStage.Instance.CloseRenderCamera();
            UI3DHeroSkillShow.Instance.ShowTreasureSkill(m_Treasure.id, () =>
            {
                m_DisplayContainer.gameObject.SetActive(true);
                UI3DTreasureSelectStage.Instance.OpenRenderCamera();
                StartScreenShot();
            });
        }

        private void OnLevelUp()
        {
            if (!m_TreasureAnimation.stepComplete)
            {
                return;
            }
            if (m_Treasure == null)
            {
                return;
            }
            var _nextStage = m_Treasure.treasureStages.Find((x) =>
            {
                return x.stage == m_Treasure.stage + 1;
            });
            if (_nextStage != null)
            {
                if (m_Treasure.exp >= _nextStage.exp)
                {
                    m_OnLevelUpStage = true;
                    CA515_tagCMMagicWeaponUp _pak = new CA515_tagCMMagicWeaponUp();
                    _pak.MWID = (uint)model.selectedTreasure;
                    GameNetSystem.Instance.SendInfo(_pak);
                }
            }
        }

        private void UpdateLevelUpSfx(bool _animation)
        {
            m_LevelUpSfx.StopImediatly();
            HumanTreasure humanTreasure = m_Treasure as HumanTreasure;
            m_LevelUpBtn.SetInteractable(m_LevelUpTxt, false);
            if (humanTreasure == null)
            {
                return;
            }
            if (humanTreasure.castSoulRedpoint.state == RedPointState.Simple)
            {
                m_LevelUpBtn.SetInteractable(m_LevelUpTxt, true);
                if (!_animation)
                {
                    m_LevelUpSfx.Play();
                    if (m_Treasure.id == TreasureModel.TREASURE_GUIDE_ID && m_Treasure.stage == 0
                        && !NewBieCenter.Instance.completeGuidesBuf.Contains(16)
                        && NewBieCenter.Instance.completeGuidesBuf.Contains(15)
                        && humanTreasure.castSoulRedpoint.state == RedPointState.Simple)
                    {
                        NewBieCenter.Instance.StartNewBieGuide(16);
                    }
                }
            }
        }

        private void GuideCompletedEvent(int _id)
        {
            if (_id == 15)
            {
                m_NewBieGuide = false;
            }
        }

        private void UpdateTreasureProgress(bool _force = false, int _id = 0)
        {
            if (_id == 0)
            {
                cacheTreasureExp = m_Treasure.exp;
                model.cacheGotAchievements.Clear();
            }
            else
            {
                var _successConfig = Config.Instance.Get<SuccessConfig>(_id);
                var _exp = 0;
                int.TryParse(_successConfig.MagicWeaponExp, out _exp);
                cacheTreasureExp += _exp;
            }
            var _nextStage = m_Treasure.treasureStages.Find((x) =>
            {
                return x.stage == m_Treasure.stage + 1;
            });
            if (_nextStage != null)
            {
                m_Slider.delay = _force ? 0 : 0.2f;
                float _value= (float)cacheTreasureExp / _nextStage.exp;
                if (_value < m_Slider.value)
                {
                    m_Slider.delay = 0;
                }
                m_Slider.value = _value;
                m_TreasureLevelProgress.text = StringUtility.Contact(cacheTreasureExp, "/",
                    _nextStage.exp);
                switch (_nextStage.unlockType)
                {
                    case TreasureStageUnlock.Property:
                        foreach (var _key in _nextStage.propertyDict.Keys)
                        {
                            var _propertyCfg = Config.Instance.Get<PlayerPropertyConfig>(_key);
                            m_TreasureStageDesc.text = StringUtility.Contact(_propertyCfg.Name, " +",
                               UIHelper.ReplaceLargeNum(_nextStage.propertyDict[_key]));
                            if (GeneralConfig.Instance.propertyIconDict.ContainsKey(_key))
                            {
                                m_CurrentStageIcon.SetSprite(GeneralConfig.Instance.propertyIconDict[_key]);
                            }
                            break;
                        }
                        break;
                    case TreasureStageUnlock.Skill:
                        var _skillId = _nextStage.GetSkill(PlayerDatas.Instance.baseData.Job);
                        var _skillCfg = Config.Instance.Get<SkillConfig>(_skillId);
                        m_TreasureStageDesc.text = Language.Get("TreasureLevelUpFunction", _skillCfg.SkillName);
                        m_CurrentStageIcon.SetSprite(_skillCfg.IconName);
                        break;
                    case TreasureStageUnlock.Func:
                        var _funcCfg = Config.Instance.Get<FuncOpenLVConfig>(_nextStage.func);
                        m_TreasureStageDesc.text = Language.Get("TreasureLevelUpSkill", _funcCfg.Remark);
                        m_CurrentStageIcon.SetSprite(_funcCfg.Icon);
                        break;
                    case TreasureStageUnlock.Item:
                        var _itemConfig = Config.Instance.Get<ItemConfig>(_nextStage.item.id);
                        m_CurrentStageIcon.SetSprite(_itemConfig.IconKey);
                        m_TreasureStageDesc.text = Language.Get("TreasureLevelUpItem", _itemConfig.ItemName);
                        break;
                    case TreasureStageUnlock.Treasure:
                        var _treasureConfig = Config.Instance.Get<TreasureConfig>(_nextStage.treasure);
                        m_CurrentStageIcon.SetSprite(_treasureConfig.Icon);
                        m_TreasureStageDesc.text = Language.Get("TreasureLevelUpTreasure", _treasureConfig.Name);
                        break;
                    case TreasureStageUnlock.TreasureSoul:
                        var _treasureSoulConfig = Config.Instance.Get<TreasurePrivilegeConfig>(_nextStage.treasureSoul);
                        m_CurrentStageIcon.SetSprite(_treasureSoulConfig.Icon);
                        m_TreasureStageDesc.text = Language.Get("TreasureLevelUpTreasureSoul", _treasureSoulConfig.Name);
                        break;
                }
            }
            else
            {
                m_Slider.delay = 0;
                m_Slider.value = 1;
                m_TreasureLevelProgress.text = StringUtility.Contact(m_Treasure.exp, "/", m_Treasure.exp);
                m_TreasureStageDesc.text = string.Empty;
            }
            var effectType = cacheTreasureExp == 0 ? 0 : m_Slider.value < 1 ? 1 : 2;
            m_AwardEffectResponse.ActiveEffect(effectType);
            if (m_Slider.value < 1)
            {
                m_AwardEffectResponse.FullEffectState(false);
            }
        }

        private void OnSliderValueUpdate(float _progress)
        {
            m_AwardEffectResponse.FullEffectState(_progress >= 0.99f);
            if (m_LevelUpBtn.interactable)
            {
                return;
            }
            if (_progress >= 0.99f)
            {
                UpdateLevelUpSfx(false);
            }
        }

        private void RedpointValueChangeEvent(int _id)
        {
            var _human = m_Treasure as HumanTreasure;
            if (_human != null && _human.castSoulRedpoint.id == _id)
            {
                if (_human.castSoulRedpoint.state == RedPointState.None || m_Slider.slider.value > 0.98f)
                {
                    UpdateLevelUpSfx(false);
                }
            }
        }

        protected override void LateUpdate()
        {
            base.LateUpdate();
            if (model.treasureStepUpShow)
            {
                timer += Time.deltaTime;
                if (timer > 8f)
                {
                    model.treasureStepUpShow = false;
                }
            }
        }

#if UNITY_EDITOR
        [SerializeField, Header("测试技能Show技能id")] int m_PreviewHeroSkillId;
        [ContextMenu("Preview")]
        public void PreviewHreoSkill()
        {
            m_TreasureAnimation.OnHeroSkillShow(m_Treasure.GetStageIndex(m_Treasure.stage));
            PlaySkillShow();
        }

        [ContextMenu("测试动画")]
        public void PreviewAnimation()
        {
            m_TreasureAnimation.step = TreasureAnimation.TreasureShowStep.FirstPotential;
            UpdateStage(2);
        }

        [ContextMenu("测试功能开启")]
        public void PreviewFuncOpen()
        {
            StartScreenShot();
        }

        [ContextMenu("测试成就特效")]
        public void PreviewSfx()
        {
            AchievementCompletedEvent(m_Treasure.achievementGroups.Values.First().GetDoingAchievement());
        }
#endif
    }

}