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;

        readonly int[] sortArray = new int[] { 3, 4, 0, 1, 2 };

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

        protected override void BindController()
        {

        }

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

        protected override void OnPreOpen()
        {
            TimeUtility.OnServerOpenDayRefresh += OnStepServerDayEvent;
            for (int i = 0; i < sortArray.Length; i++)
            {
                m_ActivitySpreadDict[sortArray[i]] = false;
            }
            impactRankModel.presentSelectType = impactRankModel.GetDefaultSelectType();
            impactRankModel.gotoImpactRankType = 0;
            envelopeModel.selectType = 1;
            UpdateFunctionBtns();
            m_TitleIcon.SetSprite(OpenServerActivityCenter.Instance.IsFlashSaleTitle() ? "XT_KF_32" : "XT_KF_9");
        }

        protected override void OnActived()
        {
            if (functionOrder == 1)
            {
                functionOrder = 0;
            }
            if (functionOrder == 0 && !WindowJumpMgr.Instance.IsJumpState)
            {
                bool _step = false;

                functionOrder = 3;
                if (OpenServerActivityCenter.Instance.IsTimeLimitGiftOpen())
                {
                    if (timeLimitGiftModel.redpoint.state == RedPointState.Simple)
                    {
                        functionOrder = 3;
                        _step = true;
                    }
                }
                else if (!OpenServerActivityCenter.Instance.IsTimeLimitGiftOpen())
                {
                    functionOrder = 4;
                }

                if (!_step && OpenServerActivityCenter.Instance.IsFlashSaleOpen())
                {
                    if (flashSaleModel.flashSaleRedpoint.state == RedPointState.Simple)
                    {
                        functionOrder = 4;
                    }
                }
                else if (!OpenServerActivityCenter.Instance.IsFlashSaleOpen() && functionOrder == 4)
                {
                    functionOrder = 0;
                }


                if (!_step && OpenServerActivityCenter.Instance.IsImpactRankOpen() && impactRankModel.HasRedpoint())
                {
                    functionOrder = 0;
                    _step = true;
                }
                else if (!OpenServerActivityCenter.Instance.IsImpactRankOpen() && functionOrder == 0)
                {
                    functionOrder = 2;
                }

                if (!_step && OpenServerActivityCenter.Instance.IsRedEnvelopeOpen())
                {
                    if (envelopeModel.m_RedAchieveRedpoint.state == RedPointState.Simple)
                    {
                        functionOrder = 2;
                        envelopeModel.selectType = 1;
                        _step = true;
                    }
                    else if (envelopeModel.m_OpenServerGetRedpin.state == RedPointState.Simple)
                    {
                        functionOrder = 2;
                        envelopeModel.selectType = 2;
                        _step = true;
                    }
                }
                else if (!OpenServerActivityCenter.Instance.IsRedEnvelopeOpen() && functionOrder == 2)
                {
                    DesignDebug.Log("是不是逻辑有错误");
                }

                //if (!_step && OpenServerActivityCenter.Instance.IsTimeLimitGiftOpen())
                //{
                //    if (timeLimitGiftModel.redpoint.state == RedPointState.Simple)
                //    {
                //        functionOrder = 3;
                //        _step = true;
                //    }
                //}
                //else if (!OpenServerActivityCenter.Instance.IsTimeLimitGiftOpen() && functionOrder == 3)
                //{
                //    functionOrder = 4;
                //}
                //
                //if (!_step && OpenServerActivityCenter.Instance.IsFlashSaleOpen())
                //{
                //
                //}
                //else if (!OpenServerActivityCenter.Instance.IsFlashSaleOpen() && functionOrder == 4)
                //{
                //    DesignDebug.Log("是不是逻辑有错误");
                //}

                for (int i = 0; i < sortArray.Length; i++)
                {
                    m_ActivitySpreadDict[sortArray[i]] = sortArray[i] == functionOrder;
                }
                UpdateFunctionBtns();
            }
            else
            {
                for (int i = 0; i < sortArray.Length; i++)
                {
                    m_ActivitySpreadDict[sortArray[i]] = 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;
            CloseOtherWin();
            WindowCenter.Instance.Open<MainInterfaceWin>();
            impactRankModel.gotoImpactRankType = 0;
        }

        protected override void OnAfterClose()
        {

        }
        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)
        {
            _cell.title.text = Language.Get(StringUtility.Contact("OSActivityTitle_", _cell.index));
            _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 < sortArray.Length; i++)
            {
                var sort = sortArray[i];
                switch (sort)
                {
                    case 0:
                        if (!OpenServerActivityCenter.Instance.IsImpactRankOpen())
                        {
                            continue;
                        }
                        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:
                        continue;
                    case 2:
                        if (!OpenServerActivityCenter.Instance.IsRedEnvelopeOpen())
                        {
                            continue;
                        }
                        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:
                        if (!OpenServerActivityCenter.Instance.IsTimeLimitGiftOpen())
                        {
                            continue;
                        }
                        m_ActivityCtrl.AddCell(ScrollerDataType.Header, sort);
                        break;
                    case 4:
                        if (!OpenServerActivityCenter.Instance.IsFlashSaleOpen())
                        {
                            continue;
                        }
                        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:
                    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;
            }
        }

        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()
        {
            if (WindowCenter.Instance.CheckOpen<ImpactRankWin>())
            {
                WindowCenter.Instance.CloseImmediately<ImpactRankWin>();
            }
            if (WindowCenter.Instance.CheckOpen<OpenServerRedEnvelopeWin>())
            {
                WindowCenter.Instance.CloseImmediately<OpenServerRedEnvelopeWin>();
            }
            if (WindowCenter.Instance.CheckOpen<OSTimeLimitGiftWin>())
            {
                WindowCenter.Instance.CloseImmediately<OSTimeLimitGiftWin>();
            }
            if (WindowCenter.Instance.CheckOpen<FlashSaleWin>())
            {
                WindowCenter.Instance.CloseImmediately<FlashSaleWin>();
            }
        }
    }
}