//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Saturday, September 16, 2017
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using System;


namespace vnxbqy.UI
{

    public class DailyQuestBehaviour : MonoBehaviour
    {
        [SerializeField] Text m_Title;
        [SerializeField] RectTransform m_ContainerTimes;
        [SerializeField] Text m_TimesUnit;
        [SerializeField] TextEx m_Times;
        [SerializeField] Text m_PracticePoint;
        [SerializeField] Text m_UnLockCondition;
        [SerializeField] TextEx m_Supplementary;
        [SerializeField] FontColorSizeConfig m_TimeColor;
        [SerializeField] Text m_AssistPoint;
        [SerializeField] Text m_GotoTxt;
        [SerializeField] Image m_Icon;
        [SerializeField] Button m_Details;
        [SerializeField] Button m_Goto;
        [SerializeField] Button m_Func;
        [SerializeField] Text m_FuncDisplay;
        [SerializeField] RectTransform m_TimeMiss;
        [SerializeField] Transform m_Complete;
        [SerializeField] Transform m_Locked;
        [SerializeField] RedpointBehaviour m_RedpointBehaviour;
        [SerializeField] RedpointBehaviour m_FuncRedpointBehaviour;
        [SerializeField] UIEffect m_UIEffect;
        [SerializeField] Image m_AwardImg;

        AchievementGuideEffect m_AchievementEffect;

        DailyQuestData data;
        DailyQuestConfig dailyQuestConfig;

        DailyQuestModel model { get { return ModelCenter.Instance.GetModel<DailyQuestModel>(); } }
        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
        TrialDungeonModel trialDungeonModel { get { return ModelCenter.Instance.GetModel<TrialDungeonModel>(); } }

        DailyQuestModel.DailyQuestState state = DailyQuestModel.DailyQuestState.Normal;

        public void Init(DailyQuestData _data)
        {
            data = _data;

            if (data == null || data.id <= 0)
            {
                return;
            }

            this.gameObject.name = StringUtility.Contact("DailyQuestBehaviour_", data.id);
            DisplayProgressAndActiveValue();

            if (model.IsNewDailyQuest(data.id))
            {
                m_UIEffect.maskArea = this.transform.parent.parent.parent.GetComponent<RectTransform>();
                m_UIEffect.Play();
            }
            else
            {
                m_UIEffect.Stop();
            }

            dailyQuestConfig = DailyQuestConfig.Get(this.data.id);
            m_Title.text = dailyQuestConfig.Title;
            m_Icon.SetSprite(dailyQuestConfig.Icon);

            m_AwardImg.SetActive(false);
            if (dailyQuestConfig.AwardImg != string.Empty)
            {
                m_AwardImg.SetActive(true);
                m_AwardImg.SetSprite(dailyQuestConfig.AwardImg);
            }

            m_Goto.RemoveAllListeners();
            m_Goto.AddListener(GotoDailyQuest);

            m_Func.RemoveAllListeners();
            m_Func.AddListener(GotoFunc);

            m_Details.RemoveAllListeners();
            m_Details.AddListener(ShowDetails);

            if (_data.redpoint != null)
            {
                m_RedpointBehaviour.SetActive(true);
                m_RedpointBehaviour.redpointId = _data.redpoint.id;
            }
            else
            {
                m_RedpointBehaviour.SetActive(false);
            }

            switch ((DailyQuestType)data.id)
            {
                default:
                    m_FuncRedpointBehaviour.redpointId = 0;
                    break;
            }

            CheckAchievementGuide();
            model.dailyQuestProgressUpdateEvent -= OnProgressUpdate;
            model.dailyQuestProgressUpdateEvent += OnProgressUpdate;
            dungeonModel.updateDungeonBuyCnt -= OnTotalTimeChange;
            dungeonModel.updateDungeonBuyCnt += OnTotalTimeChange;
            dungeonModel.dungeonRecordChangeEvent -= OnDungeonRecordChange;
            dungeonModel.dungeonRecordChangeEvent += OnDungeonRecordChange;
        }

        public void Dispose()
        {
            if (m_AchievementEffect != null)
            {
                AchievementGuideEffectPool.Recycle(m_AchievementEffect);
                m_AchievementEffect = null;
            }

            this.gameObject.name = "DailyQuestBehaviour_0";
            model.dailyQuestProgressUpdateEvent -= OnProgressUpdate;
            dungeonModel.updateDungeonBuyCnt -= OnTotalTimeChange;
            dungeonModel.dungeonRecordChangeEvent -= OnDungeonRecordChange;
        }

