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

namespace Snxxz.UI
{
    public class OpenServerActivityWin : Window
    {
        [SerializeField] ScrollerController m_ActivityCtrl;
        [SerializeField] Button m_BtnClose;
        [SerializeField] Image m_TitleIcon;
        [SerializeField] List<CustomActivityDisplay> m_CustomActivitys;

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

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

        OSRedEnvelopeModel m_OSRedEnvelopeModel;
        OSRedEnvelopeModel envelopeModel {
            get {
                return m_OSRedEnvelopeModel ?? (m_OSRedEnvelopeModel = ModelCenter.Instance.GetModel<OSRedEnvelopeModel>());
            }
        }
        FairyLeagueModel fairyLeagueModel { get { return ModelCenter.Instance.GetModel<FairyLeagueModel>(); } }

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

        protected override void BindController()
        {

        }

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

        protected override void OnPreOpen()
        {
            TimeUtility.OnServerOpenDayRefresh += OnStepServerDayEvent;
            OperationTimeHepler.Instance.operationTimeUpdateEvent += OperationTimeUpdateEvent;
            OpenServerActivityCenter.Instance.openServerActivityStateChange += OpenServerActivityStateChange;
            for (int i = 0; i < m_CustomActivitys.Count; i++)
            {
                m_ActivitySpreadDict[(int)m_CustomActivitys[i].activityType] = false;
            }
            var impactDefaultType= impactRankModel.GetDefaultSelectType();
            if (impactRankModel.IsLock(impactDefaultType))
            {
                impactDefaultType = impactRankModel.billRankCfgDict.Keys.First();
            }
            impactRankModel.presentSelectType = impactDefaultType;
            impactRankModel.gotoImpactRankType = 0;
            envelopeModel.selectType = 1;
            GlobalTimeEvent.Instance.secondEvent += SecondEvent;
            CheckAlreadyOpen();
            UpdateFunctionBtns();
        }

        protected override void OnActived()
        {
            bool force = false;
            if (OpenServerActivityCenter.Instance.selectFuncOrder != -1 && !WindowJumpMgr.Instance.IsJumpState)
            {
                functionOrder = OpenServerActivityCenter.Instance.selectFuncOrder;
                force = true;
            }
            OpenServerActivityCenter.Instance.selectFuncOrder = -1;
            if (alreadyOpenActivitys.Count == 0)
            {
                CloseImmediately();
                return;
            }
            if (functionOrder == 0 && !WindowJumpMgr.Instance.IsJumpState && !force)
            {
                functionOrder = GetDefaultSelect();
                //for (int i = 0; i < m_SortArray.Count; i++)
                //{
                //    m_ActivitySpreadDict[m_SortArray[i]] = m_SortArray[i] == functionOrder;
                //}
                UpdateFunctionBtns();
            }
            else
            {
                if (!alreadyOpenActivitys.Contains(functionOrder))
                {
                    functionOrder = GetDefaultSelect();
                }
                //for (int i = 0; i < m_SortArray.Count; i++)
                //{
                //    m_ActivitySpreadDict[m_SortArray[i]] = m_SortArray[i] == functionOrder;
                //}
                if (functionOrder == 2)
                {
                    envelopeModel.selectType = envelopeModel.JumpType != 0 ? envelopeModel.JumpType : 1;
                    envelopeModel.JumpType = 0;
                }
                UpdateFunctionBtns();
            }
            OnOpenActivity(functionOrder);
        }

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

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

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

