How to make a Rust entity cleanup plugin (tool cupboard aware)

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

namespace Oxide.Plugins
{
    [Info("Entity Cleanup", "RustPluginGenerator", "1.0.0")]
    [Description("Removes configured entity types that are not protected by a tool cupboard.")]
    public class EntityCleanup : RustPlugin
    {
        private const string PermUse = "entitycleanup.use";

        private PluginConfig config;
        private Timer cleanupTimer;
        private HashSet<string> targetNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        private bool running;

        private class PluginConfig
        {
            [JsonProperty("Auto Cleanup Enabled")]
            public bool AutoCleanupEnabled = false;

            [JsonProperty("Auto Cleanup Interval (Seconds)")]
            public float AutoCleanupInterval = 3600f;

            [JsonProperty("Minimum Entities To Start")]
            public int MinimumEntitiesToStart = 500;

            [JsonProperty("Warn Before Run")]
            public bool WarnBeforeRun = true;

            [JsonProperty("Warn Seconds Before")]
            public float WarnSecondsBefore = 30f;

            [JsonProperty("Broadcast to Players")]
            public bool BroadcastToPlayers = true;

            [JsonProperty("Protect Building Privilege")]
            public bool ProtectBuildingPrivilege = true;

            [JsonProperty("Require Authorization")]
            public bool RequireAuthorization = false;

            [JsonProperty("Skip Entities Owned By Players")]
            public bool SkipOwnedEntities = false;

            [JsonProperty("Entity Short Prefab Names")]
            public List<string> EntityShortPrefabNames = new List<string>
            {
                "sleepingbag",
                "campfire",
                "stash.small",
                "box.wooden",
                "lantern.deployed"
            };
        }

        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>
            {
                ["Removed"] = "Cleanup removed {0} entities ({1} checked, {2} protected). Took {3} ms.",
                ["Skipped"] = "Cleanup skipped: only {0} entities online, minimum is {1}.",
                ["Warn"] = "Entity cleanup starts in {0} seconds.",
                ["Running"] = "A cleanup pass is already running.",
                ["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()
        {
            RebuildNameSet();

            if (!config.AutoCleanupEnabled) return;

            float interval = Mathf.Max(60f, config.AutoCleanupInterval);
            cleanupTimer = timer.Repeat(interval, 0, () =>
            {
                if (config.WarnBeforeRun && config.BroadcastToPlayers)
                    Server.Broadcast(Msg("Warn", null, Mathf.RoundToInt(config.WarnSecondsBefore)));

                if (config.WarnBeforeRun)
                    timer.Once(Mathf.Max(1f, config.WarnSecondsBefore), () => RunCleanup(null));
                else
                    RunCleanup(null);
            });
        }

        private void Unload()
        {
            cleanupTimer?.Destroy();
            cleanupTimer = null;
        }

        [ConsoleCommand("entitycleanup.run")]
        private void CmdRun(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player != null && !permission.UserHasPermission(player.UserIDString, PermUse))
            {
                arg.ReplyWith(Msg("NoPermission", player.UserIDString));
                return;
            }

            RunCleanup(arg);
        }

        private void RunCleanup(ConsoleSystem.Arg arg)
        {
            if (running)
            {
                arg?.ReplyWith(Msg("Running"));
                return;
            }

            int total = 0;
            foreach (var entity in BaseNetworkable.serverEntities)
            {
                if (entity != null) total++;
            }

            if (total < config.MinimumEntitiesToStart)
            {
                string skipped = Msg("Skipped", null, total, config.MinimumEntitiesToStart);
                arg?.ReplyWith(skipped);
                if (config.BroadcastToPlayers) Server.Broadcast(skipped);
                return;
            }

            RebuildNameSet();
            running = true;
            float started = UnityEngine.Time.realtimeSinceStartup;

            int checkedCount = 0;
            int removed = 0;
            int protectedCount = 0;

            foreach (var entry in BaseNetworkable.serverEntities)
            {
                var entity = entry as BaseNetworkable;
                if (entity == null || entity.IsDestroyed) continue;
                if (string.IsNullOrEmpty(entity.ShortPrefabName)) continue;
                if (!targetNames.Contains(entity.ShortPrefabName)) continue;

                checkedCount++;

                var owned = entity as BaseEntity;
                if (config.SkipOwnedEntities && owned != null && owned.OwnerID != 0) continue;

                if (config.ProtectBuildingPrivilege && IsProtected(entity))
                {
                    protectedCount++;
                    continue;
                }

                entity.Kill();
                removed++;
            }

            running = false;
            int elapsed = Mathf.RoundToInt((UnityEngine.Time.realtimeSinceStartup - started) * 1000f);

            string summary = Msg("Removed", null, removed, checkedCount, protectedCount, elapsed);
            Puts(summary);
            arg?.ReplyWith(summary);
            if (config.BroadcastToPlayers && arg == null) Server.Broadcast(summary);
        }

        private bool IsProtected(BaseNetworkable entity)
        {
            var entityBase = entity as BaseEntity;
            if (entityBase == null) return false;

            var cupboard = entityBase.GetBuildingPrivilege();
            if (cupboard == null) return false;
            if (!config.RequireAuthorization) return true;

            return cupboard.OwnerID == entityBase.OwnerID || cupboard.IsAuthed(entityBase as BasePlayer);
        }

        private void RebuildNameSet()
        {
            targetNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            if (config.EntityShortPrefabNames == null) return;

            foreach (var name in config.EntityShortPrefabNames)
            {
                if (!string.IsNullOrEmpty(name)) targetNames.Add(name.Trim());
            }
        }
    }
}