smart-bow-infrared/Assets/ShotSimulator/Scripts/UI/Train/TrainSettlementUIView.cs

using Newtonsoft.Json;
using ProjectBase.UI;
using ShotSimulator.Train;
using ShotSimulator.Train.Info;
using ShotSimulator.User;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Localization.Components;
using UnityEngine.Localization.Settings;
using UnityEngine.UI;

namespace ShotSimulator.UI
{
    public class TrainSettlementUIView : BaseUIView
    {
        public Text SettlementInfoText;
        public Toggle totalResultToggle;
        public Toggle rankingToggle;

        public Transform totalResultPanel;
        public Transform rankingPanel;

        [SerializeField]
        private Button replayButton;
        [SerializeField]
        private Button backButton;

        public UIRadar radar;

        private List<GameObject> m_MetricsDataItems = new List<GameObject>();
        public Transform m_MetricsDataItemConetnt;

        private BaseTrainHandle handle;
        private TrainResultData trainResultData;

        public Transform rankViewContent;
        public RankingItem selfRankingItem;

        private Coroutine delayJumpRankingCoroutine;
        protected override void InitUIObjects()
        {
            base.InitUIObjects();

            totalResultToggle.onValueChanged.AddListener((isOn) => { OnPanelToggleChanged(totalResultPanel, isOn); });
            rankingToggle.onValueChanged.AddListener((isOn) => { OnPanelToggleChanged(rankingPanel, isOn); });

            replayButton.onClick.AddListener(OnReplayButtonClick);
            backButton.onClick.AddListener(OnBackButtonClick);
        }

        protected override void OnShowCallBack()
        {
            base.OnShowCallBack();
            replayButton.interactable = true;
            backButton.interactable = true;
            totalResultToggle.isOn = true;

            if (delayJumpRankingCoroutine != null)
            {
                StopCoroutine(delayJumpRankingCoroutine);
            }
            delayJumpRankingCoroutine = StartCoroutine(DelayJumpRanking());
        }

        private IEnumerator DelayJumpRanking()
        {
            yield return new WaitForSeconds(5f);

            rankingToggle.isOn = true;
        }

        private void OnReplayButtonClick()
        {
            replayButton.interactable = false;
            TrainTaskLoader.GetInstance().ReStartTrain();
        }

        private void OnBackButtonClick()
        {
            backButton.interactable = false;
            TrainTaskLoader.GetInstance().FinishTrain();
        }
        protected override void UpdateArguments(params object[] args)
        {
            base.UpdateArguments(args);

            handle = args[0] as BaseTrainHandle;
            if (handle != null)
            {
                trainResultData = handle.GetTrainResultData();
            }
        }

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

            GenerateRadar();
            GenerateMetricsDataItems();
            UpdateSettlementInfoDisplay();

            UpdateRanking();
        }

        private void UpdateSettlementInfoDisplay()
        {
            SettlementInfoText.text = string.Format("{0} {1} {2}", GetCurrentTime(), GetCurrentTrainName(), GetCurrentDifficulty());
        }
        private string GetCurrentTime()
        {
            System.DateTime currentTime = System.DateTime.Now;
            return currentTime.ToString("yyyy.MM.dd HH:mm");
        }
        private string GetCurrentTrainName()
        {
            var tableEntryResult = LocalizationSettings.StringDatabase.GetTableEntry("LanguagesTable", handle.TrainInfo.detail.nameID);
            return tableEntryResult.Entry.GetLocalizedString();
        }
        private string GetCurrentDifficulty()
        {
            string difficult = string.Empty;
            switch (handle.m_DifficultyType)
            {
                case DifficultyType.Standard:
                    difficult = LocalizationSettings.StringDatabase.GetTableEntry("LanguagesTable", "train_level_recruit").Entry.GetLocalizedString();
                    break;
                case DifficultyType.Advance:
                    difficult = LocalizationSettings.StringDatabase.GetTableEntry("LanguagesTable", "train_level_vanguard").Entry.GetLocalizedString();
                    break;
                case DifficultyType.Professional:
                    difficult = LocalizationSettings.StringDatabase.GetTableEntry("LanguagesTable", "train_level_elite").Entry.GetLocalizedString();
                    break;
            }
            return difficult;
        }
        private void OnPanelToggleChanged(Transform panel, bool view)
        {
            panel.gameObject.SetActive(view);
        }
        public void GenerateRadar()
        {
            List<GraphData> datas = new List<GraphData>();
            foreach (var data in trainResultData.metricsDic.Values)
            {
                string valueStr = string.Empty;
                if(double.IsNaN(data.value) || double.IsInfinity(data.value))
                {
                    valueStr = "N/A";
                }
                else
                {
                    switch (data.valueType)
                    {
                        case ValueType.Default:
                            valueStr = data.value.ToString();
                            break;
                        case ValueType.Percentage:
                            valueStr = data.value.ToString("P0");
                            break;
                    }
                }
                var tableEntryResult = LocalizationSettings.StringDatabase.GetTableEntry("LanguagesTable", data.typeNameID);
                string typeName = tableEntryResult.Entry.GetLocalizedString();
                datas.Add(new GraphData()
                {
                    StageValues = data.StageValues,
                    _value = (float)data.value,
                    _desc = string.Format("<color=#F2E9B3>{0}</color>\n{1}", typeName, valueStr)
                });
            }
            radar.RefeshRadarGraph(datas.ToArray());
        }

