How to make a Rust furnace splitter plugin (Oxide/Carbon)

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

namespace Oxide.Plugins
{
    [Info("Furnace Splitter", "RustPluginGenerator", "1.0.0")]
    [Description("Splits ore evenly across the free input slots of a furnace.")]
    public class FurnaceSplitter : RustPlugin
    {
        private const string PermUse = "furnacesplitter.use";
        private const string DataFile = "FurnaceSplitter";

        private PluginConfig config;
        private Dictionary<ulong, bool> prefs;

        private class PluginConfig
        {
            [JsonProperty("Max Stack Size")]
            public int MaxStackSize = 100;

            [JsonProperty("Splittable Shortnames")]
            public string[] SplittableShortnames =
            {
                "hq.metal.ore",
                "metal.ore",
                "sulfur.ore",
                "stones"
            };
        }

        protected override void LoadDefaultConfig() => config = new PluginConfig();

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<PluginConfig>();
                if (config == null) throw new Exception();
                if (config.SplittableShortnames == null) config.SplittableShortnames = new string[0];
                if (config.MaxStackSize < 1) config.MaxStackSize = 1;
            }
            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>
            {
                ["Enabled"] = "Furnace splitting is now <color=#7fbf5f>enabled</color>.",
                ["Disabled"] = "Furnace splitting is now <color=#bf5f5f>disabled</color>.",
                ["NoPermission"] = "You do not have permission to use this command."
            }, this);
        }

        private void Init()
        {
            permission.RegisterPermission(PermUse, this);
            prefs = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<ulong, bool>>(DataFile)
                    ?? new Dictionary<ulong, bool>();
        }

        private void Unload()
        {
            Interface.Oxide.DataFileSystem.WriteObject(DataFile, prefs);
        }

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

            ulong id = player.userID.Get();
            bool current;
            prefs.TryGetValue(id, out current);
            bool next = !current;
            prefs[id] = next;
            Interface.Oxide.DataFileSystem.WriteObject(DataFile, prefs);
            SendReply(player, Msg(next ? "Enabled" : "Disabled", player.UserIDString));
        }

        private object CanMoveItem(Item item, PlayerInventory playerInventory, ItemContainerId itemContainerId, int num, int num2, ItemMoveModifier itemMoveModifier)
        {
            if (item == null || item.info == null || playerInventory == null) return null;

            BasePlayer player = playerInventory.baseEntity;
            if (player == null || player.IsNpc) return null;
            if (!IsSplittable(item.info.shortname)) return null;
            if (!IsEnabled(player.userID.Get())) return null;

            ItemContainer target = playerInventory.FindContainer(itemContainerId);
            if (target == null) return null;

            BaseOven oven = target.entityOwner as BaseOven;
            if (oven == null || oven.inventory != target) return null;

            Split(item, target);
            return null;
        }

        private void Split(Item source, ItemContainer target)
        {
            List<int> freeSlots = new List<int>();
            for (int i = 0; i < target.capacity; i++)
            {
                if (target.GetSlot(i) == null) freeSlots.Add(i);
            }

            if (freeSlots.Count == 0) return;

            int perSlot = source.amount / (freeSlots.Count + 1);
            if (perSlot < 1) return;
            if (perSlot > config.MaxStackSize) perSlot = config.MaxStackSize;

            foreach (int slot in freeSlots)
            {
                if (source.amount <= perSlot) break;

                Item created = ItemManager.CreateByName(source.info.shortname, perSlot, source.skin);
                if (created == null) continue;
                created.condition = source.condition;
                created.maxCondition = source.maxCondition;

                if (!created.MoveToContainer(target, slot))
                {
                    created.Remove();
                    continue;
                }

                source.amount -= perSlot;
            }

            source.MarkDirty();
        }

        private bool IsSplittable(string shortname)
        {
            if (string.IsNullOrEmpty(shortname)) return false;
            foreach (string entry in config.SplittableShortnames)
            {
                if (string.Equals(entry, shortname, StringComparison.OrdinalIgnoreCase)) return true;
            }
            return false;
        }

        private bool IsEnabled(ulong userId)
        {
            bool state;
            if (!prefs.TryGetValue(userId, out state)) return true;
            return state;
        }

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