using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using ServerSync;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: IgnoresAccessChecksTo("Accessibility")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("assembly_googleanalytics")]
[assembly: IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: IgnoresAccessChecksTo("assembly_lux")]
[assembly: IgnoresAccessChecksTo("assembly_postprocessing")]
[assembly: IgnoresAccessChecksTo("assembly_simplemeshcombine")]
[assembly: IgnoresAccessChecksTo("assembly_steamworks")]
[assembly: IgnoresAccessChecksTo("assembly_sunshafts")]
[assembly: IgnoresAccessChecksTo("assembly_utils")]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: IgnoresAccessChecksTo("com.rlabrecque.steamworks.net")]
[assembly: IgnoresAccessChecksTo("ConnectedStorage")]
[assembly: IgnoresAccessChecksTo("Fishlabs.Common")]
[assembly: IgnoresAccessChecksTo("Fishlabs.Core")]
[assembly: IgnoresAccessChecksTo("Mono.Posix")]
[assembly: IgnoresAccessChecksTo("Mono.WebBrowser")]
[assembly: IgnoresAccessChecksTo("netstandard")]
[assembly: IgnoresAccessChecksTo("PlayFab")]
[assembly: IgnoresAccessChecksTo("PlayFabParty")]
[assembly: IgnoresAccessChecksTo("ui_lib")]
[assembly: IgnoresAccessChecksTo("XblPCSandbox")]
[assembly: IgnoresAccessChecksTo("XGamingRuntime")]
[assembly: AssemblyCompany("Bifrost")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.8.0")]
[assembly: AssemblyInformationalVersion("1.0.8+6a67238e40d2afcf3f667a067d25223e1535a1cd")]
[assembly: AssemblyProduct("Bifrost")]
[assembly: AssemblyTitle("Bifrost")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.8.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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]
	[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 ServerSync
{
	[PublicAPI]
	public abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	public class SyncedConfigEntry<T>(ConfigEntry<T> sourceConfig) : OwnConfigEntryBase()
	{
		public readonly ConfigEntry<T> SourceConfig = sourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

		public T Value
		{
			get
			{
				return SourceConfig.Value;
			}
			set
			{
				SourceConfig.Value = value;
			}
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	public abstract class CustomSyncedValueBase
	{
		public object? LocalBaseValue;

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

		public object? BoxedValue
		{
			get
			{
				return boxedValue;
			}
			set
			{
				boxedValue = value;
				this.ValueChanged?.Invoke();
			}
		}

		public event Action? ValueChanged;

		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[PublicAPI]
	public sealed class CustomSyncedValue<T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

		public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
			: base(configSync, identifier, typeof(T), priority)
		{
			Value = value;
		}

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	public class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			public static ZRpc? currentRpc;

			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync2 in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync2.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
				{
					ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
					{
						new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = isAdmin
						}
					});
					ConfigSync configSync = configSyncs.First();
					if (configSync != null)
					{
						((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
					}
				}
				static IEnumerator WatchAdminListChanges()
				{
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					List<string> CurrentList = new List<string>(adminList.GetList());
					while (true)
					{
						yield return (object)new WaitForSeconds(30f);
						if (!adminList.GetList().SequenceEqual(CurrentList))
						{
							CurrentList = new List<string>(adminList.GetList());
							List<ZNetPeer> list = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId != null) ? ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName })) : adminList.Contains(hostName);
							}).ToList();
							SendAdmin(ZNet.instance.GetPeers().Except(list).ToList(), isAdmin: false);
							SendAdmin(list, isAdmin: true);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		private class ParsedConfigs
		{
			public readonly Dictionary<OwnConfigEntryBase, object?> configValues = new Dictionary<OwnConfigEntryBase, object>();

			public readonly Dictionary<CustomSyncedValueBase, object?> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			private class BufferingSocket : ZPlayFabSocket, ISocket
			{
				public volatile bool finished;

				public volatile int versionMatchQueued = -1;

				public readonly List<ZPackage> Package = new List<ZPackage>();

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
					((ZPlayFabSocket)this)..ctor();
				}

				public bool IsConnected()
				{
					return Original.IsConnected();
				}

				public ZPackage Recv()
				{
					return Original.Recv();
				}

				public int GetSendQueueSize()
				{
					return Original.GetSendQueueSize();
				}

				public int GetCurrentSendRate()
				{
					return Original.GetCurrentSendRate();
				}

				public bool IsHost()
				{
					return Original.IsHost();
				}

				public void Dispose()
				{
					Original.Dispose();
				}

				public bool GotNewData()
				{
					return Original.GotNewData();
				}

				public void Close()
				{
					Original.Close();
				}

				public string GetEndPointString()
				{
					return Original.GetEndPointString();
				}

				public void GetAndResetStats(out int totalSent, out int totalRecv)
				{
					Original.GetAndResetStats(ref totalSent, ref totalRecv);
				}

				public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
				{
					Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
				}

				public ISocket Accept()
				{
					return Original.Accept();
				}

				public int GetHostPort()
				{
					return Original.GetHostPort();
				}

				public bool Flush()
				{
					return Original.Flush();
				}

				public string GetHostName()
				{
					return Original.GetHostName();
				}

				public void VersionMatch()
				{
					if (finished)
					{
						Original.VersionMatch();
					}
					else
					{
						versionMatchQueued = Package.Count;
					}
				}

				public void Send(ZPackage pkg)
				{
					//IL_004c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0052: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPriority(800)]
			[HarmonyPrefix]
			private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				if (!__instance.IsServer())
				{
					return;
				}
				BufferingSocket bufferingSocket = new BufferingSocket(rpc.GetSocket());
				AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket);
				object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
				ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
				if (val != null && (int)ZNet.m_onlineBackend != 0)
				{
					FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket");
					object? value = fieldInfo.GetValue(val);
					ZPlayFabSocket val2 = (ZPlayFabSocket)((value is ZPlayFabSocket) ? value : null);
					if (val2 != null)
					{
						typeof(ZPlayFabSocket).GetField("m_remotePlayerId").SetValue(bufferingSocket, val2.m_remotePlayerId);
					}
					fieldInfo.SetValue(val, bufferingSocket);
				}
				if (__state == null)
				{
					__state = new Dictionary<Assembly, BufferingSocket>();
				}
				__state[Assembly.GetExecutingAssembly()] = bufferingSocket;
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				ZNetPeer peer;
				if (__instance.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state[Assembly.GetExecutingAssembly()];
					bufferingSocket2.finished = true;
					for (int i = 0; i < bufferingSocket2.Package.Count; i++)
					{
						if (i == bufferingSocket2.versionMatchQueued)
						{
							bufferingSocket2.Original.VersionMatch();
						}
						bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
					}
					if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
				}
				IEnumerator sendAsync()
				{
					foreach (ConfigSync configSync in configSyncs)
					{
						List<PackageEntry> list = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							list.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						list.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)methodInfo == null) ? ((object)val.Contains(rpc.GetSocket().GetHostName())) : methodInfo.Invoke(ZNet.instance, new object[2]
							{
								val,
								rpc.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, list, partial: false);
						yield return ((MonoBehaviour)__instance).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		private class PackageEntry
		{
			public string section;

			public string key;

			public Type type;

			public object? value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		private static class PreventConfigRereadChangingValues
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, string value)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
				{
					return true;
				}
				try
				{
					ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
				}
				return false;
			}
		}

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected;

			public string received;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

		private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();

		private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

		private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

		public bool IsLocked
		{
			get
			{
				bool? flag = forceConfigLocking;
				bool num;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0051;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag == true;
				}
				if (num)
				{
					return !lockExempt;
				}
				goto IL_0051;
				IL_0051:
				return false;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin
		{
			get
			{
				if (!lockExempt)
				{
					return isSourceOfTruth;
				}
				return true;
			}
		}

		public bool IsSourceOfTruth
		{
			get
			{
				return isSourceOfTruth;
			}
			private set
			{
				if (value != isSourceOfTruth)
				{
					isSourceOfTruth = value;
					this.SourceOfTruthChanged?.Invoke(value);
				}
			}
		}

		public bool InitialSyncDone { get; private set; }

		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

		static ConfigSync()
		{
			ProcessingServerUpdate = false;
			configSyncs = new HashSet<ConfigSync>();
			lockExempt = false;
			packageCounter = 0L;
			RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
		}

		public ConfigSync(string name)
		{
			Name = name;
			configSyncs.Add(this);
			new VersionCheck(this);
		}

		public SyncedConfigEntry<T> AddConfigEntry<T>(ConfigEntry<T> configEntry)
		{
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry.SettingChanged += delegate
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += delegate
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			if (allCustomValues.Select((CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue);
			allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending((CustomSyncedValueBase v) => v.Priority));
			customValue.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, customValue);
				}
			};
		}

		private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
		{
			lockedConfigChanged += serverLockedSettingChanged;
			IsSourceOfTruth = false;
			if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
			{
				InitialSyncDone = true;
			}
		}

		private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
		{
			HandleConfigSyncRPC(sender, package, clientUpdate: true);
		}

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Expected O, but got Unknown
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out SortedDictionary<int, byte[]> value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4) != 0)
				{
					MemoryStream stream = new MemoryStream(package.ReadByteArray());
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
					val2.Save();
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

		private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
		{
			ParsedConfigs parsedConfigs = new ParsedConfigs();
			Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where((OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary((OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary((CustomSyncedValueBase c) => c.Identifier, (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int num2 = 0; num2 < num; num2++)
			{
				string text = package.ReadString();
				string text2 = package.ReadString();
				string text3 = package.ReadString();
				Type type = Type.GetType(text3);
				if (text3 == "" || type != null)
				{
					object obj;
					try
					{
						obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
					}
					catch (InvalidDeserializationTypeException ex)
					{
						Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
						continue;
					}
					OwnConfigEntryBase value2;
					if (text == "Internal")
					{
						CustomSyncedValueBase value;
						if (text2 == "serverversion")
						{
							if (obj?.ToString() != CurrentVersion)
							{
								Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
							}
						}
						else if (text2 == "lockexempt")
						{
							if (obj is bool flag)
							{
								lockExempt = flag;
							}
						}
						else if (dictionary2.TryGetValue(text2, out value))
						{
							if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
							{
								parsedConfigs.customValues[value] = obj;
								continue;
							}
							Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
						}
					}
					else if (dictionary.TryGetValue(text + "_" + text2, out value2))
					{
						Type type2 = configType(value2.BaseConfig);
						if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
						{
							parsedConfigs.configValues[value2] = obj;
							continue;
						}
						Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
					}
					else
					{
						Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
					}
					continue;
				}
				Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
				return new ParsedConfigs();
			}
			return parsedConfigs;
		}

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config));
			if (configSync == null)
			{
				return true;
			}
			if (!configSync.IsSourceOfTruth && config.SynchronizedConfig && config.LocalBaseValue != null)
			{
				if (!configSync.IsLocked)
				{
					if (config == configSync.lockedConfig)
					{
						return lockExempt;
					}
					return true;
				}
				return false;
			}
			return true;
		}

		private void serverLockedSettingChanged()
		{
			foreach (OwnConfigEntryBase allConfig in allConfigs)
			{
				configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
			}
		}

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where((OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc == null)
			{
				yield break;
			}
			byte[] data = package.GetArray();
			if (data != null && data.LongLength > 250000)
			{
				int fragments = (int)(1 + (data.LongLength - 1) / 250000);
				long packageIdentifier = ++packageCounter;
				int fragment = 0;
				while (fragment < fragments)
				{
					foreach (bool item in waitForQueue())
					{
						yield return item;
					}
					if (peer.m_socket.IsConnected())
					{
						ZPackage val = new ZPackage();
						val.Write((byte)2);
						val.Write(packageIdentifier);
						val.Write(fragment);
						val.Write(fragments);
						val.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
						SendPackage(val);
						if (fragment != fragments - 1)
						{
							yield return true;
						}
						int num = fragment + 1;
						fragment = num;
						continue;
					}
					break;
				}
				yield break;
			}
			foreach (bool item2 in waitForQueue())
			{
				yield return item2;
			}
			SendPackage(package);
			void SendPackage(ZPackage pkg)
			{
				string text = Name + " ConfigSync";
				if (isServer)
				{
					peer.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer.m_server ? 0 : peer.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer.m_uid} after 30 seconds config sending timeout");
						peer.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer);
						break;
					}
					yield return false;
				}
			}
		}

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] array = package.GetArray();
			if (array != null && array.LongLength > 10000)
			{
				ZPackage val = new ZPackage();
				val.Write((byte)4);
				MemoryStream memoryStream = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionLevel.Optimal))
				{
					deflateStream.Write(array, 0, array.Length);
				}
				val.Write(memoryStream.ToArray());
				package = val;
			}
			List<IEnumerator<bool>> writers = (from p in peers
				where p.IsReady()
				select distributeConfigToPeers(p, package)).ToList();
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			while (writers.Count > 0)
			{
				yield return null;
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			}
		}

		private void Broadcast(long target, params ConfigEntryBase[] configs)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(configs);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(null, customValues);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private static OwnConfigEntryBase? configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		public static SyncedConfigEntry<T>? ConfigData<T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

		private static Type configType(ConfigEntryBase config)
		{
			return configType(config.SettingType);
		}

		private static Type configType(Type type)
		{
			if (!type.IsEnum)
			{
				return type;
			}
			return Enum.GetUnderlyingType(type);
		}

		private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write(partial ? ((byte)1) : ((byte)0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

		private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
		{
			package.Write(entry.section);
			package.Write(entry.key);
			package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
			AddValueToZPackage(package, entry.value);
		}

		private static string GetZPackageTypeString(Type type)
		{
			return type.AssemblyQualifiedName;
		}

		private static void AddValueToZPackage(ZPackage package, object? value)
		{
			Type type = value?.GetType();
			if (value is Enum)
			{
				value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
			}
			else
			{
				if (value is ICollection collection)
				{
					package.Write(collection.Count);
					{
						foreach (object item in collection)
						{
							AddValueToZPackage(package, item);
						}
						return;
					}
				}
				if ((object)type != null && type.IsValueType && !type.IsPrimitive)
				{
					FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					package.Write(fields.Length);
					FieldInfo[] array = fields;
					foreach (FieldInfo fieldInfo in array)
					{
						package.Write(GetZPackageTypeString(fieldInfo.FieldType));
						AddValueToZPackage(package, fieldInfo.GetValue(value));
					}
					return;
				}
			}
			ZRpc.Serialize(new object[1] { value }, ref package);
		}

		private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
		{
			if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = package.ReadInt();
				if (num != fields.Length)
				{
					throw new InvalidDeserializationTypeException
					{
						received = $"(field count: {num})",
						expected = $"(field count: {fields.Length})"
					};
				}
				object uninitializedObject = FormatterServices.GetUninitializedObject(type);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					string text = package.ReadString();
					if (text != GetZPackageTypeString(fieldInfo.FieldType))
					{
						throw new InvalidDeserializationTypeException
						{
							received = text,
							expected = GetZPackageTypeString(fieldInfo.FieldType),
							field = fieldInfo.Name
						};
					}
					fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
				}
				return uninitializedObject;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				int num2 = package.ReadInt();
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
				FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
				for (int j = 0; j < num2; j++)
				{
					object obj = ReadValueWithTypeFromZPackage(package, type2);
					dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
				}
				return dictionary;
			}
			if (type != typeof(List<string>) && type.IsGenericType)
			{
				Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
				if ((object)type3 != null && type3.IsAssignableFrom(type))
				{
					int num3 = package.ReadInt();
					object obj2 = Activator.CreateInstance(type);
					MethodInfo method = type3.GetMethod("Add");
					for (int k = 0; k < num3; k++)
					{
						method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
					}
					return obj2;
				}
			}
			ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
			AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
			List<object> source = new List<object>();
			ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
			return source.First();
		}
	}
	[PublicAPI]
	[HarmonyPatch]
	public class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

		private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();

		private ConfigSync? ConfigSync;

		public string DisplayName
		{
			get
			{
				return displayName ?? Name;
			}
			set
			{
				displayName = value;
			}
		}

		public string CurrentVersion
		{
			get
			{
				return currentVersion ?? "0.0.0";
			}
			set
			{
				currentVersion = value;
			}
		}

		public string MinimumRequiredVersion
		{
			get
			{
				string text = minimumRequiredVersion;
				if (text == null)
				{
					if (!ModRequired)
					{
						return "0.0.0";
					}
					text = CurrentVersion;
				}
				return text;
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count((Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

		static VersionCheck()
		{
			versionChecks = new HashSet<VersionCheck>();
			notProcessedNames = new Dictionary<string, string>();
			typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
			{
				new Action(PatchServerSync)
			});
		}

		public VersionCheck(string name)
		{
			Name = name;
			ModRequired = true;
			versionChecks.Add(this);
		}

		public VersionCheck(ConfigSync configSync)
		{
			ConfigSync = configSync;
			Name = ConfigSync.Name;
			versionChecks.Add(this);
		}

		public void Initialize()
		{
			ReceivedCurrentVersion = null;
			ReceivedMinimumRequiredVersion = null;
			if (ConfigSync != null)
			{
				Name = ConfigSync.Name;
				DisplayName = ConfigSync.DisplayName;
				CurrentVersion = ConfigSync.CurrentVersion;
				MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
				ModRequired = ConfigSync.ModRequired;
			}
		}

		private bool IsVersionOk()
		{
			if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
			{
				return !ModRequired;
			}
			bool num = new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion);
			bool flag = new Version(ReceivedCurrentVersion) >= new Version(MinimumRequiredVersion);
			return num && flag;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			if (!(new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion)))
			{
				return DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".";
			}
			return DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".";
		}

		private string ErrorServer(ZRpc rpc)
		{
			return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
		}

		private string Error(ZRpc? rpc = null)
		{
			if (rpc != null)
			{
				return ErrorServer(rpc);
			}
			return ErrorClient();
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where((VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc)).ToArray();
		}

		private static void Logout()
		{
			Game.instance.Logout(true, true);
			AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
		}

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg)
		{
			CheckVersion(rpc, pkg, null);
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg, Action<ZRpc, ZPackage>? original)
		{
			string text = pkg.ReadString();
			string text2 = pkg.ReadString();
			string text3 = pkg.ReadString();
			bool flag = false;
			foreach (VersionCheck versionCheck in versionChecks)
			{
				if (!(text != versionCheck.Name))
				{
					Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
					versionCheck.ReceivedMinimumRequiredVersion = text2;
					versionCheck.ReceivedCurrentVersion = text3;
					if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
					{
						versionCheck.ValidatedClients.Add(rpc);
					}
					flag = true;
				}
			}
			if (flag)
			{
				return;
			}
			pkg.SetPos(0);
			if (original != null)
			{
				original(rpc, pkg);
				if (pkg.GetPos() == 0)
				{
					notProcessedNames.Add(text, text3);
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[HarmonyPrefix]
		private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
		{
			VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
			if (array.Length == 0)
			{
				return true;
			}
			VersionCheck[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				Debug.LogWarning((object)array2[i].Error(rpc));
			}
			if (__instance.IsServer())
			{
				DisconnectClient(rpc);
			}
			else
			{
				Logout();
			}
			return false;
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage pkg)
				{
					CheckVersion(rpc, pkg, action);
				});
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (versionCheck.ModRequired || __instance.IsServer())
				{
					Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
					ZPackage val = new ZPackage();
					val.Write(versionCheck.Name);
					val.Write(versionCheck.MinimumRequiredVersion);
					val.Write(versionCheck.CurrentVersion);
					peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		[HarmonyPrefix]
		private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
		{
			if (!__instance.IsServer())
			{
				return;
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.ValidatedClients.Remove(peer.m_rpc);
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			object obj = AccessTools.DeclaredField(typeof(FejdStartup), "m_connectionFailedError")?.GetValue(__instance);
			PropertyInfo propertyInfo = obj?.GetType().GetProperty("text");
			if (obj == null || propertyInfo == null)
			{
				return;
			}
			string text = (string)propertyInfo.GetValue(obj, null);
			string text2 = "";
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				text2 = text2 + "\n" + string.Join("\n", failedClient.Select((VersionCheck check) => check.Error()));
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!text.Contains(item.Key))
				{
					text2 = text2 + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
				}
			}
			if (text2.Length > 0)
			{
				propertyInfo.SetValue(obj, text + text2, null);
			}
		}
	}
}
namespace Bifrost
{
	[BepInPlugin("ashr4f.bifrost", "Bifrost", "1.0.8")]
	public class BifrostPlugin : BaseUnityPlugin
	{
		public const string ModGuid = "ashr4f.bifrost";

