How to make a Rust custom loot table plugin (crates by prefab)

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("Custom Loot Tables", "RustPluginGenerator", "1.0.0")]
    [Description("Replaces the contents of configured crates with custom loot tables")]
    public class CustomLootTables : RustPlugin
    {
        private const string PermAdmin = "customloottables.admin";

        private PluginConfig config;

        private class LootEntry
        {
            [JsonProperty("Item shortname")]
            public string Shortname = "scrap";

            [JsonProperty("Chance (0-100)")]
            public float Chance = 100f;

            [JsonProperty("Min Amount")]
            public int MinAmount = 1;

            [JsonProperty("Max Amount")]
            public int MaxAmount = 1;
        }

        private class LootTable
        {
            [JsonProperty("Max Stacks")]
            public int MaxStacks = 6;

            [JsonProperty("Items")]
            public List<LootEntry> Items = new List<LootEntry>();
        }

        private class PluginConfig
        {
            [JsonProperty("Fill Empty Slots")]
            public bool FillEmptySlots = true;

            [JsonProperty("Fallback Item")]
            public string FallbackItem = "scrap";

            [JsonProperty("Fallback Amount")]
            public int FallbackAmount = 10;

            [JsonProperty("Loot Tables")]
            public Dictionary<string, LootTable> Tables = new Dictionary<string, LootTable>
            {
                ["crate_elite"] = new LootTable
                {
                    MaxStacks = 5,
                    Items = new List<LootEntry>
                    {
                        new LootEntry { Shortname = "rifle.ak", Chance = 20f, MinAmount = 1, MaxAmount = 1 },
                        new LootEntry { Shortname = "ammo.rifle", Chance = 80f, MinAmount = 20, MaxAmount = 60 },
                        new LootEntry { Shortname = "scrap", Chance = 100f, MinAmount = 40, MaxAmount = 120 },
                        new LootEntry { Shortname = "components.riflebody", Chance = 40f, MinAmount = 1, MaxAmount = 2 }
                    }
                },
                ["crate_normal"] = new LootTable
                {
                    MaxStacks = 4,
                    Items = new List<LootEntry>
                    {
                        new LootEntry { Shortname = "scrap", Chance = 100f, MinAmount = 5, MaxAmount = 25 },
                        new LootEntry { Shortname = "metal.fragments", Chance = 60f, MinAmount = 50, MaxAmount = 200 }
                    }
                }
            };
        }

        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.",
                ["Table"] = "<color=#ce422b>{0}</color> ({1} entries, max {2} stacks): {3}",
                ["NoTables"] = "No loot tables are configured.",
                ["Preview"] = "Custom loot tables: {0} crate types configured.",
                ["CodeOnly"] = "This command must be run by a player."
            }, 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 object OnLootSpawn(LootContainer lootContainer)
        {
            if (lootContainer == null || lootContainer.ShortPrefabName == null || lootContainer.inventory == null) return null;

            LootTable table;
            if (!config.Tables.TryGetValue(lootContainer.ShortPrefabName.ToLower(), out table) || table == null) return null;

            FillContainer(lootContainer, table);
            return null;
        }

        private void FillContainer(LootContainer lootContainer, LootTable table)
        {
            ItemContainer container = lootContainer.inventory;

            for (int i = container.itemList.Count - 1; i >= 0; i--)
            {
                Item existing = container.itemList[i];
                if (existing != null) existing.Remove();
            }

            int stacks = 0;
            int maxStacks = Mathf.Max(1, table.MaxStacks);

            if (table.Items != null)
            {
                foreach (LootEntry entry in table.Items)
                {
                    if (stacks >= maxStacks) break;
                    if (entry == null || string.IsNullOrEmpty(entry.Shortname)) continue;
                    if (UnityEngine.Random.Range(0f, 100f) > entry.Chance) continue;

                    int min = Mathf.Max(1, entry.MinAmount);
                    int max = Mathf.Max(min, entry.MaxAmount);
                    int amount = UnityEngine.Random.Range(min, max + 1);

                    Item item = ItemManager.CreateByName(entry.Shortname, amount);
                    if (item == null) continue;
                    if (!item.MoveToContainer(container)) { item.Remove(); continue; }
                    stacks++;
                }
            }

            if (config.FillEmptySlots && container.itemList.Count == 0)
            {
                Item fallback = ItemManager.CreateByName(config.FallbackItem, Mathf.Max(1, config.FallbackAmount));
                if (fallback != null && !fallback.MoveToContainer(container)) fallback.Remove();
            }

            container.MarkDirty();
        }

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

            if (config.Tables == null || config.Tables.Count == 0)
            {
                player.ChatMessage(Msg("NoTables", player.UserIDString));
                return;
            }

            player.ChatMessage(Msg("Preview", player.UserIDString, config.Tables.Count));

            foreach (KeyValuePair<string, LootTable> pair in config.Tables)
            {
                if (pair.Value == null) continue;
                string names = "";
                if (pair.Value.Items != null)
                {
                    for (int i = 0; i < pair.Value.Items.Count && i < 5; i++)
                    {
                        LootEntry entry = pair.Value.Items[i];
                        if (entry == null) continue;
                        names += (names.Length > 0 ? ", " : "") + entry.Shortname + " " + entry.Chance + "%";
                    }
                }
                player.ChatMessage(Msg("Table", player.UserIDString, pair.Key, pair.Value.Items != null ? pair.Value.Items.Count : 0, pair.Value.MaxStacks, names));
            }
        }

        [ConsoleCommand("customloottables.reroll")]
        private void CcmdReroll(ConsoleSystem.Arg arg)
        {
            BasePlayer player = arg.Player();
            if (player == null)
            {
                arg.ReplyWith(Msg("CodeOnly"));
                return;
            }

            if (!permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                arg.ReplyWith(Msg("NoPermission", player.UserIDString));
                return;
            }

            RaycastHit hit;
            if (!Physics.Raycast(player.eyes.HeadRay(), out hit, 8f)) return;

            LootContainer lootContainer = hit.GetEntity() as LootContainer;
            if (lootContainer == null) return;

            LootTable table;
            if (!config.Tables.TryGetValue(lootContainer.ShortPrefabName == null ? "" : lootContainer.ShortPrefabName.ToLower(), out table) || table == null)
            {
                arg.ReplyWith("This crate has no custom loot table.");
                return;
            }

            FillContainer(lootContainer, table);
            arg.ReplyWith("Table applied to " + lootContainer.ShortPrefabName + ".");
        }
    }
}