How to make a Rust VIP kit plugin (tiered permissions)

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

namespace Oxide.Plugins
{
    [Info("VipKits", "RustPluginGenerator", "1.0.0")]
    [Description("Tiered VIP kits where each tier has its own permission, item list and cooldown.")]
    public class VipKits : RustPlugin
    {
        private const string PermUse = "vipkits.use";

        private PluginConfig config;
        private StoredData data;
        private readonly Dictionary<string, ItemDefinition> definitions = new Dictionary<string, ItemDefinition>();

        private class KitItem
        {
            [JsonProperty("Shortname")]
            public string Shortname { get; set; } = "scrap";

            [JsonProperty("Amount")]
            public int Amount { get; set; } = 1;

            [JsonProperty("Skin")]
            public ulong Skin { get; set; } = 0;

            [JsonProperty("Condition")]
            public float Condition { get; set; } = 0f;
        }

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

            [JsonProperty("Permission")]
            public string Permission { get; set; } = "vipkits.vip1";

            [JsonProperty("Cooldown seconds")]
            public int CooldownSeconds { get; set; } = 86400;

            [JsonProperty("Items")]
            public List<KitItem> Items { get; set; } = new List<KitItem>();
        }

        private class PluginConfig
        {
            [JsonProperty("Tiers (highest first)")]
            public List<Tier> Tiers { get; set; } = new List<Tier>
            {
                new Tier
                {
                    Name = "VIP 3",
                    Permission = "vipkits.vip3",
                    CooldownSeconds = 43200,
                    Items = new List<KitItem>
                    {
                        new KitItem { Shortname = "scrap", Amount = 1000 },
                        new KitItem { Shortname = "rifle.ak", Amount = 1 },
                        new KitItem { Shortname = "ammo.rifle", Amount = 120 },
                        new KitItem { Shortname = "supply.signal", Amount = 1 }
                    }
                },
                new Tier
                {
                    Name = "VIP 2",
                    Permission = "vipkits.vip2",
                    CooldownSeconds = 86400,
                    Items = new List<KitItem>
                    {
                        new KitItem { Shortname = "scrap", Amount = 500 },
                        new KitItem { Shortname = "smg.2", Amount = 1 },
                        new KitItem { Shortname = "ammo.pistol", Amount = 96 },
                        new KitItem { Shortname = "syringe.medical", Amount = 5 }
                    }
                },
                new Tier
                {
                    Name = "VIP 1",
                    Permission = "vipkits.vip1",
                    CooldownSeconds = 86400,
                    Items = new List<KitItem>
                    {
                        new KitItem { Shortname = "scrap", Amount = 200 },
                        new KitItem { Shortname = "bow.hunting", Amount = 1 },
                        new KitItem { Shortname = "arrow.wooden", Amount = 32 },
                        new KitItem { Shortname = "largemedkit", Amount = 2 }
                    }
                }
            };
        }

        private class StoredData
        {
            [JsonProperty("Last claim unix time per user id")]
            public Dictionary<string, long> ClaimTimes { get; set; } = new Dictionary<string, long>();
        }

        protected override void LoadDefaultConfig() => config = new PluginConfig();

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<PluginConfig>();
                if (config == null || config.Tiers == 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 VIP kits.",
                ["NoTier"] = "You do not have any VIP kit permission. Ask an admin about VIP tiers.",
                ["Given"] = "You claimed <color=#8fd18f>{0}</color>: {1}",
                ["Cooldown"] = "{0} is on cooldown. Try again in <color=#e0b040>{1}</color>.",
                ["ListHeader"] = "Available VIP kits (highest first):",
                ["ListLine"] = "{0} - permission <color=#9dc4e8>{1}</color>, cooldown {2}, items: {3}"
            }, 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()
        {
            foreach (var tier in config.Tiers)
            {
                if (!string.IsNullOrEmpty(tier.Permission))
                    permission.RegisterPermission(tier.Permission, this);

                if (tier.Items == null) continue;
                foreach (var entry in tier.Items)
                {
                    if (string.IsNullOrEmpty(entry.Shortname)) continue;
                    var def = ItemManager.FindItemDefinition(entry.Shortname);
                    if (def == null)
                        PrintWarning($"Unknown item shortname '{entry.Shortname}' in tier '{tier.Name}', entry skipped");
                    else
                        definitions[entry.Shortname] = def;
                }
            }

            LoadData();
        }

