How to make a Rust join and leave messages plugin (Oxide/Carbon)

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

namespace Oxide.Plugins
{
    [Info("Join Leave Messages", "RustPluginGenerator", "1.0.0")]
    [Description("Broadcasts configurable join and leave messages, optionally including the disconnect reason.")]
    public class JoinLeaveMessages : RustPlugin
    {
        private const string PermHidden = "joinleavemessages.hidden";
        private const string PermAdmin = "joinleavemessages.admin";

        private PluginConfig config;

        private class PluginConfig
        {
            [JsonProperty("Announce joins")]
            public bool AnnounceJoins { get; set; } = true;

            [JsonProperty("Announce leaves")]
            public bool AnnounceLeaves { get; set; } = true;

            [JsonProperty("Show disconnect reason")]
            public bool ShowReason { get; set; } = true;

            [JsonProperty("Write events to server console")]
            public bool ConsoleLog { get; set; } = true;

            [JsonProperty("Console join line (0 = name)")]
            public string ConsoleJoin { get; set; } = "{0} connected";

            [JsonProperty("Console leave line (0 = name, 1 = reason)")]
            public string ConsoleLeave { get; set; } = "{0} disconnected ({1})";
        }

        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>
            {
                ["Join"] = "<color=#88cc88>{0}</color> joined the server",
                ["Leave"] = "<color=#cc8888>{0}</color> left the server",
                ["LeaveReason"] = "<color=#cc8888>{0}</color> left the server ({1})",
                ["UnknownReason"] = "unknown",
                ["JoinOn"] = "Join announcements are now enabled",
                ["JoinOff"] = "Join announcements are now disabled",
                ["LeaveOn"] = "Leave announcements are now enabled",
                ["LeaveOff"] = "Leave announcements are now disabled",
                ["Reloaded"] = "Configuration reloaded",
                ["NoPermission"] = "You do not have permission to use this command",
                ["Usage"] = "Usage: /jlm reload | /jlm toggle join | /jlm toggle leave"
            }, 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(PermHidden, this);
            permission.RegisterPermission(PermAdmin, this);
        }

        private bool IsHidden(BasePlayer player)
        {
            return permission.UserHasPermission(player.UserIDString, PermHidden);
        }

        private void OnPlayerConnected(BasePlayer player)
        {
            if (player == null || !config.AnnounceJoins) return;
            if (IsHidden(player)) return;

            string name = player.displayName ?? "Unknown";
            Server.Broadcast(Msg("Join", null, name));

            if (config.ConsoleLog)
            {
                Puts(string.Format(config.ConsoleJoin ?? "{0} connected", name));
            }
        }

        private void OnPlayerDisconnected(BasePlayer player, string reason)
        {
            if (player == null || !config.AnnounceLeaves) return;
            if (IsHidden(player)) return;

            string name = player.displayName ?? "Unknown";
            string safeReason = string.IsNullOrEmpty(reason) ? Msg("UnknownReason") : reason;

            // Strip anything that could break the chat line
            safeReason = safeReason.Replace("<", string.Empty).Replace(">", string.Empty);

            if (config.ShowReason)
            {
                Server.Broadcast(Msg("LeaveReason", null, name, safeReason));
            }
            else
            {
                Server.Broadcast(Msg("Leave", null, name));
            }

            if (config.ConsoleLog)
            {
                Puts(string.Format(config.ConsoleLeave ?? "{0} disconnected ({1})", name, safeReason));
            }
        }

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

            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));
                return;
            }

            switch (args[0].ToLower())
            {
                case "reload":
                    LoadConfig();
                    LoadDefaultMessages();
                    SendReply(player, Msg("Reloaded", player.UserIDString));
                    return;

                case "toggle":
                    if (args.Length < 2)
                    {
                        SendReply(player, Msg("Usage", player.UserIDString));
                        return;
                    }

                    if (args[1].Equals("join", StringComparison.OrdinalIgnoreCase))
                    {
                        config.AnnounceJoins = !config.AnnounceJoins;
                        SaveConfig();
                        SendReply(player, Msg(config.AnnounceJoins ? "JoinOn" : "JoinOff", player.UserIDString));
                        return;
                    }

                    if (args[1].Equals("leave", StringComparison.OrdinalIgnoreCase))
                    {
                        config.AnnounceLeaves = !config.AnnounceLeaves;
                        SaveConfig();
                        SendReply(player, Msg(config.AnnounceLeaves ? "LeaveOn" : "LeaveOff", player.UserIDString));
                        return;
                    }

                    SendReply(player, Msg("Usage", player.UserIDString));
                    return;

                default:
                    SendReply(player, Msg("Usage", player.UserIDString));
                    return;
            }
        }
    }
}