How to make a Rust auto broadcast plugin (timed chat announcements)

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

namespace Oxide.Plugins
{
    [Info("Auto Broadcast", "RustPluginGenerator", "1.0.0")]
    [Description("Broadcasts a configurable list of chat messages on a timer with placeholder support.")]
    public class AutoBroadcast : RustPlugin
    {
        private const string PermReload = "autobroadcast.reload";

        private PluginConfig config;
        private Timer broadcastTimer;
        private int currentIndex;

        private class PluginConfig
        {
            [JsonProperty("Interval Seconds")]
            public float IntervalSeconds { get; set; } = 300f;

            [JsonProperty("Random Order")]
            public bool RandomOrder { get; set; } = false;

            [JsonProperty("Use Prefix")]
            public bool UsePrefix { get; set; } = true;

            [JsonProperty("Prefix")]
            public string Prefix { get; set; } = "[Server]";

            [JsonProperty("Color")]
            public string Color { get; set; } = "#ce422b";

            [JsonProperty("Messages")]
            public List<string> Messages { get; set; } = new List<string>
            {
                "Welcome! Type /help for available commands.",
                "There are {players} players online right now.",
                "Server time is {time}. Wipe information is on our Discord.",
                "Report rule breakers to admins with /report."
            };
        }

        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>
            {
                ["Reloaded"] = "Configuration reloaded. Interval set to {0} seconds.",
                ["Sent"] = "Next announcement sent.",
                ["NoMessages"] = "The message list is empty. Add entries to the config.",
                ["NoPermission"] = "You do not have permission to use this command.",
                ["Usage"] = "Usage: /broadcast reload | /broadcast next"
            }, 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(PermReload, this);
        }

        private void OnServerInitialized()
        {
            if (config.Messages == null || config.Messages.Count == 0)
            {
                PrintWarning(Msg("NoMessages"));
                return;
            }

            StartTimer();
        }

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

        private void StartTimer()
        {
            if (broadcastTimer != null) broadcastTimer.Destroy();

            float interval = Math.Max(config.IntervalSeconds, 10f);
            broadcastTimer = timer.Every(interval, BroadcastNext);
        }

        private void BroadcastNext()
        {
            if (config.Messages == null || config.Messages.Count == 0) return;

            string raw;
            if (config.RandomOrder)
            {
                int pick = UnityEngine.Random.Range(0, config.Messages.Count);
                raw = config.Messages[pick];
            }
            else
            {
                if (currentIndex >= config.Messages.Count) currentIndex = 0;
                raw = config.Messages[currentIndex];
                currentIndex = (currentIndex + 1) % config.Messages.Count;
            }

            Server.Broadcast(Format(raw));
        }

        private string Format(string raw)
        {
            if (string.IsNullOrEmpty(raw)) return string.Empty;

            string message = raw
                .Replace("{players}", BasePlayer.activePlayerList.Count.ToString())
                .Replace("{time}", DateTime.Now.ToString("HH:mm"));

            if (config.UsePrefix && !string.IsNullOrEmpty(config.Prefix))
            {
                message = config.Prefix + " " + message;
            }

            if (!string.IsNullOrEmpty(config.Color))
            {
                message = "<color=" + config.Color + ">" + message + "</color>";
            }

            return message;
        }

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

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

            if (args == null || args.Length == 0)
            {
                SendReply(player, Msg("Usage", player.UserIDString));
                return;
            }

            switch (args[0].ToLower())
            {
                case "reload":
                    Interface.Oxide.ReloadPlugin(Name);
                    break;
                case "next":
                    if (config.Messages == null || config.Messages.Count == 0)
                    {
                        SendReply(player, Msg("NoMessages", player.UserIDString));
                        return;
                    }
                    BroadcastNext();
                    SendReply(player, Msg("Sent", player.UserIDString));
                    break;
                default:
                    SendReply(player, Msg("Usage", player.UserIDString));
                    break;
            }
        }
    }
}