How to make a Rust chat anti-spam plugin (Oxide/Carbon)

using UnityEngine;
using System;
using System.Collections.Generic;
using Newtonsoft.Json;

namespace Oxide.Plugins
{
    [Info("Chat Anti-Spam", "RustPluginGenerator", "1.0.0")]
    [Description("Blocks chat spam by rate limit and duplicate messages, and mutes repeat offenders.")]
    public class ChatAntiSpam : RustPlugin
    {
        private const string PermUse = "chatantispam.use";
        private const string PermAdmin = "chatantispam.admin";
        private const string PermBypass = "chatantispam.bypass";

        private PluginConfig config;
        private readonly Dictionary<ulong, PlayerData> data = new Dictionary<ulong, PlayerData>();
        private readonly Dictionary<ulong, Timer> muteTimers = new Dictionary<ulong, Timer>();

        private class PluginConfig
        {
            [JsonProperty("Maximum messages per window")]
            public int MaxMessages { get; set; } = 5;

            [JsonProperty("Window length in seconds")]
            public int WindowSeconds { get; set; } = 10;

            [JsonProperty("Block duplicate messages")]
            public bool BlockDuplicates { get; set; } = true;

            [JsonProperty("Violations before mute")]
            public int ViolationsBeforeMute { get; set; } = 3;

            [JsonProperty("Violation window in seconds")]
            public int ViolationWindowSeconds { get; set; } = 60;

            [JsonProperty("Mute duration in seconds")]
            public int MuteSeconds { get; set; } = 300;

            [JsonProperty("Ignore admins")]
            public bool IgnoreAdmins { get; set; } = true;
        }

        private class PlayerData
        {
            public List<double> Timestamps = new List<double>();
            public string LastMessage = string.Empty;
            public int Violations;
            public double FirstViolation;
            public DateTime MutedUntil = DateTime.MinValue;
        }

        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>
            {
                ["RateLimited"] = "Slow down, you are sending messages too fast.",
                ["DuplicateMessage"] = "You already sent that message.",
                ["Muted"] = "You are muted in chat for {0} seconds for spamming.",
                ["StillMuted"] = "You are muted for another {0} seconds.",
                ["Unmuted"] = "Your chat mute has expired.",
                ["NoPermission"] = "You do not have permission to use that command.",
                ["StatusMuted"] = "You are muted for another {0} seconds.",
                ["StatusClear"] = "You are not muted. Messages in window: {0}.",
                ["ResetDone"] = "Cleared chat history and mutes for {0}.",
                ["PlayerNotFound"] = "No player found matching that name or id.",
                ["UsageReset"] = "Usage: /antispam reset <player name or id>"
            }, 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(PermAdmin, this);
            permission.RegisterPermission(PermBypass, this);
        }

        private object OnPlayerChat(BasePlayer player, string message, ConVar.Chat.ChatChannel channel)
        {
            if (player == null || string.IsNullOrEmpty(message)) return null;
            if (player.IsNpc) return null;
            if (config.IgnoreAdmins && player.IsAdmin) return null;

            var userId = player.UserIDString;
            if (permission.UserHasPermission(userId, PermBypass)) return null;

            var id = player.userID.Get();
            if (!data.TryGetValue(id, out var entry))
            {
                entry = new PlayerData();
                data[id] = entry;
            }

            if (entry.MutedUntil > DateTime.UtcNow)
            {
                var left = (int)Math.Ceiling((entry.MutedUntil - DateTime.UtcNow).TotalSeconds);
                player.ChatMessage(Msg("StillMuted", userId, left));
                return new object();
            }

            var now = UnityEngine.Time.realtimeSinceStartup;

            // Prune timestamps outside the window
            entry.Timestamps.RemoveAll(t => now - t > config.WindowSeconds);

            var duplicate = config.BlockDuplicates &&
                            !string.IsNullOrEmpty(entry.LastMessage) &&
                            string.Equals(entry.LastMessage.Trim(), message.Trim(), StringComparison.OrdinalIgnoreCase);
            var tooFast = entry.Timestamps.Count >= config.MaxMessages;

            entry.Timestamps.Add(now);

            if (!duplicate && !tooFast)
            {
                entry.LastMessage = message;
                return null;
            }