		public const string ModName = "Bifrost";

		public const string ModVersion = "1.0.8";

		internal static ManualLogSource Log = null;

		private static readonly ConfigSync configSync = new ConfigSync("ashr4f.bifrost")
		{
			DisplayName = "Bifrost",
			CurrentVersion = "1.0.8",
			MinimumRequiredVersion = "1.0.8",
			ModRequired = false
		};

		private static ConfigEntry<bool> _serverConfigLocked = null;

		internal static ConfigEntry<bool> Enabled = null;

		internal static ConfigEntry<bool> QuickTravel = null;

		internal static ConfigEntry<bool> IgnoreRestrictions = null;

		internal static ConfigEntry<string> PortalPrefabs = null;

		internal static ConfigEntry<bool> OpenOnEnter = null;

		internal static ConfigEntry<bool> HideOtherPins = null;

		internal static ConfigEntry<string> KeepPinTypes = null;

		internal static ConfigEntry<KeyboardShortcut> MapToggleKey = null;

		internal static ConfigEntry<bool> ShowWorldWhileLoading = null;

		internal static ConfigEntry<bool> SkipLoadingObjects = null;

		internal static ConfigEntry<bool> SkipLoadingArea = null;

		internal static ConfigEntry<float> SettleSeconds = null;

		private static FieldInfo? _blackField;

