//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, January 28, 2019
//--------------------------------------------------------

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

namespace vnxbqy.UI
{
    
    public class FestivalRedpackWin : Window
    {
        [SerializeField] FestivalRedpackSystemBehaviour m_FestivalSystemBehaviour;
        [SerializeField] Transform m_ContainerAchievement;
        [SerializeField] ScrollerController m_AchievementController;
        [SerializeField] Transform m_ContainerRedEnvelope;
        [SerializeField] ScrollerController m_RedEnvelopeControl;
        [SerializeField] Transform m_ContainerNoEnvelope;
        [SerializeField] Text m_OpenTime;
        [SerializeField] Transform m_ContainerGrab;
        [SerializeField] Transform m_ContainerCount;
        [SerializeField] Text m_GrabCount;
        [SerializeField] Text m_GrabJade;

        FestivalRedpackModel model { get { return ModelCenter.Instance.GetModel<FestivalRedpackModel>(); } }

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

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

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

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

        protected override void OnPreOpen()
        {
            model.selectTypeRefresh += SelectTypeRefresh;
            model.redpackGrabRefresh += RedpackGrabRefresh;
            WindowCenter.Instance.windowAfterOpenEvent += WindowAfterOpenEvent;
            OperationTimeHepler.Instance.dayResetEvent += DayResetEvent;
            achieveModel.achievementCompletedEvent += FestivalAchievementRefresh;
            achieveModel.achievementProgressUpdateEvent += FestivalAchievementRefresh;
            model.taskRedpackRefresh += TaskRedpackRefresh;
            Display();

            model.SetDayRemind();
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
            model.selectTypeRefresh -= SelectTypeRefresh;
            model.redpackGrabRefresh -= RedpackGrabRefresh;
            WindowCenter.Instance.windowAfterOpenEvent -= WindowAfterOpenEvent;
            OperationTimeHepler.Instance.dayResetEvent -= DayResetEvent;
            achieveModel.achievementCompletedEvent -= FestivalAchievementRefresh;
            achieveModel.achievementProgressUpdateEvent -= FestivalAchievementRefresh;
            model.taskRedpackRefresh -= TaskRedpackRefresh;
            m_FestivalSystemBehaviour.Dispose();
        }

        protected override void OnAfterClose()
        {
        }
        #endregion

        void Display()
        {
            DisplayType();
            DisplayOpenTime();
            DisplayGrab();
        }

        void DisplayType()
        {
            m_FestivalSystemBehaviour.SetActive(model.selectType == 1);
            m_ContainerAchievement.SetActive(model.selectType == 2);
            m_ContainerRedEnvelope.SetActive(model.selectType == 3);
            m_ContainerGrab.SetActive(model.selectType != 2);
            m_ContainerCount.SetActive(model.selectType == 3);
            switch (model.selectType)
            {
                case 1:
                    m_FestivalSystemBehaviour.Display();
                    break;
                case 2:
                    m_FestivalSystemBehaviour.Dispose();
                    DisplayAchievements();
                    break;
                case 3:
                    m_FestivalSystemBehaviour.Dispose();
                    DisplayRedpacks();
                    break;
            }
        }

        void DisplayAchievements()
        {
            m_AchievementController.Refresh();
            model.displayAchievements.Clear();
            List<FestivalRedpackAchievement> list;
            if (model.TryGetAchievements(model.operationDay + 1, out list))
            {
                model.displayAchievements.AddRange(list);
                model.displayAchievements.Sort(model.AchievementSort);
            }
            for (int i = 0; i < model.displayAchievements.Count; i++)
            {
                m_AchievementController.AddCell(ScrollerDataType.Header, i);
            }
            m_AchievementController.Restart();
        }

        void DisplayRedpacks()
        {
            m_RedEnvelopeControl.Refresh();
            model.taskDisplayRedpacks.Clear();
            List<int> list;
            if (envelopeModel.TryGetEnvelopes(FestivalRedpackModel.FESTIVALTASKREDPACKTYPE, out list))
            {
                model.taskDisplayRedpacks.AddRange(list);
            }
            model.taskDisplayRedpacks.Sort(model.CompareEnvelope);
            var _line = Mathf.CeilToInt((float)model.taskDisplayRedpacks.Count / 5);
            for (int i = 0; i < _line; i++)
            {
                m_RedEnvelopeControl.AddCell(ScrollerDataType.Header, i);
            }
            m_RedEnvelopeControl.Restart();
            m_ContainerNoEnvelope.SetActive(model.taskDisplayRedpacks.Count == 0);
        }

