using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;
#if UNITY_EDITOR
using UnityEditor;
using UnityEditorInternal;
#endif
namespace vnxbqy.UI
{
    
    public class OpenServerActivityWin : Window
    {
        [SerializeField] ScrollerController m_ActivityCtrl;
        [SerializeField] Button m_BtnClose;

        List<int> m_OpenServerActivities = new List<int>();
        Dictionary<int, bool> m_ActivitySpreadDict = new Dictionary<int, bool>();

        //ImpactRankModel impactRankModel { get { return ModelCenter.Instance.GetModel<ImpactRankModel>(); } }
        OSRedEnvelopeModel envelopeModel { get { return ModelCenter.Instance.GetModel<OSRedEnvelopeModel>(); } }
        FairyLeagueModel fairyLeagueModel { get { return ModelCenter.Instance.GetModel<FairyLeagueModel>(); } }
        OSGiftModel giftModel { get { return ModelCenter.Instance.GetModel<OSGiftModel>(); } }
        FestivalRedpackModel festivalRedpackModel { get { return ModelCenter.Instance.GetModel<FestivalRedpackModel>(); } }
        MonthWeekInvestModel monthWeekInvestModel { get { return ModelCenter.Instance.GetModel<MonthWeekInvestModel>(); } }

        List<int> openActivitys = new List<int>();
        List<int> priorityActivitys = new List<int>();
        List<int> alreadyOpenActivitys = new List<int>();

        public static event Func<bool> tryCloseEvent;

        protected override void BindController()
        {
            var configs = OpenServerActivityConfig.GetValues();
            foreach (var item in configs)
            {
                m_OpenServerActivities.Add(item.id);
            }
            m_OpenServerActivities.Sort((x, y) =>
            {
                var config_x = OpenServerActivityConfig.Get(x);
                var config_y = OpenServerActivityConfig.Get(y);
                return config_x.order.CompareTo(config_y.order);
            });
        }

        protected override void AddListeners()
        {
            m_ActivityCtrl.OnRefreshCell += OnOpenServerActivityRefresh;
            m_ActivityCtrl.OnGetDynamicSize += OnGetDynamicSize;
            m_ActivityCtrl.lockType = EnhanceLockType.KeepVertical;
            m_BtnClose.onClick.AddListener(TryClose);
        }

        protected override void OnPreOpen()
        {
            TimeUtility.OnServerOpenDayRefresh += OnStepServerDayEvent;
            OperationTimeHepler.Instance.operationTimeUpdateEvent += OperationTimeUpdateEvent;
            OpenServerActivityCenter.Instance.openServerActivityStateChange += OpenServerActivityStateChange;
            for (int i = 0; i < m_OpenServerActivities.Count; i++)
            {
                m_ActivitySpreadDict[m_OpenServerActivities[i]] = false;
            }
            //var impactDefaultType = impactRankModel.GetDefaultSelectType();
            //if (impactRankModel.IsLock(impactDefaultType))
            //{
            //    impactDefaultType = impactRankModel.impactRankSorts[0];
            //}
            //impactRankModel.presentSelectType = impactDefaultType;
            //impactRankModel.gotoImpactRankType = 0;
            envelopeModel.selectType = 1;
            festivalRedpackModel.selectType = 1;
            monthWeekInvestModel.selectType = monthWeekInvestModel.investTypes[0];
            giftModel.SetAreadyOpens();
            GlobalTimeEvent.Instance.secondEvent += SecondEvent;
            CheckAlreadyOpen();
            UpdateFunctionBtns();
        }

