using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;
using AutoStart.Core;
using AutoStart.Core.Lobby;
using AutoStart.Patch;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Cysharp.Threading.Tasks;
using Cysharp.Threading.Tasks.CompilerServices;
using FastStartup;
using FastStartup.Config;
using GameNetcodeStuff;
using HarmonyLib;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("AutoStart")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+294443216747e9cbad8758752bca757cb9cd0397")]
[assembly: AssemblyProduct("AutoStart")]
[assembly: AssemblyTitle("AutoStart")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace AutoStart
{
	[BepInPlugin("qwbarch.AutoStart", "AutoStart", "1.1.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	internal class Plugin : BaseUnityPlugin
	{
		internal const string PluginId = "qwbarch.AutoStart";

		internal const string PluginName = "AutoStart";

		internal const string PluginVersion = "1.1.1";

		private void Awake()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			Logger.LogInfo("Loading AutoStart.");
			LockFile.WithLock(delegate
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				ConfigEntry<LaunchMode> autoLaunchMode = Plugin.Config.AutoLaunchMode;
				LaunchMode val2 = (LaunchMode)1;
				((ConfigEntryBase)autoLaunchMode).SetSerializedValue(((object)(LaunchMode)(ref val2)).ToString());
				Config.InitConfig((BaseUnityPlugin)(object)this);
			});
			if (Config.AutoStart.Enabled.Value)
			{
				UniTaskExtensions.Forget(LobbyHost.Start());
				Harmony val = new Harmony("qwbarch.AutoStart");
				val.PatchAll(typeof(StartGame));
			}
			else
			{
				Logger.LogInfo("AutoStart is disabled.");
			}
		}
	}
}
namespace AutoStart.Patch
{
	internal static class StartGame
	{
		private static int ConnectedPlayers;

		[HarmonyPrefix]
		[HarmonyPatch(typeof(GameNetworkManager), "Start")]
		private static async void StartGameWhenReady()
		{
			SceneManager.GetSceneByName("MainMenu");
			while (true)
			{
				Scene sceneByName = SceneManager.GetSceneByName("MainMenu");
				if (((Scene)(ref sceneByName)).isLoaded)
				{
					break;
				}
				await Task.Yield();
			}
			MenuManager menuManager = Object.FindObjectOfType<MenuManager>();
			if (LobbyHost.IsHosting)
			{
				LockFile.WithLock(delegate
				{
					GameNetworkManager.Instance.currentSaveFileName = Config.AutoStart.SaveFile.Value;
				});
				menuManager.ConfirmHostButton();
			}
			else
			{
				UniTaskExtensions.Forget(LobbyParticipant.JoinLobby(menuManager));
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		private static void SetLobbyHostReady(PlayerControllerB __instance)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)__instance).IsHost && Config.AutoPullLever.Enabled.Value)
			{
				if (Config.AutoPullLever.PlayersRequired.Value == 0)
				{
					StartOfRound.Instance.StartGame();
				}
				else
				{
					UniTaskExtensions.Forget(LobbyHost.SetLobbyReady());
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "OnClientConnect")]
		private static void IncrementPlayerCount(StartOfRound __instance)
		{
			if (((NetworkBehaviour)__instance).IsHost && Config.AutoPullLever.Enabled.Value)
			{
				ConnectedPlayers++;
				if (ConnectedPlayers == Config.AutoPullLever.PlayersRequired.Value)
				{
					__instance.StartGame();
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "OnClientDisconnect")]
		private static void DecrementPlayerCount(StartOfRound __instance)
		{
			if (((NetworkBehaviour)__instance).IsHost && Config.AutoPullLever.Enabled.Value)
			{
				ConnectedPlayers--;
			}
		}
	}
}
namespace AutoStart.Core
{
	internal static class Config
	{
		internal static class AutoStart
		{
			internal const string Section = "AutoStart";

			internal static ConfigEntry<bool> Enabled;

			internal static ConfigEntry<string> SaveFile;
		}

		internal static class AutoPullLever
		{
			internal const string Section = "AutoPullLever";

			internal static ConfigEntry<bool> Enabled;

			internal static ConfigEntry<int> PlayersRequired;
		}

		private static readonly string[] SaveFiles = new string[4] { "LCSaveFile1", "LCSaveFile2", "LCSaveFile3", "LCChallengeFile" };

		internal static void InitConfig(BaseUnityPlugin plugin)
		{
			AutoStart.Enabled = plugin.Config.Bind<bool>("AutoStart", "Enabled", true, "Whether or not the plugin should be enabled.");
			AutoStart.SaveFile = plugin.Config.Bind<string>("AutoStart", "SaveFile", "LCSaveFile1", "Possible vanilla values: " + string.Join(", ", SaveFiles));
			AutoPullLever.Enabled = plugin.Config.Bind<bool>("AutoPullLever", "Enabled", true, "Whether or not the start lever should be automatically pulled.");
			AutoPullLever.PlayersRequired = plugin.Config.Bind<int>("AutoPullLever", "PlayersRequired", 0, "Required number of players in the lobby for the lever to be pulled (excluding the host).");
		}
	}
	internal static class LockFile
	{
		public static void WithLock(Action action)
		{
			using EventWaitHandle eventWaitHandle = new EventWaitHandle(initialState: true, EventResetMode.AutoReset, "qwbarch.AutoStart");
			try
			{
				eventWaitHandle.WaitOne();
				action();
			}
			finally
			{
				eventWaitHandle.Set();
			}
		}
	}
	internal static class Logger
	{
		private static readonly ManualLogSource Source = Logger.CreateLogSource("qwbarch.AutoStart");

		internal static void LogInfo(string message)
		{
			Source.LogInfo((object)message);
		}

		internal static void LogDebug(string message)
		{
			Source.LogDebug((object)message);
		}

		internal static void LogWarning(string message)
		{
			Source.LogWarning((object)message);
		}

		internal static void LogError(string message)
		{
			Source.LogError((object)message);
		}
	}
}
namespace AutoStart.Core.Lobby
{
	internal static class LobbyHost
	{
		[CompilerGenerated]
		private sealed class <SendReady>d__7 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder <>t__builder;

			public TcpClient client;

			private NetworkStream <stream>5__1;

			private TaskAwaiter <>u__1;

			private void MoveNext()
			{
				int num = <>1__state;
				try
				{
					if (num != 0)
					{
					}
					try
					{
						if (num != 0)
						{
							<stream>5__1 = client.GetStream();
						}
						try
						{
							TaskAwaiter awaiter;
							if (num != 0)
							{
								awaiter = <stream>5__1.WriteAsync(new byte[0], 0, 0).GetAwaiter();
								if (!awaiter.IsCompleted)
								{
									num = (<>1__state = 0);
									<>u__1 = awaiter;
									<SendReady>d__7 <SendReady>d__ = this;
									((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter, <SendReady>d__7>(ref awaiter, ref <SendReady>d__);
									return;
								}
							}
							else
							{
								awaiter = <>u__1;
								<>u__1 = default(TaskAwaiter);
								num = (<>1__state = -1);
							}
							awaiter.GetResult();
						}
						finally
						{
							if (num < 0 && <stream>5__1 != null)
							{
								((IDisposable)<stream>5__1).Dispose();
							}
						}
						<stream>5__1 = null;
					}
					finally
					{
						if (num < 0)
						{
							client.Close();
						}
					}
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
					return;
				}
				<>1__state = -2;
				((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		[CompilerGenerated]
		private sealed class <SetLobbyReady>d__8 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder <>t__builder;

			private LinkedList<TcpClient>.Enumerator <>s__1;

			private TcpClient <client>5__2;

			private Awaiter <>u__1;

			private void MoveNext()
			{
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: 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_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_0060: 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_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				try
				{
					if (num == 0)
					{
						goto IL_0034;
					}
					if (_IsHosting)
					{
						IsReady = true;
						<>s__1 = Clients.GetEnumerator();
						goto IL_0034;
					}
					goto end_IL_0007;
					IL_0034:
					try
					{
						if (num != 0)
						{
							goto IL_00c3;
						}
						Awaiter awaiter = <>u__1;
						<>u__1 = default(Awaiter);
						num = (<>1__state = -1);
						goto IL_00b3;
						IL_00c3:
						if (<>s__1.MoveNext())
						{
							<client>5__2 = <>s__1.Current;
							UniTask val = SendReady(<client>5__2);
							awaiter = ((UniTask)(ref val)).GetAwaiter();
							if (!((Awaiter)(ref awaiter)).IsCompleted)
							{
								num = (<>1__state = 0);
								<>u__1 = awaiter;
								<SetLobbyReady>d__8 <SetLobbyReady>d__ = this;
								((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <SetLobbyReady>d__8>(ref awaiter, ref <SetLobbyReady>d__);
								return;
							}
							goto IL_00b3;
						}
						goto end_IL_0034;
						IL_00b3:
						((Awaiter)(ref awaiter)).GetResult();
						<client>5__2 = null;
						goto IL_00c3;
						end_IL_0034:;
					}
					finally
					{
						if (num < 0)
						{
							((IDisposable)<>s__1).Dispose();
						}
					}
					<>s__1 = default(LinkedList<TcpClient>.Enumerator);
					Clients.Clear();
					end_IL_0007:;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
					return;
				}
				<>1__state = -2;
				((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		[CompilerGenerated]
		private sealed class <Start>d__9 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder <>t__builder;

			private TcpListener <listener>5__1;

			private TcpClient <client>5__2;

			private TcpClient <>s__3;

			private TaskAwaiter<TcpClient> <>u__1;

			private Awaiter <>u__2;

			private void MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_0115: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0152: Unknown result type (might be due to invalid IL or missing references)
				//IL_0157: Unknown result type (might be due to invalid IL or missing references)
				//IL_015f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				try
				{
					if ((uint)num <= 1u)
					{
						goto IL_006f;
					}
					<listener>5__1 = new TcpListener(IPAddress.Parse("127.0.0.1"), 7777);
					try
					{
						<listener>5__1.Start();
						_IsHosting = true;
						Logger.LogInfo("LobbyHost is enabled. Waiting for participants.");
					}
					catch (SocketException)
					{
						Logger.LogInfo("LobbyHost is disabled. Waiting for host to be ready before joining.");
					}
					if (_IsHosting)
					{
						goto IL_0199;
					}
					goto end_IL_0007;
					IL_006f:
					try
					{
						Awaiter awaiter;
						TaskAwaiter<TcpClient> awaiter2;
						if (num != 0)
						{
							if (num == 1)
							{
								awaiter = <>u__2;
								<>u__2 = default(Awaiter);
								num = (<>1__state = -1);
								goto IL_016e;
							}
							awaiter2 = <listener>5__1.AcceptTcpClientAsync().GetAwaiter();
							if (!awaiter2.IsCompleted)
							{
								num = (<>1__state = 0);
								<>u__1 = awaiter2;
								<Start>d__9 <Start>d__ = this;
								((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter<TcpClient>, <Start>d__9>(ref awaiter2, ref <Start>d__);
								return;
							}
						}
						else
						{
							awaiter2 = <>u__1;
							<>u__1 = default(TaskAwaiter<TcpClient>);
							num = (<>1__state = -1);
						}
						<>s__3 = awaiter2.GetResult();
						<client>5__2 = <>s__3;
						<>s__3 = null;
						if (IsReady)
						{
							UniTask val = SendReady(<client>5__2);
							awaiter = ((UniTask)(ref val)).GetAwaiter();
							if (!((Awaiter)(ref awaiter)).IsCompleted)
							{
								num = (<>1__state = 1);
								<>u__2 = awaiter;
								<Start>d__9 <Start>d__ = this;
								((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter, <Start>d__9>(ref awaiter, ref <Start>d__);
								return;
							}
							goto IL_016e;
						}
						Clients.AddLast(<client>5__2);
						goto IL_0189;
						IL_016e:
						((Awaiter)(ref awaiter)).GetResult();
						goto IL_0189;
						IL_0189:
						<client>5__2 = null;
					}
					catch (SocketException)
					{
					}
					goto IL_0199;
					IL_0199:
					bool flag = true;
					goto IL_006f;
					end_IL_0007:;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<listener>5__1 = null;
					((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
					return;
				}
				<>1__state = -2;
				<listener>5__1 = null;
				((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		internal const string Host = "127.0.0.1";

		internal const int Port = 7777;

		private static readonly LinkedList<TcpClient> Clients = new LinkedList<TcpClient>();

		private static bool _IsHosting = false;

		private static bool IsReady = false;

		public static bool IsHosting => _IsHosting;

		[AsyncStateMachine(typeof(<SendReady>d__7))]
		[DebuggerStepThrough]
		private static UniTask SendReady(TcpClient client)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			<SendReady>d__7 <SendReady>d__ = new <SendReady>d__7();
			<SendReady>d__.<>t__builder = AsyncUniTaskMethodBuilder.Create();
			<SendReady>d__.client = client;
			<SendReady>d__.<>1__state = -1;
			((AsyncUniTaskMethodBuilder)(ref <SendReady>d__.<>t__builder)).Start<<SendReady>d__7>(ref <SendReady>d__);
			return ((AsyncUniTaskMethodBuilder)(ref <SendReady>d__.<>t__builder)).Task;
		}

		[AsyncStateMachine(typeof(<SetLobbyReady>d__8))]
		[DebuggerStepThrough]
		public static UniTask SetLobbyReady()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			<SetLobbyReady>d__8 <SetLobbyReady>d__ = new <SetLobbyReady>d__8();
			<SetLobbyReady>d__.<>t__builder = AsyncUniTaskMethodBuilder.Create();
			<SetLobbyReady>d__.<>1__state = -1;
			((AsyncUniTaskMethodBuilder)(ref <SetLobbyReady>d__.<>t__builder)).Start<<SetLobbyReady>d__8>(ref <SetLobbyReady>d__);
			return ((AsyncUniTaskMethodBuilder)(ref <SetLobbyReady>d__.<>t__builder)).Task;
		}

		[AsyncStateMachine(typeof(<Start>d__9))]
		[DebuggerStepThrough]
		public static UniTask Start()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			<Start>d__9 <Start>d__ = new <Start>d__9();
			<Start>d__.<>t__builder = AsyncUniTaskMethodBuilder.Create();
			<Start>d__.<>1__state = -1;
			((AsyncUniTaskMethodBuilder)(ref <Start>d__.<>t__builder)).Start<<Start>d__9>(ref <Start>d__);
			return ((AsyncUniTaskMethodBuilder)(ref <Start>d__.<>t__builder)).Task;
		}
	}
	internal static class LobbyParticipant
	{
		[CompilerGenerated]
		private sealed class <JoinLobby>d__0 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder <>t__builder;

			public MenuManager menuManager;

			private TcpClient <tcpClient>5__1;

			private NetworkStream <stream>5__2;

			private TaskAwaiter<int> <>u__1;

			private void MoveNext()
			{
				int num = <>1__state;
				try
				{
					TaskAwaiter<int> awaiter;
					if (num != 0)
					{
						<tcpClient>5__1 = new TcpClient("127.0.0.1", 7777);
						<stream>5__2 = <tcpClient>5__1.GetStream();
						awaiter = <stream>5__2.ReadAsync(new byte[0], 0, 0).GetAwaiter();
						if (!awaiter.IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = awaiter;
							<JoinLobby>d__0 <JoinLobby>d__ = this;
							((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter<int>, <JoinLobby>d__0>(ref awaiter, ref <JoinLobby>d__);
							return;
						}
					}
					else
					{
						awaiter = <>u__1;
						<>u__1 = default(TaskAwaiter<int>);
						num = (<>1__state = -1);
					}
					awaiter.GetResult();
					Logger.LogInfo("Lobby is ready! Attempting to join the game.");
					menuManager.StartAClient();
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<tcpClient>5__1 = null;
					<stream>5__2 = null;
					((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
					return;
				}
				<>1__state = -2;
				<tcpClient>5__1 = null;
				<stream>5__2 = null;
				((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		[AsyncStateMachine(typeof(<JoinLobby>d__0))]
		[DebuggerStepThrough]
		public static UniTask JoinLobby(MenuManager menuManager)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			<JoinLobby>d__0 <JoinLobby>d__ = new <JoinLobby>d__0();
			<JoinLobby>d__.<>t__builder = AsyncUniTaskMethodBuilder.Create();
			<JoinLobby>d__.menuManager = menuManager;
			<JoinLobby>d__.<>1__state = -1;
			((AsyncUniTaskMethodBuilder)(ref <JoinLobby>d__.<>t__builder)).Start<<JoinLobby>d__0>(ref <JoinLobby>d__);
			return ((AsyncUniTaskMethodBuilder)(ref <JoinLobby>d__.<>t__builder)).Task;
		}
	}
}