        private void Unload()
        {
            SaveData();
        }

        [ChatCommand("vipkit")]
        private void CmdVipKit(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }

            var tier = ResolveTier(player);
            if (tier == null)
            {
                player.ChatMessage(Msg("NoTier", player.UserIDString));
                return;
            }

            long last;
            data.ClaimTimes.TryGetValue(player.UserIDString, out last);
            var now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
            var ready = last + Math.Max(1, tier.CooldownSeconds);
            if (now < ready)
            {
                player.ChatMessage(Msg("Cooldown", player.UserIDString, tier.Name, FormatTime(ready - now)));
                return;
            }

            var given = GiveTier(player, tier);
            data.ClaimTimes[player.UserIDString] = now;
            SaveData();
            player.ChatMessage(Msg("Given", player.UserIDString, tier.Name, given));
        }

        [ChatCommand("vipkits")]
        private void CmdVipKits(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }

            player.ChatMessage(Msg("ListHeader", player.UserIDString));
            foreach (var tier in config.Tiers)
            {
                var items = new List<string>();
                if (tier.Items != null)
                {
                    foreach (var entry in tier.Items)
                        items.Add($"{entry.Amount}x {entry.Shortname}");
                }
                player.ChatMessage(Msg("ListLine", player.UserIDString, tier.Name, tier.Permission,
                    FormatTime(tier.CooldownSeconds), string.Join(", ", items)));
            }
        }

        private Tier ResolveTier(BasePlayer player)
        {
            foreach (var tier in config.Tiers)
            {
                if (!string.IsNullOrEmpty(tier.Permission) &&
                    permission.UserHasPermission(player.UserIDString, tier.Permission))
                    return tier;
            }
            return null;
        }

        private string GiveTier(BasePlayer player, Tier tier)
        {
            var parts = new List<string>();
            if (tier.Items == null) return "nothing";

            foreach (var entry in tier.Items)
            {
                ItemDefinition def;
                if (string.IsNullOrEmpty(entry.Shortname) || !definitions.TryGetValue(entry.Shortname, out def))
                    continue;

                var amount = Mathf.Clamp(entry.Amount, 1, Math.Max(1, def.stackable));
                var item = ItemManager.CreateByItemID(def.itemid, amount, entry.Skin);
                if (item == null) continue;

                if (entry.Condition > 0f && item.hasCondition)
                {
                    item.condition = Mathf.Min(entry.Condition, item.maxCondition);
                }

                player.GiveItem(item);
                parts.Add($"{amount}x {def.displayName.english}");
            }

            return parts.Count > 0 ? string.Join(", ", parts) : "nothing";
        }

        private static string FormatTime(long seconds)
        {
            if (seconds < 0) seconds = 0;
            var span = TimeSpan.FromSeconds(seconds);
            if (span.TotalHours >= 1)
                return $"{(int)span.TotalHours}h {span.Minutes:00}m {span.Seconds:00}s";
            if (span.TotalMinutes >= 1)
                return $"{span.Minutes}m {span.Seconds:00}s";
            return $"{span.Seconds}s";
        }

        private void LoadData()
        {
            try
            {
                data = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(Name);
            }
            catch
            {
                PrintWarning("Data file is invalid, starting with an empty claim table");
                data = null;
            }

            if (data == null)
                data = new StoredData();
            if (data.ClaimTimes == null)
                data.ClaimTimes = new Dictionary<string, long>();
        }

        private void SaveData()
        {
            if (data != null)
                Interface.Oxide.DataFileSystem.WriteObject(Name, data);
        }
    }
}