            if (duplicate)
                player.ChatMessage(Msg("DuplicateMessage", userId));
            else
                player.ChatMessage(Msg("RateLimited", userId));

            entry.LastMessage = message;
            RegisterViolation(player, entry, now);
            return new object();
        }

        private void RegisterViolation(BasePlayer player, PlayerData entry, double now)
        {
            if (now - entry.FirstViolation > config.ViolationWindowSeconds)
            {
                entry.FirstViolation = now;
                entry.Violations = 0;
            }
            entry.Violations++;
            if (entry.Violations < config.ViolationsBeforeMute) return;
            entry.Violations = 0;
            StartMute(player, entry);
        }

        private void StartMute(BasePlayer player, PlayerData entry)
        {
            var id = player.userID.Get();
            entry.MutedUntil = DateTime.UtcNow.AddSeconds(config.MuteSeconds);
            entry.Timestamps.Clear();
            player.ChatMessage(Msg("Muted", player.UserIDString, config.MuteSeconds));

            if (muteTimers.TryGetValue(id, out var old) && old != null) old.Destroy();
            muteTimers[id] = timer.Once(config.MuteSeconds, () =>
            {
                muteTimers.Remove(id);
                if (data.TryGetValue(id, out var current))
                {
                    current.MutedUntil = DateTime.MinValue;
                    current.Violations = 0;
                }
                var online = BasePlayer.FindByID(id);
                if (online != null && online.IsConnected)
                    online.ChatMessage(Msg("Unmuted", online.UserIDString));
            });
        }

        [ChatCommand("antispam")]
        private void CmdAntiSpam(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            var userId = player.UserIDString;

            if (args == null || args.Length == 0)
            {
                if (!permission.UserHasPermission(userId, PermUse))
                {
                    player.ChatMessage(Msg("NoPermission", userId));
                    return;
                }
                ShowStatus(player);
                return;
            }

            switch (args[0].ToLower())
            {
                case "status":
                    if (!permission.UserHasPermission(userId, PermUse))
                    {
                        player.ChatMessage(Msg("NoPermission", userId));
                        return;
                    }
                    ShowStatus(player);
                    break;

                case "reset":
                    if (!permission.UserHasPermission(userId, PermAdmin))
                    {
                        player.ChatMessage(Msg("NoPermission", userId));
                        return;
                    }
                    ResetTarget(player, args);
                    break;

                default:
                    player.ChatMessage(Msg("UsageReset", userId));
                    break;
            }
        }

        private void ShowStatus(BasePlayer player)
        {
            var userId = player.UserIDString;
            var id = player.userID.Get();
            if (!data.TryGetValue(id, out var entry))
            {
                player.ChatMessage(Msg("StatusClear", userId, 0));
                return;
            }

            if (entry.MutedUntil > DateTime.UtcNow)
            {
                var left = (int)Math.Ceiling((entry.MutedUntil - DateTime.UtcNow).TotalSeconds);
                player.ChatMessage(Msg("StatusMuted", userId, left));
                return;
            }

            var now = UnityEngine.Time.realtimeSinceStartup;
            entry.Timestamps.RemoveAll(t => now - t > config.WindowSeconds);
            player.ChatMessage(Msg("StatusClear", userId, entry.Timestamps.Count));
        }

        private void ResetTarget(BasePlayer admin, string[] args)
        {
            if (args.Length < 2)
            {
                admin.ChatMessage(Msg("UsageReset", admin.UserIDString));
                return;
            }

            var query = string.Join(" ", args);
            query = query.Substring(query.IndexOf(' ') + 1).Trim();
            var target = BasePlayer.FindAwakeOrSleeping(query);
            if (target == null)
            {
                admin.ChatMessage(Msg("PlayerNotFound", admin.UserIDString));
                return;
            }

            var id = target.userID.Get();
            data.Remove(id);
            if (muteTimers.TryGetValue(id, out var t) && t != null) t.Destroy();
            muteTimers.Remove(id);

            admin.ChatMessage(Msg("ResetDone", admin.UserIDString, target.displayName));
        }

        private void Unload()
        {
            foreach (var t in muteTimers.Values)
                t?.Destroy();
            muteTimers.Clear();
            data.Clear();
        }
    }
}