How to make a Rust online players list plugin (sorted and paged)

using System.Linq;
using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("Online Players List", "RustPluginGenerator", "1.0.0")]
    [Description("Adds a /players chat command that lists online players with online, sleeping and joining counts.")]
    public class OnlinePlayersList : RustPlugin
    {
        private const string PermUse = "onlineplayerslist.use";
        private const string PermSteamId = "onlineplayerslist.steamid";

        private PluginConfig config;

        private class PluginConfig
        {
            [JsonProperty("Page size")]
            public int PageSize { get; set; } = 10;

            [JsonProperty("Show steam ids to admins")]
            public bool ShowSteamIdToAdmins { get; set; } = true;

            [JsonProperty("Message color")]
            public string MessageColor { get; set; } = "#cec8b6";

            [JsonProperty("Highlight color")]
            public string HighlightColor { get; set; } = "#8fbf6b";
        }

        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>
            {
                ["ListHeader"] = "Online players (page {0} of {1}):",
                ["Entry"] = "  {0}. {1}",
                ["EntryWithId"] = "  {0}. {1} ({2})",
                ["Counts"] = "Online: {0} | Sleeping: {1} | Joining: {2}",
                ["NoPlayers"] = "No players are currently online.",
                ["NoPermission"] = "You do not have permission to use this command.",
                ["InvalidPage"] = "Page {0} does not exist, showing page {1}."
            }, this);
        }

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

        private string Msg(string key, string userId = null, params object[] args)
        {
            return string.Format(lang.GetMessage(key, this, userId ?? "0"), args);
        }

        [ChatCommand("players")]
        private void CmdPlayers(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;

            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            var entries = new List<PlayerEntry>();
            foreach (var target in BasePlayer.activePlayerList)
            {
                if (target == null || !target.IsConnected || target.IsNpc) continue;
                entries.Add(new PlayerEntry(target.displayName, target.UserIDString));
            }

            int pageSize = Mathf.Max(1, config.PageSize);
            int totalPages = Mathf.Max(1, (entries.Count + pageSize - 1) / pageSize);
            int page = 1;
            if (args != null && args.Length > 0)
            {
                if (!int.TryParse(args[0], out page) || page < 1) page = 1;
                if (page > totalPages)
                {
                    SendReply(player, Msg("InvalidPage", player.UserIDString, page, totalPages));
                    page = totalPages;
                }
            }

            if (entries.Count == 0)
            {
                SendReply(player, Msg("NoPlayers", player.UserIDString));
            }
            else
            {
                entries.Sort((a, b) => string.Compare(a.Name, b.Name, StringComparison.OrdinalIgnoreCase));

                bool showIds = permission.UserHasPermission(player.UserIDString, PermSteamId)
                               || (config.ShowSteamIdToAdmins && player.IsAdmin);

                SendReply(player, Msg("ListHeader", player.UserIDString, page, totalPages));

                int start = (page - 1) * pageSize;
                int count = Mathf.Min(pageSize, entries.Count - start);
                for (int i = 0; i < count; i++)
                {
                    var entry = entries[start + i];
                    int number = start + i + 1;
                    if (showIds)
                        SendReply(player, Msg("EntryWithId", player.UserIDString, number, entry.Name, entry.Id));
                    else
                        SendReply(player, Msg("Entry", player.UserIDString, number, entry.Name));
                }
            }

            int online = BasePlayer.activePlayerList.Count;
            int sleeping = 0;
            foreach (var sleeper in BasePlayer.sleepingPlayerList)
            {
                if (sleeper != null && sleeper.IsSleeping()) sleeping++;
            }

            int joining = 0;
            var serverMgr = SingletonComponent<ServerMgr>.Instance;
            if (serverMgr != null && serverMgr.connectionQueue != null)
                joining = serverMgr.connectionQueue.Queued;

            SendReply(player, Msg("Counts", player.UserIDString, online, sleeping, joining));
        }

        private struct PlayerEntry
        {
            public readonly string Name;
            public readonly string Id;

            public PlayerEntry(string name, string id)
            {
                Name = name;
                Id = id;
            }
        }
    }
}