How to make a Rust leaderboard UI plugin (CUI top 10)

using System;
using System.Collections.Generic;
using System.Linq;
using Newtonsoft.Json;
using Oxide.Core;
using Oxide.Game.Rust.Cui;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("Leaderboard UI", "RustPluginGenerator", "1.0.0")]
    [Description("Tracks kills, deaths and K/D per player and shows a CUI top 10 leaderboard.")]
    public class LeaderboardUI : RustPlugin
    {
        private const string PermUse = "leaderboardui.use";
        private const string PanelName = "LeaderboardUI.Panel";
        private const string DataFileName = "LeaderboardUI";

        private PluginConfig config;
        private Dictionary<string, PlayerStats> stats;

        private class PluginConfig
        {
            [JsonProperty("Top Count")]
            public int TopCount = 10;

            [JsonProperty("Show Names")]
            public bool ShowNames = true;
        }

        private class PlayerStats
        {
            [JsonProperty("Kills")]
            public int Kills;

            [JsonProperty("Deaths")]
            public int Deaths;

            [JsonIgnore]
            public double Kd => Deaths == 0 ? Kills : (double)Kills / Deaths;
        }

        protected override void LoadDefaultConfig() => config = new PluginConfig();

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<PluginConfig>();
                if (config == null) throw new Exception();
            }
            catch
            {
                PrintWarning("Configuration file is invalid, using defaults");
                LoadDefaultConfig();
            }
            SaveConfig();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["Title"] = "Top {0} by Kills",
                ["NoData"] = "No kills recorded yet",
                ["NoPermission"] = "You do not have permission to use this.",
                ["Close"] = "Close"
            }, this);
        }

        private string Msg(string key, string userId = null, params object[] args) => string.Format(lang.GetMessage(key, this, userId), args);

        private void Init()
        {
            permission.RegisterPermission(PermUse, this);
        }

        private void OnServerInitialized()
        {
            stats = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<string, PlayerStats>>(DataFileName) ?? new Dictionary<string, PlayerStats>();
        }

        private void Unload()
        {
            foreach (var player in BasePlayer.activePlayerList)
                CuiHelper.DestroyUi(player, PanelName);

            if (stats != null)
                Interface.Oxide.DataFileSystem.WriteObject(DataFileName, stats);
        }

        private void OnServerSave()
        {
            if (stats != null)
                Interface.Oxide.DataFileSystem.WriteObject(DataFileName, stats);
        }

        private PlayerStats GetOrCreate(string userId)
        {
            PlayerStats entry;
            if (!stats.TryGetValue(userId, out entry))
            {
                entry = new PlayerStats();
                stats[userId] = entry;
            }
            return entry;
        }

        private void OnEntityDeath(BaseCombatEntity entity, HitInfo info)
        {
            var victim = entity as BasePlayer;
            if (victim == null || victim.IsNpc || info == null) return;

            var attacker = info.InitiatorPlayer;
            if (attacker == null || attacker.IsNpc) return;
            if (attacker.userID == victim.userID) return;

            GetOrCreate(attacker.UserIDString).Kills++;
            GetOrCreate(victim.UserIDString).Deaths++;
        }

        [ChatCommand("top")]
        private void CmdTop(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            OpenBoard(player);
        }

        [ConsoleCommand("leaderboard.close")]
        private void CcmdClose(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null) return;
            CuiHelper.DestroyUi(player, PanelName);
        }

        private void OpenBoard(BasePlayer player)
        {
            CuiHelper.DestroyUi(player, PanelName);

            var entries = stats.Values
                .OrderByDescending(s => s.Kills)
                .ThenBy(s => s.Deaths)
                .Take(Mathf.Clamp(config.TopCount, 3, 15))
                .ToList();

            var container = new CuiElementContainer();
            container.Add(new CuiPanel
            {
                Image = { Color = "0.08 0.08 0.08 0.92" },
                RectTransform = { AnchorMin = "0.33 0.25", AnchorMax = "0.67 0.75" },
                CursorEnabled = true
            }, "Overlay", PanelName);

            container.Add(new CuiLabel
            {
                Text = { Text = Msg("Title", player.UserIDString, config.TopCount), FontSize = 20, Align = TextAnchor.MiddleCenter, Color = "1 0.85 0.3 1" },
                RectTransform = { AnchorMin = "0 0.88", AnchorMax = "1 0.99" }
            }, PanelName);

            container.Add(new CuiButton
            {
                Button = { Command = "leaderboard.close", Color = "0.65 0.2 0.2 1" },
                RectTransform = { AnchorMin = "0.35 0.02", AnchorMax = "0.65 0.12" },
                Text = { Text = Msg("Close", player.UserIDString), FontSize = 14, Align = TextAnchor.MiddleCenter }
            }, PanelName);

            if (entries.Count == 0)
            {
                container.Add(new CuiLabel
                {
                    Text = { Text = Msg("NoData", player.UserIDString), FontSize = 14, Align = TextAnchor.MiddleCenter },
                    RectTransform = { AnchorMin = "0 0.45", AnchorMax = "1 0.55" }
                }, PanelName);
            }
            else
            {
                float top = 0.85f;
                float bottom = 0.15f;
                float rowHeight = (top - bottom) / entries.Count;

                for (int i = 0; i < entries.Count; i++)
                {
                    var entry = entries[i];
                    float rowMax = top - i * rowHeight;
                    float rowMin = rowMax - rowHeight + 0.005f;

                    container.Add(new CuiLabel
                    {
                        Text = { Text = $"#{i + 1}", FontSize = 14, Align = TextAnchor.MiddleLeft, Color = "1 0.85 0.3 1" },
                        RectTransform = { AnchorMin = $"0.03 {rowMin}", AnchorMax = $"0.13 {rowMax}" }
                    }, PanelName);

                    string name = config.ShowNames ? GetDisplayName(entry) : "Player";
                    container.Add(new CuiLabel
                    {
                        Text = { Text = name, FontSize = 14, Align = TextAnchor.MiddleLeft },
                        RectTransform = { AnchorMin = $"0.15 {rowMin}", AnchorMax = $"0.55 {rowMax}" }
                    }, PanelName);

                    container.Add(new CuiLabel
                    {
                        Text = { Text = $"K/D {entry.Kd:0.00}", FontSize = 14, Align = TextAnchor.MiddleCenter },
                        RectTransform = { AnchorMin = $"0.55 {rowMin}", AnchorMax = $"0.78 {rowMax}" }
                    }, PanelName);

                    container.Add(new CuiLabel
                    {
                        Text = { Text = $"{entry.Kills} / {entry.Deaths}", FontSize = 14, Align = TextAnchor.MiddleRight, Color = "0.7 0.85 0.7 1" },
                        RectTransform = { AnchorMin = $"0.78 {rowMin}", AnchorMax = $"0.97 {rowMax}" }
                    }, PanelName);
                }
            }

            CuiHelper.AddUi(player, container);
        }

        private string GetDisplayName(PlayerStats entry)
        {
            // Stats are keyed by id; resolve a live name when the owner is online.
            var online = BasePlayer.activePlayerList.FirstOrDefault(p => stats.ContainsKey(p.UserIDString) && ReferenceEquals(stats[p.UserIDString], entry));
            return online != null ? online.displayName : "Offline Player";
        }
    }
}