        protected override void OnActived()
        {
            if (alreadyOpenActivitys.Count == 0)
            {
                CloseImmediately();
                return;
            }
            if (functionOrder == 0 && !WindowJumpMgr.Instance.IsJumpState)
            {
                functionOrder = GetDefaultSelect();
                if (RequireAutoSpread(functionOrder))
                {
                    m_ActivitySpreadDict[functionOrder] = true;
                }
                UpdateFunctionBtns();
            }
            else
            {
                if (!alreadyOpenActivitys.Contains(functionOrder))
                {
                    functionOrder = GetDefaultSelect();
                }
                if (RequireAutoSpread(functionOrder))
                {
                    m_ActivitySpreadDict[functionOrder] = true;
                }
                if (functionOrder == 2)
                {
                    envelopeModel.selectType = envelopeModel.JumpType != 0 ? envelopeModel.JumpType : 1;
                    envelopeModel.JumpType = 0;
                }
                else if (functionOrder == 6)
                {
                    giftModel.selectIndex = giftModel.GetDefaultSelect();
                }
                else if (functionOrder == 19)
                {
                    festivalRedpackModel.selectType = festivalRedpackModel.jumpType != 0 ? festivalRedpackModel.jumpType : 1;
                    festivalRedpackModel.jumpType = 0;
                }
                else if (functionOrder == 22)
                {
                    monthWeekInvestModel.selectType = monthWeekInvestModel.GetSelectType();
                }
                
                UpdateFunctionBtns();
            }
            OnOpenActivity(functionOrder);

            var index = alreadyOpenActivitys.IndexOf(functionOrder);
            if (alreadyOpenActivitys.Contains(6))
            {
                if (index > alreadyOpenActivitys.IndexOf(6))
                {
                    index = index + giftModel.alreadyOpens.Count - 1;
                }
                else if (index == alreadyOpenActivitys.IndexOf(6))
                {
                    index = index + giftModel.selectIndex;
                }
            }
            m_ActivityCtrl.JumpIndex(index);
        }

        protected override void OnAfterOpen()
        {
            //impactRankModel.OSCEffectOpen = false;
        }

        protected override void OnPreClose()
        {
            TimeUtility.OnServerOpenDayRefresh -= OnStepServerDayEvent;
            OperationTimeHepler.Instance.operationTimeUpdateEvent -= OperationTimeUpdateEvent;
            OpenServerActivityCenter.Instance.openServerActivityStateChange -= OpenServerActivityStateChange;
            GlobalTimeEvent.Instance.secondEvent -= SecondEvent;
            CloseOtherWin();
            //impactRankModel.gotoImpactRankType = 0;
        }

        protected override void OnAfterClose()
        {
            if (!WindowJumpMgr.Instance.IsJumpState)
            {
                WindowCenter.Instance.Open<MainInterfaceWin>();
            }
        }

        private bool RequireAutoSpread(int order)
        {
            switch (order)
            {
                case 22:
                    return true;
                default:
                    return false;
            }
        }

        private void TryClose()
        {
            switch (functionOrder)
            {
                case 18:
                    if (tryCloseEvent != null)
                    {
                        if (!tryCloseEvent())
                        {
                            return;
                        }
                    }
                    break;
            }
            CloseClick();
        }

        int GetDefaultSelect()
        {
            openActivitys.Clear();
            priorityActivitys.Clear();

            for (int i = 0; i < m_OpenServerActivities.Count; i++)
            {
                var activityId = m_OpenServerActivities[i];
                if (OpenServerActivityCenter.Instance.IsActivityOpen(activityId))
                {
                    openActivitys.Add(activityId);
                    if (OpenServerActivityCenter.Instance.IsPriorityOpenOpen(activityId))
                    {
                        priorityActivitys.Add(activityId);

                        switch (activityId)
                        {
                            case 2:
                                envelopeModel.selectType = envelopeModel.m_RedAchieveRedpoint.state == RedPointState.Simple ? 1 : 2;
                                break;
                            case 6:
                                giftModel.selectIndex = giftModel.GetDefaultSelect();
                                break;
                            case 19:
                                if (festivalRedpackModel.systemRedpoint.state == RedPointState.Simple)
                                {
                                    festivalRedpackModel.selectType = 1;
                                    break;
                                }
                                else if (festivalRedpackModel.taskRedpoint.state == RedPointState.Simple)
                                {
                                    festivalRedpackModel.selectType = 2;
                                    break;
                                }
                                else if (festivalRedpackModel.receiveRedpoint.state == RedPointState.Simple)
                                {
                                    festivalRedpackModel.selectType = 3;
                                    break;
                                }
                                festivalRedpackModel.selectType = 1;
                                break;
                            case 22:
                                monthWeekInvestModel.selectType = monthWeekInvestModel.GetSelectType();
                                break;
                            default:
                                break;
                        }
                    }
                }
            }
            if (priorityActivitys.Count > 0)
            {
                priorityActivitys.Sort(Compare);
                return priorityActivitys[0];
            }
            else
            {
                openActivitys.Sort(Compare);
                return openActivitys[0];
            }
        }