        private void GenerateMetricsDataItems()
        {
            foreach (var item in m_MetricsDataItems)
            {
                GameObject.Destroy(item.gameObject);
            }
            m_MetricsDataItems.Clear();

            foreach (var data in trainResultData.metricsDic.Values)
            {
                GameObject obj = GameObject.Instantiate(Resources.Load<GameObject>("Prefabs/UI/MetricsItem"));
                LocalizeStringEvent localize = obj.transform.Find("MetricsTypeText").GetComponent<LocalizeStringEvent>();
                localize.SetTable("LanguagesTable");
                localize.SetEntry(data.typeNameID);
                if (double.IsNaN(data.value) || double.IsInfinity(data.value))
                {
                    obj.transform.Find("ValueText").GetComponent<Text>().text = "N/A";
                }
                else
                {
                    switch (data.valueType)
                    {
                        case ValueType.Default:
                            obj.transform.Find("ValueText").GetComponent<Text>().text = data.value.ToString();
                            break;
                        case ValueType.Percentage:
                            obj.transform.Find("ValueText").GetComponent<Text>().text = data.value.ToString("P0");
                            break;
                    }
                }
                obj.transform.SetParent(m_MetricsDataItemConetnt, false);
                obj.transform.localScale = Vector3.one;
                m_MetricsDataItems.Add(obj);
            }
        }

        private void UpdateRanking()
        {
            RankingFilter filter = new RankingFilter()
            {
                trainTaskType = handle.TrainInfo.trainTaskType,
                difficultyType = handle.m_DifficultyType,
                modeType = VirtualMouse.GetInstance().TacticalMode ? ModeType.Tactical : ModeType.NonTactical,
                firearmDeviceType = TrainTaskLoader.GetInstance().CurFirearmData.firearmDeviceType
            };
            UserManager.GetInstance().UploadCustomLeaderboard(filter, (int)trainResultData.GetMetrics(MetricsType.Score).value, (result) =>
            {
                List<RankingData> datas = JsonConvert.DeserializeObject<List<RankingData>>(JsonConvert.SerializeObject(result.data, Formatting.Indented));
                UpdateRankingView(datas);
            }); 
        }

        private void UpdateRankingView(List<RankingData> datas)
        {
            foreach (Transform child in rankViewContent)
            {
                Destroy(child.gameObject);
            }
            selfRankingItem.Reset();
            selfRankingItem.gameObject.SetActive(false);
            if (datas != null)
            {
                for (int i = 0; i < datas.Count; i++)
                {
                    if (datas[i].isSelf)
                    {
                        selfRankingItem.gameObject.SetActive(true);
                        selfRankingItem.SetRankData(datas[i]);
                        if (datas[i].rank > 4)
                        {
                            continue;
                        }
                    }
                    GameObject obj = Instantiate<GameObject>(Resources.Load<GameObject>("Prefabs/UI/Ranking/SettlementRankingItem"));
                    RankingItem item = obj.GetComponent<RankingItem>();
                    item.transform.SetParent(rankViewContent, false);
                    item.SetRankData(datas[i]);
                }
            }
        }
    }
}