Client/GameClient/Assets/Game/HotUpdate/Views/Arena/ArenaRankView.cs

using System.Collections.Generic;
using ET;
using FairyGUI;
using UI.Arena;
using UnityEngine;

namespace GFGGame
{
    public class ArenaRankView : BaseWindow
    {
        private UI_ArenaRankUI _ui;
        private int _rankType = 0;

        private bool _lock = false;

        public override void Dispose()
        {
            if (_ui != null)
            {
                _ui.Dispose();
                _ui = null;
            }
            base.Dispose();
        }

        protected override void OnInit()
        {
            base.OnInit();
            packageName = UI_ArenaUI.PACKAGE_NAME;
            _ui = UI_ArenaRankUI.Create();
            this.viewCom = _ui.target;
            this.viewCom.Center();
            this.modal = true;
            viewAnimationType = EnumViewAnimationType.ZOOM_CENTER;

            _ui.m_listRank.SetVirtual();
            _ui.m_listRank.itemProvider = GetListItemResource;
            _ui.m_listRank.itemRenderer = RenderListItem;
            _ui.m_listRank.scrollPane.onScroll.Add(OnListScroll);
            _ui.m_c1.onChanged.Add(OnTabChange);
            _ui.m_c2.onChanged.Add(OnTab1Change);
        }
        protected override void AddEventListener()
        {
            base.AddEventListener();

        }
        protected override void OnShown()
        {
            base.OnShown();
            _rankType = ArenaRankType.NOW_SEASON;
            _ui.m_c1.selectedIndex = 0;
            _ui.m_c2.selectedIndex = 0;
            _ui.m_listRank.numItems = 100;
            _ui.m_comMyRank.m_btnLook.visible = false;
            ArenaDataManager.Instance.RankDatasDic.Clear();
            ReqRankList(0);
        }

        protected override void OnHide()
        {
            base.OnHide();
            if (_ui.m_listRank.numItems > 0) _ui.m_listRank.ScrollToView(0);
        }