		private static bool _blackSearched;

		private ConfigEntry<TVal> BindSynced<TVal>(string group, string name, TVal value, string description)
		{
			ConfigEntry<TVal> val = ((BaseUnityPlugin)this).Config.Bind<TVal>(group, name, value, description);
			configSync.AddConfigEntry<TVal>(val);
			return val;
		}

		private void Awake()
		{
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			_serverConfigLocked = BindSynced("General", "Lock Configuration", value: true, "If on and the server runs Bifrost, the server configuration is enforced for everyone.");
			configSync.AddLockingConfigEntry<bool>(_serverConfigLocked);
			Enabled = BindSynced("General", "Enabled", value: true, "Master switch. If off, portals behave like vanilla.");
			QuickTravel = BindSynced("General", "Quick Travel", value: true, "Removes the artificial teleport wait. The screen stays faded until the destination area is ready, so the unloaded world is never shown.");
			IgnoreRestrictions = BindSynced("General", "Ignore Teleport Restrictions", value: false, "If on, items that normally cannot pass through portals no longer block travel.");
			PortalPrefabs = BindSynced("General", "Portal Prefabs", "portal_wood, portal_stone", "Comma-separated prefab names treated as portals.");
			OpenOnEnter = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Open On Enter", true, "Walking into a portal opens the destination map. Pressing E on the portal always works.");
			HideOtherPins = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Hide Other Pins", true, "While choosing a destination, resource and custom pins are hidden so nothing covers the portals. Visual only and per frame, other mods keep their pins untouched.");
			KeepPinTypes = ((BaseUnityPlugin)this).Config.Bind<string>("General", "Always Visible Pins", "Ping, Shout, Death, Bed, Player, EventArea, RandomEvent, Boss", "Comma-separated pin types that stay visible while choosing a destination, so pings, other players and death markers are never hidden.");
			MapToggleKey = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("General", "Map Toggle Key", new KeyboardShortcut((KeyCode)112, Array.Empty<KeyCode>()), "Key to show or hide every portal on the large map at any time.");
			ShowWorldWhileLoading = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Show World While Loading", false, "If on, the screen is not held black while the destination loads. Feels faster but shows the half loaded world.");
			SkipLoadingObjects = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Skip Loading Objects", false, "Arrive once the terrain is ready without waiting for every object. Warning: you can land on a lower floor of a building.");
			SkipLoadingArea = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Skip Loading Area", false, "Instant arrival, the world loads around you. Warning: you arrive before the world exists.");
			SettleSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Extra Load Wait", 0.5f, "Seconds to keep waiting after a cold destination reports ready. Terrain is generated locally and reports ready almost instantly while buildings and creatures still come from the server, so this short wait is what prevents arriving in an empty world.\nDestinations already loaded when leaving are always instant and never wait. Ignored by the skip options.");
			new Harmony("ashr4f.bifrost").PatchAll();
		}