        private void SecondEvent()
        {
            var cell = m_ActivityCtrl.GetActiveCellView(12, ScrollerDataType.Header);
            if (cell != null)
            {
                var activityCell = cell as OpenServerActivityCell;
                var seconds = fairyLeagueModel.GetBeforeFirstLeagueTime();
                activityCell.timer.text = TimeUtility.SecondsToHMS(seconds);
                activityCell.containerTimer.SetActive(seconds > 0);
            }
        }

        void CheckAlreadyOpen()
        {
            alreadyOpenActivitys.Clear();
            for (int i = 0; i < m_OpenServerActivities.Count; i++)
            {
                if (OpenServerActivityCenter.Instance.IsActivityOpen(m_OpenServerActivities[i]))
                {
                    alreadyOpenActivitys.Add(m_OpenServerActivities[i]);
                }
            }
        }

        private void OnOpenServerActivityRefresh(ScrollerDataType type, CellView cell)
        {
            switch (type)
            {
                case ScrollerDataType.Header:
                    RefreshOpenActivityCell(cell as OpenServerActivityCell);
                    break;
                case ScrollerDataType.Normal:
                    RefreshActivityTypeCell(cell as OpenActivityRankTypeCell);
                    break;
            }
        }

        private bool OnGetDynamicSize(ScrollerDataType type, int index, out float height)
        {
            height = 74;
            var sort = index;
            if (type == ScrollerDataType.Header)
            {
                if (!m_ActivitySpreadDict.ContainsKey(sort) || !m_ActivitySpreadDict[sort]
                    || !OpenServerActivityCenter.Instance.ExistChildBookmark(sort))
                {
                    height = 121;
                    return true;
                }
            }
            return false;
        }

        private void RefreshOpenActivityCell(OpenServerActivityCell _cell)
        {
            var activityType = 0;
            activityType = _cell.index >= 1000 ? _cell.index / 1000 : _cell.index;
            var extraValue = _cell.index % 1000;

            var customActivity = m_OpenServerActivities.Find((x) =>
            {
                return x == activityType;
            });

            switch (activityType)
            {
                case 12:
                    {
                        var seconds = fairyLeagueModel.GetBeforeFirstLeagueTime();
                        _cell.containerTimer.SetActive(seconds > 0);
                        if (seconds > 0)
                        {
                            _cell.timer.text = TimeUtility.SecondsToHMS(seconds);
                        }
                    }
                    break;
                default:
                    _cell.containerTimer.SetActive(false);
                    break;
            }

            _cell.activityType = activityType;

            var config = OpenServerActivityConfig.Get(activityType);

            switch (activityType)
            {
                case 6:
                    _cell.redpoint.redpointId = 20906 * 100 + extraValue;
                    var payType = giftModel.gifts[extraValue].payType;
                    _cell.SetSelect(extraValue == giftModel.selectIndex && functionOrder == activityType);
                    _cell.icon.SetSprite(StringUtility.Contact(config.icon, payType));
                    break;
                default:
                    _cell.redpoint.redpointId = MainRedDot.REDPOINT_OPENSERVER * 100 + activityType;
                    _cell.SetSelect(_cell.activityType == functionOrder);
                    _cell.icon.SetSprite(config.icon);
                    break;
            }

            _cell.downArrow.SetActive(false);
            _cell.upArrow.SetActive(false);

            if (OpenServerActivityCenter.Instance.ExistChildBookmark(_cell.activityType))
            {
                _cell.downArrow.SetActive(m_ActivitySpreadDict[_cell.activityType]);
                _cell.upArrow.SetActive(!m_ActivitySpreadDict[_cell.activityType]);
            }

            _cell.funcBtn.onClick.RemoveAllListeners();
            _cell.funcBtn.onClick.AddListener(() =>
            {
                OnActivityClick(_cell.activityType, extraValue);
            });
        }

