OnPluginLoaded

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

namespace Oxide.Plugins
{
    [Info("Plugin Load Notifier", "RustPluginGenerator", "1.0.0")]
    [Description("Notifies staff when Oxide plugins are loaded or unloaded and keeps a short in-memory history")]
    public class PluginLoadNotifier : RustPlugin
    {
        private const string PermAlerts = "pluginloadnotifier.alerts";

        private PluginConfig config;
        private readonly List<string> history = new List<string>();

        private class PluginConfig
        {
            [JsonProperty("Notify admins in chat")]
            public bool NotifyAdmins { get; set; } = true;

            [JsonProperty("Notify permission holders in chat")]
            public bool NotifyPermission { get; set; } = true;

            [JsonProperty("Maximum history entries")]
            public int MaxHistory { get; set; } = 50;

            [JsonProperty("Ignore own plugin events")]
            public bool IgnoreSelf { get; set; } = true;
        }

        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>
            {
                ["Loaded"] = "Plugin loaded: {0} v{1} by {2}",
                ["Unloaded"] = "Plugin unloaded: {0}",
                ["NoHistory"] = "No plugin load events recorded since startup.",
                ["HistoryEntry"] = "{0}  {1}",
                ["HistoryHeader"] = "{0} load events recorded:"
            }, 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(PermAlerts, this);
        }

        private void OnPluginLoaded(Plugin plugin)
        {
            if (plugin == null) return;
            if (config.IgnoreSelf && plugin.Name == Name) return;

            Record("+ " + plugin.Name);
            Broadcast(Msg("Loaded", null, plugin.Name, plugin.Version, plugin.Author));
        }

        private void OnPluginUnloaded(Plugin plugin)
        {
            if (plugin == null) return;
            if (config.IgnoreSelf && plugin.Name == Name) return;

            Record("- " + plugin.Name);
            Broadcast(Msg("Unloaded", null, plugin.Name));
        }

        private void Record(string entry)
        {
            history.Add(entry);
            while (history.Count > Mathf.Max(1, config.MaxHistory))
                history.RemoveAt(0);
        }

        private void Broadcast(string message)
        {
            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player == null) continue;
                if (config.NotifyAdmins && player.IsAdmin)
                {
                    player.ChatMessage(message);
                    continue;
                }
                if (config.NotifyPermission && permission.UserHasPermission(player.UserIDString, PermAlerts))
                    player.ChatMessage(message);
            }
        }

        [ChatCommand("plstatus")]
        private void CmdStatus(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!player.IsAdmin && !permission.UserHasPermission(player.UserIDString, PermAlerts)) return;

            if (history.Count == 0)
            {
                player.ChatMessage(Msg("NoHistory", player.UserIDString));
                return;
            }

            player.ChatMessage(Msg("HistoryHeader", player.UserIDString, history.Count));
            foreach (var entry in history)
                player.ChatMessage(Msg("HistoryEntry", player.UserIDString, DateTime.Now.ToString("HH:mm:ss"), entry));
        }
    }
}