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

using System.Linq;
using vnxbqy.UI;
namespace vnxbqy.UI
{
    public class RankPanel : Window
    {
        [SerializeField] Text m_RankRemind;
        [SerializeField] ScrollerController m_RankTypeController;
        [SerializeField] Text[] m_RankTitles;
        [SerializeField] Text m_MyRank;
        [SerializeField] ScrollerController m_RankListController;

        RankModel model { get { return ModelCenter.Instance.GetModel<RankModel>(); } }
        RoleParticularModel roleParticularModel { get { return ModelCenter.Instance.GetModel<RoleParticularModel>(); } }

        Dictionary<int, DateTime> requestRankTime = new Dictionary<int, DateTime>();

        protected override void BindController()
        {

        }

        protected override void AddListeners()
        {
            m_RankTypeController.OnRefreshCell += OnRefreshRankTypeCell;
        }

        protected override void OnPreOpen()
        {
            model.onRankRefresh += OnRankRefresh;
            model.selectRankIdRefresh += SelectRankIdRefresh;
            model.selectSubRankIdRefresh += SelectSubRankIdRefresh;

            requestRankTime.Clear();

            for (int i = 0; i < model.displayRanks.Count; i++)
            {
                model.subRankSpreads[model.displayRanks[i]] = false;
            }

            SetDefaultSelect();

            Display();

        }

        protected override void OnAfterOpen()
        {
            var index = model.displayRanks.IndexOf(model.selectRankId);
            m_RankTypeController.JumpIndex(index);

        }

        protected override void OnPreClose()
        {
            model.onRankRefresh -= OnRankRefresh;
            model.selectRankIdRefresh -= SelectRankIdRefresh;
            model.selectSubRankIdRefresh -= SelectSubRankIdRefresh;
        }

        protected override void OnAfterClose()
        {
        }

        void SetDefaultSelect()
        {
            if (model.jumpRankType != -1)
            {
                var rankId = model.jumpRankType;
                if (model.jumpRankType > 100)
                {
                    rankId = model.jumpRankType / 100;
                }
                if (model.displayRanks.Contains(rankId))
                {
                    model.selectRankId = rankId;
                    if (model.displaySubRanks.ContainsKey(rankId))
                    {
                        model.selectSubRankId = model.jumpRankType;
                    }
                }
            }
            else
            {
                model.selectRankId = 1;
            }
            model.jumpRankType = -1;
        }

        void Display()
        {
            DisplayRankTypes();
            DisplayRankTitles();
            DisplayRemind();
            DisplayRanks();
        }

        void DisplayRankTypes()
        {
            m_RankTypeController.Refresh();
            for (int i = 0; i < model.displayRanks.Count; i++)
            {
                var rankId = model.displayRanks[i];
                m_RankTypeController.AddCell(ScrollerDataType.Header, rankId, OnSelectRankId);
                if (model.displaySubRanks.ContainsKey(rankId)
                    && model.selectRankId == rankId && model.subRankSpreads[rankId])
                {
                    var subRanks = model.displaySubRanks[rankId];
                    for (int j = 0; j < subRanks.Count; j++)
                    {
                        m_RankTypeController.AddCell(ScrollerDataType.Normal, subRanks[j], OnSelectSubRankId);
                    }
                }
            }
            m_RankTypeController.Restart();
            m_RankTypeController.JumpIndex(model.jumpRankType);
        }

        void DisplayRankTitles()
        {
            var rankId = model.selectRankId;
            if (model.displaySubRanks.ContainsKey(model.selectRankId))
            {
                rankId = model.selectSubRankId;
            }
            var config = RankListConfig.Get(rankId);
            for (int i = 0; i < m_RankTitles.Length; i++)
            {
                if (config.RankAtt != null && i < config.RankAtt.Length)
                {
                    m_RankTitles[i].SetActive(true);
                    m_RankTitles[i].text = config.RankAtt[i];
                }
                else
                {
                    m_RankTitles[i].SetActive(false);
                }
            }
        }

