How to make a Rust raid block plugin (block tpr/home after explosives)

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

namespace Oxide.Plugins
{
    [Info("Raid Block", "RustPluginGenerator", "1.0.0")]
    [Description("Temporarily blocks teleport and kit commands for raiders and the owners of a raided building.")]
    public class RaidBlock : RustPlugin
    {
        private const string PermUse = "raidblock.use";
        private const string PermAdmin = "raidblock.admin";
        private const string PermImmune = "raidblock.immune";

        private class PluginConfig
        {
            [JsonProperty("Block Seconds")]
            public float BlockSeconds = 120f;

            [JsonProperty("Blocked Commands")]
            public List<string> BlockedCommands = new List<string> { "home", "tpr", "kit" };

            [JsonProperty("Block Admins")]
            public bool BlockAdmins = false;
        }

        private PluginConfig config;
        private readonly Dictionary<string, float> blocks = new Dictionary<string, float>();

        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>
            {
                ["RaidBlocked"] = "<color=#ce422b>Raid Block:</color> /{0} is blocked for another {1} seconds.",
                ["NoBlock"] = "You are not raid blocked.",
                ["Status"] = "Raid block remaining: {0} seconds.",
                ["Cleared"] = "Raid block removed from {0}.",
                ["NotFound"] = "Player '{0}' was not found.",
                ["NoPermission"] = "You do not have permission to use this command."
            }, 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);
            permission.RegisterPermission(PermImmune, this);
        }

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

        private void OnServerInitialized()
        {
            bool changed = false;
            for (int i = 0; i < config.BlockedCommands.Count; i++)
            {
                string cmd = config.BlockedCommands[i]?.Trim().TrimStart('/');
                if (!string.IsNullOrEmpty(cmd) && cmd == config.BlockedCommands[i]) continue;
                config.BlockedCommands[i] = cmd;
                changed = true;
            }
            if (changed) SaveConfig();
        }

        private object OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitInfo)
        {
            if (entity == null || hitInfo == null || hitInfo.damageTypes == null) return null;
            if (hitInfo.damageTypes.GetMajorityDamageType() != Rust.DamageType.Explosion) return null;

            BasePlayer attacker = hitInfo.InitiatorPlayer;
            if (attacker != null && !attacker.IsNpc)
            {
                TryAddBlock(attacker);
            }

            BuildingBlock block = entity as BuildingBlock;
            if (block == null) return null;

            BuildingPrivlidge privilege = block.GetBuildingPrivilege();
            if (privilege == null) return null;

            foreach (ulong userId in privilege.authorizedPlayers)
            {
                BasePlayer owner = BasePlayer.FindByID(userId);
                if (owner == null || owner == attacker) continue;
                TryAddBlock(owner);
            }

            return null;
        }

        private void TryAddBlock(BasePlayer player)
        {
            if (player == null || player.IsNpc) return;
            if (!config.BlockAdmins && player.IsAdmin) return;
            if (permission.UserHasPermission(player.UserIDString, PermImmune)) return;

            if (blocks.ContainsKey(player.UserIDString)) return;
            AddBlock(player.UserIDString);
            player.ChatMessage(Msg("RaidBlocked", player.UserIDString, CurrentCommandName(), Mathf.CeilToInt(config.BlockSeconds)));
        }

        private string CurrentCommandName()
        {
            if (config.BlockedCommands.Count == 0) return "command";
            return config.BlockedCommands[0];
        }

        private void AddBlock(string userId)
        {
            if (string.IsNullOrEmpty(userId)) return;
            blocks[userId] = Time.realtimeSinceStartup;
        }

        private float Remaining(string userId)
        {
            float start;
            if (!blocks.TryGetValue(userId, out start)) return 0f;
            float left = config.BlockSeconds - (Time.realtimeSinceStartup - start);
            if (left <= 0f)
            {
                blocks.Remove(userId);
                return 0f;
            }
            return left;
        }

        private bool IsBlocked(string userId, string cmd)
        {
            if (string.IsNullOrEmpty(cmd)) return false;
            string clean = cmd.Trim().TrimStart('/').ToLowerInvariant();
            if (!config.BlockedCommands.Contains(clean)) return false;
            return Remaining(userId) > 0f;
        }

        private object OnPlayerCommand(BasePlayer player, string cmd, string[] args)
        {
            if (player == null || string.IsNullOrEmpty(cmd)) return null;
            if (permission.UserHasPermission(player.UserIDString, PermImmune)) return null;

            if (!IsBlocked(player.UserIDString, cmd)) return null;

            if (config.BlockAdmins || !player.IsAdmin)
            {
                SendBlockedMessage(player, cmd);
                return true;
            }

            return null;
        }

        private void SendBlockedMessage(BasePlayer player, string cmd)
        {
            string clean = cmd.Trim().TrimStart('/');
            int seconds = Mathf.CeilToInt(Remaining(player.UserIDString));
            player.ChatMessage(Msg("RaidBlocked", player.UserIDString, clean, seconds));
        }

        private void OnPlayerDisconnected(BasePlayer player, string reason)
        {
            if (player == null) return;
            blocks.Remove(player.UserIDString);
        }

        [ConsoleCommand("raidblock.status")]
        private void CmdStatus(ConsoleSystem.Arg arg)
        {
            BasePlayer player = arg.Player();
            if (player == null)
            {
                arg.ReplyWith("This command must be run in-game.");
                return;
            }
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                arg.ReplyWith(Msg("NoPermission", player.UserIDString));
                return;
            }

            float left = Remaining(player.UserIDString);
            if (left <= 0f)
            {
                arg.ReplyWith(Msg("NoBlock", player.UserIDString));
                return;
            }
            arg.ReplyWith(Msg("Status", player.UserIDString, Mathf.CeilToInt(left)));
        }

        [ConsoleCommand("raidblock.clear")]
        private void CmdClear(ConsoleSystem.Arg arg)
        {
            BasePlayer caller = arg.Player();
            if (caller != null && !permission.UserHasPermission(caller.UserIDString, PermAdmin))
            {
                arg.ReplyWith(Msg("NoPermission", caller.UserIDString));
                return;
            }

            string target = arg.GetString(0, string.Empty);
            if (string.IsNullOrEmpty(target))
            {
                arg.ReplyWith("Usage: raidblock.clear <player name or steamid>");
                return;
            }

            BasePlayer player = BasePlayer.FindAwakeOrSleeping(target);
            if (player == null)
            {
                arg.ReplyWith(Msg("NotFound", caller?.UserIDString, target));
                return;
            }

            blocks.Remove(player.UserIDString);
            arg.ReplyWith(Msg("Cleared", caller?.UserIDString, player.displayName));
        }
    }
}