using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.github.enderspearl184.peakpseudonym")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+2d5c2856aa6c288db67e682e09188ebee1cbb9fd")]
[assembly: AssemblyProduct("com.github.enderspearl184.peakpseudonym")]
[assembly: AssemblyTitle("Pseudonym")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Pseudonym
{
	[BepInPlugin("com.github.enderspearl184.peakpseudonym", "Pseudonym", "0.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Log;

		private static PseudonymConfig BoundConfig;

		public const string Id = "com.github.enderspearl184.peakpseudonym";

		public static string Name => "Pseudonym";

		public static string Version => "0.1.0";

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogInfo((object)("Plugin " + Name + " is loaded!"));
			BoundConfig = new PseudonymConfig(((BaseUnityPlugin)this).Config);
			Pseudonym.Nickname = BoundConfig.Nickname.Value;
			Pseudonym.ObscureSteamId = BoundConfig.ObscureSteamId.Value;
			Harmony.CreateAndPatchAll(typeof(Pseudonym), (string)null);
		}
	}
	public class Pseudonym
	{
		public static string Nickname = "^_^";

		public static bool ObscureSteamId = false;

		[HarmonyPatch(typeof(NetworkConnector), "GetUsername")]
		[HarmonyPrefix]
		private static bool GetPseudonym(ref string __result)
		{
			__result = Nickname;
			return false;
		}

		[HarmonyPatch(typeof(NetworkConnector), "HandleConnectionState")]
		[HarmonyPrefix]
		private static bool LeaveLobbyAfterJoin(object[] __args)
		{
			if (ObscureSteamId)
			{
				if (__args.Length != 0)
				{
					object obj = __args[0];
					JoinSpecificRoomState val = (JoinSpecificRoomState)((obj is JoinSpecificRoomState) ? obj : null);
					if (val != null)
					{
						GameHandler.GetService<SteamLobbyHandler>().LeaveLobby();
						Debug.Log((object)"[Pseudonyms] Left steam lobby.");
					}
					else
					{
						Debug.Log((object)"[Pseudonyms] State is not JoinSpecificRoomState.");
					}
				}
				else
				{
					Debug.Log((object)"[Pseudonyms] For some reason state is null.");
				}
			}
			return true;
		}
	}
	internal class PseudonymConfig
	{
		public readonly ConfigEntry<string> Nickname;

		public readonly ConfigEntry<bool> ObscureSteamId;

		public PseudonymConfig(ConfigFile cfg)
		{
			cfg.SaveOnConfigSet = false;
			Nickname = cfg.Bind<string>("General", "Nickname", "^_^", "The nickname to use.");
			ObscureSteamId = cfg.Bind<bool>("General", "ObscureSteamId", false, "Leaves the steam lobby right after receiving a photon lobby ID, potentially obscuring your steam ID. Players may still get your steam ID, but it will be more difficult to link it to your nickname if they don't match.");
			ClearOrphanedEntries(cfg);
			cfg.Save();
			cfg.SaveOnConfigSet = true;
		}

		private static void ClearOrphanedEntries(ConfigFile cfg)
		{
			PropertyInfo propertyInfo = AccessTools.Property(typeof(ConfigFile), "OrphanedEntries");
			Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)propertyInfo.GetValue(cfg);
			dictionary.Clear();
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}