        private void OnStepServerDayEvent()
        {
            UpdateFunctionBtns();
        }

        private void RefreshActivityTypeCell(OpenActivityRankTypeCell _cell)
        {
            int _order = _cell.index / 100;
            int _type = _cell.index % 100;

            _cell.redpoint.redpointId = (209 * 100 + _order) * 100 + _type;
            switch (_order)
            {
                //case 0:
                //    _cell.titleTxt.text = Language.Get(StringUtility.Contact("ImpactRankType_", _type));
                //    _cell.SetSelect(_type == impactRankModel.presentSelectType);
                //    break;
                case 2:
                    _cell.titleTxt.text = Language.Get(StringUtility.Contact("OSRedEnvelopeType_", _type));
                    _cell.SetSelect(_type == envelopeModel.selectType);
                    break;
                case 19:
                    _cell.titleTxt.text = Language.Get(StringUtility.Contact("FestivalRedpackType_", _type));
                    _cell.SetSelect(_type == festivalRedpackModel.selectType);
                    break;
                case 22:
                    _cell.titleTxt.text = Language.Get(StringUtility.Contact("MonthWeekInvestType_", _type));
                    _cell.SetSelect(_type == monthWeekInvestModel.selectType);
                    break;
                default:
                    break;
            }

            _cell.functionBtn.onClick.RemoveAllListeners();
            _cell.functionBtn.onClick.AddListener(() =>
            {
                OnActivityType(_cell.index);
            });
        }

        private void UpdateFunctionBtns()
        {
            m_ActivityCtrl.Refresh();
            for (int i = 0; i < m_OpenServerActivities.Count; i++)
            {
                var activityId = m_OpenServerActivities[i];
                if (!alreadyOpenActivitys.Contains(activityId))
                {
                    continue;
                }
                switch (activityId)
                {
                    //case 0:
                    //    m_ActivityCtrl.AddCell(ScrollerDataType.Header, activityId);
                    //    if (functionOrder != activityId)
                    //    {
                    //        m_ActivitySpreadDict[activityId] = false;
                    //        break;
                    //    }
                    //    if (!m_ActivitySpreadDict[activityId])
                    //    {
                    //        break;
                    //    }
                        //foreach (var _type in impactRankModel.impactRankSorts)
                        //{
                        //    //if (impactRankModel.IsLock(_type))
                        //    //{
                        //    //    continue;
                        //    //}
                        //    m_ActivityCtrl.AddCell(ScrollerDataType.Normal, activityId * 100 + _type);
                        //}
                        //break;
                    case 2:
                        m_ActivityCtrl.AddCell(ScrollerDataType.Header, activityId);
                        if (!m_ActivitySpreadDict[activityId])
                        {
                            m_ActivitySpreadDict[activityId] = false;
                            break;
                        }
                        m_ActivityCtrl.AddCell(ScrollerDataType.Normal, activityId * 100 + 1);
                        m_ActivityCtrl.AddCell(ScrollerDataType.Normal, activityId * 100 + 2);
                        break;
                    case 6:
                        for (int k = 0; k < giftModel.alreadyOpens.Count; k++)
                        {
                            m_ActivityCtrl.AddCell(ScrollerDataType.Header, activityId * 1000 + giftModel.alreadyOpens[k]);
                        }
                        break;
                    case 19:
                        m_ActivityCtrl.AddCell(ScrollerDataType.Header, activityId);
                        if (!m_ActivitySpreadDict[activityId])
                        {
                            m_ActivitySpreadDict[activityId] = false;
                            break;
                        }
                        m_ActivityCtrl.AddCell(ScrollerDataType.Normal, activityId * 100 + 1);
                        m_ActivityCtrl.AddCell(ScrollerDataType.Normal, activityId * 100 + 2);
                        m_ActivityCtrl.AddCell(ScrollerDataType.Normal, activityId * 100 + 3);
                        break;
                    case 22:
                        m_ActivityCtrl.AddCell(ScrollerDataType.Header, activityId);
                        if (!m_ActivitySpreadDict[activityId])
                        {
                            m_ActivitySpreadDict[activityId] = false;
                            break;
                        }
                        for (int k = 0; k < monthWeekInvestModel.investTypes.Count; k++)
                        {
                            m_ActivityCtrl.AddCell(ScrollerDataType.Normal, activityId * 100 + monthWeekInvestModel.investTypes[k]);
                        }
                        break;
                    default:
                        m_ActivityCtrl.AddCell(ScrollerDataType.Header, activityId);
                        if (OpenServerActivityCenter.Instance.ExistChildBookmark(activityId))
                        {
                            if (!m_ActivitySpreadDict[activityId])
                            {
                                m_ActivitySpreadDict[activityId] = false;
                                break;
                            }
                            var childTypes = OpenServerActivityCenter.Instance.GetChildTypes(activityId);
                            for (int k = 0; k < childTypes.Length; k++)
                            {
                                m_ActivityCtrl.AddCell(ScrollerDataType.Normal, activityId * 100 + childTypes[k]);
                            }
                        }
                        break;
                }
            }
            m_ActivityCtrl.Restart();
            m_ActivityCtrl.m_Scorller.RefreshActiveCellViews();
        }

