//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Tuesday, April 24, 2018
//--------------------------------------------------------

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

namespace vnxbqy.UI {

    public class OpenServerRedEnvelopeWin : Window
    {
        [SerializeField] Text m_OSRedTitle;
        [SerializeField] Text m_AchieveCoolDown;
        [SerializeField] RectTransform m_ContainerAchievement;
        [SerializeField] RectTransform m_ContainerEnvelope;
        [SerializeField] RectTransform m_ContainerNoEnvelope;
        [SerializeField] Text m_AllGetJade;
        [SerializeField] Text m_EnvelopeCount;
        [SerializeField] Text m_EnvelopeTime;
        [SerializeField] ScrollerController m_RedAchieveControl;
        [SerializeField] ScrollerController m_RedEnvelopeControl;

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

        RedEnvelopeModel envelopeModel { get { return ModelCenter.Instance.GetModel<RedEnvelopeModel>(); } }

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

        private int m_SelectType = 1;

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

        protected override void AddListeners()
        {
            m_RedEnvelopeControl.OnRefreshCell += OnRefreshCell;
        }

        protected override void OnPreOpen()
        {
            model.FuncChangeEvent += FuncChangeEvent;
            model.OSRedAchieveUpdateEvent += OSRedAchieveUpdateEvent;
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
            model.OSRedEnvelopeUpdateEvent += OSRedEnvelopeUpdateEvent;
            model.OSRedEnvelopeInfoEnvent += OSRedEnvelopeInfoEnvent;
            TimeUtility.OnServerOpenDayRefresh += OnServerOpenDayRefresh;
            WindowCenter.Instance.windowAfterOpenEvent += WindowAfterOpenEvent;
            UpdateOSRed();
        }

        protected override void OnAfterOpen()
        {
            
        }

        protected override void OnPreClose()
        {
            model.FuncChangeEvent -= FuncChangeEvent;
            model.OSRedAchieveUpdateEvent -= OSRedAchieveUpdateEvent;
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
            model.OSRedEnvelopeUpdateEvent -= OSRedEnvelopeUpdateEvent;
            model.OSRedEnvelopeInfoEnvent -= OSRedEnvelopeInfoEnvent;
            TimeUtility.OnServerOpenDayRefresh -= OnServerOpenDayRefresh;
            WindowCenter.Instance.windowAfterOpenEvent -= WindowAfterOpenEvent;
        }

        protected override void OnAfterClose()
        {
        }

        private float m_Time = 0.0f;
        private float m_DelayTime = 0.5f;

        protected override void LateUpdate()
        {
            base.LateUpdate();
            
            m_Time += Time.deltaTime;
            if (m_Time > m_DelayTime)
            {
                if (TimeUtility.OpenDay < model.openDays)
                {
                    UpdateCoolDown();
                }
                m_Time = 0;
            }
        }
        #endregion

        private void WindowAfterOpenEvent(Window win)
        {
            if (win is OpenServerActivityWin)
            {
                AutoOpenRedpack();
            }
        }

        void AutoOpenRedpack()
        {
            if (model.autoOpen && m_SelectType == 2)
            {
                for (int i = 0; i < model.m_OSRedEnvelopes.Count; i++)
                {
                    RedEnvelopeModel.RedEnvelope envelope;
                    if (envelopeModel.TryGetEnvelope(model.m_OSRedEnvelopes[i], out envelope)
                        && envelope.state == 1)
                    {
                        if (PlayerDatas.Instance.PlayerId == envelope.player
                            || model.getEnvelopeTimes > 0)
                        {
                            ModelCenter.Instance.GetModel<RedPacketModel>().RedBagId = envelope.id;
                            WindowCenter.Instance.Open<RedpackOpenWin>();
                            break;
                        }
                    }
                }
            }
            model.autoOpen = false;
        }

        private void OnServerOpenDayRefresh()
        {
            UpdateCoolDown();
        }

