How to make a Rust team size limit plugin (invite blocking)

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

namespace Oxide.Plugins
{
    [Info("Team Size Limit", "RustPluginGenerator", "1.0.0")]
    [Description("Blocks team invites and accepts when a team has reached the configured maximum size.")]
    public class TeamSizeLimit : RustPlugin
    {
        private const string PermUse = "teamsizelimit.use";
        private const string PermBypass = "teamsizelimit.bypass";

        private PluginConfig config;

        private class PluginConfig
        {
            [JsonProperty("Maximum team size")]
            public int MaximumTeamSize { get; set; } = 5;

            [JsonProperty("Skip bypassed players when counting")]
            public bool CountBypassedPlayers { 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();
            }
            if (config.MaximumTeamSize < 1) config.MaximumTeamSize = 1;
            SaveConfig();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["Team Full"] = "That team is full. The maximum team size is {0} players.",
                ["Team Full Self"] = "You cannot join this team, it already has the maximum of {0} players.",
                ["Size Info"] = "Maximum team size: {0}. Your team has {1} members.",
                ["No Team"] = "You are not in a team. The maximum team size is {0} players."
            }, this);
        }

        private string Msg(string key, string userId = null, params object[] args)
        {
            return string.Format(lang.GetMessage(key, this, userId), args);
        }

        private void Init()
        {
            permission.RegisterPermission(PermUse, this);
            permission.RegisterPermission(PermBypass, this);
        }

        private int CountMembers(RelationshipManager.PlayerTeam team)
        {
            if (team == null || team.members == null) return 0;

            int count = 0;
            foreach (ulong id in team.members)
            {
                if (!config.CountBypassedPlayers && permission.UserHasPermission(id.ToString(), PermBypass))
                    continue;
                count++;
            }
            return count;
        }

        private object OnTeamMemberInvite(RelationshipManager.PlayerTeam playerTeam, BasePlayer player, ulong uLong, bool flag)
        {
            if (playerTeam == null || player == null) return null;
            if (playerTeam.members == null) return null;

            if (CountMembers(playerTeam) >= config.MaximumTeamSize)
            {
                player.ChatMessage(Msg("Team Full", player.UserIDString, config.MaximumTeamSize));
                return false;
            }

            return null;
        }

        private object OnTeamAcceptInvite(RelationshipManager.PlayerTeam playerTeam, BasePlayer player)
        {
            if (playerTeam == null || player == null) return null;
            if (playerTeam.members == null) return null;

            // Player might already be a member of this team.
            if (playerTeam.members.Contains(player.userID.Get())) return null;

            if (CountMembers(playerTeam) >= config.MaximumTeamSize)
            {
                player.ChatMessage(Msg("Team Full Self", player.UserIDString, config.MaximumTeamSize));
                return false;
            }

            return null;
        }

        [ChatCommand("teamsize")]
        private void CmdTeamSize(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage(Msg("No Permission", player.UserIDString));
                return;
            }

            ulong teamId = player.currentTeam;
            if (teamId == 0)
            {
                player.ChatMessage(Msg("No Team", player.UserIDString, config.MaximumTeamSize));
                return;
            }

            RelationshipManager.PlayerTeam team = RelationshipManager.ServerInstance.FindTeam(teamId);
            int members = CountMembers(team);
            player.ChatMessage(Msg("Size Info", player.UserIDString, config.MaximumTeamSize, members));
        }
    }
}