How to make a Rust deployable limits plugin (per-prefab caps with VIP tiers)

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

namespace Oxide.Plugins
{
    [Info("Deployable Limits", "RustPluginGenerator", "1.0.0")]
    [Description("Caps how many of each deployable (by short prefab name) a player can own, with permission-based VIP tiers.")]
    public class DeployableLimits : RustPlugin
    {
        private const string PermUse = "deployablelimits.use";
        private const string PermAdmin = "deployablelimits.admin";

        private PluginConfig config;
        private readonly Dictionary<string, LimitRule> rulesByPrefab = new Dictionary<string, LimitRule>();
        private readonly Dictionary<ulong, Dictionary<string, int>> counts = new Dictionary<ulong, Dictionary<string, int>>();

        private class LimitRule
        {
            [JsonProperty("Prefab short name")]
            public string Prefab { get; set; } = "";

            [JsonProperty("Display name")]
            public string DisplayName { get; set; } = "";

            [JsonProperty("Default limit (0 = unlimited)")]
            public int DefaultLimit { get; set; } = 0;

            [JsonProperty("Permission tiers")]
            public List<LimitTier> Tiers { get; set; } = new List<LimitTier>();
        }

        private class LimitTier
        {
            [JsonProperty("Permission")]
            public string Permission { get; set; } = "";

            [JsonProperty("Limit")]
            public int Limit { get; set; } = 0;
        }

        private class PluginConfig
        {
            [JsonProperty("Block building when over any capped limit")]
            public bool BlockBuildWhenOverLimit { get; set; } = false;

