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, Header("排序")] List<int> m_SortArray;

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

        OSTimeLimitGiftModel m_OSTimeLimitGiftModel;
        OSTimeLimitGiftModel timeLimitGiftModel
        {
            get
            {
                return m_OSTimeLimitGiftModel ?? (m_OSTimeLimitGiftModel = ModelCenter.Instance.GetModel<OSTimeLimitGiftModel>());
            }
        }

        FlashSaleModel flashSaleModel { get { return ModelCenter.Instance.GetModel<FlashSaleModel>(); } }

        ConsumeRebateModel consumeRebateModel { get { return ModelCenter.Instance.GetModel<ConsumeRebateModel>(); } }

        MultipleExpModel multipleExpModel { get { return ModelCenter.Instance.GetModel<MultipleExpModel>(); } }

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

        protected override void BindController()
        {

        }

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

        protected override void OnPreOpen()
        {
            TimeUtility.OnServerOpenDayRefresh += OnStepServerDayEvent;
            OperationTimeHepler.Instance.operationTimeUpdateEvent += OperationTimeUpdateEvent;
            for (int i = 0; i < m_SortArray.Count; i++)
            {
                m_ActivitySpreadDict[m_SortArray[i]] = false;
            }
            impactRankModel.presentSelectType = impactRankModel.GetDefaultSelectType();
            impactRankModel.gotoImpactRankType = 0;
            envelopeModel.selectType = 1;
            CheckAlreadyOpen();
            UpdateFunctionBtns();
        }

        protected override void OnActived()
        {
            if (functionOrder == 1)
            {
                functionOrder = 0;
            }
            if (functionOrder == 0 && !WindowJumpMgr.Instance.IsJumpState)
            {
                functionOrder = GetDefaultSelect();
                for (int i = 0; i < m_SortArray.Count; i++)
                {
                    m_ActivitySpreadDict[m_SortArray[i]] = m_SortArray[i] == functionOrder;
                }
                UpdateFunctionBtns();
            }
            else
            {
                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;
            CloseOtherWin();
            WindowCenter.Instance.Open<MainInterfaceWin>();
            impactRankModel.gotoImpactRankType = 0;
        }

        protected override void OnAfterClose()
        {

        }

        int GetDefaultSelect()
        {
            openActivitys.Clear();
            activityReds.Clear();
            if (OpenServerActivityCenter.Instance.IsTimeLimitGiftOpen())
            {
                openActivitys.Add(3);
                if (timeLimitGiftModel.redpoint.state == RedPointState.Simple)
                {
                    activityReds.Add(3);
                }
            }
            if (OpenServerActivityCenter.Instance.IsFlashSaleOpen())
            {
                openActivitys.Add(4);
                if (flashSaleModel.flashSaleRedpoint.state == RedPointState.Simple)
                {
                    activityReds.Add(4);
                }
            }
            if (OpenServerActivityCenter.Instance.IsImpactRankOpen())
            {
                openActivitys.Add(0);
                if (impactRankModel.HasRedpoint())
                {
                    activityReds.Add(0);
                }
            }
            if (OpenServerActivityCenter.Instance.IsRedEnvelopeOpen())
            {
                openActivitys.Add(2);
                if (envelopeModel.m_RedAchieveRedpoint.state == RedPointState.Simple)
                {
                    activityReds.Add(2);
                    envelopeModel.selectType = 1;
                }
                else if (envelopeModel.m_OpenServerGetRedpin.state == RedPointState.Simple)
                {
                    activityReds.Add(2);
                    envelopeModel.selectType = 2;
                }
            }
            if (OpenServerActivityCenter.Instance.IsConsumeRebateOpen())
            {
                openActivitys.Add(1);
                if (consumeRebateModel.consumeRebateRedpoint.state == RedPointState.Simple)
                {
                    activityReds.Add(1);
                }
            }
            if (OpenServerActivityCenter.Instance.IsMultipleExpOpen())
            {
                openActivitys.Add(5);
                if (multipleExpModel.multipleExpRedpoint.state == RedPointState.Simple)
                {
                    activityReds.Add(5);
                }
            }

            if (activityReds.Count > 0)
            {
                activityReds.Sort(Compare);
                return activityReds[0];
            }
            else
            {
                openActivitys.Sort(Compare);
                return openActivitys[0];
            }
        }

        void CheckAlreadyOpen()
        {
            alreadyOpenActivitys.Clear();
            if (OpenServerActivityCenter.Instance.IsTimeLimitGiftOpen())
            {
                alreadyOpenActivitys.Add(3);
            }
            if (OpenServerActivityCenter.Instance.IsFlashSaleOpen())
            {
                alreadyOpenActivitys.Add(4);
            }
            if (OpenServerActivityCenter.Instance.IsImpactRankOpen())
            {
                alreadyOpenActivitys.Add(0);
            }
            if (OpenServerActivityCenter.Instance.IsRedEnvelopeOpen())
            {
                alreadyOpenActivitys.Add(2);
            }
            if (OpenServerActivityCenter.Instance.IsConsumeRebateOpen())
            {
                alreadyOpenActivitys.Add(1);
            }
            if (OpenServerActivityCenter.Instance.IsMultipleExpOpen())
            {
                alreadyOpenActivitys.Add(5);
            }
        }

        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 void RefreshOpenActivityCell(OpenServerActivityCell _cell)
        {
            switch (_cell.index)
            {
                case 5:
                    OperationBase operationBase;
                    if (OperationTimeHepler.Instance.TryGetOperationTime(Operation.MultipleExp, out operationBase))
                    {
                        _cell.title.text = Language.Get("ExpActivity_Text5", (operationBase as OperationMultiExp).GetMultipleCHS());
                    }
                    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.arrow.rectTransform.localEulerAngles = m_ActivitySpreadDict[_cell.order] ? new Vector3(0, 0, -90) : Vector3.zero;
            _cell.arrow.gameObject.SetActive(_cell.order == 0 || _cell.order == 2);
            _cell.funcBtn.onClick.RemoveAllListeners();
            _cell.funcBtn.onClick.AddListener(() =>
            {
                OnActivityClick(_cell.order);
            });
        }

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

        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_SortArray.Count; i++)
            {
                var sort = m_SortArray[i];
                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)
                        {
                            m_ActivityCtrl.AddCell(ScrollerDataType.Normal, sort * 100 + _type);
                        }
                        break;
                    case 1:
                        m_ActivityCtrl.AddCell(ScrollerDataType.Header, sort);
                        continue;
                    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;
                    case 3:
                        m_ActivityCtrl.AddCell(ScrollerDataType.Header, sort);
                        break;
                    case 4:
                        m_ActivityCtrl.AddCell(ScrollerDataType.Header, sort);
                        break;
                    case 5:
                        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;
            }
        }

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

        private int Compare(int x, int y)
        {
            var index_x = m_SortArray.IndexOf(x);
            var index_y = m_SortArray.IndexOf(y);
            return index_x.CompareTo(index_y);
        }

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