How to make a Rust remove tool plugin (hammer refunds)

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

namespace Oxide.Plugins
{
    [Info("Remove Tool", "RustPluginGenerator", "1.0.0")]
    [Description("Gives players a timed remove mode that deletes owned building blocks and deployables with a hammer and refunds materials.")]
    public class RemoveTool : RustPlugin
    {
        private const string PermUse = "removetool.use";
        private const string PermAdmin = "removetool.admin";

        private PluginConfig config;
        private readonly Dictionary<ulong, float> removeMode = new Dictionary<ulong, float>();

        private class PluginConfig
        {
            [JsonProperty("Mode duration (seconds)")]
            public float ModeDuration = 30f;

            [JsonProperty("Refund percent (0-100)")]
            public float RefundPercent = 50f;

            [JsonProperty("Allow removing twig blocks")]
            public bool AllowTwigs = true;

            [JsonProperty("Allow removing other players' deployables when authed")]
            public bool AllowForeignDeployables = false;

            [JsonProperty("Deployable refunds (short prefab name -> item shortname x amount)")]
            public Dictionary<string, string> DeployableRefunds = new Dictionary<string, string>
            {
                ["box.wooden.large"] = "wood:50",
                ["box.wooden"] = "wood:25",
                ["door.hinged.wood"] = "wood:40",
                ["door.hinged.metal"] = "metal.fragments:25",
                ["wall.frame.shopfront"] = "metal.fragments:20",
                ["furnace"] = "stones:40",
                ["bbq"] = "wood:30",
                ["sleepingbag"] = "cloth:10",
                ["barricade.wood"] = "wood:20"
            };
        }

        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>
            {
                ["Enabled"] = "Remove mode enabled for {0} seconds. Hit your own structures with a hammer.",
                ["Disabled"] = "Remove mode disabled.",
                ["Expired"] = "Remove mode expired.",
                ["NotYours"] = "You can only remove structures you own or are authorised on.",
                ["Blocked"] = "You cannot remove structures while building blocked.",
                ["GradeBlocked"] = "This structure grade cannot be removed.",
                ["Refunded"] = "Removed and refunded {0}x {1}.",
                ["NoRefund"] = "Removed {0}.",
                ["NotRemovable"] = "That cannot be removed with the hammer."
            }, 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(PermAdmin, this);
        }

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

            if (removeMode.ContainsKey(player.userID.Get()))
            {
                removeMode.Remove(player.userID.Get());
                player.ChatMessage(Msg("Disabled", player.UserIDString));
                return;
            }

            removeMode[player.userID.Get()] = Time.realtimeSinceStartup + config.ModeDuration;
            player.ChatMessage(Msg("Enabled", player.UserIDString, config.ModeDuration));
        }

        private object OnHammerHit(BasePlayer ownerPlayer, HitInfo info)
        {
            if (ownerPlayer == null || info == null) return null;
            if (!removeMode.TryGetValue(ownerPlayer.userID.Get(), out var expires)) return null;

            if (Time.realtimeSinceStartup > expires)
            {
                removeMode.Remove(ownerPlayer.userID.Get());
                ownerPlayer.ChatMessage(Msg("Expired", ownerPlayer.UserIDString));
                return null;
            }

            var entity = info.HitEntity;
            if (entity == null) return null;

            var block = entity as BuildingBlock;
            if (block != null)
            {
                if (!config.AllowTwigs && block.grade == BuildingGrade.Enum.Twigs)
                {
                    ownerPlayer.ChatMessage(Msg("GradeBlocked", ownerPlayer.UserIDString));
                    return true;
                }
                if (ownerPlayer.IsBuildingBlocked())
                {
                    ownerPlayer.ChatMessage(Msg("Blocked", ownerPlayer.UserIDString));
                    return true;
                }
                if (!IsBlockOwner(block, ownerPlayer))
                {
                    ownerPlayer.ChatMessage(Msg("NotYours", ownerPlayer.UserIDString));
                    return true;
                }

                RefundBlock(block, ownerPlayer);
                block.Kill();
                return true;
            }

            var deployable = entity as BaseCombatEntity;
            if (deployable == null) return null;

            var shortName = deployable.ShortPrefabName;
            if (shortName == null || !config.DeployableRefunds.ContainsKey(shortName)) return null;

            if (ownerPlayer.IsBuildingBlocked())
            {
                ownerPlayer.ChatMessage(Msg("Blocked", ownerPlayer.UserIDString));
                return true;
            }

            if (deployable.OwnerID != ownerPlayer.userID.Get())
            {
                if (!config.AllowForeignDeployables || !IsPrivilegeAuthed(entity, ownerPlayer))
                {
                    ownerPlayer.ChatMessage(Msg("NotYours", ownerPlayer.UserIDString));
                    return true;
                }
            }

            RefundDeployable(shortName, ownerPlayer);
            deployable.Kill();
            return true;
        }

        private bool IsBlockOwner(BuildingBlock block, BasePlayer player)
        {
            if (block.OwnerID == player.userID.Get()) return true;
            var privilege = block.GetBuildingPrivilege();
            return privilege != null && privilege.IsAuthed(player);
        }

        private bool IsPrivilegeAuthed(BaseEntity entity, BasePlayer player)
        {
            var privilege = entity.GetBuildingPrivilege();
            return privilege != null && privilege.IsAuthed(player);
        }

        private void RefundBlock(BuildingBlock block, BasePlayer player)
        {
            var grade = block.blockDefinition?.GetGrade(block.grade, block.skinID);
            if (grade == null) return;

            var percent = permission.UserHasPermission(player.UserIDString, PermAdmin) ? 100f : config.RefundPercent;
            RefundItems(grade.CostToBuild(), percent, player);
        }

        private void RefundItems(List<ItemAmount> costs, float percent, BasePlayer player)
        {
            if (costs == null) return;
            foreach (var amount in costs)
            {
                if (amount == null || amount.itemDef == null) continue;
                var count = Mathf.RoundToInt(amount.amount * percent / 100f);
                if (count <= 0) continue;
                var item = ItemManager.CreateByItemID(amount.itemDef.itemid, count);
                if (item == null) continue;
                player.GiveItem(item);
                player.ChatMessage(Msg("Refunded", player.UserIDString, count, amount.itemDef.displayName.english));
            }
        }

        private void RefundDeployable(string shortName, BasePlayer player)
        {
            if (!config.DeployableRefunds.TryGetValue(shortName, out var raw) || string.IsNullOrEmpty(raw)) return;
            var parts = raw.Split(':');
            if (parts.Length != 2) return;
            if (!int.TryParse(parts[1], out var baseAmount)) return;

            var percent = permission.UserHasPermission(player.UserIDString, PermAdmin) ? 100f : config.RefundPercent;
            var count = Mathf.RoundToInt(baseAmount * percent / 100f);
            if (count <= 0)
            {
                player.ChatMessage(Msg("NoRefund", player.UserIDString, shortName));
                return;
            }

            var item = ItemManager.CreateByName(parts[0], count);
            if (item == null) return;
            player.GiveItem(item);
            player.ChatMessage(Msg("Refunded", player.UserIDString, count, item.info.displayName.english));
        }

        private void Unload()
        {
            removeMode.Clear();
        }
    }
}