using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using HG.Reflection;
using IL.RoR2;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using On.RoR2.UI;
using ProperSave;
using R2API.Utils;
using RespawnButton.Patches;
using RoR2;
using RoR2.UI;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: OptIn]
[assembly: NetworkCompatibility(/*Could not decode attribute arguments.*/)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("RespawnButton")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+3e165d11156c273bc297d51c54dc96fcccb18dcf")]
[assembly: AssemblyProduct("RespawnButton")]
[assembly: AssemblyTitle("RespawnButton")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace RespawnButton
{
	internal static class LanguageFolderHandler
	{
		public static void Register(string searchFolder, string langFolderName = "lang")
		{
			string langFolderPath = Path.Combine(searchFolder, langFolderName);
			if (Directory.Exists(langFolderPath))
			{
				Language.collectLanguageRootFolders += delegate(List<string> folders)
				{
					folders.Add(langFolderPath);
				};
			}
		}
	}
	internal static class Log
	{
		private static readonly StringBuilder _sharedStringBuilder;

		private static readonly int _cachedCallerPathPrefixLength;

		private static ManualLogSource _logSource;

		static Log()
		{
			_sharedStringBuilder = new StringBuilder(256);
			_cachedCallerPathPrefixLength = getCallerPathPrefixLength("X:\\Git\\RoR2\\RespawnButton\\RespawnButton\\Log.cs");
			static int getCallerPathPrefixLength([CallerFilePath] string callerPath = null)
			{
				int num = callerPath.LastIndexOf("RespawnButton\\");
				if (num >= 0)
				{
					return num + "RespawnButton\\".Length;
				}
				Debug.LogError((object)"[RespawnButton] Logger failed to determine caller path prefix length");
				return 0;
			}
		}

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		private static StringBuilder AppendCallerPrefix(this StringBuilder stringBuilder, string callerPath, string callerMemberName, int callerLineNumber)
		{
			return stringBuilder.Append(callerPath, _cachedCallerPathPrefixLength, callerPath.Length - _cachedCallerPathPrefixLength).Append(':').Append(callerLineNumber)
				.Append(" (")
				.Append(callerMemberName)
				.Append("):");
		}

		private static StringBuilder buildCallerLogString(string callerPath, string callerMemberName, int callerLineNumber, object data)
		{
			return _sharedStringBuilder.Clear().AppendCallerPrefix(callerPath, callerMemberName, callerLineNumber).Append(' ')
				.Append(data);
		}

		internal static void Error(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
		{
			_logSource.LogError((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Error_NoCallerPrefix(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
		{
			_logSource.LogFatal((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Fatal_NoCallerPrefix(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
		{
			_logSource.LogInfo((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Info_NoCallerPrefix(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
		{
			_logSource.LogMessage((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Message_NoCallerPrefix(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
		{
			_logSource.LogWarning((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Warning_NoCallerPrefix(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	public class RespawnButtonController : MonoBehaviour
	{
		private Transform _respawnButtonInstance;

		private GameEndReportPanelController _gameEndPanelController;

		public bool IsVisible
		{
			get
			{
				if (Object.op_Implicit((Object)(object)_respawnButtonInstance))
				{
					return ((Component)_respawnButtonInstance).gameObject.activeSelf;
				}
				return false;
			}
			set
			{
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Expected O, but got Unknown
				if (IsVisible == value)
				{
					return;
				}
				if (!Object.op_Implicit((Object)(object)_respawnButtonInstance))
				{
					if (!value)
					{
						return;
					}
					MPButton continueButton = _gameEndPanelController.continueButton;
					if (Object.op_Implicit((Object)(object)continueButton))
					{
						GameObject val = Object.Instantiate<GameObject>(((Component)continueButton).gameObject, ((Component)continueButton).transform.parent);
						val.transform.SetAsLastSibling();
						((Object)val).name = "RespawnButton";
						HGButton component = val.GetComponent<HGButton>();
						((UnityEventBase)((Button)component).onClick).RemoveAllListeners();
						((UnityEvent)((Button)component).onClick).AddListener(new UnityAction(onRespawnClicked));
						((Selectable)component).interactable = shouldBeInteractable();
						LanguageTextMeshController componentInChildren = val.GetComponentInChildren<LanguageTextMeshController>();
						if (Object.op_Implicit((Object)(object)componentInChildren))
						{
							componentInChildren.token = "GAME_REPORT_SCREEN_RESPAWN_BUTTON_LABEL";
						}
						Transform val2 = val.transform.Find("GenericGlyph");
						if (Object.op_Implicit((Object)(object)val2))
						{
							((Component)val2).gameObject.SetActive(false);
						}
						_respawnButtonInstance = val.transform;
					}
				}
				else
				{
					((Component)_respawnButtonInstance).gameObject.SetActive(value);
				}
			}
		}

		private static bool shouldShowOnReportScreen(RunReport runReport)
		{
			if (!NetworkServer.dontListen)
			{
				Run instance = Run.instance;
				if (instance is EclipseRun || instance is WeeklyRun)
				{
					return false;
				}
			}
			if (runReport == null)
			{
				return false;
			}
			if (!Object.op_Implicit((Object)(object)runReport.gameEnding) || runReport.gameEnding.isWin)
			{
				return false;
			}
			return true;
		}

		private static bool shouldBeInteractable()
		{
			return Loading.CurrentSave != null;
		}

		private void Awake()
		{
			_gameEndPanelController = ((Component)this).GetComponent<GameEndReportPanelController>();
		}

		public void OnSetDisplayData(DisplayData newDisplayData)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			IsVisible = NetworkServer.active && shouldShowOnReportScreen(newDisplayData.runReport);
		}

		private void onRespawnClicked()
		{
			if (!Object.op_Implicit((Object)(object)Run.instance))
			{
				return;
			}
			SceneDef currentRunScene = SceneCatalog.mostRecentSceneDef;
			ProperSave_SaveFileDeletionHook.SuppressSaveFileDeletion = true;
			OverridePostRunDestinationPatch.OverridePostRunDestinationDelegate oldPostRunDestinationOverride = OverridePostRunDestinationPatch.PostRunDestinationOverride;
			OverridePostRunDestinationPatch.PostRunDestinationOverride = delegate
			{
				if (NetworkServer.active)
				{
					NetworkManager.singleton.ServerChangeScene("lobby");
				}
			};
			try
			{
				NetworkSession.instance.EndRun();
			}
			finally
			{
				((MonoBehaviour)RoR2Application.instance).StartCoroutine(waitThenDisableSaveSuppression());
			}
			((MonoBehaviour)RoR2Application.instance).StartCoroutine(waitForLobbyLoadThenLoadSave());
			IEnumerator waitForLobbyLoadThenLoadSave()
			{
				SceneDef characterSelectScene = SceneCatalog.FindSceneDef("lobby");
				while ((Object)(object)SceneCatalog.mostRecentSceneDef != (Object)(object)characterSelectScene)
				{
					if ((Object)(object)SceneCatalog.mostRecentSceneDef != (Object)(object)currentRunScene)
					{
						Log.Info("Unexpected exit scene, run exited to " + SceneCatalog.mostRecentSceneDef.cachedName + ", expected " + characterSelectScene.cachedName + ". Aborting restart.", "X:\\Git\\RoR2\\RespawnButton\\RespawnButton\\RespawnButtonController.cs", "onRespawnClicked", 159);
						yield break;
					}
					yield return 0;
				}
				yield return (object)new WaitUntil((Func<bool>)NetworkUser.AllParticipatingNetworkUsersReady);
				yield return (object)new WaitForEndOfFrame();
				yield return Loading.LoadLobby();
			}
			IEnumerator waitThenDisableSaveSuppression()
			{
				yield return (object)new WaitForEndOfFrame();
				ProperSave_SaveFileDeletionHook.SuppressSaveFileDeletion = false;
				OverridePostRunDestinationPatch.PostRunDestinationOverride = oldPostRunDestinationOverride;
			}
		}
	}
	[BepInPlugin("Gorakh.RespawnButton", "RespawnButton", "1.0.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class RespawnButtonPlugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Awake <0>__GameEndReportPanelController_Awake;

			public static hook_SetDisplayData <1>__GameEndReportPanelController_SetDisplayData;
		}

		public const string PluginGUID = "Gorakh.RespawnButton";

		public const string PluginAuthor = "Gorakh";

		public const string PluginName = "RespawnButton";

		public const string PluginVersion = "1.0.2";

		internal static RespawnButtonPlugin Instance { get; private set; }

		private void Awake()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			Stopwatch stopwatch = Stopwatch.StartNew();
			Log.Init(((BaseUnityPlugin)this).Logger);
			Instance = SingletonHelper.Assign<RespawnButtonPlugin>(Instance, this);
			LanguageFolderHandler.Register(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location));
			object obj = <>O.<0>__GameEndReportPanelController_Awake;
			if (obj == null)
			{
				hook_Awake val = GameEndReportPanelController_Awake;
				<>O.<0>__GameEndReportPanelController_Awake = val;
				obj = (object)val;
			}
			GameEndReportPanelController.Awake += (hook_Awake)obj;
			object obj2 = <>O.<1>__GameEndReportPanelController_SetDisplayData;
			if (obj2 == null)
			{
				hook_SetDisplayData val2 = GameEndReportPanelController_SetDisplayData;
				<>O.<1>__GameEndReportPanelController_SetDisplayData = val2;
				obj2 = (object)val2;
			}
			GameEndReportPanelController.SetDisplayData += (hook_SetDisplayData)obj2;
			stopwatch.Stop();
			Log.Info_NoCallerPrefix($"Initialized in {stopwatch.Elapsed.TotalSeconds:F2} seconds");
		}

		private void OnDestroy()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			object obj = <>O.<0>__GameEndReportPanelController_Awake;
			if (obj == null)
			{
				hook_Awake val = GameEndReportPanelController_Awake;
				<>O.<0>__GameEndReportPanelController_Awake = val;
				obj = (object)val;
			}
			GameEndReportPanelController.Awake -= (hook_Awake)obj;
			object obj2 = <>O.<1>__GameEndReportPanelController_SetDisplayData;
			if (obj2 == null)
			{
				hook_SetDisplayData val2 = GameEndReportPanelController_SetDisplayData;
				<>O.<1>__GameEndReportPanelController_SetDisplayData = val2;
				obj2 = (object)val2;
			}
			GameEndReportPanelController.SetDisplayData -= (hook_SetDisplayData)obj2;
			Instance = SingletonHelper.Unassign<RespawnButtonPlugin>(Instance, this);
		}

		private static void GameEndReportPanelController_Awake(orig_Awake orig, GameEndReportPanelController self)
		{
			orig.Invoke(self);
			((Component)self).gameObject.AddComponent<RespawnButtonController>();
		}

		private static void GameEndReportPanelController_SetDisplayData(orig_SetDisplayData orig, GameEndReportPanelController self, DisplayData newDisplayData)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, newDisplayData);
			RespawnButtonController respawnButtonController = default(RespawnButtonController);
			if (((Component)self).TryGetComponent<RespawnButtonController>(ref respawnButtonController))
			{
				respawnButtonController.OnSetDisplayData(newDisplayData);
			}
		}
	}
}
namespace RespawnButton.Patches
{
	internal static class OverridePostRunDestinationPatch
	{
		public delegate void OverridePostRunDestinationDelegate(Run run);

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<Instruction, bool> <>9__2_1;

			public static Func<Run, bool> <>9__2_2;

			public static Manipulator <>9__2_0;

			internal void <Init>b__2_0(ILContext il)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected O, but got Unknown
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(il);
				if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Run>(x, "HandlePostRunDestination")
				}))
				{
					ILLabel val2 = val.MarkLabel();
					val.Index -= 2;
					val.Emit(OpCodes.Ldarg_0);
					val.EmitDelegate<Func<Run, bool>>((Func<Run, bool>)delegate(Run run)
					{
						if (PostRunDestinationOverride == null)
						{
							return true;
						}
						PostRunDestinationOverride(run);
						return false;
					});
					val.Emit(OpCodes.Brfalse, (object)val2);
				}
				else
				{
					Log.Error("Failed to find patch location", "X:\\Git\\RoR2\\RespawnButton\\RespawnButton\\Patches\\OverridePostRunDestinationPatch.cs", "Init", 42);
				}
			}

			internal bool <Init>b__2_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Run>(x, "HandlePostRunDestination");
			}

			internal bool <Init>b__2_2(Run run)
			{
				if (PostRunDestinationOverride == null)
				{
					return true;
				}
				PostRunDestinationOverride(run);
				return false;
			}
		}

		public static OverridePostRunDestinationDelegate PostRunDestinationOverride;

		[SystemInitializer(new Type[] { })]
		private static void Init()
		{
			//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)
			//IL_001f: Expected O, but got Unknown
			object obj = <>c.<>9__2_0;
			if (obj == null)
			{
				Manipulator val = delegate(ILContext il)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Expected O, but got Unknown
					//IL_004e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0080: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val2 = new ILCursor(il);
					if (val2.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
					{
						(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Run>(x, "HandlePostRunDestination")
					}))
					{
						ILLabel val3 = val2.MarkLabel();
						val2.Index -= 2;
						val2.Emit(OpCodes.Ldarg_0);
						val2.EmitDelegate<Func<Run, bool>>((Func<Run, bool>)delegate(Run run)
						{
							if (PostRunDestinationOverride == null)
							{
								return true;
							}
							PostRunDestinationOverride(run);
							return false;
						});
						val2.Emit(OpCodes.Brfalse, (object)val3);
					}
					else
					{
						Log.Error("Failed to find patch location", "X:\\Git\\RoR2\\RespawnButton\\RespawnButton\\Patches\\OverridePostRunDestinationPatch.cs", "Init", 42);
					}
				};
				<>c.<>9__2_0 = val;
				obj = (object)val;
			}
			Run.OnDestroy += (Manipulator)obj;
		}
	}
	internal static class ProperSave_SaveFileDeletionHook
	{
		private delegate void orig_Saving_RunOnServerGameOver(Run run, GameEndingDef ending);

		private static orig_Saving_RunOnServerGameOver _origRunOnServerGameOver;

		public static bool SuppressSaveFileDeletion;

		private static bool _deleteSaveFileOnRunEnd;

		private static Run _lastRunInstance;

		private static GameEndingDef _lastGameEndingDef;

		[SystemInitializer(new Type[] { })]
		private static void Init()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			_origRunOnServerGameOver = new Hook((Expression<Action>)(() => Saving.RunOnServerGameOver((Run)null, (GameEndingDef)null)), (Delegate)new Action<orig_Saving_RunOnServerGameOver, Run, GameEndingDef>(Saving_RunOnServerGameOver)).GenerateTrampoline<orig_Saving_RunOnServerGameOver>();
			Run.onRunDestroyGlobal += Run_onRunDestroyGlobal;
		}

		private static void Saving_RunOnServerGameOver(orig_Saving_RunOnServerGameOver orig, Run run, GameEndingDef ending)
		{
			if (ending.isWin)
			{
				orig(run, ending);
				return;
			}
			_deleteSaveFileOnRunEnd = true;
			_lastRunInstance = run;
			_lastGameEndingDef = ending;
		}

		private static void deleteSaveFile()
		{
			_origRunOnServerGameOver(_lastRunInstance, _lastGameEndingDef);
		}

		private static void Run_onRunDestroyGlobal(Run _)
		{
			if (!_deleteSaveFileOnRunEnd)
			{
				return;
			}
			try
			{
				if (NetworkServer.active && !SuppressSaveFileDeletion)
				{
					deleteSaveFile();
				}
			}
			finally
			{
				_deleteSaveFileOnRunEnd = false;
				_lastRunInstance = null;
				_lastGameEndingDef = null;
			}
		}
	}
}