How to make a Rust farming yield plugin (per-crop multipliers)

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

namespace Oxide.Plugins
{
    [Info("Farming Yield Multiplier", "RustPluginGenerator", "1.0.0")]
    [Description("Multiplies crops harvested from planters and wild plants with per-item multipliers.")]
    public class FarmingYieldMultiplier : RustPlugin
    {
        private const string PermAdmin = "farmingyieldmultiplier.admin";

        private PluginConfig config;

        private class PluginConfig
        {
            [JsonProperty("Default multiplier")]
            public float DefaultMultiplier = 1f;

            [JsonProperty("Max amount per harvest")]
            public int MaxAmountPerHarvest = 1000;

            [JsonProperty("Notify player on bonus")]
            public bool NotifyPlayer = true;

            [JsonProperty("Item multipliers (shortname)")]
            public Dictionary<string, float> Multipliers = new Dictionary<string, float>
            {
                ["cloth"] = 1f,
                ["corn"] = 1f,
                ["pumpkin"] = 1f,
                ["mushroom"] = 1f,
                ["clone.hemp"] = 1f,
                ["berry.blue"] = 1f,
                ["berry.red"] = 1f,
                ["berry.white"] = 1f,
                ["berry.yellow"] = 1f,
                ["berry.green"] = 1f
            };
        }

        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();
            }
            if (config.Multipliers == null) config.Multipliers = new Dictionary<string, float>();
            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.",
                ["Usage"] = "Usage: /farmyield <shortname> <multiplier>, /farmyield list, /farmyield reload",
                ["Set"] = "Multiplier for {0} set to {1}x.",
                ["InvalidItem"] = "'{0}' is not a valid item shortname.",
                ["InvalidNumber"] = "'{0}' is not a valid multiplier.",
                ["List"] = "Configured multipliers: {0}",
                ["ListEmpty"] = "No multipliers are configured.",
                ["Reloaded"] = "Configuration reloaded.",
                ["Bonus"] = "+{0}x {1}"
            }, 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 void OnServerInitialized()
        {
            foreach (var pair in config.Multipliers)
            {
                if (ItemManager.FindItemDefinition(pair.Key) == null)
                    PrintWarning($"Configured shortname '{pair.Key}' is not a valid item and will be ignored");
            }
        }

        private void OnGrowableGathered(GrowableEntity growableEntity, Item item, BasePlayer player)
        {
            if (item == null || item.info == null) return;

            float multiplier;
            if (!config.Multipliers.TryGetValue(item.info.shortname, out multiplier))
                multiplier = config.DefaultMultiplier;

            if (multiplier <= 0f || Mathf.Approximately(multiplier, 1f)) return;

            int baseAmount = item.amount;
            int amount = Mathf.RoundToInt(baseAmount * multiplier);
            if (amount < 1) amount = 1;

            int cap = config.MaxAmountPerHarvest;
            if (cap > 0 && amount > cap) amount = cap;
            if (item.info.stackable > 0 && amount > item.info.stackable) amount = item.info.stackable;

            if (amount == baseAmount) return;

            item.amount = amount;
            item.MarkDirty();

            if (config.NotifyPlayer && player != null && amount > baseAmount)
                SendReply(player, Msg("Bonus", player.UserIDString, amount - baseAmount, item.info.displayName.english));
        }

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

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

            if (args[0].Equals("list", StringComparison.OrdinalIgnoreCase))
            {
                if (config.Multipliers.Count == 0)
                {
                    player.ChatMessage(Msg("ListEmpty", player.UserIDString));
                    return;
                }

                var entries = new List<string>();
                foreach (var pair in config.Multipliers)
                    entries.Add($"{pair.Key}: {pair.Value}x");
                entries.Sort(StringComparer.OrdinalIgnoreCase);
                player.ChatMessage(Msg("List", player.UserIDString, string.Join(", ", entries)));
                return;
            }

            if (args[0].Equals("reload", StringComparison.OrdinalIgnoreCase))
            {
                LoadConfig();
                player.ChatMessage(Msg("Reloaded", player.UserIDString));
                return;
            }

            if (args.Length < 2)
            {
                player.ChatMessage(Msg("Usage", player.UserIDString));
                return;
            }

            string shortname = args[0].ToLowerInvariant();
            if (ItemManager.FindItemDefinition(shortname) == null)
            {
                player.ChatMessage(Msg("InvalidItem", player.UserIDString, shortname));
                return;
            }

            float multiplier;
            if (!float.TryParse(args[1], out multiplier) || multiplier <= 0f)
            {
                player.ChatMessage(Msg("InvalidNumber", player.UserIDString, args[1]));
                return;
            }

            config.Multipliers[shortname] = multiplier;
            SaveConfig();
            player.ChatMessage(Msg("Set", player.UserIDString, shortname, multiplier));
        }
    }
}