OnUserGroupAdded

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

namespace Oxide.Plugins
{
    [Info("Group Join Notifier", "RustPluginGenerator", "1.0.0")]
    [Description("Announces and logs permission group assignments for users")]
    public class GroupJoinNotifier : RustPlugin
    {
        private const string PermAdmin = "groupjoinnotifier.admin";

        private PluginConfig config;
        private StoredData data;

        private class PluginConfig
        {
            [JsonProperty("Announcements by group")]
            public Dictionary<string, string> Announcements = new Dictionary<string, string>
            {
                ["vip"] = "You were added to the VIP group. Thanks for your support!",
                ["staff"] = "You are now part of the staff group."
            };

            [JsonProperty("Max log entries per user")]
            public int MaxLogEntries = 20;
        }

        private class StoredData
        {
            [JsonProperty("Assignment log")]
            public Dictionary<string, List<string>> Log = new Dictionary<string, List<string>>();
        }

        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>
            {
                ["Announce"] = "{0} was added to the '{1}' group.",
                ["NoLog"] = "No group assignments recorded for {0}.",
                ["LogHeader"] = "Group history for {0} ({1} entries):",
                ["Denied"] = "You do not have permission to use this command."
            }, 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(PermAdmin, this);
            data = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(Name) ?? new StoredData();
        }

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

        private void OnUserGroupAdded(string playerId, string groupName)
        {
            if (string.IsNullOrEmpty(playerId) || string.IsNullOrEmpty(groupName)) return;

            if (!data.Log.TryGetValue(playerId, out List<string> entries))
            {
                entries = new List<string>();
                data.Log[playerId] = entries;
            }
            entries.Add($"{DateTime.UtcNow:yyyy-MM-dd HH:mm:ss} {groupName}");
            while (entries.Count > Mathf.Max(1, config.MaxLogEntries)) entries.RemoveAt(0);
            Interface.Oxide.DataFileSystem.WriteObject(Name, data);

            if (!config.Announcements.TryGetValue(groupName, out string text) || string.IsNullOrEmpty(text)) return;

            BasePlayer player = BasePlayer.FindByID(Convert.ToUInt64(playerId));
            if (player == null || !player.IsConnected) return;

            player.ChatMessage(text);
        }

        [ChatCommand("groupjoin.log")]
        private void CmdGroupLog(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                player.ChatMessage(Msg("Denied", player.UserIDString));
                return;
            }

            string targetId = args != null && args.Length > 0 ? args[0] : player.UserIDString;
            if (!data.Log.TryGetValue(targetId, out List<string> entries) || entries.Count == 0)
            {
                player.ChatMessage(Msg("NoLog", player.UserIDString, targetId));
                return;
            }

            player.ChatMessage(Msg("LogHeader", player.UserIDString, targetId, entries.Count));
            foreach (string line in entries) player.ChatMessage(line);
        }
    }
}