How to make a Rust last seen plugin (Oxide /seen command)

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

namespace Oxide.Plugins
{
    [Info("Last Seen", "RustPluginGenerator", "1.0.0")]
    [Description("Records player disconnect times and answers /seen with a relative last-online gap.")]
    public class LastSeen : RustPlugin
    {
        private const string PermUse = "lastseen.use";

        private PluginConfig config;
        private Dictionary<ulong, PlayerRecord> records = new Dictionary<ulong, PlayerRecord>();

        private class PluginConfig
        {
            [JsonProperty("Show steam id in result")]
            public bool ShowSteamId { get; set; } = true;

            [JsonProperty("Data file name")]
            public string DataFileName { get; set; } = "LastSeen";
        }

        [JsonObject(MemberSerialization.OptIn)]
        private class PlayerRecord
        {
            [JsonProperty("Name")]
            public string Name { get; set; } = "unknown";

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

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

        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>
            {
                ["Usage"] = "Usage: /seen <name or steamid>",
                ["NoPermission"] = "You do not have permission to use this command.",
                ["OnlineNow"] = "{0} ({1}) is online now.",
                ["LastSeen"] = "{0} ({1}) was last seen {2}.",
                ["Unknown"] = "No record found for '{0}'.",
                ["Unit.Minutes"] = "{0} minute(s) ago",
                ["Unit.Hours"] = "{0} hour(s) ago",
                ["Unit.Days"] = "{0} day(s) ago",
                ["Unit.Weeks"] = "{0} week(s) ago",
                ["Unit.Months"] = "{0} month(s) ago",
                ["Unit.Long"] = "more than a year ago"
            }, 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()
        {
            records = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<ulong, PlayerRecord>>(config.DataFileName)
                      ?? new Dictionary<ulong, PlayerRecord>();
        }

        private void Unload()
        {
            SaveRecords();
        }

        private void SaveRecords()
        {
            Interface.Oxide.DataFileSystem.WriteObject(config.DataFileName, records);
        }

        private void OnPlayerConnected(BasePlayer player)
        {
            if (player == null || player.IsNpc) return;

            ulong id = player.userID.Get();
            PlayerRecord record;
            if (!records.TryGetValue(id, out record))
            {
                record = new PlayerRecord();
                records[id] = record;
            }

            record.Name = player.displayName;
            record.Connected = ToUnix(DateTime.UtcNow);
        }

        private void OnPlayerDisconnected(BasePlayer player, string reason)
        {
            if (player == null || player.IsNpc) return;

            ulong id = player.userID.Get();
            PlayerRecord record;
            if (!records.TryGetValue(id, out record))
            {
                record = new PlayerRecord();
                records[id] = record;
            }

            record.Name = player.displayName;
            record.LastSeen = ToUnix(DateTime.UtcNow);
            record.Connected = 0;
            SaveRecords();
        }

        [ChatCommand("seen")]
        private void CmdSeen(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;
            }

            string query = string.Join(" ", args);
            ulong id;
            if (!ulong.TryParse(query, out id))
            {
                BasePlayer target = BasePlayer.FindAwakeOrSleeping(query);
                if (target != null)
                {
                    id = target.userID.Get();
                }
                else
                {
                    id = FindIdByName(query);
                }
            }

            PlayerRecord record;
            if (id == 0 || !records.TryGetValue(id, out record))
            {
                SendReply(player, Msg("Unknown", player.UserIDString, query));
                return;
            }

            BasePlayer live = BasePlayer.FindByID(id);
            bool online = live != null && live.IsConnected && record.Connected > 0;

            string idText = config.ShowSteamId ? id.ToString() : "no id";
            if (online)
            {
                SendReply(player, Msg("OnlineNow", player.UserIDString, record.Name, idText));
                return;
            }

            long now = ToUnix(DateTime.UtcNow);
            long gap = record.LastSeen > 0 ? now - record.LastSeen : 0;
            SendReply(player, Msg("LastSeen", player.UserIDString, record.Name, idText, record.LastSeen > 0 ? FormatGap(gap, player.UserIDString) : Msg("Unit.Long", player.UserIDString)));
        }

        private ulong FindIdByName(string name)
        {
            foreach (KeyValuePair<ulong, PlayerRecord> entry in records)
            {
                if (string.Equals(entry.Value.Name, name, StringComparison.OrdinalIgnoreCase))
                {
                    return entry.Key;
                }
            }
            return 0;
        }

        private static long ToUnix(DateTime time) => (long)(time - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds;

        private string FormatGap(long seconds, string userId)
        {
            if (seconds < 0) seconds = 0;
            long minutes = seconds / 60;
            if (minutes < 60) return Msg("Unit.Minutes", userId, Math.Max(1, minutes));
            long hours = minutes / 60;
            if (hours < 24) return Msg("Unit.Hours", userId, hours);
            long days = hours / 24;
            if (days < 7) return Msg("Unit.Days", userId, days);
            long weeks = days / 7;
            if (weeks < 5) return Msg("Unit.Weeks", userId, weeks);
            long months = days / 30;
            if (months < 12) return Msg("Unit.Months", userId, months);
            return Msg("Unit.Long", userId);
        }
    }
}