            [JsonProperty("Rules")]
            public List<LimitRule> Rules { get; set; } = new List<LimitRule>
            {
                new LimitRule
                {
                    Prefab = "autoturret_deployed",
                    DisplayName = "Auto Turret",
                    DefaultLimit = 6,
                    Tiers = new List<LimitTier>
                    {
                        new LimitTier { Permission = "deployablelimits.vip", Limit = 12 }
                    }
                },
                new LimitRule
                {
                    Prefab = "box.wooden.large",
                    DisplayName = "Large Wooden Box",
                    DefaultLimit = 20,
                    Tiers = new List<LimitTier>
                    {
                        new LimitTier { Permission = "deployablelimits.vip", Limit = 40 }
                    }
                },
                new LimitRule
                {
                    Prefab = "cupboard.tool.deployed",
                    DisplayName = "Tool Cupboard",
                    DefaultLimit = 1,
                    Tiers = new List<LimitTier>()
                },
                new LimitRule
                {
                    Prefab = "sleepingbag_leather_deployed",
                    DisplayName = "Sleeping Bag",
                    DefaultLimit = 8,
                    Tiers = new List<LimitTier>()
                }
            };
        }

        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>
            {
                ["LimitReached"] = "You already have {0}/{1} of {2}.",
                ["LimitWarning"] = "You are over the limit for {0} ({1}/{2}). Nothing was destroyed.",
                ["NoRules"] = "No deployable limits are configured.",
                ["NoPermission"] = "You do not have permission to use this command.",
                ["Usage"] = "{0}: {1}/{2}",
                ["Reloaded"] = "Deployable limits reloaded and recounted.",
                ["UnknownPrefab"] = "No limit is configured for '{0}'."
            }, 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);
            foreach (var rule in config.Rules)
            {
                if (rule == null || rule.Tiers == null) continue;
                foreach (var tier in rule.Tiers)
                {
                    if (tier == null || string.IsNullOrEmpty(tier.Permission)) continue;
                    if (!permission.PermissionExists(tier.Permission, this))
                        permission.RegisterPermission(tier.Permission, this);
                }
            }
        }

        private void OnServerInitialized()
        {
            RebuildRules();
            RecountEntities();
        }

        private void RebuildRules()
        {
            rulesByPrefab.Clear();
            foreach (var rule in config.Rules)
            {
                if (rule == null || string.IsNullOrEmpty(rule.Prefab)) continue;
                rulesByPrefab[rule.Prefab] = rule;
            }
        }

        private void RecountEntities()
        {
            counts.Clear();
            foreach (var net in BaseNetworkable.serverEntities)
            {
                var entity = net as BaseEntity;
                if (entity == null) continue;
                var owner = entity.OwnerID;
                if (owner == 0UL) continue;
                var shortName = entity.ShortPrefabName;
                if (string.IsNullOrEmpty(shortName) || !rulesByPrefab.ContainsKey(shortName)) continue;
                Increment(owner, shortName);
            }
        }

        private void Increment(ulong owner, string prefab)
        {
            Dictionary<string, int> perPlayer;
            if (!counts.TryGetValue(owner, out perPlayer))
            {
                perPlayer = new Dictionary<string, int>();
                counts[owner] = perPlayer;
            }
            int current;
            perPlayer.TryGetValue(prefab, out current);
            perPlayer[prefab] = current + 1;
        }

        private void Decrement(ulong owner, string prefab)
        {
            Dictionary<string, int> perPlayer;
            if (!counts.TryGetValue(owner, out perPlayer)) return;
            int current;
            if (!perPlayer.TryGetValue(prefab, out current)) return;
            if (current <= 1) perPlayer.Remove(prefab);
            else perPlayer[prefab] = current - 1;
            if (perPlayer.Count == 0) counts.Remove(owner);
        }

        private int CountOf(ulong owner, string prefab)
        {
            Dictionary<string, int> perPlayer;
            if (!counts.TryGetValue(owner, out perPlayer)) return 0;
            int current;
            return perPlayer.TryGetValue(prefab, out current) ? current : 0;
        }

        private int LimitFor(LimitRule rule, BasePlayer player)
        {
            if (rule.Tiers != null)
            {
                foreach (var tier in rule.Tiers)
                {
                    if (tier == null || string.IsNullOrEmpty(tier.Permission)) continue;
                    if (permission.UserHasPermission(player.UserIDString, tier.Permission)) return tier.Limit;
                }
            }
            return rule.DefaultLimit;
        }

        private object OnEntityBuilt(Planner planner, GameObject gameObject)
        {
            if (planner == null || gameObject == null) return null;
            var entity = gameObject.ToBaseEntity();
            if (entity == null) return null;
            var shortName = entity.ShortPrefabName;
            if (string.IsNullOrEmpty(shortName)) return null;
            LimitRule rule;
            if (!rulesByPrefab.TryGetValue(shortName, out rule)) return null;
            if (rule.DefaultLimit <= 0 && (rule.Tiers == null || rule.Tiers.Count == 0)) return null;

            var player = planner.GetOwnerPlayer();
            if (player == null) return null;

            var limit = LimitFor(rule, player);
            var name = string.IsNullOrEmpty(rule.DisplayName) ? shortName : rule.DisplayName;
            var current = CountOf(player.userID.Get(), shortName);

            if (limit > 0 && current >= limit)
            {
                player.ChatMessage(Msg("LimitReached", player.UserIDString, current, limit, name));
                entity.Kill();
                return null;
            }

            Increment(player.userID.Get(), shortName);
            if (limit > 0 && current + 1 > limit)
                player.ChatMessage(Msg("LimitWarning", player.UserIDString, name, current + 1, limit));
            return null;
        }

        private object CanBuild(Planner planner, Construction construction, Construction.Target target)
        {
            if (!config.BlockBuildWhenOverLimit) return null;
            if (planner == null) return null;
            var player = planner.GetOwnerPlayer();
            if (player == null) return null;
            if (player.IsAdmin) return null;

            var userId = player.userID.Get();
            foreach (var kvp in rulesByPrefab)
            {
                var limit = LimitFor(kvp.Value, player);
                if (limit <= 0) continue;
                if (CountOf(userId, kvp.Key) >= limit) return false;
            }
            return null;
        }

        private object OnEntityKill(BaseNetworkable entity)
        {
            if (entity == null) return null;
            var ent = entity as BaseEntity;
            if (ent == null) return null;
            var owner = ent.OwnerID;
            if (owner == 0UL) return null;
            var shortName = ent.ShortPrefabName;
            if (string.IsNullOrEmpty(shortName)) return null;
            if (!rulesByPrefab.ContainsKey(shortName)) return null;
            Decrement(owner, shortName);
            return null;
        }

        [ChatCommand("dlimits")]
        private void CmdLimits(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }
            if (args != null && args.Length >= 2 && args[0].Equals("check", StringComparison.OrdinalIgnoreCase))
            {
                var prefab = args[1];
                LimitRule rule;
                if (!rulesByPrefab.TryGetValue(prefab, out rule))
                {
                    player.ChatMessage(Msg("UnknownPrefab", player.UserIDString, prefab));
                    return;
                }
                var limit = LimitFor(rule, player);
                var name = string.IsNullOrEmpty(rule.DisplayName) ? prefab : rule.DisplayName;
                player.ChatMessage(Msg("Usage", player.UserIDString, name, CountOf(player.userID.Get(), prefab), limit <= 0 ? "unlimited" : limit.ToString()));
                return;
            }
            ShowAll(player);
        }

        private void ShowAll(BasePlayer player)
        {
            if (rulesByPrefab.Count == 0)
            {
                player.ChatMessage(Msg("NoRules", player.UserIDString));
                return;
            }
            var userId = player.userID.Get();
            foreach (var kvp in rulesByPrefab)
            {
                var limit = LimitFor(kvp.Value, player);
                var name = string.IsNullOrEmpty(kvp.Value.DisplayName) ? kvp.Key : kvp.Value.DisplayName;
                player.ChatMessage(Msg("Usage", player.UserIDString, name, CountOf(userId, kvp.Key), limit <= 0 ? "unlimited" : limit.ToString()));
            }
        }

        [ConsoleCommand("dlimits.reload")]
        private void CcmdReload(ConsoleSystem.Arg arg)
        {
            if (arg == null) return;
            var player = arg.Player();
            if (!arg.IsAdmin && (player == null || !permission.UserHasPermission(player.UserIDString, PermAdmin)))
            {
                arg.ReplyWith("No permission.");
                return;
            }
            LoadConfig();
            RebuildRules();
            RecountEntities();
            arg.ReplyWith(Msg("Reloaded"));
        }

        private void Unload()
        {
            counts.Clear();
            rulesByPrefab.Clear();
        }
    }
}