How to make a Rust one-time claim kits plugin (Oxide)

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

namespace Oxide.Plugins
{
    [Info("OneTimeKits", "RustPluginGenerator", "1.0.0")]
    [Description("Gives players configurable kits that can be claimed once per wipe.")]
    public class OneTimeKits : RustPlugin
    {
        private const string PermUse = "onetimekits.use";
        private const string DataFile = "OneTimeKits";

        [PluginReference] private Plugin Economics;

        private PluginConfig config;
        private Data data;

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

        private class KitEntry
        {
            [JsonProperty("Permission")] public string Permission { get; set; } = "";
            [JsonProperty("Description")] public string Description { get; set; } = "";
            [JsonProperty("Items")] public List<KitItem> Items { get; set; } = new List<KitItem>();
        }

        private class Settings
        {
            [JsonProperty("Require per-kit permission")] public bool RequirePerKitPermission { get; set; } = false;
            [JsonProperty("Wipe reset broadcast")] public string WipeResetMessage { get; set; } = "A new wipe has started. All kit claims are available again.";
        }

        private class PluginConfig
        {
            [JsonProperty("Settings")] public Settings Settings { get; set; } = new Settings();
            [JsonProperty("Kits")] public Dictionary<string, KitEntry> Kits { get; set; } = new Dictionary<string, KitEntry>();
        }

        private class Data
        {
            [JsonProperty("Claims")] public Dictionary<string, List<string>> Claims { get; set; } = new Dictionary<string, List<string>>();
        }

