How to make a Rust stack size plugin (global, category and per-item multipliers)

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

namespace Oxide.Plugins
{
    [Info("Stack Sizes", "RustPluginGenerator", "1.0.0")]
    [Description("Scales item stack sizes with global, per-category and per-item settings and restores originals on unload.")]
    public class StackSizes : RustPlugin
    {
        private const string PermUse = "stacksizes.use";

        private PluginConfig config;

        // itemid -> vanilla stackable value, captured before the first change
        private readonly Dictionary<int, int> originals = new Dictionary<int, int>();

        private class PluginConfig
        {
            [JsonProperty("Global Multiplier")]
            public float GlobalMultiplier = 2f;

            [JsonProperty("Category Multipliers")]
            public Dictionary<string, float> CategoryMultipliers = new Dictionary<string, float>
            {
                ["Resources"] = 4f,
                ["Ammunition"] = 2f,
                ["Component"] = 2f
            };

            [JsonProperty("Per-Item Overrides")]
            public Dictionary<string, int> Overrides = new Dictionary<string, int>
            {
                ["rifle.ammo"] = 128,
                ["pistol.ammo"] = 128
            };

            [JsonProperty("Excluded Categories")]
            public List<string> ExcludedCategories = new List<string>
            {
                "Weapon",
                "Attire"
            };
        }

        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>
            {
                ["UnknownItem"] = "No item definition found for '{0}'.",
                ["Info"] = "{0} ({1}): original {2}, current {3}, effective x{4}{5}",
                ["OverrideNote"] = " (override)",
                ["Denied"] = "You do not have permission to use this command."
            }, 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(bool initial)
        {
            ApplyAll();
        }

        private void Unload()
        {
            RestoreAll();
        }

        private bool IsExcluded(ItemDefinition definition)
        {
            foreach (var name in config.ExcludedCategories)
            {
                ItemCategory category;
                if (Enum.TryParse(name, true, out category) && category == definition.category)
                    return true;
            }
            return false;
        }

        private float CategoryMultiplier(ItemDefinition definition)
        {
            float value;
            if (config.CategoryMultipliers != null && config.CategoryMultipliers.TryGetValue(definition.category.ToString(), out value))
                return value;
            return 1f;
        }

        private void ApplyAll()
        {
            var global = Mathf.Max(0.01f, config.GlobalMultiplier);
            foreach (var definition in ItemManager.itemList)
            {
                if (definition == null || IsExcluded(definition))
                    continue;

                if (!originals.ContainsKey(definition.itemid))
                    originals[definition.itemid] = definition.stackable;

                int result;
                if (config.Overrides != null && config.Overrides.TryGetValue(definition.shortname, out result))
                {
                    definition.stackable = Mathf.Max(1, result);
                    continue;
                }

                var scaled = originals[definition.itemid] * global * CategoryMultiplier(definition);
                definition.stackable = Mathf.Max(1, Mathf.RoundToInt(scaled));
            }
        }

        private void RestoreAll()
        {
            if (ItemManager.itemList != null)
            {
                foreach (var definition in ItemManager.itemList)
                {
                    int original;
                    if (definition != null && originals.TryGetValue(definition.itemid, out original))
                        definition.stackable = original;
                }
            }
            originals.Clear();
        }

        [ChatCommand("stackinfo")]
        private void CmdStackInfo(BasePlayer player, string command, string[] args)
        {
            if (player == null)
                return;

            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("Denied", player.UserIDString));
                return;
            }

            if (args == null || args.Length == 0)
            {
                SendReply(player, "Usage: /stackinfo <shortname>");
                return;
            }

            var definition = ItemManager.FindItemDefinition(args[0]);
            if (definition == null)
            {
                SendReply(player, Msg("UnknownItem", player.UserIDString, args[0]));
                return;
            }

            int original;
            if (!originals.TryGetValue(definition.itemid, out original))
                original = definition.stackable;

            var effective = original > 0 ? (float)definition.stackable / original : 1f;
            var overrideActive = config.Overrides != null && config.Overrides.ContainsKey(definition.shortname);
            SendReply(player, Msg("Info", player.UserIDString, definition.displayName.english, definition.shortname,
                original, definition.stackable, effective.ToString("0.##"), overrideActive ? Msg("OverrideNote", player.UserIDString) : string.Empty));
        }
    }
}