How to make a Rust private messages plugin (with /ignore)

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

namespace Oxide.Plugins
{
    [Info("PrivateMessages", "RustPluginGenerator", "1.0.0")]
    [Description("Adds /pm, /r and /ignore chat commands with a cooldown and message length limit.")]
    public class PrivateMessages : RustPlugin
    {
        private const string PermUse = "privatemessages.use";
        private const string PermIgnore = "privatemessages.ignore";

        private PluginConfig config;
        private Dictionary<ulong, HashSet<ulong>> ignoreData = new Dictionary<ulong, HashSet<ulong>>();
        private readonly Dictionary<ulong, ulong> lastSender = new Dictionary<ulong, ulong>();
        private readonly Dictionary<ulong, float> lastSent = new Dictionary<ulong, float>();

        private class PluginConfig
        {
            [JsonProperty("Cooldown seconds between messages")]
            public float CooldownSeconds = 5f;

            [JsonProperty("Maximum message length")]
            public int MaxMessageLength = 200;

            [JsonProperty("Show sender name to receiver")]
            public bool ShowSenderName = true;

            [JsonProperty("Allow messaging yourself")]
            public bool AllowSelfMessage = false;
        }

        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>
            {
                ["NoPermission"] = "You do not have permission to use this command.",
                ["UsagePm"] = "Usage: /pm <player> <message>",
                ["UsageReply"] = "Usage: /r <message>",
                ["UsageIgnore"] = "Usage: /ignore <player>",
                ["PlayerNotFound"] = "No player found matching '{0}'.",
                ["MultipleMatches"] = "Several players match '{0}'. Be more specific.",
                ["SelfMessage"] = "You cannot message yourself.",
                ["Cooldown"] = "Wait {0} more second(s) before sending another message.",
                ["EmptyMessage"] = "The message is empty.",
                ["Delivered"] = "To {0}: {1}",
                ["Received"] = "From {0}: {1}",
                ["ReceivedAnonymous"] = "Message: {0}",
                ["BlockedByTarget"] = "{0} is ignoring you.",
                ["NotMessaged"] = "Nobody has messaged you recently.",
                ["TargetOffline"] = "{0} is no longer online.",
                ["IgnoreAdded"] = "You are now ignoring {0}.",
                ["IgnoreRemoved"] = "You are no longer ignoring {0}."
            }, 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(PermUse, this);
            permission.RegisterPermission(PermIgnore, this);
            LoadIgnoreData();
        }

        private void OnServerInitialized()
        {
            timer.Once(1f, LoadIgnoreData);
        }

        private void LoadIgnoreData()
        {
            var data = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<ulong, HashSet<ulong>>>(Name);
            if (data != null) ignoreData = data;
        }

        private void Unload()
        {
            Interface.Oxide.DataFileSystem.WriteObject(Name, ignoreData);
        }

        [ChatCommand("pm")]
        private void CmdPm(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }
            if (args == null || args.Length < 2)
            {
                player.ChatMessage(Msg("UsagePm", player.UserIDString));
                return;
            }

            BasePlayer target = FindTarget(args[0], player);
            if (target == null)
            {
                player.ChatMessage(Msg("PlayerNotFound", player.UserIDString, args[0]));
                return;
            }
            if (target == player && !config.AllowSelfMessage)
            {
                player.ChatMessage(Msg("SelfMessage", player.UserIDString));
                return;
            }

