How to make a Rust name filter plugin (kick on join)

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

namespace Oxide.Plugins
{
    [Info("Name Filter", "RustPluginGenerator", "1.0.0")]
    [Description("Kicks connecting players whose display name is too short, contains blocked words, or looks like advertising.")]
    public class NameFilter : RustPlugin
    {
        private const string PermBypass = "namefilter.bypass";
        private const string PermAdmin = "namefilter.admin";

        private PluginConfig config;
        private readonly List<Regex> patterns = new List<Regex>();

        private class PluginConfig
        {
            [JsonProperty("Minimum Name Length")]
            public int MinimumNameLength = 3;

            [JsonProperty("Blocked Words")]
            public string[] BlockedWords =
            {
                "admin",
                "owner",
                "moderator",
                "server",
                "vac_ban",
                "freevip"
            };

            [JsonProperty("Blocked Patterns")]
            public string[] BlockedPatterns =
            {
                @"https?://",
                @"www\.",
                @"discord\.gg",
                @"\.com\b",
                @"\.gg\b",
                @"\b(?:discord|steam)\b.*#\d{4}",
                @"(?:discord|steam|skype|telegram)[\.\-_]"
            };

            [JsonProperty("Kick Message")]
            public string KickMessage = "Your display name is not allowed on this server. Please change it and reconnect.";

            [JsonProperty("Log Blocked Connections")]
            public bool LogBlockedConnections = 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();
            }
            catch
            {
                PrintWarning("Configuration file is invalid, using defaults");
                LoadDefaultConfig();
            }

            CompilePatterns();
            SaveConfig();
        }

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

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["CheckClean"] = "{0} ({1}) passes the name filter.",
                ["CheckBlocked"] = "{0} ({1}) is blocked: {2}",
                ["TargetNotFound"] = "No player found for '{0}'.",
                ["Reloaded"] = "NameFilter configuration reloaded."
            }, this);
        }

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

        private void CompilePatterns()
        {
            patterns.Clear();
            if (config.BlockedPatterns == null) return;

            foreach (string pattern in config.BlockedPatterns)
            {
                if (string.IsNullOrEmpty(pattern)) continue;
                try
                {
                    patterns.Add(new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.CultureInvariant));
                }
                catch (Exception ex)
                {
                    PrintWarning("Invalid pattern '" + pattern + "': " + ex.Message);
                }
            }
        }

        private void OnPlayerConnected(BasePlayer player)
        {
            if (player == null || player.IsNpc) return;
            if (permission.UserHasPermission(player.UserIDString, PermBypass)) return;

            string name = player.displayName ?? string.Empty;
            string reason;
            if (!IsNameBlocked(name, out reason)) return;

            if (config.LogBlockedConnections)
                Puts("Blocked connection: " + name + " (" + player.UserIDString + ") - " + reason);

            player.Kick(config.KickMessage);
        }

        private bool IsNameBlocked(string name, out string reason)
        {
            reason = null;

            if (name.Length < config.MinimumNameLength)
            {
                reason = "name shorter than " + config.MinimumNameLength + " characters";
                return true;
            }

            string lower = name.ToLowerInvariant();

            if (config.BlockedWords != null)
            {
                foreach (string word in config.BlockedWords)
                {
                    if (string.IsNullOrEmpty(word)) continue;
                    if (lower.Contains(word.ToLowerInvariant()))
                    {
                        reason = "contains blocked word '" + word + "'";
                        return true;
                    }
                }
            }

            foreach (Regex regex in patterns)
            {
                if (regex.IsMatch(name))
                {
                    reason = "matches pattern '" + regex + "'";
                    return true;
                }
            }

            return false;
        }

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

        [ConsoleCommand("namefilter.check")]
        private void CmdCheck(ConsoleSystem.Arg arg)
        {
            if (!arg.IsAdmin && arg.Player() != null && !permission.UserHasPermission(arg.Player().UserIDString, PermAdmin))
            {
                arg.ReplyWith("You do not have permission to use this command.");
                return;
            }

            string target = arg.GetString(0, string.Empty);
            if (string.IsNullOrEmpty(target))
            {
                arg.ReplyWith("Usage: namefilter.check <player name or steamid>");
                return;
            }

            var player = BasePlayer.FindAwakeOrSleeping(target);
            if (player == null)
            {
                arg.ReplyWith(Msg("TargetNotFound", null, target));
                return;
            }

            string reason;
            if (IsNameBlocked(player.displayName ?? string.Empty, out reason))
                arg.ReplyWith(Msg("CheckBlocked", null, player.displayName, player.UserIDString, reason));
            else
                arg.ReplyWith(Msg("CheckClean", null, player.displayName, player.UserIDString));
        }

        [ConsoleCommand("namefilter.reload")]
        private void CmdReload(ConsoleSystem.Arg arg)
        {
            if (!arg.IsAdmin && arg.Player() != null && !permission.UserHasPermission(arg.Player().UserIDString, PermAdmin))
            {
                arg.ReplyWith("You do not have permission to use this command.");
                return;
            }

            LoadConfig();
            arg.ReplyWith(Msg("Reloaded"));
        }
    }
}