        private void OnActivityClick(int _order, int extra = 0)
        {
            if (functionOrder == _order && _order != 6)
            {
                m_ActivitySpreadDict[_order] = !m_ActivitySpreadDict[_order];
                UpdateFunctionBtns();
                return;
            }
            else
            {
                m_ActivitySpreadDict[functionOrder] = false;
                m_ActivitySpreadDict[_order] = true;
            }

            if (functionOrder != _order)
            {
                functionOrder = _order;
                OnOpenActivity(functionOrder);
            }

            switch (functionOrder)
            {
                case 6:
                    giftModel.selectIndex = extra;
                    break;
            }

            UpdateFunctionBtns();
        }

        private void OnOpenActivity(int _order)
        {
            CloseOtherWin();

            var functionInfos = WindowConfig.GetWindowFunctionInfos("OpenServerActivityWin");
            var index = functionInfos.FindIndex((x) =>
             {
                 return x.order == _order;
             });

            if (index != -1)
            {
                WindowCenter.Instance.Open(functionInfos[index].window, true);
            }
        }

        private void OnActivityType(int _index)
        {
            var _order = _index / 100;
            var _type = _index % 100;
            switch (_order)
            {
                //case 0:
                //    if (impactRankModel.IsLock(_type))
                //    {
                //        SysNotifyMgr.Instance.ShowTip("ImpactRankActivityUnOpen");
                //        return;
                //    }
                //    impactRankModel.presentSelectType = _type;
                //    break;
                case 2:
                    envelopeModel.selectType = _type;
                    break;
                case 19:
                    festivalRedpackModel.selectType = _type;
                    break;
                case 22:
                    monthWeekInvestModel.selectType = _type;
                    break;
                default:
                    break;
            }
            m_ActivityCtrl.m_Scorller.RefreshActiveCellViews();
        }

        private void CloseOtherWin()
        {
            var children = WindowConfig.GetChildWindows("OpenServerActivityWin");
            foreach (var window in children)
            {
                WindowCenter.Instance.Close(window);
            }
        }

        private int Compare(int order_x, int order_y)
        {
            var index_x = m_OpenServerActivities.FindIndex((x) =>
            {
                return order_x == x;
            });
            var index_y = m_OpenServerActivities.FindIndex((x) =>
            {
                return order_y == x;
            });
            return index_x.CompareTo(index_y);
        }

        private void OperationTimeUpdateEvent(Operation type)
        {
            if (type == Operation.MultipleExp || type == Operation.MultipRealmPoint)
            {
                m_ActivityCtrl.m_Scorller.RefreshActiveCellViews();
            }
        }

        private void OpenServerActivityStateChange()
        {
            bool _update = false;
            for (int i = 0; i < m_OpenServerActivities.Count; i++)
            {
                var activityId = m_OpenServerActivities[i];
                if (OpenServerActivityCenter.Instance.IsActivityOpen(activityId)
                    && !alreadyOpenActivitys.Contains(activityId))
                {
                    alreadyOpenActivitys.Add(activityId);
                    _update = true;
                }
            }
            if (_update)
            {
                UpdateFunctionBtns();
            }
        }
    }
}