How to make a Rust chat mute plugin (timed, persistent)

using System.Linq;
using System;
using System.Collections.Generic;
using Facepunch.Math;
using Newtonsoft.Json;
using Oxide.Core;
using Oxide.Core.Libraries.Covalence;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("Chat Mute", "RustPluginGenerator", "1.0.0")]
    [Description("Timed chat mutes that block global chat, persist across restarts and expire automatically.")]
    public class ChatMute : RustPlugin
    {
        private const string PermMute = "chatmute.mute";

        private PluginConfig config;
        private Dictionary<ulong, MuteEntry> mutes = new Dictionary<ulong, MuteEntry>();
        private readonly Dictionary<ulong, float> lastWarning = new Dictionary<ulong, float>();
        private Timer sweepTimer;

        private class MuteEntry
        {
            [JsonProperty("Steam ID")] public ulong SteamId;
            [JsonProperty("Display name")] public string Name;
            [JsonProperty("Expires (unix)")] public int Expires;
            [JsonProperty("Reason")] public string Reason;
            [JsonProperty("Created by")] public string CreatedBy;

            public MuteEntry() { }

            public MuteEntry(ulong steamId, string name, int expires, string reason, string createdBy)
            {
                SteamId = steamId;
                Name = name;
                Expires = expires;
                Reason = reason;
                CreatedBy = createdBy;
            }
        }

        private class PluginConfig
        {
            [JsonProperty("Blocked channels")]
            public List<string> BlockedChannels = new List<string> { "Global" };

            [JsonProperty("Warning cooldown seconds")]
            public float WarningCooldownSeconds = 10f;
        }

        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.BlockedChannels == null) config.BlockedChannels = new List<string>();
            }
            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>
            {
                ["Mute.Success"] = "Muted {0} ({1}) for {2} minute(s).",
                ["Mute.Usage"] = "Usage: /mute <player> <minutes> [reason]",
                ["Unmute.Success"] = "Unmuted {0} ({1}).",
                ["Unmute.NotFound"] = "{0} is not muted.",
                ["Unmute.Usage"] = "Usage: /unmute <player>",
                ["List.Header"] = "Active mutes: {0}",
                ["List.Entry"] = "{0} ({1}) - {2} minute(s) left - {3}",
                ["List.Empty"] = "There are no active mutes.",
                ["Target.Muted"] = "You are muted for another {0} minute(s). Reason: {1}",
                ["Target.MutedNoReason"] = "You are muted for another {0} minute(s).",
                ["Error.NoPermission"] = "You do not have permission to do that.",
                ["Error.PlayerNotFound"] = "No player found matching '{0}'.",
                ["Error.Ambiguous"] = "Multiple players match '{0}', use a Steam ID.",
                ["Error.SelfTarget"] = "Use a Steam ID, not your own name.",
                ["Error.Input"] = "The minutes value must be a whole number.",
                ["Broadcast.Muted"] = "{0} was muted for {1} minute(s) by {2}.",
                ["Broadcast.Unmuted"] = "{0} was unmuted by {1}."
            }, 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(PermMute, this);
        }

        private void OnServerInitialized()
        {
            LoadData();
            SweepExpired();
            sweepTimer = timer.Every(60f, SweepExpired);
            Puts($"Loaded {mutes.Count} active mute(s).");
        }

        private void Unload()
        {
            sweepTimer?.Destroy();
            SaveData();
        }

        private void LoadData()
        {
            mutes = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<ulong, MuteEntry>>(Name)
                    ?? new Dictionary<ulong, MuteEntry>();
        }

        private void SaveData()
        {
            Interface.Oxide.DataFileSystem.WriteObject(Name, mutes);
        }

        private void SweepExpired()
        {
            if (mutes.Count == 0) return;
            int now = Epoch.Current;
            List<ulong> expired = null;
            foreach (var kvp in mutes)
            {
                if (kvp.Value == null || kvp.Value.Expires <= now)
                {
                    if (expired == null) expired = new List<ulong>();
                    expired.Add(kvp.Key);
                }
            }
            if (expired == null) return;
            foreach (ulong id in expired)
            {
                mutes.Remove(id);
                lastWarning.Remove(id);
            }
            SaveData();
        }

        private bool IsMuted(ulong userId)
        {
            if (!mutes.TryGetValue(userId, out MuteEntry entry) || entry == null) return false;
            if (entry.Expires <= Epoch.Current)
            {
                mutes.Remove(userId);
                lastWarning.Remove(userId);
                SaveData();
                return false;
            }
            return true;
        }

        private bool ChannelBlocked(ConVar.Chat.ChatChannel channel)
        {
            return config.BlockedChannels.Contains(channel.ToString());
        }

        private object OnPlayerChat(BasePlayer player, string message, ConVar.Chat.ChatChannel channel)
        {
            if (player == null || player.IsNpc) return null;
            if (!ChannelBlocked(channel)) return null;
            if (!IsMuted(player.userID.Get())) return null;

            MuteEntry entry = mutes[player.userID.Get()];
            float now = Time.realtimeSinceStartup;
            if (lastWarning.TryGetValue(player.userID.Get(), out float last) &&
                now - last < config.WarningCooldownSeconds) return false;
            lastWarning[player.userID.Get()] = now;

            int minutesLeft = Mathf.Max(1, (entry.Expires - Epoch.Current) / 60);
            player.ChatMessage(string.IsNullOrEmpty(entry.Reason)
                ? Msg("Target.MutedNoReason", player.UserIDString, minutesLeft)
                : Msg("Target.Muted", player.UserIDString, minutesLeft, entry.Reason));
            return false;
        }

        [ChatCommand("mute")]
        private void CmdMute(BasePlayer player, string command, string[] args)
        {
            if (player != null && !permission.UserHasPermission(player.UserIDString, PermMute))
            {
                SendReply(player, Msg("Error.NoPermission", player.UserIDString));
                return;
            }
            HandleMute(player, args, player?.displayName ?? "Console");
        }

        [ConsoleCommand("chatmute.mute")]
        private void CcmdMute(ConsoleSystem.Arg arg)
        {
            BasePlayer caller = arg.Player();
            if (caller != null && !permission.UserHasPermission(caller.UserIDString, PermMute))
            {
                arg.ReplyWith(Msg("Error.NoPermission", caller.UserIDString));
                return;
            }
            string[] args = arg.Args != null ? arg.Args.Select(x => x.ToString()).ToArray() : new string[0];
            string actor = caller?.displayName ?? "Console";
            string result = HandleMute(caller, args, actor);
            if (caller == null) arg.ReplyWith(result);
        }

        private string HandleMute(BasePlayer caller, string[] args, string actor)
        {
            if (args == null || args.Length < 2)
            {
                if (caller != null) SendReply(caller, Msg("Mute.Usage", caller.UserIDString));
                return Msg("Mute.Usage");
            }
            string targetArg = args[0];
            if (!int.TryParse(args[1], out int minutes) || minutes < 0)
            {
                if (caller != null) SendReply(caller, Msg("Error.Input", caller.UserIDString));
                return Msg("Error.Input");
            }
            string reason = args.Length > 2 ? string.Join(" ", args, 2, args.Length - 2) : string.Empty;

            ulong targetId;
            string targetName;
            string error = Resolve(targetArg, caller, out targetId, out targetName);
            if (error != null)
            {
                if (caller != null) SendReply(caller, error);
                return error;
            }

            if (minutes == 0)
            {
                mutes.Remove(targetId);
                lastWarning.Remove(targetId);
                SaveData();
                string done = Msg("Unmute.Success", caller?.UserIDString, targetName, targetId);
                if (caller != null) SendReply(caller, done);
                Server.Broadcast(Msg("Broadcast.Unmuted", null, targetName, actor));
                return done;
            }

            int expires = Epoch.Current + minutes * 60;
            mutes[targetId] = new MuteEntry(targetId, targetName, expires, reason, actor);
            SaveData();

            string text = Msg("Mute.Success", caller?.UserIDString, targetName, targetId, minutes);
            if (caller != null) SendReply(caller, text);
            Server.Broadcast(Msg("Broadcast.Muted", null, targetName, minutes, actor));

            BasePlayer target = BasePlayer.FindByID(targetId);
            if (target != null && target.IsConnected)
                target.ChatMessage(string.IsNullOrEmpty(reason)
                    ? Msg("Target.MutedNoReason", target.UserIDString, minutes)
                    : Msg("Target.Muted", target.UserIDString, minutes, reason));
            return text;
        }

        [ChatCommand("unmute")]
        private void CmdUnmute(BasePlayer player, string command, string[] args)
        {
            if (player != null && !permission.UserHasPermission(player.UserIDString, PermMute))
            {
                SendReply(player, Msg("Error.NoPermission", player.UserIDString));
                return;
            }
            string[] a = args ?? new string[0];
            string actor = player?.displayName ?? "Console";
            string result = HandleUnmute(player, a, actor);
            if (player == null) Puts(result);
        }

        [ConsoleCommand("chatmute.unmute")]
        private void CcmdUnmute(ConsoleSystem.Arg arg)
        {
            BasePlayer caller = arg.Player();
            if (caller != null && !permission.UserHasPermission(caller.UserIDString, PermMute))
            {
                arg.ReplyWith(Msg("Error.NoPermission", caller.UserIDString));
                return;
            }
            string[] args = arg.Args != null ? arg.Args.Select(x => x.ToString()).ToArray() : new string[0];
            string actor = caller?.displayName ?? "Console";
            string result = HandleUnmute(caller, args, actor);
            if (caller == null) arg.ReplyWith(result);
        }

        private string HandleUnmute(BasePlayer caller, string[] args, string actor)
        {
            if (args.Length < 1)
            {
                if (caller != null) SendReply(caller, Msg("Unmute.Usage", caller.UserIDString));
                return Msg("Unmute.Usage");
            }
            ulong targetId;
            string targetName;
            string error = Resolve(args[0], caller, out targetId, out targetName);
            if (error != null)
            {
                if (caller != null) SendReply(caller, error);
                return error;
            }
            if (!mutes.Remove(targetId))
            {
                string notMuted = Msg("Unmute.NotFound", caller?.UserIDString, targetName);
                if (caller != null) SendReply(caller, notMuted);
                return notMuted;
            }
            lastWarning.Remove(targetId);
            SaveData();
            string done = Msg("Unmute.Success", caller?.UserIDString, targetName, targetId);
            if (caller != null) SendReply(caller, done);
            Server.Broadcast(Msg("Broadcast.Unmuted", null, targetName, actor));
            return done;
        }

        [ChatCommand("mutelist")]
        private void CmdMuteList(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermMute))
            {
                SendReply(player, Msg("Error.NoPermission", player.UserIDString));
                return;
            }
            SweepExpired();
            if (mutes.Count == 0)
            {
                SendReply(player, Msg("List.Empty", player.UserIDString));
                return;
            }
            SendReply(player, Msg("List.Header", player.UserIDString, mutes.Count));
            int now = Epoch.Current;
            foreach (var kvp in mutes)
            {
                MuteEntry entry = kvp.Value;
                int minutesLeft = Mathf.Max(1, (entry.Expires - now) / 60);
                string reason = string.IsNullOrEmpty(entry.Reason) ? "-" : entry.Reason;
                SendReply(player, Msg("List.Entry", player.UserIDString, entry.Name, entry.SteamId, minutesLeft, reason));
            }
        }

        private string Resolve(string input, BasePlayer caller, out ulong userId, out string name)
        {
            userId = 0;
            name = input;
            if (string.IsNullOrEmpty(input)) return Msg("Error.PlayerNotFound", caller?.UserIDString, input);

            if (ulong.TryParse(input, out ulong parsed))
            {
                BasePlayer byId = BasePlayer.FindAwakeOrSleeping(input);
                userId = parsed;
                name = byId != null ? byId.displayName : parsed.ToString();
                return null;
            }

            BasePlayer exact = BasePlayer.FindAwakeOrSleeping(input);
            if (exact != null && caller != null && exact.userID == caller.userID) return Msg("Error.SelfTarget", caller.UserIDString);

            BasePlayer match = null;
            int count = 0;
            foreach (BasePlayer p in BasePlayer.allPlayerList)
            {
                if (p == null || p.IsNpc) continue;
                if (exact != null && p.userID == exact.userID) { match = p; count = 1; break; }
                if (p.displayName != null && p.displayName.IndexOf(input, StringComparison.OrdinalIgnoreCase) >= 0)
                {
                    match = p;
                    count++;
                }
            }
            if (count == 0) return Msg("Error.PlayerNotFound", caller?.UserIDString, input);
            if (count > 1) return Msg("Error.Ambiguous", caller?.UserIDString, input);

            userId = match.userID.Get();
            name = match.displayName;
            return null;
        }
    }
}