How to make a Rust player stats plugin (K/D tracker)

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

namespace Oxide.Plugins
{
    [Info("Player Stats Tracker", "RustPluginGenerator", "1.0.0")]
    [Description("Tracks PvP kills, deaths, K/D, headshots and NPC kills per player.")]
    public class PlayerStatsTracker : RustPlugin
    {
        private const string PermLookup = "playerstatstracker.lookup";
        private const string DataFileName = "PlayerStatsTracker";

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

        private class PluginConfig
        {
            [JsonProperty("Reset stats on new save")]
            public bool ResetOnNewSave { get; set; } = true;

            [JsonProperty("Save interval in seconds")]
            public float SaveInterval { get; set; } = 30f;
        }

        private class StoredPlayer
        {
            [JsonProperty("Name")]
            public string Name { get; set; }

            [JsonProperty("Kills")]
            public long Kills { get; set; }

            [JsonProperty("Deaths")]
            public long Deaths { get; set; }

            [JsonProperty("Headshot kills")]
            public long HeadshotKills { get; set; }

            [JsonProperty("NPC kills")]
            public long NpcKills { get; set; }
        }

        private class StatsData
        {
            [JsonProperty("Players")]
            public Dictionary<string, StoredPlayer> Players { get; set; } = new Dictionary<string, StoredPlayer>();
        }

        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>
            {
                ["OwnHeader"] = "Your stats:",
                ["Header"] = "Stats for {0}:",
                ["Kills"] = "Kills: {0}",
                ["Deaths"] = "Deaths: {0}",
                ["Kd"] = "K/D: {0}",
                ["Extra"] = "NPC kills: {0} | Headshot kills: {1}",
                ["NoStatsFor"] = "No stats recorded for {0}.",
                ["NoPlayer"] = "No player found matching '{0}'.",
                ["NoPermission"] = "You don't have permission to look up other players."
            }, 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(PermLookup, this);
        }

        private void OnServerInitialized()
        {
            data = Interface.Oxide.DataFileSystem.ReadObject<StatsData>(DataFileName) ?? new StatsData();
            if (data.Players == null) data.Players = new Dictionary<string, StoredPlayer>();
        }

        private void Unload()
        {
            SaveData();
        }

        private void OnNewSave(string strFilename)
        {
            if (!config.ResetOnNewSave) return;
            data = new StatsData();
            SaveData();
        }

        private void OnEntityDeath(BaseCombatEntity entity, HitInfo info)
        {
            if (entity == null) return;

            var victim = entity as BasePlayer;
            var killer = info?.InitiatorPlayer;

            if (victim != null && !victim.IsNpc)
            {
                var victimRecord = GetOrCreate(victim);
                victimRecord.Deaths++;
                dirty = true;

                if (killer != null && killer != victim && !killer.IsNpc)
                {
                    var killerRecord = GetOrCreate(killer);
                    killerRecord.Kills++;
                    if (info.isHeadshot) killerRecord.HeadshotKills++;
                    dirty = true;
                }
            }
            else if (killer != null && !killer.IsNpc)
            {
                var killerRecord = GetOrCreate(killer);
                killerRecord.NpcKills++;
                dirty = true;
            }

            if (dirty) ScheduleSave();
        }

        private StoredPlayer GetOrCreate(BasePlayer player)
        {
            var id = player.UserIDString;
            if (!data.Players.TryGetValue(id, out var record))
            {
                record = new StoredPlayer { Name = player.displayName };
                data.Players[id] = record;
            }
            if (!string.IsNullOrEmpty(player.displayName)) record.Name = player.displayName;
            return record;
        }

        private void ScheduleSave()
        {
            if (saveTimer != null) return;
            saveTimer = timer.Once(Mathf.Max(1f, config.SaveInterval), () =>
            {
                saveTimer = null;
                SaveData();
            });
        }

        private void SaveData()
        {
            if (saveTimer != null)
            {
                saveTimer.Destroy();
                saveTimer = null;
            }
            if (data == null) return;
            Interface.Oxide.DataFileSystem.WriteObject(DataFileName, data);
            dirty = false;
        }

        [ChatCommand("stats")]
        private void CmdStats(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;

            if (args == null || args.Length == 0)
            {
                ShowStats(player, player.UserIDString);
                return;
            }

            if (!permission.UserHasPermission(player.UserIDString, PermLookup))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }

            var query = string.Join(" ", args).Trim();
            var target = BasePlayer.FindAwakeOrSleeping(query);
            string targetId = null;
            string targetName = query;

            if (target != null)
            {
                targetId = target.UserIDString;
                targetName = target.displayName;
            }
            else if (ulong.TryParse(query, out var parsedId))
            {
                targetId = parsedId.ToString();
                if (data.Players.TryGetValue(targetId, out var stored))
                {
                    targetName = stored.Name;
                }
            }

            if (targetId == null || !data.Players.ContainsKey(targetId))
            {
                player.ChatMessage(Msg("NoPlayer", player.UserIDString, query));
                return;
            }

            ShowStats(player, targetId, targetName);
        }

        private void ShowStats(BasePlayer viewer, string targetId, string targetName = null)
        {
            if (!data.Players.TryGetValue(targetId, out var record))
            {
                viewer.ChatMessage(Msg("NoStatsFor", viewer.UserIDString, targetName ?? targetId));
                return;
            }

            var name = string.IsNullOrEmpty(record.Name) ? (targetName ?? targetId) : record.Name;
            var kd = record.Deaths == 0 ? record.Kills : (double)record.Kills / record.Deaths;

            if (targetId == viewer.UserIDString)
            {
                viewer.ChatMessage(Msg("OwnHeader", viewer.UserIDString));
            }
            else
            {
                viewer.ChatMessage(Msg("Header", viewer.UserIDString, name));
            }

            viewer.ChatMessage(Msg("Kills", viewer.UserIDString, record.Kills));
            viewer.ChatMessage(Msg("Deaths", viewer.UserIDString, record.Deaths));
            viewer.ChatMessage(Msg("Kd", viewer.UserIDString, kd.ToString("0.00")));
            viewer.ChatMessage(Msg("Extra", viewer.UserIDString, record.NpcKills, record.HeadshotKills));
        }
    }
}