        private void ShowDetails()
        {
            model.currentDailyQuest = data.id;
            WindowCenter.Instance.Open<DailyQuestExplainWin>();
        }

        private void GotoDailyQuest()
        {
            if (m_AchievementEffect != null)
            {
                AchievementGuideEffectPool.Recycle(m_AchievementEffect);
                m_AchievementEffect = null;
            }
            WindowJumpMgr.Instance.ClearJumpData();
            if (data.id > 0)
            {
                if (state == DailyQuestModel.DailyQuestState.CanBuyTimes)
                {
                    switch ((DailyQuestType)data.id)
                    {
                        case DailyQuestType.RuneTowerSweep:
                            model.GotoDailyQuest(data.id);
                            break;
                        case DailyQuestType.HazyRegion:
                        case DailyQuestType.default4:
                            WindowCenter.Instance.Open<HazyRegionBuyTimesWin>(false, data.id);
                            break;
                        case DailyQuestType.ActivityPlace:
                            model.GotoDailyQuest(data.id);
                            break;                        
                        default:
                            var config = DailyQuestConfig.Get(data.id);
                            dungeonModel.currentDungeon = new Dungeon(config.RelatedID, 0);
                            WindowCenter.Instance.Open<DungeonBuyTimesWin>();
                            break;
                    }
                }
                else
                {
                    model.GotoDailyQuest(data.id);
                }
            }

            model.AddHasShowNewDailyQuest(data.id);
        }

        private void GotoFunc()
        {
            if (data != null)
            {
            }
        }

        private void OnProgressUpdate(int _id)
        {
            var config = DailyQuestConfig.Get(data.id);
            if (config == null || config.RelatedType != 1 || config.RelatedID != _id)
            {
                return;
            }

            DisplayProgressAndActiveValue();
        }


