OnSteamInventoryUpdated

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

namespace Oxide.Plugins
{
    [Info("Steam Inventory Sync Monitor", "RustPluginGenerator", "1.0.0")]
    [Description("Warns players when their Steam inventory sync leaves the container full and optionally logs syncs")]
    public class SteamInventorySyncMonitor : RustPlugin
    {
        private const string PermNotify = "steaminventorysyncmonitor.notify";

        private PluginConfig config;
        private readonly Dictionary<ulong, float> lastNotice = new Dictionary<ulong, float>();

        private class PluginConfig
        {
            [JsonProperty("Send sync summary to player")]
            public bool SendSummary { get; set; } = true;

            [JsonProperty("Cooldown seconds between notices")]
            public float CooldownSeconds { get; set; } = 30f;
        }

        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>
            {
                ["Full"] = "Your Steam inventory synced, but the container is full ({0} items). Free space to receive new items.",
                ["Synced"] = "Steam inventory synced: {0} items in the container.",
                ["NoPermission"] = "You do not have permission to receive Steam inventory notices."
            }, 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(PermNotify, this);
        }

        private void OnSteamInventoryUpdated(SteamInventory steamInventory)
        {
            if (steamInventory == null || steamInventory.baseEntity == null) return;

            var player = steamInventory.baseEntity;
            if (player == null || player.IsDestroyed || !player.IsConnected) return;

            var container = player.inventory?.containerMain;
            if (container == null) return;

            if (!config.SendSummary) return;
            if (!permission.UserHasPermission(player.UserIDString, PermNotify)) return;

            float now = UnityEngine.Time.realtimeSinceStartup;
            float last;
            if (lastNotice.TryGetValue(player.userID, out last) && now - last < config.CooldownSeconds) return;
            lastNotice[player.userID] = now;

            int freeSlots = container.capacity - container.itemList.Count;
            if (container.IsFull() || freeSlots <= 0)
            {
                player.ChatMessage(Msg("Full", player.UserIDString, container.itemList.Count));
            }
            else
            {
                player.ChatMessage(Msg("Synced", player.UserIDString, container.itemList.Count));
            }
        }

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