            string text = string.Join(" ", args, 1, args.Length - 1);
            SendPrivate(player, target, text);
        }

        [ChatCommand("r")]
        private void CmdReply(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }
            if (args == null || args.Length < 1)
            {
                player.ChatMessage(Msg("UsageReply", player.UserIDString));
                return;
            }

            ulong senderId;
            if (!lastSender.TryGetValue(player.userID.Get(), out senderId))
            {
                player.ChatMessage(Msg("NotMessaged", player.UserIDString));
                return;
            }

            BasePlayer target = BasePlayer.FindByID(senderId);
            if (target == null || !target.IsConnected)
            {
                player.ChatMessage(Msg("TargetOffline", player.UserIDString, senderId));
                return;
            }

            SendPrivate(player, target, string.Join(" ", args));
        }

        [ChatCommand("ignore")]
        private void CmdIgnore(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermIgnore))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }
            if (args == null || args.Length < 1)
            {
                player.ChatMessage(Msg("UsageIgnore", player.UserIDString));
                return;
            }

            BasePlayer target = FindTarget(args[0], player);
            if (target == null)
            {
                player.ChatMessage(Msg("PlayerNotFound", player.UserIDString, args[0]));
                return;
            }

            ulong owner = player.userID.Get();
            HashSet<ulong> set;
            if (!ignoreData.TryGetValue(owner, out set))
            {
                set = new HashSet<ulong>();
                ignoreData[owner] = set;
            }

            if (set.Contains(target.userID.Get()))
            {
                set.Remove(target.userID.Get());
                player.ChatMessage(Msg("IgnoreRemoved", player.UserIDString, target.displayName));
            }
            else
            {
                set.Add(target.userID.Get());
                player.ChatMessage(Msg("IgnoreAdded", player.UserIDString, target.displayName));
            }
        }

        private BasePlayer FindTarget(string nameOrId, BasePlayer requester)
        {
            ulong id;
            if (ulong.TryParse(nameOrId, out id))
            {
                BasePlayer byId = BasePlayer.FindByID(id);
                if (byId != null) return byId;
            }

            BasePlayer exact = BasePlayer.FindAwakeOrSleeping(nameOrId);
            if (exact != null) return exact;

            BasePlayer match = null;
            int count = 0;
            foreach (BasePlayer p in BasePlayer.activePlayerList)
            {
                if (p == null || !p.IsConnected) continue;
                if (p.displayName.IndexOf(nameOrId, StringComparison.OrdinalIgnoreCase) < 0) continue;
                match = p;
                count++;
            }

            if (count > 1)
            {
                requester.ChatMessage(Msg("MultipleMatches", requester.UserIDString, nameOrId));
                return null;
            }
            return match;
        }

        private void SendPrivate(BasePlayer sender, BasePlayer target, string text)
        {
            if (string.IsNullOrEmpty(text) || text.Trim().Length == 0)
            {
                sender.ChatMessage(Msg("EmptyMessage", sender.UserIDString));
                return;
            }

            ulong senderId = sender.userID.Get();
            float now = Time.realtimeSinceStartup;
            float last;
            if (lastSent.TryGetValue(senderId, out last) && now - last < config.CooldownSeconds)
            {
                sender.ChatMessage(Msg("Cooldown", sender.UserIDString,
                    Math.Ceiling(config.CooldownSeconds - (now - last))));
                return;
            }

            if (text.Length > config.MaxMessageLength)
                text = text.Substring(0, config.MaxMessageLength);

            HashSet<ulong> ignored;
            if (ignoreData.TryGetValue(target.userID.Get(), out ignored) && ignored.Contains(senderId))
            {
                sender.ChatMessage(Msg("BlockedByTarget", sender.UserIDString, target.displayName));
                return;
            }

            lastSent[senderId] = now;
            lastSender[target.userID.Get()] = senderId;

            sender.ChatMessage(Msg("Delivered", sender.UserIDString, target.displayName, text));
            target.ChatMessage(config.ShowSenderName
                ? Msg("Received", target.UserIDString, sender.displayName, text)
                : Msg("ReceivedAnonymous", target.UserIDString, text));
        }

        private void OnPlayerDisconnected(BasePlayer player, string reason)
        {
            if (player == null) return;
            ulong userId = player.userID.Get();
            lastSent.Remove(userId);
            lastSender.Remove(userId);
        }
    }
}