How to make a Rust server HUD plugin (CUI)

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

namespace Oxide.Plugins
{
    [Info("Server HUD", "RustPluginGenerator", "1.0.0")]
    [Description("Shows a persistent CUI panel with server name, online count and in-game time.")]
    public class ServerHud : RustPlugin
    {
        private const string PanelName = "ServerHud.Panel";

        private PluginConfig config;
        private StoredData stored;
        private Timer refreshTimer;

        private class PluginConfig
        {
            [JsonProperty("Refresh Interval (seconds)")]
            public float RefreshInterval = 3f;

            [JsonProperty("Show Clock")]
            public bool ShowClock = true;

            [JsonProperty("Show Player Count")]
            public bool ShowPlayerCount = true;

            [JsonProperty("Anchor Min")]
            public string AnchorMin = "0.01 0.94";

            [JsonProperty("Anchor Max")]
            public string AnchorMax = "0.16 0.99";

            [JsonProperty("Panel Color")]
            public string PanelColor = "0.05 0.05 0.05 0.75";

            [JsonProperty("Text Color")]
            public string TextColor = "1 1 1 1";

            [JsonProperty("Font Size")]
            public int FontSize = 12;

            [JsonProperty("Hidden Steam IDs")]
            public List<ulong> Hidden = new List<ulong>();
        }

        private class StoredData
        {
            [JsonProperty("Hidden Steam IDs")]
            public HashSet<ulong> Hidden = new HashSet<ulong>();
        }

        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();
            }
            if (config.Hidden == null)
            {
                config.Hidden = new List<ulong>();
            }
            SaveConfig();
        }

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

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["HudEnabled"] = "HUD enabled.",
                ["HudDisabled"] = "HUD disabled."
            }, this);
        }

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

        private void OnServerInitialized()
        {
            LoadData();

            float interval = config.RefreshInterval;
            if (interval < 1f) interval = 1f;
            refreshTimer = timer.Every(interval, RefreshAll);
        }

        private void Unload()
        {
            if (refreshTimer != null)
            {
                refreshTimer.Destroy();
                refreshTimer = null;
            }

            SaveData();

            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player != null)
                {
                    CuiHelper.DestroyUi(player, PanelName);
                }
            }
        }

        private void LoadData()
        {
            try
            {
                stored = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(Name);
            }
            catch
            {
                stored = null;
            }

            if (stored == null)
            {
                stored = new StoredData();
            }
            if (stored.Hidden == null)
            {
                stored.Hidden = new HashSet<ulong>();
            }
        }

        private void SaveData()
        {
            if (stored != null)
            {
                Interface.Oxide.DataFileSystem.WriteObject(Name, stored);
            }
        }

        private void RefreshAll()
        {
            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player == null || player.IsNpc || !player.IsConnected)
                {
                    continue;
                }
                if (stored.Hidden.Contains(player.userID.Get()))
                {
                    continue;
                }
                ShowHud(player);
            }
        }

        private void ShowHud(BasePlayer player)
        {
            if (player == null || !player.IsConnected)
            {
                return;
            }

            string text = config.ShowPlayerCount
                ? $"{BasePlayer.activePlayerList.Count} online"
                : null;

            if (config.ShowClock)
            {
                string clock = GetGameTime();
                text = string.IsNullOrEmpty(text) ? clock : text + "  |  " + clock;
            }

            if (string.IsNullOrEmpty(text))
            {
                text = " ";
            }

            var container = new CuiElementContainer();
            string panel = container.Add(new CuiPanel
            {
                Image = { Color = config.PanelColor },
                RectTransform = { AnchorMin = config.AnchorMin, AnchorMax = config.AnchorMax },
                CursorEnabled = false
            }, "Overlay", PanelName);

            container.Add(new CuiLabel
            {
                Text =
                {
                    Text = ConVar.Server.hostname ?? "Rust Server",
                    FontSize = config.FontSize,
                    Align = TextAnchor.MiddleCenter,
                    Color = config.TextColor
                },
                RectTransform = { AnchorMin = "0 0.5", AnchorMax = "1 1" }
            }, panel);

            container.Add(new CuiLabel
            {
                Text =
                {
                    Text = text,
                    FontSize = config.FontSize,
                    Align = TextAnchor.MiddleCenter,
                    Color = config.TextColor
                },
                RectTransform = { AnchorMin = "0 0", AnchorMax = "1 0.5" }
            }, panel);

            CuiHelper.DestroyUi(player, PanelName);
            CuiHelper.AddUi(player, container);
        }

        private string GetGameTime()
        {
            var sky = TOD_Sky.Instance;
            if (sky == null)
            {
                return "--:--";
            }

            float hour = sky.Cycle.Hour;
            int h = Mathf.FloorToInt(hour);
            int m = Mathf.FloorToInt((hour - h) * 60f);
            return string.Format("{0:00}:{1:00}", h, m);
        }

        private void OnPlayerConnected(BasePlayer player)
        {
            if (player == null || player.IsNpc)
            {
                return;
            }
            if (stored.Hidden.Contains(player.userID.Get()))
            {
                return;
            }

            timer.Once(1f, () =>
            {
                if (player != null && player.IsConnected && !stored.Hidden.Contains(player.userID.Get()))
                {
                    ShowHud(player);
                }
            });
        }

        private void OnPlayerDisconnected(BasePlayer player, string reason)
        {
            SaveData();
        }

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

            ulong id = player.userID.Get();
            if (stored.Hidden.Contains(id))
            {
                stored.Hidden.Remove(id);
                ShowHud(player);
                SendReply(player, Msg("HudEnabled", player.UserIDString));
            }
            else
            {
                stored.Hidden.Add(id);
                CuiHelper.DestroyUi(player, PanelName);
                SendReply(player, Msg("HudDisabled", player.UserIDString));
            }

            SaveData();
        }
    }
}