How to make a Rust raid alert plugin (chat warnings for base owners)

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

namespace Oxide.Plugins
{
    [Info("Raid Alerts", "RustPluginGenerator", "1.0.0")]
    [Description("Warns online owners and tool cupboard authed players in chat when explosives damage their building.")]
    public class RaidAlerts : RustPlugin
    {
        private const string PermUse = "raidalerts.use";

        private PluginConfig config;
        private readonly Dictionary<ulong, float> lastAlert = new Dictionary<ulong, float>();
        private readonly HashSet<ulong> optedOut = new HashSet<ulong>();
        private Timer pruneTimer;

        private class PluginConfig
        {
            [JsonProperty("Alert Throttle Seconds")]
            public float AlertThrottleSeconds { get; set; } = 60f;

            [JsonProperty("Alert On Decay Damage")]
            public bool AlertOnDecayDamage { get; set; } = false;

            [JsonProperty("Prune Interval Seconds")]
            public float PruneIntervalSeconds { get; set; } = 300f;
        }

        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>
            {
                ["RaidAlert"] = "<color=#ff6b6b>[Raid]</color> {0} is damaging your base at grid {1}",
                ["RaidAlertUnknown"] = "<color=#ff6b6b>[Raid]</color> Your base is under attack at grid {1}",
                ["ToggleOn"] = "Raid alerts are now <color=#7ee787>enabled</color>.",
                ["ToggleOff"] = "Raid alerts are now <color=#ffa657>disabled</color>.",
                ["NoPermission"] = "You do not have permission to use this command."
            }, this);
        }

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

        private void Init()
        {
            permission.RegisterPermission(PermUse, this);
        }

        private void OnServerInitialized()
        {
            pruneTimer = timer.Every(Mathf.Max(30f, config.PruneIntervalSeconds), PruneThrottle);
        }

        private void Unload()
        {
            pruneTimer?.Destroy();
        }

        private void PruneThrottle()
        {
            if (lastAlert.Count == 0) return;
            float now = UnityEngine.Time.realtimeSinceStartup;
            float cutoff = Mathf.Max(config.AlertThrottleSeconds * 5f, 600f);
            var stale = new List<ulong>();
            foreach (var entry in lastAlert)
            {
                if (now - entry.Value > cutoff) stale.Add(entry.Key);
            }
            foreach (var id in stale) lastAlert.Remove(id);
        }

        private object OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitInfo)
        {
            if (hitInfo == null || entity == null) return null;
            var block = entity as BuildingBlock;
            if (block == null) return null;
            if (hitInfo.damageTypes == null) return null;

            var major = hitInfo.damageTypes.GetMajorityDamageType();
            if (major != Rust.DamageType.Explosion)
            {
                if (!config.AlertOnDecayDamage || major != Rust.DamageType.Decay) return null;
            }

            ulong buildingId = block.buildingID;
            if (buildingId == 0 && block.OwnerID != 0) buildingId = block.OwnerID;
            if (buildingId == 0) return null;

            float now = UnityEngine.Time.realtimeSinceStartup;
            float last;
            if (lastAlert.TryGetValue(buildingId, out last) && now - last < config.AlertThrottleSeconds) return null;

            BasePlayer attacker = hitInfo.InitiatorPlayer;
            ulong attackerId = attacker != null ? attacker.userID.Get() : (hitInfo.Initiator != null ? hitInfo.Initiator.OwnerID : 0);
            string attackerName = attacker != null ? attacker.displayName : null;
            if (attackerId == 0) return null;

            var privilege = block.GetBuildingPrivilege();
            var audience = new HashSet<ulong>();
            ulong ownerId = block.OwnerID;
            if (privilege != null)
            {
                if (privilege.OwnerID != 0) ownerId = privilege.OwnerID;
                foreach (var authorized in privilege.authorizedPlayers)
                {
                    ulong authorizedId = authorized;
                    if (authorizedId != 0) audience.Add(authorizedId);
                }
            }
            if (ownerId != 0) audience.Add(ownerId);
            if (audience.Count == 0) return null;

            string grid = PositionToGrid(hitInfo.HitPositionWorld);
            ulong attackerTeam = attacker != null ? attacker.currentTeam : 0;
            bool sent = false;

            foreach (var userId in audience)
            {
                if (userId == attackerId) continue;
                if (optedOut.Contains(userId)) continue;
                var target = BasePlayer.FindByID(userId);
                if (target == null || !target.IsConnected) continue;
                if (attackerTeam != 0 && target.currentTeam == attackerTeam) continue;

                if (attackerName != null)
                    target.ChatMessage(Msg("RaidAlert", target.UserIDString, attackerName, grid));
                else
                    target.ChatMessage(Msg("RaidAlertUnknown", target.UserIDString, grid));
                sent = true;
            }

            if (sent) lastAlert[buildingId] = now;
            return null;
        }

        private static string PositionToGrid(Vector3 position)
        {
            if (World.Size <= 0f) return "?";
            float cellSize = World.Size / 146.3f;
            int x = Mathf.FloorToInt((position.x + World.Size * 0.5f) / cellSize);
            int z = Mathf.FloorToInt((position.z + World.Size * 0.5f) / cellSize);
            x = Mathf.Clamp(x, 0, 145);
            z = Mathf.Clamp(z, 0, 145);
            return ((char)('A' + x)).ToString() + (146 - z).ToString();
        }

        [ChatCommand("raidalerts")]
        private void CmdRaidAlerts(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }
            ulong id = player.userID.Get();
            if (!optedOut.Remove(id))
            {
                optedOut.Add(id);
                player.ChatMessage(Msg("ToggleOff", player.UserIDString));
            }
            else
            {
                player.ChatMessage(Msg("ToggleOn", player.UserIDString));
            }
        }
    }
}