        protected override void RemoveEventListener()
        {
            base.RemoveEventListener();

        }
        private void OnTabChange()
        {
            if (_ui.m_c1.selectedIndex == 0)
            {
                _ui.m_c2.selectedIndex = 0;
                _rankType = ArenaRankType.NOW_SEASON;
            }
            else
            {
                _rankType = ArenaRankType.FRIEND;
            }
            if (_ui.m_listRank.numItems > 0) _ui.m_listRank.ScrollToView(0);
            _ui.m_listRank.numItems = 0;
            ReqRankList(0);
        }
        private void OnTab1Change()
        {
            if (_ui.m_c2.selectedIndex == 0)
            {
                _rankType = ArenaRankType.NOW_SEASON;
            }
            else
            {
                _rankType = ArenaRankType.LAST_SEASON;
            }
            if (_ui.m_listRank.numItems > 0) _ui.m_listRank.ScrollToView(0);
            _ui.m_listRank.numItems = 0;
            ReqRankList(0);
        }
        private void OnListScroll()
        {

            int itemIndex = _ui.m_listRank.ChildIndexToItemIndex(_ui.m_listRank.numChildren - 1);
            if (itemIndex % 20 == 0)
            {
                ReqRankList(itemIndex);
            }
        }
        private async void ReqRankList(int index)
        {

            int count = 0;
            if (ArenaDataManager.Instance.RankDatasDic.ContainsKey(_rankType))
            {
                count = ArenaDataManager.Instance.RankDatasDic[_rankType].Count;
            }
            if (_lock) return;
            if (count > index)
            {
                UpdateView();
                return;
            }
            _lock = true;
            int startIndex = index + 1;
            bool result = await ArenaSproxy.ReqArenaRank(_rankType, startIndex, startIndex + 19);
            if (result)
            {
                UpdateView();
            }
            _lock = false;
        }
        private void UpdateView()
        {
            UpdateSelf();
            if (_rankType == ArenaRankType.FRIEND)
            {
                _ui.m_listRank.numItems = ArenaDataManager.Instance.RankDatasDic[_rankType].Count;
            }
            else if (_rankType == ArenaRankType.LAST_SEASON)
            {
                if (ArenaDataManager.Instance.RankDatasDic[_rankType].Count == 0)
                {
                    _ui.m_listRank.numItems = 0;
                }
                else
                {
                    _ui.m_listRank.numItems = 100;
                }
            }
            else
            {
                _ui.m_listRank.numItems = 100;
            }
            _ui.m_listRank.RefreshVirtualList();
            _ui.m_txtTips.visible = _ui.m_listRank.numItems == 0;

        }
        private void UpdateSelf()
        {
            _ui.m_comMyRank.target.visible = false;
            if ((_rankType == ArenaRankType.FRIEND || _rankType == ArenaRankType.NOW_SEASON) && ArenaDataManager.Instance.SelfData != null)
            {
                _ui.m_comMyRank.target.visible = true;
                UpdateOtherItem(ArenaDataManager.Instance.SelfData, _ui.m_comMyRank.target, true);
            }
            else if (_rankType == ArenaRankType.LAST_SEASON && ArenaDataManager.Instance.SelfLastData != null)
            {
                _ui.m_comMyRank.target.visible = true;
                UpdateOtherItem(ArenaDataManager.Instance.SelfLastData, _ui.m_comMyRank.target, true);
            }
        }
        private string GetListItemResource(int index)
        {
            if (index == 0)
                return "ui://Arena/ListRankItem0";
            else if (index == 1)
                return "ui://Arena/ListRankItem1";
            else if (index == 2)
                return "ui://Arena/ListRankItem2";
            else
                return "ui://Arena/ListRankItem3";
        }
        private void RenderListItem(int index, GObject obj)
        {
            ArenaTargetData arenaData = null;
            Dictionary<int, List<ArenaTargetData>> RankDatasDic = ArenaDataManager.Instance.RankDatasDic;
            if (RankDatasDic.ContainsKey(_rankType) && RankDatasDic[_rankType].Count > index)
            {
                arenaData = ArenaDataManager.Instance.RankDatasDic[_rankType][index];
            }
            if (index == 0)
            {
                int itemIndex0 = 0;
                if (RankDatasDic.ContainsKey(_rankType) && RankDatasDic[_rankType].Count > itemIndex0)
                {
                    arenaData = ArenaDataManager.Instance.RankDatasDic[_rankType][itemIndex0];
                }
                GObject obj0 = obj.asCom.GetChildAt(itemIndex0);
                UpdateTopItem(itemIndex0, arenaData, obj0);

                int itemIndex1 = 1;
                arenaData = null;
                if (RankDatasDic.ContainsKey(_rankType) && RankDatasDic[_rankType].Count > itemIndex1)
                {
                    arenaData = ArenaDataManager.Instance.RankDatasDic[_rankType][itemIndex1];
                }
                GObject obj1 = obj.asCom.GetChildAt(itemIndex1);
                UpdateTopItem(itemIndex1, arenaData, obj1);
                obj1.visible = _rankType != ArenaRankType.FRIEND || _rankType == ArenaRankType.FRIEND && arenaData != null;

                int itemIndex2 = 2;
                arenaData = null;
                if (RankDatasDic.ContainsKey(_rankType) && RankDatasDic[_rankType].Count > itemIndex2)
                {
                    arenaData = ArenaDataManager.Instance.RankDatasDic[_rankType][itemIndex2];
                }
                GObject obj2 = obj.asCom.GetChildAt(itemIndex2);
                UpdateTopItem(itemIndex2, arenaData, obj2);
                obj2.visible = _rankType != ArenaRankType.FRIEND || _rankType == ArenaRankType.FRIEND && arenaData != null;
            }
            if (index > 2)
            {
                UpdateOtherItem(arenaData, obj);
            }
        }
        private void UpdateTopItem(int index, ArenaTargetData arenaData, GObject obj)
        {
            UI_ListRankItem item = UI_ListRankItem.Proxy(obj.asCom);
            item.m_c1.selectedIndex = index + 1;
            if (arenaData == null)
            {
                item.m_txtName.text = "--";
                item.m_txtFightScore.text = "竞技场战力：--";
                item.m_txtDanRank.text = "段位排行：--";
                item.m_loaDanIcon.url = "";
                RoleInfoManager.Instance.UpdateLv(item.m_comLv, 0);
                RoleInfoManager.Instance.UpdateNpcHead(item.m_comHead, "");
            }
            else
            {
                item.m_txtName.text = arenaData.RoleInfo.roleName;

                long fightScore = ArenaDataManager.Instance.GetAllFightScore(arenaData.FightDatas);
                if (arenaData.Type == FightTargetType.PLAYER)
                {
                    //上榜的玩家一定战斗过，可以直接计算
                    item.m_txtFightScore.text = string.Format("竞技场战力：{0}", ArenaDataManager.Instance.GetAllFightScore(arenaData.FightScores));
                    RoleInfoManager.Instance.UpdateHead(item.m_comHead, arenaData.RoleInfo.headId, 0);
                }
                else
                {
                    //上榜的机器人不一定战斗过，所以不一定有竞技场战力数据，所以机器人需要重新计算
                    item.m_txtFightScore.text = string.Format("竞技场战力：{0}", ArenaDataManager.Instance.GetAllFightScore(arenaData.FightDatas));
                    RoleInfoManager.Instance.UpdateNpcHead(item.m_comHead, arenaData.RoleInfo.headRes);
                }
                // item.m_txtFightScore.text = string.Format("竞技场战力：{0}", fightScore);
                item.m_txtDanRank.text = string.Format("段位排行：{0}", arenaData.Grade);
                ArenaViewManager.Instance.UpdateDanIcon(item.m_loaDanIcon, arenaData.Grade);
                RoleInfoManager.Instance.UpdateLv(item.m_comLv, arenaData.RoleInfo.roleLv);
                if (arenaData.Type == FightTargetType.PLAYER)
                {
                    RoleInfoManager.Instance.UpdateHead(item.m_comHead, arenaData.RoleInfo.headId, 0);
                }
                else
                {
                    RoleInfoManager.Instance.UpdateNpcHead(item.m_comHead, arenaData.RoleInfo.headRes);
                }
            }
            item.m_btnLook.visible = _rankType != ArenaRankType.LAST_SEASON;
            if (item.m_btnLook.data == null)
            {
                item.m_btnLook.onClick.Add(OnBtnLookClick);
                item.m_comHead.onClick.Add(OnBtnLookClick);
            }
            item.m_btnLook.data = arenaData;
            item.m_comHead.data = arenaData;
            UI_ListRankItem.ProxyEnd();
        }