        private void DisplayProgressAndActiveValue()
        {
            var config = DailyQuestConfig.Get(this.data.id);

            var activeValue = model.GetDailyQuestActiveValue(data.id);
            var completedTimes = model.GetDailyQuestCompletedTimes(data.id);
            var totalTimes = model.GetDailyQuestTotalTimes(data.id);

            if (totalTimes == 60000)
            {
                m_ContainerTimes.SetActive(false);
            }
            else
            {
                m_ContainerTimes.SetActive(true);

                switch ((DailyQuestType)this.data.id)
                {
                    case DailyQuestType.KillMonster:
                        m_TimesUnit.text = Language.Get("DailyQuestMonster");
                        break;
                    default:
                        m_TimesUnit.text = Language.Get("DailyQuestTimes");
                        break;
                }
                switch ((DailyQuestType)this.data.id)
                {
                    case DailyQuestType.ArenaPK:
                        m_Times.text =ArenaManager.ShowLeftTimes;
                        m_Times.colorType = ArenaManager.isArenaOver  ? TextColType.Red : TextColType.DarkGreen;
                        if (ArenaManager.isArenaOver)
                            model.UpdateArenaRedPoint();
                        break;
                    case DailyQuestType.KillMonster:
                        m_Times.text = StringUtility.Contact(totalTimes >= completedTimes ? totalTimes - completedTimes : 0, "/", totalTimes);
                        m_Times.colorType = completedTimes >= totalTimes ? TextColType.Red : TextColType.DarkGreen;
                        break;
                    default:
                        m_Times.text = StringUtility.Contact(totalTimes >= completedTimes ? totalTimes - completedTimes : 0);
                        m_Times.colorType = completedTimes >= totalTimes ? TextColType.Red : TextColType.DarkGreen;
                        break;
                }
            }

            state = model.GetQuestState(data.id);

            m_Locked.SetActive(state == DailyQuestModel.DailyQuestState.Locked);
            m_UnLockCondition.SetActive(state == DailyQuestModel.DailyQuestState.Locked);
            m_Supplementary.SetActive(state == DailyQuestModel.DailyQuestState.OutTime);

            m_PracticePoint.SetActive(state == DailyQuestModel.DailyQuestState.Normal || state == DailyQuestModel.DailyQuestState.CanBuyTimes);
            m_AssistPoint.SetActive(state == DailyQuestModel.DailyQuestState.Completed);
            m_Goto.SetActive(state == DailyQuestModel.DailyQuestState.Normal || state == DailyQuestModel.DailyQuestState.CanBuyTimes);
            m_Complete.SetActive(false);
            m_TimeMiss.SetActive(false);
            
            switch (state)
            {
                case DailyQuestModel.DailyQuestState.Locked:
                    m_UnLockCondition.text = DailyQuestModel.GetDailyQuestUnLockDescription(data.id);
                    break;
                case DailyQuestModel.DailyQuestState.OutTime:
                    DailyQuestOpenTime openTime2;
                    HourMinute hourMinute;
                    if (model.TryGetOpenTime(data.id, out openTime2) && openTime2.TryGetTodayNearestOpenTime(out hourMinute))
                    {
                        if (hourMinute.AfterOpenTime(TimeUtility.ServerNow.Hour, TimeUtility.ServerNow.Minute) && completedTimes == 0)
                        {
                            m_TimeMiss.SetActive(true);
                        }
                        m_Supplementary.text = StringUtility.Contact(Language.Get("DailyQuestWin_OpenTime"), hourMinute.ToOpenTime());
                        m_Supplementary.color = m_TimeColor.GetColorSize("TodayColor").color;
                    }
                    else
                    {
                        m_Supplementary.text = openTime2.ToOpenTimeString();
                        m_Supplementary.color = m_TimeColor.GetColorSize("NotTodayColor").color;
                    }
                    break;
                case DailyQuestModel.DailyQuestState.CanBuyTimes:
                    UpdateGotoTitle(state);
                    DisplayPracticePoint();
                    break;
                case DailyQuestModel.DailyQuestState.Completed:
                    if (config.RelatedType == 2)
                    {
                        var openTimeConfig = DungeonOpenTimeConfig.Get(config.RelatedID);
                        var dungeonId = dungeonModel.GetDungeonId(config.RelatedID, 0);
                        var dungeonConfig = DungeonConfig.Get(dungeonId);
                        var mapConfig = MapConfig.Get(dungeonConfig.MapID);
                        if (openTimeConfig.HelpPoint > 0 && mapConfig.MapFBType == (int)MapType.MultipleFB)
                        {
                            m_Goto.SetActive(true);
                            m_Complete.SetActive(false);
                            UpdateGotoTitle(state);
                            m_AssistPoint.text = Language.Get("AssitPerTime", openTimeConfig.HelpPoint);
                        }
                        else
                        {
                            m_AssistPoint.text = string.Empty;
                            m_Goto.SetActive(false);
                            m_Complete.SetActive(true);
                        }
                    }
                    else
                    {
                        m_AssistPoint.text = string.Empty;
                        if ((DailyQuestType)data.id == DailyQuestType.DungeonAssist)
                        {
                            m_Complete.SetActive(false);
                            m_Goto.SetActive(true);
                            m_GotoTxt.text = Language.Get("GoodEquip_See");

                        }
                        else if ((DailyQuestType)data.id == DailyQuestType.ArenaPK)
                        {
                            m_Complete.SetActive(false);
                            m_Goto.SetActive(true);
                            m_GotoTxt.text = Language.Get("GoodEquip_See");

                        }
                        else
                        {
                            m_Goto.SetActive(false);
                            m_Complete.SetActive(true);
                        }
                    }
                    break;
                case DailyQuestModel.DailyQuestState.Normal:
                    UpdateGotoTitle(state);
                    DisplayPracticePoint();
                    break;
            }

            switch ((DailyQuestType)data.id)
            {
                case DailyQuestType.DungeonAssist:
                    m_Func.SetActive(false);
                    m_Complete.SetActive(false);
                    break;
                default:
                    m_Func.SetActive(false);
                    break;
            }

        }

        private void OnTotalTimeChange()
        {
            DisplayProgressAndActiveValue();
        }

        private void OnDungeonRecordChange(int _dataMapId)
        {
            if (dailyQuestConfig.RelatedType == 2 && dailyQuestConfig.RelatedID == _dataMapId)
            {
                OnTotalTimeChange();
            }
        }

