How to make a Rust offline raid protection plugin (cupboard based)

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

namespace Oxide.Plugins
{
    [Info("Offline Raid Protection", "RustPluginGenerator", "1.0.0")]
    [Description("Scales damage to buildings and deployables when every cupboard-authorized player is offline.")]
    public class OfflineRaidProtection : RustPlugin
    {
        private const string PermUse = "offlineraidprotection.use";

        private PluginConfig config;
        private Timer sweepTimer;

        // cupboard net id -> authorized user ids
        private readonly Dictionary<ulong, HashSet<ulong>> authByCupboard = new Dictionary<ulong, HashSet<ulong>>();
        // cupboard net id -> first moment the last authorized player was seen offline
        private readonly Dictionary<ulong, DateTime> offlineSince = new Dictionary<ulong, DateTime>();

        private static readonly HashSet<string> DeployablePrefabs = new HashSet<string>
        {
            "door.hinged.wood", "door.hinged.metal", "door.hinged.toptier", "door.hinged.industrial",
            "door.double.hinged.wood", "door.double.hinged.metal", "door.double.hinged.toptier",
            "door.hinged.wood.wardrobe", "door.reinforced.wood", "wall.frame.garagedoor",
            "box.wooden.large", "box.wooden", "fridge", "cupboard.tool", "lock.code", "lock.key",
            "autoturret", "woodbox_deployed", "small_stash", "vendingmachine", "barricade.*",
            "furnace", "furnace.large", "BBQ.deployed", "campfire", "waterbarrel", "waterpurifier.deployed",
            "sleepingbag", "bed", "shelves", "locker.deployed", "mailbox.deployed", "sign.post", "sign.small"
        };

        private class PluginConfig
        {
            [JsonProperty("Delay Minutes")]
            public int DelayMinutes { get; set; } = 15;

            [JsonProperty("Damage Scale")]
            public float DamageScale { get; set; } = 0.1f;

            [JsonProperty("Protect Deployables")]
            public bool ProtectDeployables { get; set; } = true;
        }

        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>
            {
                ["Status"] = "Offline raid protection: {0} buildings protected. Delay {1} min, damage scale {2}.",
                ["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);
        }

        private void OnServerInitialized()
        {
            sweepTimer = timer.Every(60f, Sweep);
        }

        private void Unload()
        {
            sweepTimer?.Destroy();
            authByCupboard.Clear();
            offlineSince.Clear();
        }

        private void OnCupboardAuthorize(BuildingPrivlidge cupboard, BasePlayer player)
        {
            if (cupboard == null || player == null) return;
            var key = cupboard.net.ID.Value;
            HashSet<ulong> set;
            if (!authByCupboard.TryGetValue(key, out set))
            {
                set = new HashSet<ulong>();
                authByCupboard[key] = set;
            }
            set.Add(player.userID.Get());
            offlineSince.Remove(key);
        }

        private void OnCupboardDeauthorize(BuildingPrivlidge cupboard, BasePlayer player)
        {
            if (cupboard == null || player == null) return;
            HashSet<ulong> set;
            if (!authByCupboard.TryGetValue(cupboard.net.ID.Value, out set)) return;
            set.Remove(player.userID.Get());
            if (set.Count == 0)
            {
                authByCupboard.Remove(cupboard.net.ID.Value);
                offlineSince.Remove(cupboard.net.ID.Value);
            }
        }

        private void OnPlayerDisconnected(BasePlayer player, string reason)
        {
            if (player == null || player.IsNpc) return;
            var userId = player.userID.Get();
            foreach (var pair in authByCupboard)
            {
                if (!pair.Value.Contains(userId)) continue;
                if (AnyAuthorizedOnline(pair.Value))
                {
                    offlineSince.Remove(pair.Key);
                }
                else if (!offlineSince.ContainsKey(pair.Key))
                {
                    offlineSince[pair.Key] = DateTime.UtcNow;
                }
            }
        }

        private bool AnyAuthorizedOnline(HashSet<ulong> ids)
        {
            foreach (var id in ids)
            {
                var p = BasePlayer.FindByID(id);
                if (p != null && p.IsConnected && !p.IsSleeping())
                    return true;
            }
            return false;
        }

        private void Sweep()
        {
            var now = DateTime.UtcNow;
            var removed = new List<ulong>();
            foreach (var pair in authByCupboard)
            {
                if (AnyAuthorizedOnline(pair.Value))
                {
                    offlineSince.Remove(pair.Key);
                    continue;
                }
                if (!offlineSince.ContainsKey(pair.Key))
                    offlineSince[pair.Key] = now;
            }
            foreach (var key in offlineSince.Keys)
            {
                if (!authByCupboard.ContainsKey(key))
                    removed.Add(key);
            }
            for (var i = 0; i < removed.Count; i++)
                offlineSince.Remove(removed[i]);
        }

        private bool IsProtected(BuildingPrivlidge cupboard)
        {
            if (cupboard == null) return false;
            DateTime since;
            if (!offlineSince.TryGetValue(cupboard.net.ID.Value, out since)) return false;
            return (DateTime.UtcNow - since).TotalMinutes >= config.DelayMinutes;
        }

        private bool IsDeployable(string prefabName)
        {
            if (string.IsNullOrEmpty(prefabName)) return false;
            foreach (var key in DeployablePrefabs)
            {
                if (key.EndsWith("*") ? prefabName.StartsWith(key.Substring(0, key.Length - 1)) : prefabName.Equals(key))
                    return true;
            }
            return false;
        }

        private object OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitInfo)
        {
            if (entity == null || hitInfo == null || hitInfo.damageTypes == null) return null;
            if (hitInfo.Initiator == null) return null;

            var block = entity as BuildingBlock;
            if (block == null && !(config.ProtectDeployables && IsDeployable(entity.ShortPrefabName)))
                return null;

            var cupboard = entity.GetBuildingPrivilege();
            if (!IsProtected(cupboard)) return null;

            hitInfo.damageTypes.ScaleAll(config.DamageScale);
            return null;
        }

        private void OnEntityKill(BuildingPrivlidge cupboard)
        {
            if (cupboard == null) return;
            authByCupboard.Remove(cupboard.net.ID.Value);
            offlineSince.Remove(cupboard.net.ID.Value);
        }

        [ChatCommand("orp.status")]
        private void CmdStatus(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }
            player.ChatMessage(Msg("Status", player.UserIDString, offlineSince.Count, config.DelayMinutes, config.DamageScale));
        }
    }
}