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

namespace Snxxz.UI
{

    public class DailyQuestBehaviour : MonoBehaviour
    {
        [SerializeField] Text m_Title;
        [SerializeField] RectTransform m_ContainerTimes;
        [SerializeField] TextEx m_Times;
        [SerializeField] Text m_PracticePoint;
        [SerializeField] Text m_UnLockCondition;
        [SerializeField] TextEx m_Supplementary;
        [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] Transform m_Complete;
        [SerializeField] Transform m_Locked;
        [SerializeField] RedpointBehaviour m_RedpointBehaviour;
        [SerializeField] RedpointBehaviour m_FuncRedpointBehaviour;

        AchievementGuideEffect m_AchievementEffect;

        DailyQuestData data;
        DailyQuestWin dailyQuestWin;
        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, DailyQuestWin _dailyQuestWin)
        {
            data = _data;
            dailyQuestWin = _dailyQuestWin;

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

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

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

            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.gameObject.SetActive(true);
                m_RedpointBehaviour.redpointId = _data.redpoint.id;
            }
            else
            {
                m_RedpointBehaviour.gameObject.SetActive(false);
            }

            switch ((DailyQuestType)data.id)
            {
                case DailyQuestType.Trial:
                    m_FuncRedpointBehaviour.redpointId = model.trialExchangeRedpoint.id;
                    break;
                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()
        {
            WindowJumpMgr.Instance.ClearJumpData();
            if (data.id > 0)
            {
                if (state == DailyQuestModel.DailyQuestState.CanBuyTimes)
                {
                    switch ((DailyQuestType)data.id)
                    {
                        case DailyQuestType.RuneTowerSweep:
                            dailyQuestWin.GotoDailyQuest(data.id);
                            break;
                        default:
                            var config = Config.Instance.Get<DailyQuestConfig>(data.id);
                            dungeonModel.currentDungeon = new Dungeon(config.RelatedID, 0);
                            WindowCenter.Instance.Open<DungeonBuyTimesWin>();
                            break;
                    }
                }
                else
                {
                    dailyQuestWin.GotoDailyQuest(data.id);
                }
            }
        }

        private void GotoFunc()
        {
            if (data != null)
            {
                switch ((DailyQuestType)data.id)
                {
                    case DailyQuestType.Trial:
                        if (!trialDungeonModel.CompleteTrialFloor(0))
                        {
                            trialDungeonModel.ProcessOpenTrialExchangeError();
                            return;
                        }
                        WindowCenter.Instance.Open<TrialExchangeWin>();
                        break;
                }
            }
        }

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

            DisplayProgressAndActiveValue();
        }

        private void DisplayProgressAndActiveValue()
        {
            var config = Config.Instance.Get<DailyQuestConfig>(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.gameObject.SetActive(false);
            }
            else
            {
                m_ContainerTimes.gameObject.SetActive(true);
                m_Times.text = StringUtility.Contact(completedTimes, "/", totalTimes);
                m_Times.colorType = completedTimes >= totalTimes ? TextColType.DarkGreen : TextColType.NavyBrown;
            }

            state = model.GetQuestState(data.id);

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

            m_PracticePoint.gameObject.SetActive(state == DailyQuestModel.DailyQuestState.Normal || state == DailyQuestModel.DailyQuestState.CanBuyTimes);
            m_AssistPoint.gameObject.SetActive(state == DailyQuestModel.DailyQuestState.Completed);
            m_Goto.gameObject.SetActive(state == DailyQuestModel.DailyQuestState.Normal || state == DailyQuestModel.DailyQuestState.CanBuyTimes);
            m_Complete.gameObject.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))
                    {
                        m_Supplementary.text = StringUtility.Contact(Language.Get("DailyQuestWin_OpenTime"), hourMinute.ToOpenTime());
                    }
                    else
                    {
                        m_Supplementary.text = openTime2.ToOpenTimeString();
                    }
                    break;
                case DailyQuestModel.DailyQuestState.CanBuyTimes:
                    UpdateGotoTitle(state);
                    DisplayPracticePoint();
                    break;
                case DailyQuestModel.DailyQuestState.Completed:
                    if (config.RelatedType == 2)
                    {
                        var dungeonConfig = Config.Instance.Get<DungeonOpenTimeConfig>(config.RelatedID);
                        if (dungeonConfig.HelpPoint > 0)
                        {
                            m_Goto.gameObject.SetActive(true);
                            m_Complete.gameObject.SetActive(false);
                            UpdateGotoTitle(state);
                            m_AssistPoint.text = Language.Get("AssitPerTime", dungeonConfig.HelpPoint);
                        }
                        else
                        {
                            m_AssistPoint.text = string.Empty;
                            m_Goto.gameObject.SetActive(false);
                            m_Complete.gameObject.SetActive(true);
                        }
                    }
                    else
                    {
                        m_AssistPoint.text = string.Empty;
                        m_Goto.gameObject.SetActive(false);
                        m_Complete.gameObject.SetActive(true);
                    }
                    break;
                case DailyQuestModel.DailyQuestState.Normal:
                    UpdateGotoTitle(state);
                    DisplayPracticePoint();
                    break;
            }

            switch ((DailyQuestType)data.id)
            {
                case DailyQuestType.Trial:
                    m_Func.gameObject.SetActive(state != DailyQuestModel.DailyQuestState.Locked);
                    m_FuncDisplay.text = Language.Get("ItemHandle_exchange");
                    break;
                default:
                    m_Func.gameObject.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:
                    m_GotoTxt.text = Language.Get("DailyQuestWin_Assistance");
                    break;
                default:
                    switch ((DailyQuestType)data.id)
                    {
                        case DailyQuestType.DungeonAssist:
                            m_GotoTxt.text = Language.Get("DailyQuestTalk");
                            break;
                        default:
                            m_GotoTxt.text = Language.Get("DailyQuestWin_Goto");
                            break;
                    }
                    break;
            }

        }

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

        private void DisplayPracticePoint()
        {
            var config = Config.Instance.Get<DailyQuestConfig>(this.data.id);

            switch ((DailyQuestType)data.id)
            {
                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;
                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 (dailyQuestWin.guidingDailyQuestId == 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();
            }
        }

        float secondTimer = 0f;
        private void LateUpdate()
        {
            if (dailyQuestConfig.RelatedType == 2 && state == DailyQuestModel.DailyQuestState.Normal)
            {
                var cd = dungeonModel.GetEnterCD(dailyQuestConfig.RelatedID);
                if (cd != null && cd.overdueTime > DateTime.Now)
                {
                    UpdateGotoTitle((int)(cd.overdueTime - DateTime.Now).TotalSeconds);

                    secondTimer += Time.deltaTime;
                    if (secondTimer > 1f)
                    {
                        secondTimer = 0f;
                        UpdateGotoTitle((int)(cd.overdueTime - DateTime.Now).TotalSeconds);
                    }
                }
                else
                {
                    UpdateGotoTitle(state);
                }
            }
            else
            {
                UpdateGotoTitle(state);
            }
        }



    }

}