        private void UpdateGotoTitle(DailyQuestModel.DailyQuestState _state)
        {
            switch (_state)
            {
                case DailyQuestModel.DailyQuestState.CanBuyTimes:
                    m_GotoTxt.text = Language.Get("DailyQuestWin_BuyTimes");
                    break;
                case DailyQuestModel.DailyQuestState.Completed:
                    if ((DailyQuestType)data.id == DailyQuestType.DungeonAssist)
                        m_GotoTxt.text = Language.Get("GoodEquip_See");
                    else
                        m_GotoTxt.text = Language.Get("DailyQuestWin_Goto");

                    break;
                default:
                    m_GotoTxt.text = Language.Get("DailyQuestWin_Goto");
                    break;
            }

        }

        private void UpdateGotoTitle(int _seconds)
        {
            m_GotoTxt.text = TimeUtility.SecondsToMS(_seconds);
        }

        private void DisplayPracticePoint()
        {
            var config = DailyQuestConfig.Get(this.data.id);
            if (config.OnceActivity == 0)
            {
                m_PracticePoint.text = "";
            }
            else
            {
                switch ((DailyQuestType)data.id)
                {
                    case DailyQuestType.KillMonster:
                        m_PracticePoint.text = Language.Get("DailyQuestPerPoint2", config.OnceActivity, config.OnceActivityTime);
                        break;
                    case DailyQuestType.BlastStove:
                        m_PracticePoint.text = Language.Get("DailyQuestLiandan", config.OnceActivity);
                        break;
                    case DailyQuestType.BossHome:
                    case DailyQuestType.PersonalBoss:
                    case DailyQuestType.WorldBoss:
                        m_PracticePoint.text = Language.Get("PointPerBoss", config.OnceActivity);
                        break;
                    case DailyQuestType.RuneTower:
                        m_PracticePoint.text = Language.Get("PointPerFloor", config.OnceActivity);
                        break;
                    case DailyQuestType.HazyRegion:
                    case DailyQuestType.ActivityPlace:
                        if (config.OnceActivity == 0)
                        {
                            m_PracticePoint.text = string.Empty;
                        }
                        else
                        {
                            m_PracticePoint.text = Language.Get("DailyQuestPerTime", config.OnceActivity);
                        }
                        break;
                    default:
                        if (config.OnceActivity / (float)config.OnceActivityTime < 1f)
                        {
                            m_PracticePoint.text = Language.Get("DailyQuestPerPoint", config.OnceActivity, config.OnceActivityTime);
                        }
                        else
                        {
                            m_PracticePoint.text = Language.Get("DailyQuestPerTime", config.OnceActivity);
                        }
                        break;
                }
            }
        }

        private void CheckAchievementGuide()
        {
            if (m_AchievementEffect != null)
            {
                AchievementGuideEffectPool.Recycle(m_AchievementEffect);
                m_AchievementEffect = null;
            }

            if (model.wannaLookDailyQuest == this.data.id)
            {
                m_AchievementEffect = AchievementGuideEffectPool.Require(5);
                m_AchievementEffect.transform.SetParentEx(this.transform, Vector3.zero, Vector3.zero, Vector3.one);
                ((RectTransform)m_AchievementEffect.transform).anchoredPosition = Vector2.zero;
                m_AchievementEffect.effect.SetMask();

                model.wannaLookDailyQuest = 0;
            }
        }

        float secondTimer = 0f;
        private void LateUpdate()
        {
            if (dailyQuestConfig.RelatedType == 2 && state == DailyQuestModel.DailyQuestState.Normal)
            {
                var cd = dungeonModel.GetEnterCoolDown(dailyQuestConfig.RelatedID);
                if (cd != null && dungeonModel.IsEnterCountDown(dailyQuestConfig.RelatedID))
                {
                    UpdateGotoTitle((int)(cd.endCoolDownTime - TimeUtility.ServerNow).TotalSeconds);

                    secondTimer += Time.deltaTime;
                    if (secondTimer > 1f)
                    {
                        secondTimer = 0f;
                        UpdateGotoTitle((int)(cd.endCoolDownTime - TimeUtility.ServerNow).TotalSeconds);
                    }
                }
                else
                {
                    UpdateGotoTitle(state);
                }
            }
            else
            {
                UpdateGotoTitle(state);
            }
        }



    }

}