		internal static string T(string en, string fr)
		{
			if (Localization.instance == null || !(Localization.instance.GetSelectedLanguage() == "French"))
			{
				return en;
			}
			return fr;
		}

		private void LateUpdate()
		{
			if ((Object)(object)Minimap.instance != (Object)null)
			{
				PortalGui.AfterUpdatePins(Minimap.instance);
			}
			if (!Enabled.Value || !QuickTravel.Value || ShowWorldWhileLoading.Value)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && localPlayer.m_teleporting && !((Object)(object)Hud.instance == (Object)null) && !TravelGate.ArrivalAllowed(localPlayer))
			{
				if (!_blackSearched)
				{
					_blackSearched = true;
					_blackField = HudVeil.Find();
				}
				if (!(_blackField == null))
				{
					HudVeil.Keep(_blackField.GetValue(Hud.instance));
				}
			}
		}
	}
	internal static class HudVeil
	{
		internal static FieldInfo? Find()
		{
			string[] array = new string[4] { "m_blackScreen", "m_loadingScreen", "m_loadingScreenPanel", "m_black" };
			foreach (string name in array)
			{
				FieldInfo field = typeof(Hud).GetField(name, AccessTools.all);
				if (field != null && IsUsable(field.FieldType))
				{
					return field;
				}
			}
			FieldInfo[] fields = typeof(Hud).GetFields(AccessTools.all);
			foreach (FieldInfo fieldInfo in fields)
			{
				string text = fieldInfo.Name.ToLowerInvariant();
				if ((text.Contains("black") || text.Contains("loading")) && IsUsable(fieldInfo.FieldType))
				{
					return fieldInfo;
				}
			}
			BifrostPlugin.Log.LogWarning((object)"Bifrost: loading veil not found, the world stays visible while a destination loads.");
			return null;
		}

		private static bool IsUsable(Type type)
		{
			if (!typeof(CanvasGroup).IsAssignableFrom(type) && !typeof(GameObject).IsAssignableFrom(type))
			{
				return typeof(Component).IsAssignableFrom(type);
			}
			return true;
		}

		internal static void Keep(object? value)
		{
			GameObject val = null;
			CanvasGroup val2 = (CanvasGroup)((value is CanvasGroup) ? value : null);
			if (val2 != null && Object.op_Implicit((Object)(object)val2))
			{
				val = ((Component)val2).gameObject;
			}
			else
			{
				GameObject val3 = (GameObject)((value is GameObject) ? value : null);
				if (val3 != null && Object.op_Implicit((Object)(object)val3))
				{
					val = val3;
				}
				else
				{
					Component val4 = (Component)((value is Component) ? value : null);
					if (val4 != null && Object.op_Implicit((Object)(object)val4))
					{
						val = val4.gameObject;
					}
				}
			}
			if (!((Object)(object)val == (Object)null))
			{
				if (!val.activeSelf)
				{
					val.SetActive(true);
				}
				CanvasGroup val5 = val.GetComponent<CanvasGroup>();
				if ((Object)(object)val5 == (Object)null)
				{
					val5 = val.AddComponent<CanvasGroup>();
				}
				if (val5.alpha != 1f)
				{
					val5.alpha = 1f;
				}
			}
		}
	}
	internal static class PortalSync
	{
		internal struct Entry
		{
			public Vector3 pos;

			public float rotY;

			public string tag;
		}

		internal static readonly List<Entry> Portals = new List<Entry>();

		internal static Action? OnPortalsUpdated;

		internal static void RegisterRpcs()
		{
			ZRoutedRpc.instance.Register("Bifrost_RequestPortals", (Action<long>)OnRequest);
			ZRoutedRpc.instance.Register<ZPackage>("Bifrost_Portals", (Action<long, ZPackage>)OnReceive);
		}

		internal static void Request()
		{
			if (!((Object)(object)ZNet.instance == (Object)null))
			{
				if (ZNet.instance.IsServer())
				{
					Portals.Clear();
					Portals.AddRange(Collect());
					OnPortalsUpdated?.Invoke();
				}
				else
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "Bifrost_RequestPortals", Array.Empty<object>());
				}
			}
		}

		private static void OnRequest(long sender)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			ZPackage val = new ZPackage();
			List<Entry> list = Collect();
			val.Write(list.Count);
			foreach (Entry item in list)
			{
				val.Write(item.pos);
				val.Write(item.rotY);
				val.Write(item.tag);
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(sender, "Bifrost_Portals", new object[1] { val });
		}

		private static void OnReceive(long sender, ZPackage pkg)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Portals.Clear();
			int num = pkg.ReadInt();
			for (int i = 0; i < num; i++)
			{
				Entry item = new Entry
				{
					pos = pkg.ReadVector3(),
					rotY = pkg.ReadSingle(),
					tag = pkg.ReadString()
				};
				Portals.Add(item);
			}
			OnPortalsUpdated?.Invoke();
		}

		private static List<Entry> Collect()
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			List<Entry> list = new List<Entry>();
			if (ZDOMan.instance == null)
			{
				return list;
			}
			string[] array = BifrostPlugin.PortalPrefabs.Value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length == 0)
				{
					continue;
				}
				List<ZDO> list2 = new List<ZDO>();
				int num = 0;
				while (!ZDOMan.instance.GetAllZDOsWithPrefabIterative(text, list2, ref num))
				{
				}
				foreach (ZDO item2 in list2)
				{
					Entry item = new Entry
					{
						pos = item2.GetPosition()
					};
					Quaternion rotation = item2.GetRotation();
					item.rotY = ((Quaternion)(ref rotation)).eulerAngles.y;
					item.tag = item2.GetString("tag", "");
					list.Add(item);
				}
			}
			return list;
		}
	}
	[HarmonyPatch(typeof(Game), "Start")]
	internal static class Game_Start_Patch
	{
		private static void Postfix()
		{
			PortalSync.RegisterRpcs();
			PortalGui.ResetAll();
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "Interact")]
	internal static class TeleportWorld_Interact_Patch
	{
		private static bool Prefix(TeleportWorld __instance, Humanoid human, bool hold, ref bool __result)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (!BifrostPlugin.Enabled.Value)
			{
				return true;
			}
			if ((Object)(object)human != (Object)(object)Player.m_localPlayer)
			{
				return true;
			}
			if (hold)
			{
				__result = true;
				return false;
			}
			if (Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303))
			{
				if (!PrivateArea.CheckAccess(((Component)__instance).transform.position, 0f, true, false))
				{
					__result = true;
					return false;
				}
				TextInput.instance.RequestText((TextReceiver)(object)__instance, "$piece_portal_tag", 10);
				__result = true;
				return false;
			}
			PortalGui.Open(__instance);
			__result = true;
			return false;
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "GetHoverText")]
	internal static class TeleportWorld_GetHoverText_Patch
	{
		private static void Postfix(TeleportWorld __instance, ref string __result)
		{
			if (BifrostPlugin.Enabled.Value)
			{
				string text = __instance.GetText();
				string text2 = (string.IsNullOrEmpty(text) ? "$piece_portal" : ("$piece_portal \"" + text + "\""));
				__result = Localization.instance.Localize(text2 + "\n[<color=yellow><b>$KEY_Use</b></color>] " + BifrostPlugin.T("Choose destination", "Choisir la destination") + "\n[<color=yellow><b>Shift + $KEY_Use</b></color>] $piece_portal_settag");
			}
		}
	}
	[HarmonyPatch]
	internal static class TeleportWorld_Target_Patch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			string[] array = new string[2] { "HaveTarget", "TargetFound" };
			foreach (string text in array)
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(TeleportWorld), text, (Type[])null, (Type[])null);
				if (methodInfo != null && methodInfo.ReturnType == typeof(bool))
				{
					yield return methodInfo;
				}
			}
		}

		private static void Postfix(ref bool __result)
		{
			if (BifrostPlugin.Enabled.Value)
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "Teleport", new Type[] { typeof(Player) })]
	internal static class TeleportWorld_Teleport_Patch
	{
		private static bool Prefix(TeleportWorld __instance, Player player)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Invalid comparison between Unknown and I4
			if (!BifrostPlugin.Enabled.Value || !BifrostPlugin.OpenOnEnter.Value)
			{
				return true;
			}
			if ((Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return true;
			}
			if (player.m_teleporting || Time.time < PortalGui.SuppressUntil)
			{
				return false;
			}
			if ((Object)(object)Minimap.instance == (Object)null || (int)Minimap.instance.m_mode == 2)
			{
				return false;
			}
			PortalGui.Open(__instance);
			return false;
		}
	}
	internal static class PortalGui
	{
		private static bool _open;

		private static bool _browse;

		internal static float SuppressUntil;

		private static Vector3 _sourcePos;

		private static readonly List<KeyValuePair<PinData, PortalSync.Entry>> _pins = new List<KeyValuePair<PinData, PortalSync.Entry>>();

		private static readonly List<PinData> _browsePins = new List<PinData>();

		private static readonly List<FieldInfo> _pinGoFields = new List<FieldInfo>();

		private static readonly List<KeyValuePair<FieldInfo, FieldInfo>> _pinNestedGoFields = new List<KeyValuePair<FieldInfo, FieldInfo>>();

		private static bool _fieldsSearched;

		private static string _keepRaw = "";

		private static readonly HashSet<string> _keepTypes = new HashSet<string>();

		private static readonly HashSet<CanvasGroup> _hidden = new HashSet<CanvasGroup>();

		private static MethodInfo? _addPin;

		internal static bool IsOpen => _open;

		internal static void ResetAll()
		{
			_open = false;
			_browse = false;
			_pins.Clear();
			_browsePins.Clear();
			_hidden.Clear();
		}

		internal static void Open(TeleportWorld portal)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Minimap.instance == (Object)null) && !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				_sourcePos = ((Component)portal).transform.position;
				_open = true;
				PortalSync.OnPortalsUpdated = OnData;
				PortalSync.Request();
				Minimap.instance.SetMapMode((MapMode)2);
				RebuildPins();
				((Character)Player.m_localPlayer).Message((MessageType)2, BifrostPlugin.T("Choose a destination portal", "Choisis un portail de destination"), 0, (Sprite)null);
			}
		}

		internal static void Close()
		{
			if (!_open)
			{
				return;
			}
			_open = false;
			foreach (KeyValuePair<PinData, PortalSync.Entry> pin in _pins)
			{
				Minimap instance = Minimap.instance;
				if (instance != null)
				{
					instance.RemovePin(pin.Key);
				}
			}
			_pins.Clear();
			RestoreHidden();
		}

		internal static void ToggleBrowse()
		{
			_browse = !_browse;
			if (_browse)
			{
				PortalSync.OnPortalsUpdated = OnData;
				PortalSync.Request();
				RebuildBrowse();
			}
			else
			{
				ClearBrowse();
			}
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, _browse ? BifrostPlugin.T("Portals shown", "Portails affichés") : BifrostPlugin.T("Portals hidden", "Portails masqués"), 0, (Sprite)null);
			}
		}

		private static void OnData()
		{
			if (_open)
			{
				RebuildPins();
			}
			if (_browse)
			{
				RebuildBrowse();
			}
		}

		private static void RebuildPins()
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if (!_open || (Object)(object)Minimap.instance == (Object)null)
			{
				return;
			}
			foreach (KeyValuePair<PinData, PortalSync.Entry> pin in _pins)
			{
				Minimap.instance.RemovePin(pin.Key);
			}
			_pins.Clear();
			foreach (PortalSync.Entry portal in PortalSync.Portals)
			{
				if (!(Vector3.Distance(portal.pos, _sourcePos) < 3f))
				{
					PinData val = AddPinDirect(portal.pos, portal.tag ?? "");
					if (val != null)
					{
						_pins.Add(new KeyValuePair<PinData, PortalSync.Entry>(val, portal));
					}
				}
			}
		}

		private static void ClearBrowse()
		{
			foreach (PinData browsePin in _browsePins)
			{
				Minimap instance = Minimap.instance;
				if (instance != null)
				{
					instance.RemovePin(browsePin);
				}
			}
			_browsePins.Clear();
		}

		private static void RebuildBrowse()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (!_browse || (Object)(object)Minimap.instance == (Object)null)
			{
				return;
			}
			ClearBrowse();
			foreach (PortalSync.Entry portal in PortalSync.Portals)
			{
				PinData val = AddPinDirect(portal.pos, portal.tag ?? "");
				if (val != null)
				{
					_browsePins.Add(val);
				}
			}
		}

		internal static void AfterUpdatePins(Minimap map)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if (!_open || !BifrostPlugin.HideOtherPins.Value)
			{
				return;
			}
			HashSet<PinData> hashSet = new HashSet<PinData>();
			foreach (KeyValuePair<PinData, PortalSync.Entry> pin in _pins)
			{
				hashSet.Add(pin.Key);
			}
			foreach (PinData pin2 in map.m_pins)
			{
				if (!hashSet.Contains(pin2) && !IsAlwaysVisible(pin2.m_type))
				{
					try
					{
						HideAllVisuals(pin2);
					}
					catch
					{
					}
				}
			}
		}

		private unsafe static bool IsAlwaysVisible(PinType type)
		{
			string value = BifrostPlugin.KeepPinTypes.Value;
			if (value != _keepRaw)
			{
				_keepRaw = value;
				_keepTypes.Clear();
				string[] array = value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
				for (int i = 0; i < array.Length; i++)
				{
					string text = array[i].Trim();
					if (text.Length > 0)
					{
						_keepTypes.Add(text.ToLowerInvariant());
					}
				}
			}
			return _keepTypes.Contains(((object)(*(PinType*)(&type))/*cast due to .constrained prefix*/).ToString().ToLowerInvariant());
		}

		private static void CachePinFields()
		{
			_fieldsSearched = true;
			FieldInfo[] fields = typeof(PinData).GetFields(AccessTools.all);
			foreach (FieldInfo fieldInfo in fields)
			{
				if (typeof(GameObject).IsAssignableFrom(fieldInfo.FieldType) || typeof(Component).IsAssignableFrom(fieldInfo.FieldType))
				{
					_pinGoFields.Add(fieldInfo);
				}
				else
				{
					if (!fieldInfo.FieldType.IsClass || !(fieldInfo.FieldType != typeof(string)) || typeof(Object).IsAssignableFrom(fieldInfo.FieldType))
					{
						continue;
					}
					FieldInfo[] fields2 = fieldInfo.FieldType.GetFields(AccessTools.all);
					foreach (FieldInfo fieldInfo2 in fields2)
					{
						if (typeof(GameObject).IsAssignableFrom(fieldInfo2.FieldType) || typeof(Component).IsAssignableFrom(fieldInfo2.FieldType))
						{
							_pinNestedGoFields.Add(new KeyValuePair<FieldInfo, FieldInfo>(fieldInfo, fieldInfo2));
						}
					}
				}
			}
		}

		private static void HideAllVisuals(PinData pin)
		{
			if (!_fieldsSearched)
			{
				CachePinFields();
			}
			foreach (FieldInfo pinGoField in _pinGoFields)
			{
				Deactivate(pinGoField.GetValue(pin));
			}
			foreach (KeyValuePair<FieldInfo, FieldInfo> pinNestedGoField in _pinNestedGoFields)
			{
				object value = pinNestedGoField.Key.GetValue(pin);
				if (value != null)
				{
					Deactivate(pinNestedGoField.Value.GetValue(value));
				}
			}
		}

		private static void Deactivate(object? value)
		{
			GameObject val = null;
			GameObject val2 = (GameObject)((value is GameObject) ? value : null);
			if (val2 != null && Object.op_Implicit((Object)(object)val2))
			{
				val = val2;
			}
			else
			{
				Component val3 = (Component)((value is Component) ? value : null);
				if (val3 != null && Object.op_Implicit((Object)(object)val3))
				{
					val = val3.gameObject;
				}
			}
			if (!((Object)(object)val == (Object)null))
			{
				CanvasGroup val4 = val.GetComponent<CanvasGroup>();
				if ((Object)(object)val4 == (Object)null)
				{
					val4 = val.AddComponent<CanvasGroup>();
				}
				if (val4.alpha != 0f)
				{
					val4.alpha = 0f;
					val4.blocksRaycasts = false;
				}
				_hidden.Add(val4);
			}
		}

		private static void RestoreHidden()
		{
			foreach (CanvasGroup item in _hidden)
			{
				if (!((Object)(object)item == (Object)null))
				{
					item.alpha = 1f;
					item.blocksRaycasts = true;
				}
			}
			_hidden.Clear();
		}

		private static PinData? AddPinDirect(Vector3 pos, string name)
		{
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Minimap.instance == (Object)null)
			{
				return null;
			}
			try
			{
				PinData val = new PinData();
				val.m_type = (PinType)6;
				val.m_name = name;
				val.m_pos = pos;
				val.m_save = false;
				val.m_checked = false;
				foreach (SpriteData icon in Minimap.instance.m_icons)
				{
					if ((int)icon.m_name == 6)
					{
						val.m_icon = icon.m_icon;
						break;
					}
				}
				try
				{
					if (!string.IsNullOrEmpty(name))
					{
						FieldInfo fieldInfo = AccessTools.Field(typeof(PinData), "m_NamePinData");
						if (fieldInfo != null)
						{
							fieldInfo.SetValue(val, Activator.CreateInstance(fieldInfo.FieldType, val));
						}
					}
				}
				catch
				{
				}
				Minimap.instance.m_pins.Add(val);
				return val;
			}
			catch (Exception ex)
			{
				BifrostPlugin.Log.LogWarning((object)("Bifrost: direct pin failed (" + ex.Message + "), falling back to AddPin."));
				return AddPinCompat(pos, name);
			}
		}

		private static PinData? AddPinCompat(Vector3 pos, string name)
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			if (_addPin == null)
			{
				MethodInfo[] methods = typeof(Minimap).GetMethods(AccessTools.all);
				foreach (MethodInfo methodInfo in methods)
				{
					ParameterInfo[] parameters = methodInfo.GetParameters();
					if (methodInfo.Name == "AddPin" && parameters.Length >= 5 && parameters[0].ParameterType == typeof(Vector3) && parameters[2].ParameterType == typeof(string))
					{
						_addPin = methodInfo;
						break;
					}
				}
				if (_addPin == null)
				{
					BifrostPlugin.Log.LogWarning((object)"Bifrost: Minimap.AddPin not found.");
					return null;
				}
			}
			ParameterInfo[] parameters2 = _addPin.GetParameters();
			object[] array = new object[parameters2.Length];
			array[0] = pos;
			array[1] = (object)(PinType)6;
			array[2] = name;
			array[3] = false;
			array[4] = false;
			for (int j = 5; j < parameters2.Length; j++)
			{
				Type parameterType = parameters2[j].ParameterType;
				array[j] = (parameterType.IsValueType ? Activator.CreateInstance(parameterType) : null);
			}
			object? obj = _addPin.Invoke(Minimap.instance, array);
			return (PinData?)((obj is PinData) ? obj : null);
		}

		internal static bool HandleMapClick()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			if (!_open || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			Vector3 val = Minimap.instance.ScreenToWorldPoint(Input.mousePosition);
			float num = Minimap.instance.m_removeRadius * (Minimap.instance.m_largeZoom * 2f);
			bool flag = false;
			PortalSync.Entry entry = default(PortalSync.Entry);
			float num2 = float.MaxValue;
			foreach (KeyValuePair<PinData, PortalSync.Entry> pin in _pins)
			{
				Vector3 pos = pin.Value.pos;
				float num3 = Vector2.Distance(new Vector2(pos.x, pos.z), new Vector2(val.x, val.z));
				if (num3 < num && num3 < num2)
				{
					num2 = num3;
					entry = pin.Value;
					flag = true;
				}
			}
			if (flag)
			{
				Teleport(entry);
			}
			return true;
		}

		private static void Teleport(PortalSync.Entry entry)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				if (!BifrostPlugin.IgnoreRestrictions.Value && !((Humanoid)localPlayer).IsTeleportable())
				{
					((Character)localPlayer).Message((MessageType)2, BifrostPlugin.T("You carry something that cannot pass through", "Tu portes un objet qui ne passe pas le portail"), 0, (Sprite)null);
					Minimap.instance.SetMapMode((MapMode)1);
					return;
				}
				Quaternion val = Quaternion.Euler(0f, entry.rotY, 0f);
				Vector3 val2 = entry.pos + val * Vector3.forward * 1.2f + Vector3.up * 0.5f;
				SuppressUntil = Time.time + 5f;
				((Character)localPlayer).TeleportTo(val2, val, true);
				Minimap.instance.SetMapMode((MapMode)1);
			}
		}
	}
	[HarmonyPatch(typeof(Minimap), "SetMapMode")]
	internal static class Minimap_SetMapMode_Patch
	{
		private static void Postfix(MapMode mode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)mode != 2)
			{
				PortalGui.Close();
			}
		}
	}
	[HarmonyPatch(typeof(Minimap), "Update")]
	internal static class Minimap_Update_Patch
	{
		private static void Postfix(Minimap __instance)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (!BifrostPlugin.Enabled.Value)
			{
				return;
			}
			PortalGui.AfterUpdatePins(__instance);
			if ((int)__instance.m_mode == 2 && !Minimap.InTextInput() && !PortalGui.IsOpen)
			{
				KeyboardShortcut value = BifrostPlugin.MapToggleKey.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					PortalGui.ToggleBrowse();
				}
			}
		}
	}
	[HarmonyPatch(typeof(Minimap), "UpdatePins")]
	internal static class Minimap_UpdatePins_Patch
	{
		private static void Postfix(Minimap __instance)
		{
			PortalGui.AfterUpdatePins(__instance);
		}
	}
	[HarmonyPatch(typeof(Minimap), "OnMapLeftClick")]
	internal static class Minimap_OnMapLeftClick_Patch
	{
		private static bool Prefix()
		{
			return !PortalGui.HandleMapClick();
		}
	}
	[HarmonyPatch(typeof(Minimap), "OnMapDblClick")]
	internal static class Minimap_OnMapDblClick_Patch
	{
		private static bool Prefix()
		{
			return !PortalGui.IsOpen;
		}
	}
	[HarmonyPatch(typeof(Player), "SetControls")]
	internal static class Player_SetControls_Patch
	{
		private static void Prefix(Player __instance, ref Vector3 movedir, ref bool jump, ref bool autoRun)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (PortalGui.IsOpen && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				movedir = Vector3.zero;
				jump = false;
				autoRun = false;
			}
		}
	}
	internal static class TravelGate
	{
		private const float MaxHold = 12f;

		private static float _readySince = -1f;

		private static float _holdSince = -1f;

		private static Vector3 _target;

		private static bool _wasWarm;

		internal static bool IsWarm => _wasWarm;

		internal static void Reset()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			_readySince = -1f;
			_holdSince = -1f;
			_target = Vector3.zero;
		}

		internal static bool ArrivalAllowed(Player player)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			if (!BifrostPlugin.Enabled.Value)
			{
				return true;
			}
			if (BifrostPlugin.SkipLoadingArea.Value)
			{
				return true;
			}
			Vector3 teleportTargetPos = player.m_teleportTargetPos;
			if (teleportTargetPos != _target)
			{
				_target = teleportTargetPos;
				_readySince = -1f;
				_holdSince = Time.time;
				_wasWarm = (Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.IsZoneLoaded(teleportTargetPos) && (Object)(object)ZNetScene.instance != (Object)null && ZNetScene.instance.IsAreaReady(teleportTargetPos);
			}
			if (_wasWarm)
			{
				return true;
			}
			if (_holdSince > 0f && Time.time - _holdSince >= 12f)
			{
				return true;
			}
			if (!((Object)(object)ZoneSystem.instance != (Object)null) || !ZoneSystem.instance.IsZoneLoaded(teleportTargetPos))
			{
				return false;
			}
			if (BifrostPlugin.SkipLoadingObjects.Value)
			{
				return true;
			}
			if ((Object)(object)ZNetScene.instance == (Object)null || !ZNetScene.instance.IsAreaReady(teleportTargetPos))
			{
				_readySince = -1f;
				return false;
			}
			if (_readySince < 0f)
			{
				_readySince = Time.time;
			}
			return Time.time - _readySince >= Mathf.Max(0f, BifrostPlugin.SettleSeconds.Value);
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateTeleport")]
	internal static class Player_Teleport_Reset_Patch
	{
		[HarmonyPriority(800)]
		private static void Prefix(Player __instance)
		{
			if (!__instance.m_teleporting)
			{
				TravelGate.Reset();
			}
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "IsAreaReady")]
	internal static class ZNetScene_IsAreaReady_Patch
	{
		private static void Postfix(Vector3 point, ref bool __result)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			if (__result || !BifrostPlugin.Enabled.Value || !BifrostPlugin.QuickTravel.Value)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && localPlayer.m_teleporting && !(Vector3.Distance(point, localPlayer.m_teleportTargetPos) > 4f))
			{
				if (BifrostPlugin.SkipLoadingArea.Value)
				{
					__result = true;
				}
				else if (BifrostPlugin.SkipLoadingObjects.Value && (Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.IsZoneLoaded(point))
				{
					__result = true;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateTeleport")]
	internal static class Player_UpdateTeleport_Patch
	{
		private const float ColdFloor = 0.35f;

		[HarmonyPriority(0)]
		private static void Prefix(Player __instance, ref float ___m_teleportTimer)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if (BifrostPlugin.Enabled.Value && BifrostPlugin.QuickTravel.Value && __instance.m_teleporting)
			{
				bool flag = TravelGate.ArrivalAllowed(__instance);
				if ((TravelGate.IsWarm || !(___m_teleportTimer < 0.35f) || ((Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.IsZoneLoaded(__instance.m_teleportTargetPos))) && ___m_teleportTimer < 20f && flag)
				{
					___m_teleportTimer = 20f;
				}
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}