        void DisplayOpenTime()
        {
            OperationFestivalRedpack operation;
            if (OperationTimeHepler.Instance.TryGetOperation(Operation.FestivalRedpack, out operation))
            {
                m_OpenTime.text = StringUtility.Contact(Language.Get("ExpActivity_Text1"), operation.ToDisplayTime());
            }
        }

        void DisplayGrab()
        {
            m_GrabCount.text = model.grabRedpackTimes.ToString();
            m_GrabJade.text = model.grabTotalJade.ToString();
        }

        private void OnRefreshAchievementCell(ScrollerDataType type, CellView cell)
        {
            var achievementCell = cell as FestivalAchievementCell;
            achievementCell.Display(cell.index);
        }

        private void OnRefreshRedEnvelopeCell(ScrollerDataType type, CellView cell)
        {
            var redpackCell = cell as OSRedEnvelopeCell;
            redpackCell.DisplayFestivalRedpacks(cell.index);
        }

        private void SelectTypeRefresh()
        {
            DisplayType();
        }

        private void RedpackGrabRefresh()
        {
            DisplayGrab();
        }

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

        void AutoOpenRedpack()
        {
            if (model.autoOpen && model.selectType == 3)
            {
                for (int i = 0; i < model.taskDisplayRedpacks.Count; i++)
                {
                    RedEnvelopeModel.RedEnvelope envelope;
                    if (envelopeModel.TryGetEnvelope(model.taskDisplayRedpacks[i], out envelope)
                        && envelope.state == 1)
                    {
                        if (PlayerDatas.Instance.PlayerId == envelope.player
                            || model.grabRedpackTimes > 0)
                        {
                            ModelCenter.Instance.GetModel<RedPacketModel>().RedBagId = envelope.id;
                            WindowCenter.Instance.Open<RedpackOpenWin>();
                            break;
                        }
                    }
                }
            }
            else if (model.autoOpen && model.selectType == 1)
            {
                for (int i = 0; i < model.systemDisplayRedpacks.Count; i++)
                {
                    var redpackServerId = 0;
                    if (model.IsExistSystemRedpack(model.systemDisplayRedpacks[i], out redpackServerId))
                    {
                        RedEnvelopeModel.RedEnvelope envelope;
                        if (envelopeModel.TryGetEnvelope(redpackServerId, out envelope)
                            && envelope.state == 1)
                        {
                            RedpackSystemOpenWin.redpackId = model.systemDisplayRedpacks[i];
                            RedpackSystemOpenWin.redpackServerId = redpackServerId;
                            WindowCenter.Instance.Open<RedpackSystemOpenWin>();
                            break;
                        }
                    }
                }
            }
            model.autoOpen = false;
        }

        private void DayResetEvent(int resetType)
        {
            OperationFestivalRedpack operation;
            if (OperationTimeHepler.Instance.TryGetOperation(Operation.FestivalRedpack, out operation))
            {
                if (resetType == operation.resetType)
                {
                    if (model.selectType == 2)
                    {
                        DisplayAchievements();
                    }
                }
            }
        }

        private void FestivalAchievementRefresh(int id)
        {
            if (model.selectType != 2)
            {
                return;
            }
            Achievement achievement;
            if (model.IsContainsAchievement(model.displayAchievements, id))
            {
                FestivalRedpackAchievement festivalRedpackAchievement = model.displayAchievements.Find((x) =>
                {
                    return x.Contains(id);
                });
                if (festivalRedpackAchievement != null)
                {
                    if (achieveModel.TryGetAchievement(festivalRedpackAchievement.CurrentAchieve, out achievement))
                    {
                        if (Achievement.IsReach(achievement.id, achievement.progress))
                        {
                            DisplayAchievements();
                            return;
                        }
                    }
                }
            }
            m_AchievementController.m_Scorller.RefreshActiveCellViews();
        }

        private void TaskRedpackRefresh()
        {
            if (model.selectType == 3)
            {
                DisplayRedpacks();
            }
        }
    }

}