//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, October 09, 2017
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using TableConfig;
using System;

namespace Snxxz.UI
{

    public class TreasureAchievement : ScrollItem
    {
        [SerializeField] Text m_Description;
        [SerializeField] RectTransform m_ContainerReward;
        [SerializeField] ItemBehaviour[] itemBehaviours;
        [SerializeField] Text m_Progress;
        [SerializeField] Button m_Goto;
        [SerializeField] Button m_AcceptAward;
        [SerializeField] Image m_CompleteSign;
        [SerializeField] Text m_SoulExp;
        [SerializeField] TreasureCyclicScroll m_TreasureCyclicScroll;

        [SerializeField] UIAlphaTween m_AlphaTween;
        public UIAlphaTween alphaTween { get { return m_AlphaTween; } }

        [SerializeField] UILinerMove m_LinerMove;
        public UILinerMove linerMove { get { return m_LinerMove; } }

        [SerializeField] TreasureAchievementUnfoldShow m_UnfoldShow;
        public TreasureAchievementUnfoldShow unfoldShow { get { return m_UnfoldShow; } }

        TreasureModel treasureModel { get { return ModelCenter.Instance.GetModel<TreasureModel>(); } }
        AchievementModel model { get { return ModelCenter.Instance.GetModel<AchievementModel>(); } }
        PlayerTaskDatas task { get { return ModelCenter.Instance.GetModel<PlayerTaskDatas>(); } }

        AchievementGroup m_AchievementGroup;
        public AchievementGroup achievementGroup {
            get { return m_AchievementGroup; }
            private set { m_AchievementGroup = value; }
        }

        Achievement achievement;
        Treasure treasure;

        bool hiding = false;

        public override void Display(object _data)
        {
            base.Display(_data);

            hiding = false;

            model.achievementProgressUpdateEvent -= OnAchievementProgressUpdate;
            model.achievementCompletedEvent -= OnAchievementCompleted;

            treasureModel.treasureStateChangeEvent -= TreasureStateChangeEvent;

            if (!treasureModel.TryGetTreasure(treasureModel.selectedTreasure, out treasure))
            {
                return;
            }

            m_AchievementGroup = (AchievementGroup)_data;

            var achievementId = 0;
            if (m_AchievementGroup.IsCompleted())
            {
                achievementId = m_AchievementGroup.GetLastAchievement();
            }
            else
            {
                achievementId = m_AchievementGroup.GetDoingAchievement();
            }

            DisplayAchievementDetails(achievementId);

            m_Goto.RemoveAllListeners();
            m_Goto.AddListener(GotoComplete);

            m_AcceptAward.RemoveAllListeners();
            m_AcceptAward.AddListener(GetAward);

            model.achievementProgressUpdateEvent += OnAchievementProgressUpdate;
            model.achievementCompletedEvent += OnAchievementCompleted;
            treasureModel.treasureStateChangeEvent += TreasureStateChangeEvent;
        }

        private void TreasureStateChangeEvent(int _id)
        {
            if (treasure != null && treasure.id == _id && m_AchievementGroup != null)
            {
                var achievementId = m_AchievementGroup.GetLastAchievement();
                DisplayAchievementDetails(achievementId);
            }
        }

        public override void Dispose()
        {
            base.Dispose();

            m_UnfoldShow.Stop();
            m_Goto.RemoveAllListeners();
            m_AcceptAward.RemoveAllListeners();
            model.achievementProgressUpdateEvent -= OnAchievementProgressUpdate;
            model.achievementCompletedEvent -= OnAchievementCompleted;
            treasureModel.treasureStateChangeEvent -= TreasureStateChangeEvent;

            if (FunctionalGuideCenter.Instance.ExistAnyUnderwayGuide()
                && this.name.Equals("Achievement_0"))
            {
                FunctionalGuideCenter.Instance.RemoveGuide(65);
            }
        }

        public override void OpeningShow()
        {
            base.OpeningShow();
            m_UnfoldShow.Begin();
        }

