OnPayForUpgrade

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

namespace Oxide.Plugins
{
    [Info("Upgrade Tax", "RustPluginGenerator", "1.0.0")]
    [Description("Charges an economy fee for building upgrades and blocks grades the player is not allowed to use.")]
    public class UpgradeTax : RustPlugin
    {
        private const string PermUse = "upgradetax.use";
        private const string PermMetal = "upgradetax.metal";
        private const string PermTopTier = "upgradetax.toptier";

        [PluginReference] private Plugin Economics;

        private class PluginConfig
        {
            [JsonProperty("Enable economy fee")]
            public bool EnableFee = true;

            [JsonProperty("Fee for Wood")]
            public double FeeWood = 5.0;

            [JsonProperty("Fee for Stone")]
            public double FeeStone = 10.0;

            [JsonProperty("Fee for Metal")]
            public double FeeMetal = 25.0;

            [JsonProperty("Fee for TopTier")]
            public double FeeTopTier = 50.0;

            [JsonProperty("Require permission for Metal")]
            public bool RequireMetalPerm = false;

            [JsonProperty("Require permission for TopTier")]
            public bool RequireTopTierPerm = false;
        }

        private PluginConfig config;

        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>
            {
                ["NoPermissionGrade"] = "You are not allowed to upgrade to this grade.",
                ["CannotAfford"] = "You cannot afford the upgrade fee of {0}.",
                ["NoEconomy"] = "Upgrade fees are not available right now."
            }, 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);
            permission.RegisterPermission(PermMetal, this);
            permission.RegisterPermission(PermTopTier, this);
        }

        private object OnPayForUpgrade(BasePlayer player, BuildingBlock buildingBlock, ConstructionGrade g)
        {
            if (player == null || buildingBlock == null || g == null || g.gradeBase == null) return null;
            if (player.IsAdmin) return null;
            if (!permission.UserHasPermission(player.UserIDString, PermUse)) return null;

            BuildingGrade.Enum grade = g.gradeBase.type;

            if (grade == BuildingGrade.Enum.Metal && config.RequireMetalPerm && !permission.UserHasPermission(player.UserIDString, PermMetal))
            {
                player.ChatMessage(Msg("NoPermissionGrade", player.UserIDString));
                return false;
            }

            if (grade == BuildingGrade.Enum.TopTier && config.RequireTopTierPerm && !permission.UserHasPermission(player.UserIDString, PermTopTier))
            {
                player.ChatMessage(Msg("NoPermissionGrade", player.UserIDString));
                return false;
            }

            if (!config.EnableFee) return null;

            double fee = FeeForGrade(grade);
            if (fee <= 0.0) return null;

            if (Economics == null)
            {
                player.ChatMessage(Msg("NoEconomy", player.UserIDString));
                return null;
            }

            double balance = Economics.Call<double>("Balance", player.UserIDString);
            if (balance < fee)
            {
                player.ChatMessage(Msg("CannotAfford", player.UserIDString, fee));
                return false;
            }

            Economics.Call("Withdraw", player.UserIDString, fee);
            return null;
        }

        private double FeeForGrade(BuildingGrade.Enum grade)
        {
            switch (grade)
            {
                case BuildingGrade.Enum.Wood: return config.FeeWood;
                case BuildingGrade.Enum.Stone: return config.FeeStone;
                case BuildingGrade.Enum.Metal: return config.FeeMetal;
                case BuildingGrade.Enum.TopTier: return config.FeeTopTier;
                default: return 0.0;
            }
        }
    }
}