How to make a Rust PvP kill log plugin (rolling history + /kills lookup)

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

namespace Oxide.Plugins
{
    [Info("KillLog", "RustPluginGenerator", "1.0.0")]
    [Description("Records PvP kills into a rolling data file and lets admins read a player's history.")]
    public class KillLog : RustPlugin
    {
        private const string PermView = "killlog.view";

        private class PluginConfig
        {
            [JsonProperty("Maximum records kept")]
            public int MaxRecords { get; set; } = 2000;

            [JsonProperty("Seconds between data saves")]
            public float SaveDelay { get; set; } = 5f;

            [JsonProperty("Print kills to server console")]
            public bool LogToConsole { get; set; } = false;
        }

        private class KillRecord
        {
            public string KillerName { get; set; }
            public string KillerId { get; set; }
            public string VictimName { get; set; }
            public string VictimId { get; set; }
            public string Weapon { get; set; }
            public float Distance { get; set; }
            public bool Headshot { get; set; }
            public string Position { get; set; }
            public int Time { get; set; }
        }

        private PluginConfig config;
        private List<KillRecord> records = new List<KillRecord>();
        private Timer saveTimer;
        private bool dirty;

        private static readonly HashSet<Rust.DamageType> AllowedTypes = new HashSet<Rust.DamageType>
        {
            Rust.DamageType.Bullet,
            Rust.DamageType.Slash,
            Rust.DamageType.Stab,
            Rust.DamageType.Blunt,
            Rust.DamageType.Explosion
        };

        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: /kills <player name or steam id>",
                ["NoKills"] = "No recorded kills for {0}.",
                ["Header"] = "Last {0} kills for {1}:",
                ["Line"] = "{0} killed {1} with {2} at {3}m{4} ({5})"
            }, 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(PermView, this);
        }

        private void OnServerInitialized()
        {
            records = Interface.Oxide.DataFileSystem.ReadObject<List<KillRecord>>(Name) ?? new List<KillRecord>();
        }

        private void Unload()
        {
            saveTimer?.Destroy();
            saveTimer = null;
            SaveData();
        }

        private object OnPlayerDeath(BasePlayer player, HitInfo info)
        {
            if (player == null || player.IsNpc || info == null) return null;

            var killer = info.InitiatorPlayer;
            if (killer == null || killer.IsNpc || killer == player) return null;
            if (!AllowedTypes.Contains(info.damageTypes.GetMajorityDamageType())) return null;

            string weapon = info.WeaponPrefab != null ? info.WeaponPrefab.ShortPrefabName : "unknown";
            var pos = player.transform.position;

            var record = new KillRecord
            {
                KillerName = killer.displayName,
                KillerId = killer.UserIDString,
                VictimName = player.displayName,
                VictimId = player.UserIDString,
                Weapon = weapon,
                Distance = (float)Math.Round(info.ProjectileDistance, 1),
                Headshot = info.isHeadshot,
                Position = $"{Mathf.RoundToInt(pos.x)},{Mathf.RoundToInt(pos.y)},{Mathf.RoundToInt(pos.z)}",
                Time = Facepunch.Math.Epoch.Current
            };

            records.Add(record);
            while (records.Count > config.MaxRecords)
            {
                records.RemoveAt(0);
            }

            if (config.LogToConsole)
            {
                PrintWarning($"{record.KillerName} killed {record.VictimName} with {record.Weapon}");
            }

            dirty = true;
            if (saveTimer == null)
            {
                saveTimer = timer.Once(config.SaveDelay, () =>
                {
                    saveTimer = null;
                    SaveData();
                });
            }

            return null;
        }

        private void SaveData()
        {
            if (!dirty && saveTimer != null) return;
            Interface.Oxide.DataFileSystem.WriteObject(Name, records);
            dirty = false;
        }

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

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

            string query = args[0];
            var target = BasePlayer.FindAwakeOrSleeping(query);
            string targetId = target != null ? target.UserIDString : query;
            string targetName = target != null ? target.displayName : query;

            var matches = records.Where(r =>
                r.KillerId == targetId || r.VictimId == targetId ||
                string.Equals(r.KillerName, targetName, StringComparison.OrdinalIgnoreCase) ||
                string.Equals(r.VictimName, targetName, StringComparison.OrdinalIgnoreCase))
                .Reverse()
                .Take(10)
                .ToList();

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

            SendReply(player, Msg("Header", player.UserIDString, matches.Count, targetName));
            foreach (var r in matches)
            {
                string hs = r.Headshot ? " [HS]" : string.Empty;
                string time = DateTimeOffset.FromUnixTimeSeconds(r.Time).UtcDateTime.ToString("MM-dd HH:mm");
                SendReply(player, Msg("Line", player.UserIDString, r.KillerName, r.VictimName, r.Weapon, r.Distance, hs, time));
            }
        }
    }
}