How to make a Rust give kit plugin (admin /givekit command)

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

namespace Oxide.Plugins
{
    [Info("GiveKit", "RustPluginGenerator", "1.0.0")]
    [Description("Adds an admin chat and console command that gives config-defined kits to players.")]
    public class GiveKit : RustPlugin
    {
        private const string PermUse = "givekit.use";

        private PluginConfig config;

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

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

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

        private class PluginConfig
        {
            [JsonProperty("Kits")]
            public Dictionary<string, List<KitItem>> Kits { get; set; } = new Dictionary<string, List<KitItem>>(StringComparer.OrdinalIgnoreCase)
            {
                ["starter"] = new List<KitItem>
                {
                    new KitItem { Shortname = "rock", Amount = 1 },
                    new KitItem { Shortname = "torch", Amount = 1 },
                    new KitItem { Shortname = "bandage", Amount = 5 },
                    new KitItem { Shortname = "wood", Amount = 500 },
                    new KitItem { Shortname = "metal.fragments", Amount = 100 }
                }
            };
        }

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

        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, List<KitItem>>(StringComparer.OrdinalIgnoreCase);
            }
            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>
            {
                ["KitGiven"] = "Gave kit '{0}' ({1} items) to {2}.",
                ["KitMissing"] = "No kit named '{0}' exists in the config.",
                ["PlayerNotFound"] = "No player found matching '{0}'.",
                ["NoPermission"] = "You do not have permission to use this command.",
                ["Usage"] = "Usage: /givekit <player> <kit>",
                ["ItemMissing"] = "Kit '{0}' contains an unknown item '{1}', giving aborted."
            }, 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 kit in config.Kits)
            {
                if (kit.Value == null) continue;
                foreach (var entry in kit.Value)
                {
                    if (entry == null || string.IsNullOrEmpty(entry.Shortname)) continue;
                    if (ItemManager.FindItemDefinition(entry.Shortname) == null)
                        PrintWarning($"Kit '{kit.Key}' references unknown item '{entry.Shortname}'");
                }
            }
        }

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

            Run(player, args[0], args[1]);
        }

        [ConsoleCommand("givekit")]
        private void CcmdGiveKit(ConsoleSystem.Arg arg)
        {
            var caller = arg.Player();
            if (caller != null && !permission.UserHasPermission(caller.UserIDString, PermUse))
            {
                arg.ReplyWith(Msg("NoPermission", caller.UserIDString));
                return;
            }

            if (arg.Args == null || arg.Args.Length < 2)
            {
                arg.ReplyWith(Msg("Usage", caller?.UserIDString));
                return;
            }

            Run(caller, arg.Args[0].ToString(), arg.Args[1].ToString());
        }

        private void Run(BasePlayer caller, string targetArg, string kitArg)
        {
            var target = BasePlayer.FindAwakeOrSleeping(targetArg);
            if (target == null)
            {
                Reply(caller, Msg("PlayerNotFound", caller?.UserIDString, targetArg));
                return;
            }

            List<KitItem> kit;
            if (!TryGetKit(kitArg, out kit))
            {
                Reply(caller, Msg("KitMissing", caller?.UserIDString, kitArg));
                return;
            }

            var given = GiveKitToPlayer(target, kit);
            if (given < 0)
            {
                Reply(caller, Msg("ItemMissing", caller?.UserIDString, kitArg, "?"));
                return;
            }

            Reply(caller, Msg("KitGiven", caller?.UserIDString, kitArg, given, target.displayName));
        }

        private bool TryGetKit(string name, out List<KitItem> kit)
        {
            kit = null;
            if (string.IsNullOrEmpty(name) || config.Kits == null) return false;

            foreach (var pair in config.Kits)
            {
                if (string.Equals(pair.Key, name, StringComparison.OrdinalIgnoreCase))
                {
                    kit = pair.Value;
                    return kit != null;
                }
            }

            return false;
        }

        private int GiveKitToPlayer(BasePlayer player, List<KitItem> kit)
        {
            var given = 0;
            foreach (var entry in kit)
            {
                if (entry == null || string.IsNullOrEmpty(entry.Shortname)) continue;

                var amount = entry.Amount < 1 ? 1 : entry.Amount;
                var item = ItemManager.CreateByName(entry.Shortname, amount, entry.Skin);
                if (item == null)
                {
                    if (given > 0) player.ChatMessage(Msg("KitGiven", player.UserIDString, "?", given, player.displayName));
                    return -1;
                }

                player.GiveItem(item);
                given++;
            }

            Interface.Oxide.LogInfo($"[GiveKit] {player.displayName} ({player.UserIDString}) received a kit with {given} item stacks");
            return given;
        }

        private void Reply(BasePlayer caller, string message)
        {
            if (caller != null)
                SendReply(caller, message);
            else
                Puts(message);
        }
    }
}