        private void UpdateCoolDown()
        {
            var t = model.overTime - TimeUtility.ServerNow;
            m_AchieveCoolDown.text = StringUtility.Contact(Language.Get("OSActivityCoolDown"),
                TimeUtility.SecondsToDHMSCHS((int)t.TotalSeconds));
            if (TimeUtility.OpenDay >= model.openDays)
            {
                m_AchieveCoolDown.color = UIHelper.GetUIColor(TextColType.NavyYellow);
                m_AchieveCoolDown.text = Language.Get("ActivityEnd");
            }
            else
            {
                m_AchieveCoolDown.color = UIHelper.GetUIColor(TextColType.LightGreen);
            }
        }

        private void FuncChangeEvent()
        {
            if (m_SelectType != model.selectType)
            {
                UpdateOSRed();
            }
        }

        private void OSRedAchieveUpdateEvent(int _achieve)
        {
            if (model.selectType != 1)
            {
                return;
            }
            Achievement achievement;
            if(achieveModel.TryGetAchievement(model.m_OSRedAchieveDict[_achieve].CurrentAchieve, out achievement))
            {
                if (Achievement.IsReach(achievement.id, achievement.progress))
                {
                    UpdateOSRed();
                    return;
                }
            }
            m_RedAchieveControl.m_Scorller.RefreshActiveCellViews();
        }

        private void OnFuncStateChangeEvent(int _func)
        {
            if (model.selectType == 1 && model.m_AllFuncs.Contains(_func))
            {
                UpdateOSRed();
            }
        }

        private void OSRedEnvelopeUpdateEvent()
        {
            if (model.selectType != 2)
            {
                return;
            }
            UpdateOSRed();
        }

        private void UpdateOSRed()
        {
            m_SelectType = model.selectType;
            m_OSRedTitle.text = m_SelectType == 1 ? Language.Get("OSAchievementTitle") : Language.Get("OSRedEnvelopeTitle");
            m_ContainerAchievement.SetActive(m_SelectType == 1);
            m_ContainerEnvelope.SetActive(m_SelectType == 2);
            UpdateCoolDown();
            if (m_SelectType == 1)
            {
                m_RedAchieveControl.Refresh();
                model.m_OSRedAchieves.Sort(model.CompareAchievement);
                for (int i = 0; i < model.m_OSRedAchieves.Count; i++)
                {
                    var _cfg = OSRedAchieveConfig.Get(model.m_OSRedAchieves[i]);
                    if (_cfg.func == 0 || FuncOpen.Instance.IsFuncOpen(_cfg.func))
                    {
                        m_RedAchieveControl.AddCell(ScrollerDataType.Header, i);
                    }
                }
                m_RedAchieveControl.Restart();
            }
            else
            {
                m_RedEnvelopeControl.Refresh();
                var _line = Mathf.CeilToInt((float)model.m_OSRedEnvelopes.Count / 5);
                for (int i = 0; i < _line; i++)
                {
                    m_RedEnvelopeControl.AddCell(ScrollerDataType.Header, i);
                }
                m_RedEnvelopeControl.Restart();
                OSRedEnvelopeInfoEnvent();
                m_ContainerNoEnvelope.SetActive(model.m_OSRedEnvelopes.Count == 0);
            }
        }

        private void OnRefreshCell(ScrollerDataType type, CellView _cell)
        {
            OSRedEnvelopeCell cell = _cell as OSRedEnvelopeCell;
            cell.Display(_cell.index);
        }

        private void OSRedEnvelopeInfoEnvent()
        {
            if (m_SelectType == 2)
            {
                m_AllGetJade.text = model.totalJadeGet.ToString();
                UpdateCounts();
                UpdateAddTime();
            }
        }

        private void UpdateAddTime()
        {
            m_EnvelopeTime.text = Language.Get("OSRedEnvelopeAddTimes", model.addCounts);
        }

        private void UpdateCounts()
        {
            m_EnvelopeCount.text = model.getEnvelopeTimes.ToString();
        }
    }

}