How to make a Rust group respawn kit plugin (Oxide/Carbon)

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

namespace Oxide.Plugins
{
    [Info("Group Respawn Kits", "RustPluginGenerator", "1.0.0")]
    [Description("Gives a respawn loadout based on the player's highest-priority Oxide group.")]
    public class GroupRespawnKits : RustPlugin
    {
        private const string PermAdmin = "grouprespawnkits.admin";

        private PluginConfig config;

        private class KitItem
        {
            [JsonProperty("Shortname")] public string Shortname = "wood";
            [JsonProperty("Amount")] public int Amount = 100;
            [JsonProperty("Skin")] public ulong Skin = 0;
            [JsonProperty("Condition")] public float Condition = 0f;
        }

        private class PluginConfig
        {
            [JsonProperty("Priority (highest first)")]
            public List<string> Priority = new List<string> { "admin", "vip", "default" };

            [JsonProperty("Loadouts by group")]
            public Dictionary<string, List<KitItem>> Loadouts = new Dictionary<string, List<KitItem>>
            {
                ["default"] = new List<KitItem>
                {
                    new KitItem { Shortname = "wood", Amount = 100 },
                    new KitItem { Shortname = "stone", Amount = 50 }
                },
                ["vip"] = new List<KitItem>
                {
                    new KitItem { Shortname = "wood", Amount = 500 },
                    new KitItem { Shortname = "stone", Amount = 250 },
                    new KitItem { Shortname = "supply.signal", Amount = 1 }
                },
                ["admin"] = new List<KitItem>
                {
                    new KitItem { Shortname = "wood", Amount = 1000 },
                    new KitItem { Shortname = "stone", Amount = 500 },
                    new KitItem { Shortname = "metal.fragments", Amount = 250 },
                    new KitItem { Shortname = "supply.signal", Amount = 1 }
                }
            };
        }

        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>
            {
                ["NoPermission"] = "You do not have permission to use this command.",
                ["ListHeader"] = "Respawn kits in priority order:",
                ["ListEntry"] = "{0}. {1} - {2} item(s)",
                ["TestUsage"] = "Usage: /respawnkit test <group>",
                ["TestUnknownGroup"] = "Group '{0}' has no loadout configured.",
                ["TestGiven"] = "Gave the '{0}' loadout to you for testing.",
                ["KitGiven"] = "You respawned with the {0} kit.",
                ["BadItem"] = "One or more items in a respawn kit were invalid and skipped."
            }, 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(PermAdmin, this);
        }

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

            string group = ResolveGroup(player);
            if (group == null) return;

            GiveKit(player, group);
        }

        private string ResolveGroup(BasePlayer player)
        {
            if (config.Priority == null) return null;
            foreach (string group in config.Priority)
            {
                if (string.IsNullOrEmpty(group)) continue;
                if (permission.UserHasGroup(player.UserIDString, group)) return group;
            }
            return null;
        }

        private void GiveKit(BasePlayer player, string group)
        {
            List<KitItem> items;
            if (config.Loadouts == null || !config.Loadouts.TryGetValue(group, out items) || items == null) return;

            bool invalid = false;
            foreach (KitItem entry in items)
            {
                if (entry == null || string.IsNullOrEmpty(entry.Shortname)) continue;
                Item item = ItemManager.CreateByName(entry.Shortname, Mathf.Max(1, entry.Amount), entry.Skin);
                if (item == null)
                {
                    invalid = true;
                    continue;
                }

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

                player.GiveItem(item);
            }

            if (invalid)
            {
                PrintWarning("The '" + group + "' respawn kit contains an invalid item shortname");
            }
        }

        [ChatCommand("respawnkit")]
        private void CmdRespawnKit(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            if (args == null || args.Length == 0)
            {
                SendReply(player, Msg("TestUsage", player.UserIDString));
                return;
            }

            string sub = args[0].ToLower();
            if (sub == "list")
            {
                SendReply(player, Msg("ListHeader", player.UserIDString));
                int index = 1;
                foreach (string group in config.Priority)
                {
                    List<KitItem> items;
                    int count = config.Loadouts != null && config.Loadouts.TryGetValue(group, out items) && items != null ? items.Count : 0;
                    SendReply(player, Msg("ListEntry", player.UserIDString, index, group, count));
                    index++;
                }
                return;
            }

            if (sub == "test")
            {
                if (args.Length < 2)
                {
                    SendReply(player, Msg("TestUsage", player.UserIDString));
                    return;
                }

                string group = args[1];
                if (config.Loadouts == null || !config.Loadouts.ContainsKey(group))
                {
                    SendReply(player, Msg("TestUnknownGroup", player.UserIDString, group));
                    return;
                }

                GiveKit(player, group);
                SendReply(player, Msg("TestGiven", player.UserIDString, group));
                return;
            }

            SendReply(player, Msg("TestUsage", player.UserIDString));
        }
    }
}