How to make a Rust playtime group promotion plugin (Oxide/Carbon)

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

namespace Oxide.Plugins
{
    [Info("Playtime Groups", "RustPluginGenerator", "1.0.0")]
    [Description("Tracks player playtime and moves players into Oxide groups at configured thresholds.")]
    public class PlaytimeGroups : RustPlugin
    {
        private const string PermUse = "playtimegroups.use";
        private const string PermAdmin = "playtimegroups.admin";
        private const string DataFile = "PlaytimeGroups";

        private PluginConfig config;

        private class PluginConfig
        {
            [JsonProperty("Stack groups (keep lower tiers)")]
            public bool StackGroups { get; set; } = true;

            [JsonProperty("Promotion thresholds (group name and minutes played)")]
            public List<GroupRequirement> Thresholds { get; set; } = new List<GroupRequirement>
            {
                new GroupRequirement { Group = "regular", Minutes = 600.0 },
                new GroupRequirement { Group = "veteran", Minutes = 3000.0 }
            };
        }

        private class GroupRequirement
        {
            [JsonProperty("Group name")]
            public string Group { get; set; } = string.Empty;

            [JsonProperty("Minutes played")]
            public double Minutes { get; set; }
        }

        // Steam ID -> total tracked minutes
        private Dictionary<string, double> playtime = new Dictionary<string, double>();

        // Steam ID -> session start timestamp
        private readonly Dictionary<ulong, float> sessionStart = new Dictionary<ulong, float>();

        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>
            {
                ["Playtime"] = "You have played for {0} minutes.",
                ["NextTier"] = "Next group '{0}' at {1} minutes ({2} to go).",
                ["TopTier"] = "You have reached the highest playtime group.",
                ["ConsoleCheck"] = "Player {0}: {1} minutes stored. Current groups: {2}",
                ["NoGroups"] = "none"
            }, 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);
            permission.RegisterPermission(PermAdmin, this);

            playtime = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<string, double>>(DataFile)
                       ?? new Dictionary<string, double>();
        }

        private void OnServerInitialized()
        {
            if (config.Thresholds == null) config.Thresholds = new List<GroupRequirement>();

            foreach (var entry in config.Thresholds)
            {
                if (string.IsNullOrEmpty(entry.Group)) continue;
                if (!permission.GroupExists(entry.Group))
                {
                    PrintWarning($"Configured group '{entry.Group}' does not exist and will be skipped");
                }
            }
        }

        private void Unload()
        {
            foreach (var player in BasePlayer.activePlayerList)
            {
                FlushSession(player);
            }

            SaveData();
        }

        private void OnServerSave() => SaveData();

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

            sessionStart[player.userID] = UnityEngine.Time.realtimeSinceStartup;
            ApplyGroup(player);
        }

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

            FlushSession(player);
            SaveData();
        }

        private void FlushSession(BasePlayer player)
        {
            float started;
            if (!sessionStart.TryGetValue(player.userID, out started)) return;

            sessionStart.Remove(player.userID);

            var minutes = (UnityEngine.Time.realtimeSinceStartup - started) / 60f;
            if (minutes <= 0f) return;

            var id = player.UserIDString;
            double existing;
            playtime.TryGetValue(id, out existing);
            playtime[id] = existing + minutes;
        }

        private double GetTotal(BasePlayer player)
        {
            double stored = 0.0;
            playtime.TryGetValue(player.UserIDString, out stored);

            float started;
            if (sessionStart.TryGetValue(player.userID, out started))
            {
                stored += (UnityEngine.Time.realtimeSinceStartup - started) / 60f;
            }

            return stored;
        }

        private List<GroupRequirement> SortedThresholds()
        {
            return (config.Thresholds ?? new List<GroupRequirement>())
                .Where(t => t != null && !string.IsNullOrEmpty(t.Group))
                .OrderBy(t => t.Minutes)
                .ToList();
        }

        private void ApplyGroup(BasePlayer player)
        {
            var total = GetTotal(player);
            var ladder = SortedThresholds();
            var target = -1;

            for (int i = 0; i < ladder.Count; i++)
            {
                if (total >= ladder[i].Minutes) target = i;
            }

            var id = player.UserIDString;
            var wanted = new List<string>();

            if (target >= 0)
            {
                if (config.StackGroups)
                {
                    for (int i = 0; i <= target; i++) wanted.Add(ladder[i].Group);
                }
                else
                {
                    wanted.Add(ladder[target].Group);
                }
            }

            var changed = false;

            foreach (var entry in ladder)
            {
                if (wanted.Contains(entry.Group)) continue;
                if (permission.UserHasGroup(id, entry.Group))
                {
                    permission.RemoveUserGroup(id, entry.Group);
                    changed = true;
                }
            }

            foreach (var group in wanted)
            {
                if (permission.UserHasGroup(id, group)) continue;
                permission.AddUserGroup(id, group);
                changed = true;
            }
        }

        private void SaveData() => Interface.Oxide.DataFileSystem.WriteObject(DataFile, playtime);

        [ChatCommand("playtime")]
        private void CmdPlaytime(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage("You do not have permission to use this command.");
                return;
            }

            var total = GetTotal(player);
            player.ChatMessage(Msg("Playtime", player.UserIDString, Math.Round(total)));

            var ladder = SortedThresholds();
            var next = ladder.FirstOrDefault(t => t.Minutes > total);
            if (next == null)
            {
                player.ChatMessage(Msg("TopTier", player.UserIDString));
                return;
            }

            player.ChatMessage(Msg("NextTier", player.UserIDString, next.Group, next.Minutes, Math.Round(next.Minutes - total)));
        }

        [ConsoleCommand("playtimegroups.check")]
        private void CcmdCheck(ConsoleSystem.Arg arg)
        {
            if (arg == null || !arg.IsAdmin) return;

            var id = arg.GetString(0, string.Empty);
            if (string.IsNullOrEmpty(id))
            {
                arg.ReplyWith("Usage: playtimegroups.check <steamid>");
                return;
            }

            double stored;
            playtime.TryGetValue(id, out stored);

            var groups = permission.GetUserGroups(id);
            var groupText = groups == null || groups.Length == 0
                ? Msg("NoGroups")
                : string.Join(", ", groups);

            arg.ReplyWith(Msg("ConsoleCheck", null, id, Math.Round(stored), groupText));
        }
    }
}