How to make a Rust playtime tracker plugin (total and wipe time)

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

namespace Oxide.Plugins
{
    [Info("Playtime Tracker", "RustPluginGenerator", "1.0.0")]
    [Description("Tracks total and per-wipe connected playtime per player with an optional AFK exclusion.")]
    public class PlaytimeTracker : RustPlugin
    {
        private const string PermLookup = "playtimetracker.lookup";
        private const string DataFile = "PlaytimeTracker";
        private const float AfkMoveThreshold = 0.5f;

        private PluginConfig config;
        private Dictionary<string, PlayerRecord> records = new Dictionary<string, PlayerRecord>();
        private readonly Dictionary<ulong, Session> sessions = new Dictionary<ulong, Session>();

        private class PlayerRecord
        {
            [JsonProperty("Display name")] public string DisplayName = "";
            [JsonProperty("Total seconds")] public double TotalSeconds;
            [JsonProperty("Wipe seconds")] public double WipeSeconds;
        }

        private class Session
        {
            public double StartedAt;
            public double LastActivity;
            public Vector3 LastPosition;
        }

        private class PluginConfig
        {
            [JsonProperty("Exclude AFK")] public bool ExcludeAFK = true;
            [JsonProperty("AFK Timeout Seconds")] public int AfkTimeoutSeconds = 300;
        }

        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>
            {
                ["YourPlaytime"] = "Your playtime: {0} total, {1} this wipe.",
                ["PlayerPlaytime"] = "{2}'s playtime: {0} total, {1} this wipe.",
                ["NotFound"] = "No playtime record found for '{0}'.",
                ["NoPermission"] = "You do not 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);
            LoadData();
        }

        private void Unload()
        {
            SaveData();
        }

        private void LoadData()
        {
            records = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<string, PlayerRecord>>(DataFile)
                      ?? new Dictionary<string, PlayerRecord>();
        }

        private void SaveData()
        {
            Interface.Oxide.DataFileSystem.WriteObject(DataFile, records);
        }

        private PlayerRecord GetRecord(string userId, string displayName = null)
        {
            PlayerRecord record;
            if (!records.TryGetValue(userId, out record))
            {
                record = new PlayerRecord();
                records[userId] = record;
            }
            if (!string.IsNullOrEmpty(displayName)) record.DisplayName = displayName;
            return record;
        }

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

            GetRecord(player.UserIDString, player.displayName);
            double now = Time.realtimeSinceStartup;
            sessions[player.userID.Get()] = new Session
            {
                StartedAt = now,
                LastActivity = now,
                LastPosition = player.transform.position
            };
        }

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

            Session session;
            if (!sessions.TryGetValue(player.userID.Get(), out session)) return;
            sessions.Remove(player.userID.Get());

            double now = Time.realtimeSinceStartup;
            double elapsed = now - session.StartedAt;
            if (elapsed <= 0) return;

            if (config.ExcludeAFK)
            {
                double idleAfterActivity = now - session.LastActivity;
                if (idleAfterActivity > config.AfkTimeoutSeconds)
                {
                    elapsed -= idleAfterActivity - config.AfkTimeoutSeconds;
                }
            }

            if (elapsed <= 0) return;

            PlayerRecord record = GetRecord(player.UserIDString, player.displayName);
            record.TotalSeconds += elapsed;
            record.WipeSeconds += elapsed;
            SaveData();
        }

        private void OnPlayerTick(BasePlayer player)
        {
            if (!config.ExcludeAFK || player == null) return;

            Session session;
            if (!sessions.TryGetValue(player.userID.Get(), out session)) return;

            Vector3 position = player.transform.position;
            if (Vector3.Distance(position, session.LastPosition) > AfkMoveThreshold)
            {
                session.LastPosition = position;
                session.LastActivity = Time.realtimeSinceStartup;
            }
        }

        private void OnNewSave(string strFilename)
        {
            foreach (KeyValuePair<string, PlayerRecord> entry in records)
            {
                entry.Value.WipeSeconds = 0;
            }
            SaveData();
        }

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

            if (args == null || args.Length == 0)
            {
                PlayerRecord own = GetRecord(player.UserIDString);
                SendReply(player, Msg("YourPlaytime", player.UserIDString, Format(own.TotalSeconds), Format(own.WipeSeconds)));
                return;
            }

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

            string target = args[0];
            BasePlayer online = BasePlayer.FindAwakeOrSleeping(target);
            if (online != null)
            {
                PlayerRecord rec = GetRecord(online.UserIDString, online.displayName);
                SendReply(player, Msg("PlayerPlaytime", player.UserIDString, Format(rec.TotalSeconds), Format(rec.WipeSeconds), rec.DisplayName));
                return;
            }

            PlayerRecord offline;
            if (records.TryGetValue(target, out offline))
            {
                SendReply(player, Msg("PlayerPlaytime", player.UserIDString, Format(offline.TotalSeconds), Format(offline.WipeSeconds), offline.DisplayName));
                return;
            }

            SendReply(player, Msg("NotFound", player.UserIDString, target));
        }

        private string Format(double seconds)
        {
            long totalMinutes = (long)(seconds / 60.0);
            long hours = totalMinutes / 60;
            long minutes = totalMinutes % 60;
            return string.Format("{0}h {1}m", hours, minutes);
        }
    }
}