How to make a Rust chat word filter plugin (whole-word asterisk masking)

using System.Linq;
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using Newtonsoft.Json;
using Oxide.Core;
using Oxide.Core.Libraries.Covalence;

namespace Oxide.Plugins
{
    [Info("WordFilter", "RustPluginGenerator", "1.0.0")]
    [Description("Masks blocked words in global chat with asterisks and re-broadcasts the filtered message.")]
    public class WordFilter : RustPlugin
    {
        private const string PermAdmin = "wordfilter.admin";
        private const string PermBypass = "wordfilter.bypass";

        private PluginConfig config;
        private Regex pattern;

        private class PluginConfig
        {
            [JsonProperty("Blocked Words")]
            public List<string> BlockedWords = new List<string>
            {
                "badword1",
                "badword2"
            };

            [JsonProperty("Show Sender Name In Brackets")]
            public bool ShowBrackets = true;
        }

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

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

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

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["Added"] = "Word '{0}' was added to the filter.",
                ["AlreadyPresent"] = "Word '{0}' is already in the filter.",
                ["Removed"] = "Word '{0}' was removed from the filter.",
                ["NotFound"] = "Word '{0}' is not in the filter.",
                ["Usage"] = "Usage: {0}",
                ["ListHeader"] = "Blocked words ({0}):",
                ["ListEmpty"] = "The word filter list is empty.",
                ["NoPermission"] = "You do not have permission to use this command."
            }, this);
        }

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

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

        private void OnServerInitialized()
        {
            RebuildPattern();
        }

        private void RebuildPattern()
        {
            if (config == null || config.BlockedWords == null || config.BlockedWords.Count == 0)
            {
                pattern = null;
                return;
            }

            var pieces = new List<string>();
            foreach (var word in config.BlockedWords)
            {
                if (string.IsNullOrWhiteSpace(word)) continue;
                pieces.Add("\\b" + Regex.Escape(word.Trim()) + "\\b");
            }

            if (pieces.Count == 0)
            {
                pattern = null;
                return;
            }

            pattern = new Regex(string.Join("|", pieces.ToArray()), RegexOptions.IgnoreCase | RegexOptions.Compiled);
        }

        private object OnPlayerChat(BasePlayer player, string message, ConVar.Chat.ChatChannel channel)
        {
            if (player == null || player.IsNpc || string.IsNullOrEmpty(message)) return null;
            if (channel != ConVar.Chat.ChatChannel.Global) return null;
            if (player.IsAdmin) return null;
            if (permission.UserHasPermission(player.UserIDString, PermBypass)) return null;
            if (pattern == null) return null;

            string filtered = MaskText(message);
            if (filtered == message) return null;

            string name = config.ShowBrackets ? "[" + player.displayName + "]" : player.displayName;
            Server.Broadcast(name + " " + filtered);
            return false;
        }

        private string MaskText(string text)
        {
            return pattern.Replace(text, m => new string('*', m.Value.Length));
        }

        [ChatCommand("filteradd")]
        private void CmdFilterAdd(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }
            if (args == null || args.Length == 0)
            {
                SendReply(player, Msg("Usage", player.UserIDString, "/filteradd <word>"));
                return;
            }

            string word = args[0].Trim();
            if (word.Length == 0) return;

            foreach (var existing in config.BlockedWords)
            {
                if (string.Equals(existing, word, StringComparison.OrdinalIgnoreCase))
                {
                    SendReply(player, Msg("AlreadyPresent", player.UserIDString, word));
                    return;
                }
            }

            config.BlockedWords.Add(word);
            SaveConfig();
            RebuildPattern();
            SendReply(player, Msg("Added", player.UserIDString, word));
        }

        [ChatCommand("filterremove")]
        private void CmdFilterRemove(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }
            if (args == null || args.Length == 0)
            {
                SendReply(player, Msg("Usage", player.UserIDString, "/filterremove <word>"));
                return;
            }

            string word = args[0].Trim();
            int index = config.BlockedWords.FindIndex(w => string.Equals(w, word, StringComparison.OrdinalIgnoreCase));
            if (index < 0)
            {
                SendReply(player, Msg("NotFound", player.UserIDString, word));
                return;
            }

            config.BlockedWords.RemoveAt(index);
            SaveConfig();
            RebuildPattern();
            SendReply(player, Msg("Removed", player.UserIDString, word));
        }

        [ChatCommand("filterlist")]
        private void CmdFilterList(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            if (config.BlockedWords == null || config.BlockedWords.Count == 0)
            {
                SendReply(player, Msg("ListEmpty", player.UserIDString));
                return;
            }

            SendReply(player, Msg("ListHeader", player.UserIDString, config.BlockedWords.Count));
            SendReply(player, string.Join(", ", config.BlockedWords.ToArray()));
        }
    }
}