How to make a Rust auto upgrade on build plugin (grade per player)

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

namespace Oxide.Plugins
{
    [Info("Auto Upgrade", "RustPluginGenerator", "1.0.0")]
    [Description("Upgrades newly placed building blocks to each player's chosen grade using inventory resources")]
    public class AutoUpgrade : RustPlugin
    {
        private const string PermUse = "autoupgrade.use";
        private const string DataFile = "AutoUpgrade";

        private PluginConfig config;
        private StoredData data;

        private class PluginConfig
        {
            [JsonProperty("Use upgrade cost")]
            public bool UseUpgradeCost { get; set; } = true;

            [JsonProperty("Show upgrade effect")]
            public bool ShowUpgradeEffect { get; set; } = true;
        }

        private class StoredData
        {
            public Dictionary<ulong, int> Grades = new Dictionary<ulong, int>();
        }

        // Per-step cost of upgrading FROM the given grade to the next one.
        private static readonly Dictionary<BuildingGrade.Enum, Dictionary<string, int>> StepCost = new Dictionary<BuildingGrade.Enum, Dictionary<string, int>>
        {
            [BuildingGrade.Enum.Twigs] = new Dictionary<string, int> { ["wood"] = 10 },
            [BuildingGrade.Enum.Wood] = new Dictionary<string, int> { ["wood"] = 50 },
            [BuildingGrade.Enum.Stone] = new Dictionary<string, int> { ["stones"] = 100 },
            [BuildingGrade.Enum.Metal] = new Dictionary<string, int> { ["metal.fragments"] = 100 },
            [BuildingGrade.Enum.TopTier] = new Dictionary<string, int> { ["metal.refined"] = 25 }
        };

        private static readonly BuildingGrade.Enum[] Ladder =
        {
            BuildingGrade.Enum.Twigs,
            BuildingGrade.Enum.Wood,
            BuildingGrade.Enum.Stone,
            BuildingGrade.Enum.Metal,
            BuildingGrade.Enum.TopTier
        };

        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 auto upgrade.",
                ["Current"] = "Your auto upgrade grade: <color=#ce422b>{0}</color>. Use /up 1-4 to change it, /up off to disable.",
                ["NotSet"] = "Auto upgrade is disabled. Use /up 1-4 to pick a grade.",
                ["Set"] = "Auto upgrade grade set to <color=#ce422b>{0}</color>.",
                ["Disabled"] = "Auto upgrade disabled.",
                ["Usage"] = "Usage: /up <1-4> or /up off. 1 = wood, 2 = stone, 3 = metal, 4 = HQM.",
                ["NotEnough"] = "Not enough resources to auto upgrade this block to {0}.",
                ["Upgraded"] = "Block upgraded to <color=#ce422b>{0}</color>."
            }, 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 Loaded()
        {
            data = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(DataFile) ?? new StoredData();
        }

        private void OnServerInitialized()
        {
            if (data.Grades == null) data.Grades = new Dictionary<ulong, int>();
        }

        private void Unload()
        {
            SaveData();
        }

        private void SaveData() => Interface.Oxide.DataFileSystem.WriteObject(DataFile, data);

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

            if (args == null || args.Length == 0)
            {
                int current;
                if (data.Grades.TryGetValue(player.userID.Get(), out current))
                {
                    player.ChatMessage(Msg("Current", player.UserIDString, GradeName(current)));
                }
                else
                {
                    player.ChatMessage(Msg("NotSet", player.UserIDString));
                }
                return;
            }

            string arg = args[0].ToLowerInvariant();
            if (arg == "off")
            {
                data.Grades.Remove(player.userID.Get());
                SaveData();
                player.ChatMessage(Msg("Disabled", player.UserIDString));
                return;
            }

            int choice;
            if (!int.TryParse(arg, out choice) || choice < 1 || choice > 4)
            {
                player.ChatMessage(Msg("Usage", player.UserIDString));
                return;
            }

            data.Grades[player.userID.Get()] = choice;
            SaveData();
            player.ChatMessage(Msg("Set", player.UserIDString, GradeName(choice)));
        }

        private object OnEntityBuilt(Planner planner, GameObject gameObject)
        {
            if (planner == null || gameObject == null) return null;

            BasePlayer player = planner.GetOwnerPlayer();
            if (player == null || player.IsNpc) return null;
            if (!permission.UserHasPermission(player.UserIDString, PermUse)) return null;

            int choice;
            if (!data.Grades.TryGetValue(player.userID.Get(), out choice)) return null;

            BuildingBlock block = gameObject.ToBaseEntity() as BuildingBlock;
            if (block == null) return null;

            BuildingGrade.Enum target = ChoiceToGrade(choice);
            if (target == BuildingGrade.Enum.None || target == block.grade) return null;

            string targetName = GradeName(choice);

            if (config.UseUpgradeCost)
            {
                Dictionary<string, int> cost = GetUpgradeCost(block.grade, target);
                if (cost == null || !TakeResources(player, cost))
                {
                    player.ChatMessage(Msg("NotEnough", player.UserIDString, targetName));
                    return null;
                }
            }

            block.SetGrade(target);
            block.SetHealthToMax();
            block.SendNetworkUpdate();

            if (config.ShowUpgradeEffect)
            {
                Effect.server.Run("assets/bundled/prefabs/fx/build/promote_metal.prefab", block.transform.position);
            }

            return null;
        }

        private Dictionary<string, int> GetUpgradeCost(BuildingGrade.Enum from, BuildingGrade.Enum to)
        {
            int start = Array.IndexOf(Ladder, from);
            int end = Array.IndexOf(Ladder, to);
            if (start < 0 || end < 0 || end <= start) return null;

            Dictionary<string, int> total = new Dictionary<string, int>();
            for (int i = start; i < end; i++)
            {
                Dictionary<string, int> step;
                if (!StepCost.TryGetValue(Ladder[i], out step)) continue;
                foreach (KeyValuePair<string, int> kv in step)
                {
                    int existing;
                    total.TryGetValue(kv.Key, out existing);
                    total[kv.Key] = existing + kv.Value;
                }
            }
            return total;
        }

        private bool TakeResources(BasePlayer player, Dictionary<string, int> cost)
        {
            foreach (KeyValuePair<string, int> kv in cost)
            {
                ItemDefinition def = ItemManager.FindItemDefinition(kv.Key);
                if (def == null) return false;
                if (player.inventory.GetAmount(def.itemid) < kv.Value) return false;
            }

            foreach (KeyValuePair<string, int> kv in cost)
            {
                ItemDefinition def = ItemManager.FindItemDefinition(kv.Key);
                player.inventory.Take(null, def.itemid, kv.Value);
            }
            return true;
        }

        private static BuildingGrade.Enum ChoiceToGrade(int choice)
        {
            switch (choice)
            {
                case 1: return BuildingGrade.Enum.Wood;
                case 2: return BuildingGrade.Enum.Stone;
                case 3: return BuildingGrade.Enum.Metal;
                case 4: return BuildingGrade.Enum.TopTier;
                default: return BuildingGrade.Enum.None;
            }
        }

        private static string GradeName(int choice)
        {
            switch (choice)
            {
                case 1: return "Wood";
                case 2: return "Stone";
                case 3: return "Metal";
                case 4: return "HQM";
                default: return "None";
            }
        }
    }
}