        void DisplayRemind()
        {
            m_RankRemind.text = UIHelper.ReplaceNewLine(Language.Get(StringUtility.Contact("RankTip_", model.selectRankId)));
        }

        void DisplayRanks()
        {
            if (m_RankListController.GetNumberOfCells(m_RankListController.m_Scorller) < 1)
            {
                m_RankListController.Refresh();
                for (int i = 0; i < model.displayRankCount; i++)
                {
                    m_RankListController.AddCell(i % 2 == 0 ? ScrollerDataType.Normal : ScrollerDataType.Header, i, OnSelectRank);
                }
                m_RankListController.Restart();
            }

            m_RankListController.m_Scorller.RefreshActiveCellViews();
            

            int rank = 0;
            if (model.TryGetMyRank(model.selectRankType, out rank))
            {
                m_MyRank.text = Language.Get("L1092", rank);
            }
            else
            {
                m_MyRank.text = Language.Get("L1045");
            }
        }

        private void OnRankRefresh(int type)
        {
            if (type == model.selectRankType)
            {
                DisplayRanks();
            }
        }

        private void OnSelectRankId(CellView cell)
        {
            var rankId = cell.index;
            if (model.selectRankId == rankId)
            {
                if (model.displaySubRanks.ContainsKey(rankId))
                {
                    model.subRankSpreads[rankId] = !model.subRankSpreads[rankId];
                    DisplayRankTypes();
                }
            }
            else
            {
                model.selectRankId = rankId;
            }
        }

        void OnSelectSubRankId(CellView cell)
        {
            model.selectSubRankId = cell.index;
            m_RankTypeController.m_Scorller.RefreshActiveCellViews();
        }

        private void OnRefreshRankTypeCell(ScrollerDataType type, CellView cell)
        {
            switch (type)
            {
                case ScrollerDataType.Header:
                    {
                        var rankTypeCell = cell as RankTypeCell;
                        rankTypeCell.Display(cell.index);
                    }
                    break;
                case ScrollerDataType.Normal:
                    {
                        var rankSubTypeCell = cell as RankSubTypeCell;
                        rankSubTypeCell.Display(cell.index);
                    }
                    break;
            }
        }

        private void RequestRanks(int type)
        {
            if (requestRankTime.ContainsKey(type))
            {
                if ((DateTime.Now - requestRankTime[type]).TotalSeconds < 1f)
                {
                    return;
                }
            }
            var pak = new C1001_tagCWatchBillboard();
            pak.Type = (byte)type;
            GameNetSystem.Instance.SendInfo(pak);
            requestRankTime[type] = DateTime.Now;
        }

        private void SelectSubRankIdRefresh()
        {
            m_RankTypeController.m_Scorller.RefreshActiveCellViews();
            RequestRanks(model.selectRankType);
            DisplayRanks();
            DisplayRankTitles();
        }

        private void SelectRankIdRefresh()
        {
            foreach (var rankId in model.displayRanks)
            {
                model.subRankSpreads[rankId] = false;
            }

            if (model.displaySubRanks.ContainsKey(model.selectRankId))
            {
                var subRanks = model.displaySubRanks[model.selectRankId];
                model.selectSubRankId = subRanks[0];
                model.subRankSpreads[model.selectRankId] = true;
                DisplayRemind();
            }
            else
            {
                RequestRanks(model.selectRankType);
                DisplayRanks();
                DisplayRankTitles();
                DisplayRemind();
            }
            DisplayRankTypes();
        }

        private void OnSelectRank(CellView cell)
        {
            List<RankData> rankDatas = null;
            if (model.TryGetRanks(model.selectRankType, out rankDatas))
            {
                int index = cell.index;
                if (index < rankDatas.Count)
                {
                    if (rankDatas[index].id == PlayerDatas.Instance.baseData.PlayerID)
                    {
                        SysNotifyMgr.Instance.ShowTip("SeePlayer_Cannot");
                        return;
                    }
                    roleParticularModel.ViewRoleEquip((int)rankDatas[index].id);
                }
            }
        }
    }
}