        private void UpdateOtherItem(ArenaTargetData arenaData, GObject obj, bool isSelf = false)
        {
            UI_ListRankItem3 item = UI_ListRankItem3.Proxy(obj);

            if (arenaData == null)
            {
                item.m_txtRank.text = "--";
                item.m_txtName.text = "--";
                item.m_txtFightScore.text = "竞技场战力：--";
                item.m_txtDanRank.text = "--";
                item.m_loaDanIcon.url = "";
                RoleInfoManager.Instance.UpdateLv(item.m_comLv, 0);
                RoleInfoManager.Instance.UpdateNpcHead(item.m_comHead, "");

            }
            else
            {
                item.m_txtRank.text = arenaData.RankInGrade.ToString();
                item.m_txtName.text = arenaData.RoleInfo.roleName;
                item.m_txtDanRank.text = arenaData.Grade.ToString();

                ArenaViewManager.Instance.UpdateDanIcon(item.m_loaDanIcon, arenaData.Grade);
                RoleInfoManager.Instance.UpdateLv(item.m_comLv, arenaData.RoleInfo.roleLv);
                if (arenaData.Type == FightTargetType.PLAYER)
                {
                    //上榜的玩家一定战斗过，可以直接计算
                    item.m_txtFightScore.text = string.Format("竞技场战力：{0}", ArenaDataManager.Instance.GetAllFightScore(arenaData.FightScores));
                    RoleInfoManager.Instance.UpdateHead(item.m_comHead, arenaData.RoleInfo.headId, 0);
                }
                else
                {
                    //上榜的机器人不一定战斗过，所以不一定有竞技场战力数据，所以机器人需要重新计算
                    item.m_txtFightScore.text = string.Format("竞技场战力：{0}", ArenaDataManager.Instance.GetAllFightScore(arenaData.FightDatas));
                    RoleInfoManager.Instance.UpdateNpcHead(item.m_comHead, arenaData.RoleInfo.headRes);
                }
            }
            item.m_btnLook.visible = _rankType != ArenaRankType.LAST_SEASON;
            if (item.m_btnLook.data == null)
            {
                item.m_btnLook.onClick.Add(OnBtnLookClick);
                item.m_comHead.onClick.Add(OnBtnLookClick);
            }
            item.m_btnLook.data = arenaData;
            item.m_comHead.data = arenaData;

            UI_ListRankItem3.ProxyEnd();
        }
        private async void OnBtnLookClick(EventContext context)
        {
            ArenaTargetData targetData = (context.sender as GObject).data as ArenaTargetData;
            if (targetData == null || targetData.Type == FightTargetType.ROBOT)
            {
                PromptController.Instance.ShowFloatTextPrompt("玩家不在线");
                return;
            }
            bool result = await ArenaSproxy.ReqArenaFightAttr(targetData.RoleInfo.roleId, targetData.FightDatas);
            if (result)
            {
                ViewManager.Show<ArenaDressInfoView>(new object[] { FightRoleType.TAEGET, 0, targetData.FightDatas, typeof(ArenaRankView).FullName }, new object[] { typeof(ArenaView).FullName, ViewManager.GetUIView(typeof(ArenaView).Name).viewData }, true);
            }
        }
    }
}