How to make a Rust supply drop loot plugin (weighted custom table)

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

namespace Oxide.Plugins
{
    [Info("Supply Drop Loot", "RustPluginGenerator", "1.0.0")]
    [Description("Replaces supply drop loot with a weighted table and announces the crate grid.")]
    public class SupplyDropLoot : RustPlugin
    {
        private class LootEntry
        {
            [JsonProperty("Item shortname")]
            public string Shortname = "rifle.ak";
            [JsonProperty("Min amount")]
            public int MinAmount = 1;
            [JsonProperty("Max amount")]
            public int MaxAmount = 1;
            [JsonProperty("Weight")]
            public int Weight = 10;
            [JsonProperty("Skin")]
            public ulong Skin = 0;
        }

        private class PluginConfig
        {
            [JsonProperty("Announce drop in chat")]
            public bool AnnounceDrop = true;
            [JsonProperty("Max items in crate (0 = crate capacity)")]
            public int MaxItems = 0;
            [JsonProperty("Supply drop prefabs")]
            public List<string> SupplyPrefabs = new List<string> { "supply_drop" };
            [JsonProperty("Loot table")]
            public List<LootEntry> Loot = new List<LootEntry>
            {
                new LootEntry { Shortname = "rifle.ak", MinAmount = 1, MaxAmount = 1, Weight = 10 },
                new LootEntry { Shortname = "ammo.rifle", MinAmount = 30, MaxAmount = 90, Weight = 25 },
                new LootEntry { Shortname = "scrap", MinAmount = 100, MaxAmount = 300, Weight = 40 },
                new LootEntry { Shortname = "metal.refined", MinAmount = 50, MaxAmount = 150, Weight = 20 },
                new LootEntry { Shortname = "explosive.timed", MinAmount = 1, MaxAmount = 2, Weight = 5 }
            };
        }

        private PluginConfig config;
        private readonly HashSet<string> warnedShortnames = new HashSet<string>();
        private readonly HashSet<string> prefabSet = new HashSet<string>();

        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();
            BuildPrefabSet();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["Announce"] = "Supply drop inbound at grid {0}. Loot has been replaced.",
                ["Empty"] = ""
            }, this);
        }

        private string Msg(string key, string userId = null, params object[] args)
        {
            return string.Format(lang.GetMessage(key, this, userId), args);
        }

        private void BuildPrefabSet()
        {
            prefabSet.Clear();
            if (config?.SupplyPrefabs == null) return;
            foreach (var name in config.SupplyPrefabs)
            {
                if (!string.IsNullOrEmpty(name)) prefabSet.Add(name.ToLowerInvariant());
            }
        }

        private void OnEntitySpawned(BaseNetworkable entity)
        {
            if (entity == null || entity.IsDestroyed) return;
            var prefab = entity.ShortPrefabName;
            if (string.IsNullOrEmpty(prefab) || !prefabSet.Contains(prefab.ToLowerInvariant())) return;

            var crate = entity as StorageContainer;
            if (crate == null) return;

            NextTick(() =>
            {
                if (crate == null || crate.IsDestroyed) return;
                Fill(crate);
            });
        }

        private void Fill(StorageContainer crate)
        {
            var inventory = crate.inventory;
            if (inventory == null) return;

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

            int limit = config.MaxItems > 0 ? Math.Min(config.MaxItems, inventory.capacity) : inventory.capacity;
            int placed = 0;
            int attempts = 0;

            while (placed < limit && attempts < limit * 4)
            {
                attempts++;
                var entry = PickEntry();
                if (entry == null) break;

                var info = ItemManager.FindItemDefinition(entry.Shortname);
                if (info == null)
                {
                    if (warnedShortnames.Add(entry.Shortname))
                        PrintWarning("Unknown item shortname in config: " + entry.Shortname);
                    continue;
                }

                int amount = UnityEngine.Random.Range(entry.MinAmount, entry.MaxAmount + 1);
                if (amount < 1) amount = 1;
                if (info.stackable > 0 && amount > info.stackable) amount = info.stackable;

                var item = ItemManager.CreateByName(entry.Shortname, amount, entry.Skin);
                if (item == null) continue;

                if (!item.MoveToContainer(inventory))
                {
                    item.Remove();
                    continue;
                }
                placed++;
            }

            if (config.AnnounceDrop)
            {
                Server.Broadcast(Msg("Announce", null, GridReference(crate.transform.position)));
            }
        }

        private LootEntry PickEntry()
        {
            if (config?.Loot == null || config.Loot.Count == 0) return null;

            int total = 0;
            foreach (var entry in config.Loot)
            {
                if (entry == null || entry.Weight <= 0) continue;
                total += entry.Weight;
            }
            if (total <= 0) return null;

            int roll = UnityEngine.Random.Range(0, total);
            foreach (var entry in config.Loot)
            {
                if (entry == null || entry.Weight <= 0) continue;
                roll -= entry.Weight;
                if (roll < 0) return entry;
            }
            return null;
        }

        private string GridReference(Vector3 position)
        {
            const float cell = 150f;
            int letter = (int)Math.Floor(position.x / cell);
            int number = (int)Math.Floor(position.z / cell);
            if (letter < 0) letter = 0;
            if (number < 0) number = 0;
            char column = (char)('A' + letter % 26);
            return column + number.ToString();
        }
    }
}