OnUserBanned

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

namespace Oxide.Plugins
{
    [Info("Ban Audit Log", "RustPluginGenerator", "1.0.0")]
    [Description("Records every ban to a data file and reports it to staff in chat")]
    public class BanAuditLog : RustPlugin
    {
        private const string PermStaff = "banauditlog.staff";

        private PluginConfig config;
        private BanData data;

        private class PluginConfig
        {
            [JsonProperty("Maximum stored entries")]
            public int MaxEntries = 500;

            [JsonProperty("Notify staff in chat")]
            public bool NotifyStaff = true;
        }

        private class BanEntry
        {
            [JsonProperty("Player name")]
            public string PlayerName;

            [JsonProperty("Steam ID")]
            public string SteamId;

            [JsonProperty("IP address")]
            public string Address;

            [JsonProperty("Reason")]
            public string Reason;

            [JsonProperty("Expiry (unix, 0 = permanent)")]
            public long Expiry;

            [JsonProperty("Banned at (unix)")]
            public long BannedAt;
        }

        private class BanData
        {
            [JsonProperty("Bans")]
            public List<BanEntry> Bans = new List<BanEntry>();
        }

        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>
            {
                ["BanReported"] = "BAN: {0} ({1}) - {2} - {3}",
                ["Permanent"] = "permanent",
                ["Expires"] = "expires {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(PermStaff, this);
            data = Interface.Oxide.DataFileSystem.ReadObject<BanData>(Name) ?? new BanData();
        }

        private void OnUserBanned(string playerName, string steamId, string Address, string reason, long expiry)
        {
            var entry = new BanEntry
            {
                PlayerName = playerName,
                SteamId = steamId,
                Address = Address,
                Reason = reason,
                Expiry = expiry,
                BannedAt = Facepunch.Math.Epoch.Current
            };

            data.Bans.Add(entry);
            if (data.Bans.Count > config.MaxEntries)
                data.Bans.RemoveRange(0, data.Bans.Count - config.MaxEntries);

            if (!config.NotifyStaff) return;

            string when = expiry == 0
                ? Msg("Permanent")
                : Msg("Expires", null, DateTimeOffset.FromUnixTimeSeconds(expiry).UtcDateTime.ToString("yyyy-MM-dd HH:mm 'UTC'"));
            string line = Msg("BanReported", null, playerName ?? "unknown", steamId, reason ?? "no reason", when);

            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player != null && permission.UserHasPermission(player.UserIDString, PermStaff))
                    player.ChatMessage(line);
            }
        }

        private void OnPlayerUnbanned(string playerName, ulong playerId, string reason)
        {
            data.Bans.RemoveAll(b => b.SteamId == playerId.ToString());
        }

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