                        switch (m_CustomActivitys[i].activityType)
                        {
                            case OpenServerActivityCenter.OSActivityType.OSRedpack:
                                envelopeModel.selectType = envelopeModel.m_RedAchieveRedpoint.state == RedPointState.Simple ? 1 : 2;
                                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((int)OpenServerActivityCenter.OSActivityType.FairyLeagueNotice);
            if (cell != null)
            {
                var activityCell = cell as OpenServerActivityCell;
                var seconds = fairyLeagueModel.GetBeforeFirstLeagueTime();
                if (seconds > 0)
                {
                    activityCell.title.text = UIHelper.ReplaceNewLine(Language.Get("FairyLeagueForcast", TimeUtility.SecondsToHMS(seconds)));
                }
                else
                {
                    activityCell.title.text = Language.Get("FamilyMatchName");
                }
            }
        }

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

        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]
                    || (sort != 2 && sort != 0))
                {
                    height = 80;
                    return true;
                }
            }
            return false;
        }

        private void RefreshOpenActivityCell(OpenServerActivityCell _cell)
        {
            OperationBase operationBase;
            switch (_cell.index)
            {
                case 5:
                    if (OperationTimeHepler.Instance.TryGetOperationTime(Operation.MultipleExp, out operationBase))
                    {
                        _cell.title.text = Language.Get("ExpActivity_Text5", (operationBase as OperationMultiExp).GetMultipleCHS());
                    }
                    break;
                case 8:
                    if (OperationTimeHepler.Instance.TryGetOperationTime(Operation.MultipRealmPoint, out operationBase))
                    {
                        _cell.title.text = Language.Get("MultipleRealmPoint", Language.Get(StringUtility.Contact("Num_CHS_", (operationBase as OperationMultipleRealmPoint).multiplePractice)));
                    }
                    break;
                case 12:
                    var seconds = fairyLeagueModel.GetBeforeFirstLeagueTime();
                    if (seconds > 0)
                    {
                        _cell.title.text = UIHelper.ReplaceNewLine(Language.Get("FairyLeagueForcast", TimeUtility.SecondsToHMS(seconds)));
                    }
                    else
                    {
                        _cell.title.text = Language.Get("FamilyMatchName");
                    }
                    break;
                default:
                    _cell.title.text = Language.Get(StringUtility.Contact("OSActivityTitle_", _cell.index));
                    break;
            }
            _cell.order = _cell.index;
            _cell.redpoint.redpointId = MainRedDot.REDPOINT_OPENSERVER * 100 + _cell.index;
            _cell.ChangeState(_cell.order == functionOrder ? TitleBtnState.Click : TitleBtnState.Normal);
            _cell.downArrow.gameObject.SetActive(false);
            _cell.upArrow.gameObject.SetActive(false);

            var customActivity = m_CustomActivitys.Find((x) =>
            {
                return (int)x.activityType == _cell.index;
            });

            bool customIcon = !string.IsNullOrEmpty(customActivity.titleIcon);
            _cell.title.gameObject.SetActive(!customIcon);
            _cell.titleImage.gameObject.SetActive(customIcon);
            if (customIcon)
            {
                _cell.titleImage.SetSprite(customActivity.titleIcon);
                _cell.titleImage.SetNativeSize();
            }

            if (_cell.order == 0 || _cell.order == 2)
            {
                _cell.downArrow.gameObject.SetActive(m_ActivitySpreadDict[_cell.order]);
                _cell.upArrow.gameObject.SetActive(!m_ActivitySpreadDict[_cell.order]);
            }
            _cell.funcBtn.onClick.RemoveAllListeners();
            _cell.funcBtn.onClick.AddListener(() =>
            {
                OnActivityClick(_cell.order);
            });
        }

        private void OnStepServerDayEvent()
        {
            //m_ActivityCtrl.m_Scorller.RefreshActiveCellViews();
            UpdateFunctionBtns();
        }

        private void RefreshActivityTypeCell(OpenActivityRankTypeCell _cell)
        {
            int _order = _cell.index / 100;
            int _type = _cell.index % 100;
            switch (_order)
            {
                case 0:
                    _cell.redpoint.redpointId = ImpactRankModel.Redpoint_Key_ImpactRank * 100 + _type;
                    _cell.titleTxt.text = Language.Get(StringUtility.Contact("ImpactRankType_", _type));
                    _cell.ChangeState(_type == impactRankModel.presentSelectType ? TitleBtnState.Click : TitleBtnState.Normal);
                    break;
                case 2:
                    _cell.redpoint.redpointId = 20902 * 100 + _type;
                    _cell.titleTxt.text = Language.Get(StringUtility.Contact("OSRedEnvelopeType_", _type));
                    _cell.ChangeState(_type == envelopeModel.selectType ? TitleBtnState.Click : TitleBtnState.Normal);
                    break;
            }
            _cell.functionBtn.onClick.RemoveAllListeners();
            _cell.functionBtn.onClick.AddListener(() =>
            {
                OnActivityType(_cell.index);
            });
        }

        private void UpdateFunctionBtns()
        {
            m_ActivityCtrl.Refresh();
            for (int i = 0; i < m_CustomActivitys.Count; i++)
            {
                var sort = (int)m_CustomActivitys[i].activityType;
                if (!alreadyOpenActivitys.Contains(sort))
                {
                    continue;
                }
                switch (sort)
                {
                    case 0:
                        m_ActivityCtrl.AddCell(ScrollerDataType.Header, sort);
                        if (functionOrder != sort)
                        {
                            break;
                        }
                        if (!m_ActivitySpreadDict[sort])
                        {
                            break;
                        }
                        foreach (var _type in impactRankModel.billRankCfgDict.Keys)
                        {
                            if (impactRankModel.IsLock(_type))
                            {
                                continue;
                            }
                            m_ActivityCtrl.AddCell(ScrollerDataType.Normal, sort * 100 + _type);
                        }
                        break;
                    case 2:
                        m_ActivityCtrl.AddCell(ScrollerDataType.Header, sort);
                        if (!m_ActivitySpreadDict[sort])
                        {
                            break;
                        }
                        m_ActivityCtrl.AddCell(ScrollerDataType.Normal, sort * 100 + 1);
                        m_ActivityCtrl.AddCell(ScrollerDataType.Normal, sort * 100 + 2);
                        break;
                    default:
                        m_ActivityCtrl.AddCell(ScrollerDataType.Header, sort);
                        break;
                }
            }
            m_ActivityCtrl.Restart();
            m_ActivityCtrl.m_Scorller.RefreshActiveCellViews();
        }

        private void OnActivityClick(int _order)
        {
            if (functionOrder == _order)
            {
                m_ActivitySpreadDict[_order] = !m_ActivitySpreadDict[_order];
                UpdateFunctionBtns();
                return;
            }
            else
            {
                m_ActivitySpreadDict[functionOrder] = false;
                m_ActivitySpreadDict[_order] = true;
            }
            functionOrder = _order;
            OnOpenActivity(functionOrder);
            UpdateFunctionBtns();
        }

        private void OnOpenActivity(int _order)
        {
            CloseOtherWin();
            switch (_order)
            {
                case 0:
                    if (windowState == WindowState.Opened)
                    {
                        WindowCenter.Instance.OpenWithoutAnimation<ImpactRankWin>();
                    }
                    else
                    {
                        WindowCenter.Instance.Open<ImpactRankWin>(true);
                    }
                    break;
                case 1:
                    if (windowState == WindowState.Opened)
                    {
                        WindowCenter.Instance.OpenWithoutAnimation<ConsumeRebateWin>();
                    }
                    else
                    {
                        WindowCenter.Instance.Open<ConsumeRebateWin>(true);
                    }
                    break;
                case 2:
                    if (windowState == WindowState.Opened)
                    {
                        WindowCenter.Instance.OpenWithoutAnimation<OpenServerRedEnvelopeWin>();
                    }
                    else
                    {
                        WindowCenter.Instance.Open<OpenServerRedEnvelopeWin>(true);
                    }
                    break;
                case 3:
                    if (windowState == WindowState.Opened)
                    {
                        WindowCenter.Instance.OpenWithoutAnimation<OSTimeLimitGiftWin>();
                    }
                    else
                    {
                        WindowCenter.Instance.Open<OSTimeLimitGiftWin>(true);
                    }
                    break;
                case 4:
                    if (windowState == WindowState.Opened)
                    {
                        WindowCenter.Instance.OpenWithoutAnimation<FlashSaleWin>();
                    }
                    else
                    {
                        WindowCenter.Instance.Open<FlashSaleWin>(true);
                    }
                    break;
                case 5:
                    if (windowState == WindowState.Opened)
                    {
                        WindowCenter.Instance.OpenWithoutAnimation<MultipleExpWin>();
                    }
                    else
                    {
                        WindowCenter.Instance.Open<MultipleExpWin>(true);
                    }
                    break;
                case 6:
                    if (windowState == WindowState.Opened)
                    {
                        WindowCenter.Instance.OpenWithoutAnimation<OpenServerGiftWin>();
                    }
                    else
                    {
                        WindowCenter.Instance.Open<OpenServerGiftWin>(true);
                    }
                    break;
                case 7:
                    if (windowState == WindowState.Opened)
                    {
                        WindowCenter.Instance.OpenWithoutAnimation<LimitedTimePackageWin>();
                    }
                    else
                    {
                        WindowCenter.Instance.Open<LimitedTimePackageWin>(true);
                    }
                    break;
                case 8:
                    if (windowState == WindowState.Opened)
                    {
                        WindowCenter.Instance.OpenWithoutAnimation<NPracticePointWin>();
                    }
                    else
                    {
                        WindowCenter.Instance.Open<NPracticePointWin>(true);
                    }
                    break;
                case 9:
                    if (windowState == WindowState.Opened)
                    {
                        WindowCenter.Instance.OpenWithoutAnimation<BossRebornWin>();
                    }
                    else
                    {
                        WindowCenter.Instance.Open<BossRebornWin>(true);
                    }
                    break;
                case 10:
                    if (windowState == WindowState.Opened)
                    {
                        WindowCenter.Instance.OpenWithoutAnimation<FairyJadeInvestmentWin>();
                    }
                    else
                    {
                        WindowCenter.Instance.Open<FairyJadeInvestmentWin>(true);
                    }
                    break;
                case 11:
                    if (windowState == WindowState.Opened)
                    {
                        WindowCenter.Instance.OpenWithoutAnimation<VipInvestWin>();
                    }
                    else
                    {
                        WindowCenter.Instance.Open<VipInvestWin>(true);
                    }
                    break;
                case 12:
                    if (windowState == WindowState.Opened)
                    {
                        WindowCenter.Instance.OpenWithoutAnimation<FairyLeagueNoticeWin>();
                    }
                    else
                    {
                        WindowCenter.Instance.Open<FairyLeagueNoticeWin>(true);
                    }
                    break;
            }
        }

        private void OnActivityType(int _index)
        {
            var _order = _index / 100;
            var _type = _index % 100;
            switch (_order)
            {
                case 0:
                    impactRankModel.presentSelectType = _type;
                    break;
                case 2:
                    envelopeModel.selectType = _type;
                    break;
            }
            m_ActivityCtrl.m_Scorller.RefreshActiveCellViews();
        }

        private void CloseOtherWin()
        {
            WindowCenter.Instance.CloseImmediately<ImpactRankWin>();
            WindowCenter.Instance.CloseImmediately<OpenServerRedEnvelopeWin>();
            WindowCenter.Instance.CloseImmediately<OSTimeLimitGiftWin>();
            WindowCenter.Instance.CloseImmediately<FlashSaleWin>();
            WindowCenter.Instance.CloseImmediately<ConsumeRebateWin>();
            WindowCenter.Instance.CloseImmediately<MultipleExpWin>();
            WindowCenter.Instance.CloseImmediately<NPracticePointWin>();
            WindowCenter.Instance.CloseImmediately<BossRebornWin>();
            WindowCenter.Instance.CloseImmediately<OpenServerGiftWin>();
            WindowCenter.Instance.CloseImmediately<LimitedTimePackageWin>();
            WindowCenter.Instance.CloseImmediately<FairyJadeInvestmentWin>();
            WindowCenter.Instance.CloseImmediately<VipInvestWin>();
            WindowCenter.Instance.CloseImmediately<FairyLeagueNoticeWin>();
        }

        private int Compare(int order_x, int order_y)
        {
            var index_x = m_CustomActivitys.FindIndex((x) =>
            {
                return order_x == (int)x.activityType;
            });
            var index_y = m_CustomActivitys.FindIndex((x) =>
            {
                return order_y == (int)x.activityType;
            });
            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_CustomActivitys.Count; i++)
            {
                if (OpenServerActivityCenter.Instance.IsActivityOpen((int)m_CustomActivitys[i].activityType)
                    && !alreadyOpenActivitys.Contains((int)m_CustomActivitys[i].activityType))
                {
                    alreadyOpenActivitys.Add((int)m_CustomActivitys[i].activityType);
                    _update = true;
                }
            }
            if (_update)
            {
                UpdateFunctionBtns();
            }
        }

        [Serializable]
        public struct CustomActivityDisplay
        {
            [Header("活动类型"), EnumLabel(typeof(OpenServerActivityCenter.OSActivityType))]
            public OpenServerActivityCenter.OSActivityType activityType;
            public string titleIcon;
        }
    }
}