OnToggleVendingBroadcast

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

namespace Oxide.Plugins
{
    [Info("Vending Broadcast Tracker", "RustPluginGenerator", "1.0.0")]
    [Description("Records vending machine broadcast toggles and reports per-player statistics")]
    public class VendingBroadcastTracker : RustPlugin
    {
        private const string PermStats = "vendingbroadcasttracker.stats";
        private const int MaxEntries = 200;

        private PluginConfig config;
        private TrackerData data;

        private class PluginConfig
        {
            [JsonProperty("Chat command enabled")]
            public bool ChatCommandEnabled { get; set; } = true;

            [JsonProperty("Announce to staff on broadcast enable")]
            public bool AnnounceEnable { get; set; } = true;
        }

        private class TrackEntry
        {
            [JsonProperty("Steam ID")]
            public string UserId { get; set; }

            [JsonProperty("Player name")]
            public string PlayerName { get; set; }

            [JsonProperty("Shop name")]
            public string ShopName { get; set; }

            [JsonProperty("Broadcasting")]
            public bool Broadcasting { get; set; }

            [JsonProperty("Position")]
            public string Position { get; set; }

            [JsonProperty("Unix time")]
            public long Time { get; set; }
        }

        private class TrackerData
        {
            [JsonProperty("Entries")]
            public List<TrackEntry> Entries { get; set; } = new List<TrackEntry>();

            [JsonProperty("Toggle counts")]
            public Dictionary<string, int> Counts { get; set; } = new Dictionary<string, int>();
        }

        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>
            {
                ["NoPermission"] = "You do not have permission to use this command.",
                ["Stats"] = "You have toggled vending broadcast {0} time(s).",
                ["StaffAlert"] = "{0} enabled broadcast on shop '{1}' at {2}."
            }, 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(PermStats, this);
        }

        private void OnServerInitialized()
        {
            data = Interface.Oxide.DataFileSystem.ReadObject<TrackerData>(Name) ?? new TrackerData();
        }

        private void Unload()
        {
            if (data != null)
                Interface.Oxide.DataFileSystem.WriteObject(Name, data);
        }

        private void OnToggleVendingBroadcast(VendingMachine vendingMachine, BasePlayer player)
        {
            if (vendingMachine == null || player == null || data == null) return;

            bool broadcasting = vendingMachine.HasFlag(BaseEntity.Flags.Reserved4);
            string position = vendingMachine.transform.position.ToString("F0");
            string shopName = vendingMachine.shopName ?? "unnamed";

            data.Entries.Add(new TrackEntry
            {
                UserId = player.UserIDString,
                PlayerName = player.displayName ?? "unknown",
                ShopName = shopName,
                Broadcasting = broadcasting,
                Position = position,
                Time = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
            });

            if (data.Entries.Count > MaxEntries)
                data.Entries.RemoveRange(0, data.Entries.Count - MaxEntries);

            int count;
            data.Counts.TryGetValue(player.UserIDString, out count);
            data.Counts[player.UserIDString] = count + 1;

            if (!config.AnnounceEnable || !broadcasting) return;

            string alert = Msg("StaffAlert", null, player.displayName, shopName, position);
            foreach (BasePlayer target in BasePlayer.activePlayerList)
            {
                if (target != null && target.IsAdmin)
                    target.ChatMessage(alert);
            }
        }

        [ChatCommand("vending.broadcaststats")]
        private void CmdStats(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;

            if (!config.ChatCommandEnabled)
            {
                player.ChatMessage("This command is disabled.");
                return;
            }

            if (!permission.UserHasPermission(player.UserIDString, PermStats))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }

            int count = 0;
            if (data?.Counts != null)
                data.Counts.TryGetValue(player.UserIDString, out count);

            player.ChatMessage(Msg("Stats", player.UserIDString, count));
        }
    }
}