        private void GotoComplete()
        {
            if (m_TreasureCyclicScroll.showing || treasureModel.treasureStepUpShow
                || treasureModel.TreasureStageUpLimit(treasureModel.selectedTreasure))
            {
                return;
            }
            FunctionalGuideCenter.Instance.RemoveGuide(65);
            model.GotoCompleteAchievement(achievement.id);

            var guid = model.GetBetterEquipByPlace();

            if (achievement.id == GeneralConfig.Instance.specialGuide41Achievement
                && task.GetTaskStatus(GeneralConfig.Instance.specialGuide41Mission)
                == PlayerTaskDatas.TaskStatus.TreasureCardLevel
                && !NewBieCenter.Instance.completeGuidesBuf.Contains(41)
                && string.IsNullOrEmpty(guid))
            {
                NewBieCenter.Instance.StartNewBieGuide(41);
            }
        }

        private void GetAward()
        {
            if (m_TreasureCyclicScroll.showing || treasureModel.treasureStepUpShow)
            {
                return;
            }
            model.GetAchievementReward(achievement.id);
            if (!treasureModel.cacheGotAchievements.Contains(achievement.id))
            {
                treasureModel.cacheGotAchievements.Add(achievement.id);
            }
        }

        private void OnAchievementProgressUpdate(int _achievementId)
        {
            if (achievement.id != _achievementId)
            {
                return;
            }

            var config = Config.Instance.Get<SuccessConfig>(achievement.id);
            var reach = achievement.progress >= config.NeedCnt;
            m_Progress.text = StringUtility.Contact(Mathf.Clamp(achievement.progress, 0, config.NeedCnt), "/", config.NeedCnt);
            m_Goto.gameObject.SetActive(config.NeedGoto == 1 && !reach);
            m_AcceptAward.gameObject.SetActive(reach && !achievement.completed);
        }

        private void OnAchievementCompleted(int _achievement)
        {
            if (!achievementGroup.Contain(_achievement))
            {
                return;
            }

            var achievementId = 0;
            if (m_AchievementGroup.IsCompleted())
            {
                achievementId = m_AchievementGroup.GetLastAchievement();
                if (treasureModel.serverInited)
                {
                    hiding = true;
                    m_TreasureCyclicScroll.ShowBegin(this);
                }
            }
            else
            {
                achievementId = m_AchievementGroup.GetDoingAchievement();
                if (!m_AchievementGroup.IsAwardable())
                {
                    if (treasureModel.serverInited)
                    {
                        m_TreasureCyclicScroll.ShowBegin(this);
                    }
                }
            }

            DisplayAchievementDetails(achievementId);
        }

        private void DisplayAchievementDetails(int _achievementId)
        {
            if (!model.TryGetAchievement(_achievementId, out achievement))
            {
                return;
            }

            m_ContainerReward.gameObject.SetActive(true);

            var items = achievement.GetAllBehaviourItems();
            if (items == null || items.Length == 0)
            {
                for (int i = 0; i < 1; i++)
                {
                    var behaviour = itemBehaviours[i];
                    behaviour.gameObject.SetActive(i == 0);
                    if (i == 0)
                    {
                        behaviour.SetItem(2103, 0);
                    }
                }
            }
            else
            {
                for (int i = 0; i < itemBehaviours.Length; i++)
                {
                    var behaviour = itemBehaviours[i];
                    if (i < items.Length)
                    {
                        behaviour.gameObject.SetActive(true);
                        behaviour.SetItem(items[i]);
                    }
                    else
                    {
                        behaviour.gameObject.SetActive(false);
                    }
                }
            }

            var config = Config.Instance.Get<SuccessConfig>(achievement.id);
            var reach = achievement.progress >= config.NeedCnt;
            var completed = achievement.completed;

            m_CompleteSign.gameObject.SetActive(completed && !hiding);
            m_Description.text = AchievementModel.ParseAchievementDescription(achievement.id);
            if (m_SoulExp != null)
            {
                m_SoulExp.text = config.MagicWeaponExp;
            }
            m_Progress.text = StringUtility.Contact(completed ? config.NeedCnt : Mathf.Clamp(achievement.progress, 0, config.NeedCnt), "/", config.NeedCnt);

            m_Goto.gameObject.SetActive(config.NeedGoto == 1 && treasure.state != TreasureState.Locked && !reach && !completed);
            m_AcceptAward.gameObject.SetActive(treasure.state != TreasureState.Locked && reach && !completed);

            hiding = false;
        }

    }

}