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 OpenServerActivityRankWin : Window
    {
        [SerializeField] ScrollerController m_ActivityCtrl;
        [SerializeField] Button m_BtnClose;

        List<int> m_OpenServerActivities = new List<int>();

        ImpactRankModel impactRankModel { get { return ModelCenter.Instance.GetModel<ImpactRankModel>(); } }

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

        protected override void BindController()
        {
            m_OpenServerActivities.Add(100);
            m_OpenServerActivities.Add(0);

        }

        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;
            OpenServerActivityCenter.Instance.openServerActivityStateChange += OpenServerActivityStateChange;
            var impactDefaultType = impactRankModel.GetDefaultSelectType();
            if (impactRankModel.IsLock(impactDefaultType))
            {
                impactDefaultType = impactRankModel.impactRankSorts[0];
            }
            impactRankModel.presentSelectType = impactDefaultType;
            impactRankModel.gotoImpactRankType = 0;
            CheckAlreadyOpen();
            UpdateFunctionBtns();
        }

        protected override void OnActived()
        {
            if (alreadyOpenActivitys.Count == 0)
            {
                CloseImmediately();
                return;
            }
            if (functionOrder == 0 && !WindowJumpMgr.Instance.IsJumpState)
            {
                functionOrder = GetDefaultSelect();
                UpdateFunctionBtns();
            }
            if (functionOrder != 0)
                WindowCenter.Instance.Open<BossFirstBloodWin>();
            else
                WindowCenter.Instance.Open<ImpactRankWin>();

            var index = alreadyOpenActivitys.IndexOf(functionOrder);

            m_ActivityCtrl.JumpIndex(index);
        }

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

        protected override void OnPreClose()
        {
            TimeUtility.OnServerOpenDayRefresh -= OnStepServerDayEvent;
            OpenServerActivityCenter.Instance.openServerActivityStateChange -= OpenServerActivityStateChange;
            impactRankModel.gotoImpactRankType = 0;
            CloseOtherWin();
        }

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


        private void TryClose()
        {
            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);
                    }
                }
            }
            if (priorityActivitys.Count > 0)
            {
                priorityActivitys.Sort(Compare);
                return priorityActivitys[0];
            }
            else
            {
                openActivitys.Sort(Compare);
                return openActivitys[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;
            });

            _cell.containerTimer.SetActive(false);

            _cell.activityType = activityType;

            _cell.redpoint.redpointId = MainRedDot.REDPOINT_OPENRANK * 100 + activityType;
            _cell.SetSelect(_cell.activityType == functionOrder);
            if (_cell.activityType == 0)
                _cell.icon.SetSprite("OpenServerActivty_QMCB");
            else
                _cell.icon.SetSprite("OpenServerActivty_BOSSFK");
            _cell.downArrow.SetActive(false);
            _cell.upArrow.SetActive(false);


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

        }

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

        private void OnActivityClick(int _order)
        {

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


            UpdateFunctionBtns();
        }

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

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

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

        private void OnStepServerDayEvent()
        {
            UpdateFunctionBtns();
        }

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

            _cell.redpoint.redpointId = (MainRedDot.REDPOINT_OPENRANK * 100 + _order) * 100 + _type;
            _cell.titleTxt.text = Language.Get(StringUtility.Contact("ImpactRankType_", _type));
            _cell.SetSelect(_type == impactRankModel.presentSelectType);
            _cell.functionBtn.onClick.RemoveAllListeners();
            _cell.functionBtn.onClick.AddListener(() =>
            {
                OnActivityType(_cell.index);
            });
            if (impactRankModel.IsLock(_type))
            {
                _cell.functionBtn.SetColorful(null, false);
                _cell.lockImage.SetActive(true);
            }

            else
            {
                _cell.functionBtn.SetColorful(null, true);
                _cell.lockImage.SetActive(false);

            }
        }

        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);

                        foreach (var _type in impactRankModel.impactRankSorts)
                        {
                            //if (impactRankModel.IsLock(_type))
                            //{
                            //    continue;
                            //}
                            m_ActivityCtrl.AddCell(ScrollerDataType.Normal, activityId * 100 + _type);
                        }
                        break;
                    
                    default:
                        m_ActivityCtrl.AddCell(ScrollerDataType.Header, activityId);
                        break;
                }
            }
            m_ActivityCtrl.Restart();
            m_ActivityCtrl.m_Scorller.RefreshActiveCellViews();
        }


        private void OnActivityType(int _index)
        {
            if (!WindowCenter.Instance.IsOpen<ImpactRankWin>())
                OnActivityClick(0);
            var _order = _index / 100;
            var _type = _index % 100;
            if (impactRankModel.IsLock(_type))
            {

                SysNotifyMgr.Instance.ShowTip("ImpactRankActivityUnOpen", 
                    Language.Get(StringUtility.Contact("ImpactRankType_", _type)),
                    impactRankModel.GetOpenStartDay(_type));
                return;
            }
            impactRankModel.presentSelectType = _type;
            m_ActivityCtrl.m_Scorller.RefreshActiveCellViews();
        }



        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 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();
            }
        }
    }
}