        protected override void LoadDefaultConfig()
        {
            config = new PluginConfig
            {
                Kits = new Dictionary<string, KitEntry>
                {
                    ["starter"] = new KitEntry
                    {
                        Description = "Basic starter kit",
                        Items = new List<KitItem>
                        {
                            new KitItem { Shortname = "wood", Amount = 5000 },
                            new KitItem { Shortname = "stone", Amount = 3000 },
                            new KitItem { Shortname = "scrap", Amount = 250 }
                        }
                    },
                    ["builder"] = new KitEntry
                    {
                        Permission = "onetimekits.builder",
                        Description = "Building materials kit",
                        Items = new List<KitItem>
                        {
                            new KitItem { Shortname = "wood", Amount = 10000 },
                            new KitItem { Shortname = "stone", Amount = 8000 },
                            new KitItem { Shortname = "metal.fragments", Amount = 2000 }
                        }
                    }
                }
            };
        }

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<PluginConfig>();
                if (config == null) throw new Exception();
                if (config.Kits == null) config.Kits = new Dictionary<string, KitEntry>();
                if (config.Settings == null) config.Settings = new Settings();
            }
            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 this command.",
                ["Usage"] = "Usage: /claim <kit>",
                ["KitPermission"] = "You do not have permission to claim the {0} kit.",
                ["KitUnknown"] = "There is no kit called {0}.",
                ["KitUsed"] = "You have already claimed the {0} kit this wipe.",
                ["KitGiven"] = "You claimed the {0} kit.",
                ["KitBroken"] = "Some items in the {0} kit could not be created. Contact an admin.",
                ["ResetDone"] = "Reset {0} claim(s) for {1}.",
                ["ResetNone"] = "No matching claims found.",
                ["ListHeader"] = "Configured kits:"
            }, 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 Loaded()
        {
            data = Interface.Oxide.DataFileSystem.ReadObject<Data>(DataFile);
            if (data == null || data.Claims == null)
            {
                data = new Data();
                data.Claims = new Dictionary<string, List<string>>();
            }
        }

        private void Unload()
        {
            SaveData();
        }

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

        private void OnNewSave(string strFilename)
        {
            data = new Data();
            data.Claims = new Dictionary<string, List<string>>();
            SaveData();
            if (!string.IsNullOrEmpty(config.Settings.WipeResetMessage))
            {
                Server.Broadcast(config.Settings.WipeResetMessage);
            }
        }

        [ChatCommand("claim")]
        private void CmdClaim(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 < 1)
            {
                SendReply(player, Msg("Usage", player.UserIDString));
                return;
            }

            string kitName = args[0].ToLowerInvariant();
            KitEntry kit;
            if (!config.Kits.TryGetValue(kitName, out kit) || kit == null)
            {
                SendReply(player, Msg("KitUnknown", player.UserIDString, kitName));
                return;
            }

            if (config.Settings.RequirePerKitPermission && !string.IsNullOrEmpty(kit.Permission)
                && !permission.UserHasPermission(player.UserIDString, kit.Permission))
            {
                SendReply(player, Msg("KitPermission", player.UserIDString, kitName));
                return;
            }

            List<string> claims;
            if (data.Claims.TryGetValue(player.UserIDString, out claims) && claims != null && claims.Contains(kitName))
            {
                SendReply(player, Msg("KitUsed", player.UserIDString, kitName));
                return;
            }

            if (!GiveKit(player, kitName, kit))
            {
                SendReply(player, Msg("KitBroken", player.UserIDString, kitName));
            }
            else
            {
                SendReply(player, Msg("KitGiven", player.UserIDString, kitName));
            }

            if (claims == null)
            {
                claims = new List<string>();
                data.Claims[player.UserIDString] = claims;
            }
            claims.Add(kitName);
            SaveData();
        }

        private bool GiveKit(BasePlayer player, string kitName, KitEntry kit)
        {
            if (kit.Items == null) return true;
            bool allOk = true;
            foreach (KitItem entry in kit.Items)
            {
                if (entry == null || string.IsNullOrEmpty(entry.Shortname)) continue;
                Item item = ItemManager.CreateByName(entry.Shortname, Math.Max(1, entry.Amount), 0);
                if (item == null)
                {
                    PrintWarning("Kit '" + kitName + "' references an unknown item: " + entry.Shortname);
                    allOk = false;
                    continue;
                }
                player.GiveItem(item);
            }
            return allOk;
        }

        [ConsoleCommand("onetimekits.reset")]
        private void CcmdReset(ConsoleSystem.Arg arg)
        {
            if (arg == null || arg.Args == null || arg.Args.Length < 1) return;

            string who = arg.GetString(0, "");
            string kitArg = arg.Args.Length >= 2 ? arg.GetString(1, "").ToLowerInvariant() : null;

            string key = null;
            BasePlayer target = BasePlayer.FindAwakeOrSleeping(who);
            if (target != null)
            {
                key = target.UserIDString;
            }
            else if (who.Length > 0 && data.Claims.ContainsKey(who))
            {
                key = who;
            }

            if (key == null)
            {
                arg.ReplyWith(lang.GetMessage("ResetNone", this));
                return;
            }

            List<string> claims;
            if (!data.Claims.TryGetValue(key, out claims) || claims == null)
            {
                arg.ReplyWith(lang.GetMessage("ResetNone", this));
                return;
            }

            int removed;
            if (kitArg == null)
            {
                removed = claims.Count;
                data.Claims.Remove(key);
            }
            else
            {
                removed = claims.RemoveAll(c => c == kitArg);
                if (claims.Count == 0) data.Claims.Remove(key);
            }

            SaveData();
            arg.ReplyWith(string.Format(Msg("ResetDone", null, removed, key)));
        }

        [ConsoleCommand("onetimekits.list")]
        private void CcmdList(ConsoleSystem.Arg arg)
        {
            if (arg == null) return;
            arg.ReplyWith(Msg("ListHeader", null));
            foreach (KeyValuePair<string, KitEntry> kvp in config.Kits)
            {
                string perm = string.IsNullOrEmpty(kvp.Value.Permission) ? "-" : kvp.Value.Permission;
                arg.ReplyWith("  " + kvp.Key + " | permission: " + perm + " | items: " + (kvp.Value.Items != null ? kvp.Value.Items.Count : 0));
            }
        }
    }
}