How to make a Rust respawn loadout plugin (save belt and clothing, restore on respawn)

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

namespace Oxide.Plugins
{
    [Info("Saved Respawn Loadout", "RustPluginGenerator", "1.0.0")]
    [Description("Saves a player's belt and clothing items and restores them on respawn")]
    public class SavedRespawnLoadout : RustPlugin
    {
        private const string PermUse = "savedrespawnloadout.use";

        private PluginConfig config;
        private StoredData data;
        private readonly Dictionary<ulong, DateTime> lastSave = new Dictionary<ulong, DateTime>();

        private class PluginConfig
        {
            [JsonProperty("Whitelisted shortnames")]
            public List<string> WhitelistedShortnames = new List<string>
            {
                "rifle.ak", "rifle.bolt", "smg.mp5", "pistol.semiauto",
                "ammo.rifle", "ammo.pistol", "syringe.medical", "bandage",
                "hoodie", "pants", "shoes.boots", "metal.facemask"
            };

            [JsonProperty("Save cooldown (seconds)")]
            public double SaveCooldownSeconds = 60.0;

            [JsonProperty("Remove loadout after respawn")]
            public bool RemoveAfterRespawn = false;
        }

        private class LoadoutEntry
        {
            [JsonProperty("Shortname")]
            public string Shortname;

            [JsonProperty("Amount")]
            public int Amount;
        }

        private class StoredData
        {
            [JsonProperty("Loadouts")]
            public Dictionary<string, List<LoadoutEntry>> Loadouts = new Dictionary<string, List<LoadoutEntry>>();
        }

        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 loadouts.",
                ["Saved"] = "Saved {0} item(s) to your respawn loadout.",
                ["SaveEmpty"] = "Nothing in your belt or clothing could be saved.",
                ["Cleared"] = "Your saved respawn loadout was deleted.",
                ["Cooldown"] = "You can save again in {0} second(s).",
                ["Restored"] = "Your saved loadout was returned to you.",
                ["Usage"] = "Usage: /loadout save or /loadout clear"
            }, 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);
            data = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(Name) ?? new StoredData();
        }

        private void Unload()
        {
            Interface.Oxide.DataFileSystem.WriteObject(Name, data);
        }

        private bool IsWhitelisted(string shortname)
        {
            return config.WhitelistedShortnames != null && config.WhitelistedShortnames.Contains(shortname);
        }

        private void AddFromContainer(ItemContainer container, List<LoadoutEntry> result)
        {
            if (container == null) return;
            foreach (var item in container.itemList)
            {
                if (item?.info == null) continue;
                if (!IsWhitelisted(item.info.shortname)) continue;
                if (ItemManager.FindItemDefinition(item.info.shortname) == null) continue;
                result.Add(new LoadoutEntry { Shortname = item.info.shortname, Amount = item.amount });
            }
        }

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

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

            switch (args[0].ToLower())
            {
                case "save":
                    SaveLoadout(player);
                    break;
                case "clear":
                    ClearLoadout(player);
                    break;
                default:
                    player.ChatMessage(Msg("Usage", player.UserIDString));
                    break;
            }
        }

        private void SaveLoadout(BasePlayer player)
        {
            var now = DateTime.UtcNow;
            DateTime previous;
            if (lastSave.TryGetValue(player.userID, out previous))
            {
                var remaining = config.SaveCooldownSeconds - (now - previous).TotalSeconds;
                if (remaining > 0)
                {
                    player.ChatMessage(Msg("Cooldown", player.UserIDString, Math.Ceiling(remaining)));
                    return;
                }
            }

            var entries = new List<LoadoutEntry>();
            AddFromContainer(player.inventory?.containerBelt, entries);
            AddFromContainer(player.inventory?.containerWear, entries);

            if (entries.Count == 0)
            {
                player.ChatMessage(Msg("SaveEmpty", player.UserIDString));
                return;
            }

            data.Loadouts[player.UserIDString] = entries;
            lastSave[player.userID] = now;
            Interface.Oxide.DataFileSystem.WriteObject(Name, data);
            player.ChatMessage(Msg("Saved", player.UserIDString, entries.Count));
        }

        private void ClearLoadout(BasePlayer player)
        {
            if (data != null && data.Loadouts.Remove(player.UserIDString))
            {
                Interface.Oxide.DataFileSystem.WriteObject(Name, data);
            }
            player.ChatMessage(Msg("Cleared", player.UserIDString));
        }

        private void OnPlayerRespawned(BasePlayer player)
        {
            if (player == null || data == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse)) return;

            List<LoadoutEntry> entries;
            if (!data.Loadouts.TryGetValue(player.UserIDString, out entries) || entries == null || entries.Count == 0) return;

            foreach (var entry in entries)
            {
                if (entry == null || string.IsNullOrEmpty(entry.Shortname)) continue;
                var item = ItemManager.CreateByName(entry.Shortname, Mathf.Max(1, entry.Amount));
                if (item == null) continue;
                player.GiveItem(item);
            }

            player.ChatMessage(Msg("Restored", player.UserIDString));

            if (config.RemoveAfterRespawn)
            {
                data.Loadouts.Remove(player.UserIDString);
                Interface.Oxide.DataFileSystem.WriteObject(Name, data);
            }
        }
    }
}