How to make a Rust info commands plugin (dynamic /rules, /discord)

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

namespace Oxide.Plugins
{
    [Info("Info Commands", "RustPluginGenerator", "1.0.0")]
    [Description("Registers config-driven text commands such as /rules, /discord and /website.")]
    public class InfoCommands : RustPlugin
    {
        private const string PermUse = "infocommands.use";

        private PluginConfig config;
        private readonly Dictionary<ulong, float> cooldowns = new Dictionary<ulong, float>();
        private readonly HashSet<string> registered = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

        private class InfoEntry
        {
            [JsonProperty("Command name")]
            public string Name { get; set; } = "rules";

            [JsonProperty("Permission (empty = base permission)")]
            public string Permission { get; set; } = "";

            [JsonProperty("Cooldown seconds (0 = none)")]
            public float Cooldown { get; set; } = 0f;

            [JsonProperty("Lines")]
            public List<string> Lines { get; set; } = new List<string>();
        }

        private class PluginConfig
        {
            [JsonProperty("Commands")]
            public List<InfoEntry> Commands { get; set; } = new List<InfoEntry>
            {
                new InfoEntry
                {
                    Name = "discord",
                    Lines = new List<string> { "Join our Discord: <color=#7289DA>discord.gg/example</color>" }
                },
                new InfoEntry
                {
                    Name = "rules",
                    Lines = new List<string>
                    {
                        "<color=#FFC107>Server rules:</color>",
                        "1. No cheating or exploiting.",
                        "2. No raiding before wipe day ends.",
                        "3. Be respectful in chat."
                    }
                },
                new InfoEntry
                {
                    Name = "website",
                    Lines = new List<string> { "Website: <color=#4CAF50>example.com</color>" }
                }
            };
        }

        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>
            {
                ["Header"] = "<color=#4CAF50>{0}</color>",
                ["NoPermission"] = "You do not have permission to use this command.",
                ["Cooldown"] = "Please wait {0} seconds before using this command again.",
                ["Listing"] = "Available info commands: {0}",
                ["None"] = "There are no info commands available to you.",
                ["NotFound"] = "Unknown info command."
            }, 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);

            if (config?.Commands == null) return;

            foreach (var entry in config.Commands)
            {
                if (entry == null || string.IsNullOrEmpty(entry.Name)) continue;

                string name = entry.Name.Trim().TrimStart('/').ToLowerInvariant();
                if (name.Length == 0 || name.Contains(" ")) continue;
                if (name == "info") continue;
                if (registered.Contains(name)) continue;

                if (!string.IsNullOrEmpty(entry.Permission) && !permission.PermissionExists(entry.Permission, this))
                    permission.RegisterPermission(entry.Permission, this);

                cmd.AddChatCommand(name, this, nameof(CmdInfo));
                registered.Add(name);
            }
        }

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

            var allowed = new List<string>();
            foreach (var entry in config.Commands)
            {
                if (entry == null || string.IsNullOrEmpty(entry.Name)) continue;
                if (CanUse(player, entry)) allowed.Add("/" + entry.Name.ToLowerInvariant());
            }

            if (allowed.Count == 0)
            {
                SendReply(player, Msg("None", player.UserIDString));
                return;
            }

            allowed.Sort();
            SendReply(player, Msg("Listing", player.UserIDString, string.Join(", ", allowed)));
        }

        private void CmdInfo(BasePlayer player, string command, string[] args)
        {
            if (player == null || !player.IsConnected) return;

            InfoEntry entry = null;
            foreach (var candidate in config.Commands)
            {
                if (candidate != null && string.Equals(candidate.Name, command, StringComparison.OrdinalIgnoreCase))
                {
                    entry = candidate;
                    break;
                }
            }

            if (entry == null)
            {
                SendReply(player, Msg("NotFound", player.UserIDString));
                return;
            }

            if (!CanUse(player, entry))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            if (entry.Cooldown > 0f)
            {
                float last;
                if (cooldowns.TryGetValue(player.userID, out last))
                {
                    float remaining = entry.Cooldown - (Time.realtimeSinceStartup - last);
                    if (remaining > 0f)
                    {
                        SendReply(player, Msg("Cooldown", player.UserIDString, Mathf.CeilToInt(remaining)));
                        return;
                    }
                }
                cooldowns[player.userID] = Time.realtimeSinceStartup;
            }

            SendReply(player, Msg("Header", player.UserIDString, entry.Name));
            if (entry.Lines != null)
            {
                foreach (var line in entry.Lines)
                    SendReply(player, line ?? "");
            }
        }

        private bool CanUse(BasePlayer player, InfoEntry entry)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermUse)) return false;
            if (!string.IsNullOrEmpty(entry.Permission) && !permission.UserHasPermission(player.UserIDString, entry.Permission)) return false;
            return true;
        }

        private void Unload()
        {
            cooldowns.Clear();
            registered.Clear();
        }
    }
}