How to make a Rust chat logger plugin (rolling log + search)

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

namespace Oxide.Plugins
{
    [Info("ChatLogger", "RustPluginGenerator", "1.0.0")]
    [Description("Stores a rolling log of chat messages and lets admins read a player's recent messages.")]
    public class ChatLogger : RustPlugin
    {
        private const string PermUse = "chatlogger.use";

        private class PluginConfig
        {
            [JsonProperty("Maximum stored messages")]
            public int MaxStoredMessages = 3000;

            [JsonProperty("Messages shown per query")]
            public int MessagesShown = 50;

            [JsonProperty("Max message length")]
            public int MaxMessageLength = 500;

            [JsonProperty("Timestamp format")]
            public string TimestampFormat = "yyyy-MM-dd HH:mm:ss";

            [JsonProperty("Save interval seconds")]
            public float SaveIntervalSeconds = 20f;
        }

        private class ChatRecord
        {
            public string Time;
            public string SteamId;
            public string Name;
            public string Channel;
            public string Text;
        }

        private class LogData
        {
            public List<ChatRecord> Records = new List<ChatRecord>();
        }

        private PluginConfig config;
        private LogData data;
        private Timer saveTimer;
        private bool dirty;

        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.",
                ["Usage"] = "Usage: /chatlog <player name or SteamID> [count]",
                ["NoMessages"] = "No stored chat messages for {0}.",
                ["Header"] = "Recent messages for {0} ({1} found):",
                ["Line"] = "{0}. [{1}] [{2}] {3}",
                ["BadCount"] = "Count must be a number between 1 and 200."
            }, 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);
        }

        private void OnServerInitialized()
        {
            try
            {
                data = Interface.Oxide.DataFileSystem.ReadObject<LogData>(Name);
            }
            catch
            {
                data = null;
            }
            if (data == null || data.Records == null) data = new LogData();
            if (data.Records.Count > config.MaxStoredMessages) TrimToLimit();
            saveTimer = timer.Every(config.SaveIntervalSeconds, () =>
            {
                if (dirty) SaveLog();
            });
        }

        private void Unload()
        {
            if (saveTimer != null) saveTimer.Destroy();
            SaveLog();
        }

        // Capture every chat message; return null so chat behavior is unchanged.
        private object OnPlayerChat(BasePlayer player, string message, ConVar.Chat.ChatChannel channel)
        {
            if (player == null || string.IsNullOrEmpty(message)) return null;
            if (data == null) return null;

            string text = message.Length > config.MaxMessageLength
                ? message.Substring(0, config.MaxMessageLength) + "..."
                : message;

            data.Records.Add(new ChatRecord
            {
                Time = DateTime.UtcNow.ToString(config.TimestampFormat, CultureInfo.InvariantCulture),
                SteamId = player.userID.Get().ToString(),
                Name = player.displayName ?? "unknown",
                Channel = channel.ToString(),
                Text = text
            });

            TrimToLimit();
            dirty = true;
            return null;
        }

        private void TrimToLimit()
        {
            int limit = Mathf.Max(1, config.MaxStoredMessages);
            while (data.Records.Count > limit) data.Records.RemoveAt(0);
        }

        private void SaveLog()
        {
            if (data == null) return;
            Interface.Oxide.DataFileSystem.WriteObject(Name, data);
            dirty = false;
        }

        [ChatCommand("chatlog")]
        private void CmdChatLog(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            if (args == null || args.Length == 0)
            {
                SendReply(player, Msg("Usage", player.UserIDString));
                return;
            }

            int count = config.MessagesShown;
            int queryLength = args.Length;
            if (args.Length > 1 && int.TryParse(args[args.Length - 1], out int requested))
            {
                if (requested < 1 || requested > 200)
                {
                    SendReply(player, Msg("BadCount", player.UserIDString));
                    return;
                }
                count = requested;
                queryLength--;
            }

            string query = string.Join(" ", args, 0, queryLength);
            if (string.IsNullOrEmpty(query))
            {
                SendReply(player, Msg("Usage", player.UserIDString));
                return;
            }

            bool byId = query.Length == 17 && ulong.TryParse(query, out _);
            var matches = new List<ChatRecord>();
            foreach (var record in data.Records)
            {
                if (record == null) continue;
                if (byId)
                {
                    if (record.SteamId == query) matches.Add(record);
                }
                else if (string.Equals(record.Name, query, StringComparison.OrdinalIgnoreCase))
                {
                    matches.Add(record);
                }
            }

            if (matches.Count == 0)
            {
                SendReply(player, Msg("NoMessages", player.UserIDString, query));
                return;
            }

            int start = Mathf.Max(0, matches.Count - count);
            SendReply(player, Msg("Header", player.UserIDString, query, matches.Count));
            for (int i = start; i < matches.Count; i++)
            {
                var record = matches[i];
                SendReply(player, Msg("Line", player.UserIDString, i + 1, record.Time, record.Channel, record.Text));
            }
        }
    }
}