using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using ClassicMoonsHQModule.Patches;
using HarmonyLib;
using LethalLevelLoader;
using LethalLevelLoader.Tools;
using Microsoft.CodeAnalysis;
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("Tomatobird.ClassicMoonsHQModule")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.4.0")]
[assembly: AssemblyInformationalVersion("1.0.4+2e1d988eeb7d24aad43f9c9c14ba7ab1e1f2bd4b")]
[assembly: AssemblyProduct("ClassicMoonsHQModule")]
[assembly: AssemblyTitle("Tomatobird.ClassicMoonsHQModule")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.4.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ClassicMoonsHQModule
{
	[BepInPlugin("Tomatobird.ClassicMoonsHQModule", "ClassicMoonsHQModule", "1.0.4")]
	public class ClassicMoonsHQModule : BaseUnityPlugin
	{
		internal static Dictionary<string, PluginInfo> pluginInfos = new Dictionary<string, PluginInfo>();

		public static ClassicMoonsHQModule Instance { get; private set; } = null;


		internal static ManualLogSource Logger { get; private set; } = null;


		internal static Harmony? Harmony { get; set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			pluginInfos = Chainloader.PluginInfos;
			Patch();
			SceneManager.sceneLoaded += OnSceneLoad;
			Logger.LogInfo((object)"Tomatobird.ClassicMoonsHQModule v1.0.4 has loaded!");
		}

		internal static void Patch()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony = new Harmony("Tomatobird.ClassicMoonsHQModule");
			}
			Logger.LogDebug((object)"Patching...");
			Harmony.PatchAll(typeof(MenuManagerPatcher));
			if (Chainloader.PluginInfos.TryGetValue("imabatby.lethallevelloader", out var value))
			{
				if (value.Metadata.Version >= new Version(PackDefinition.v73Mods["imabatby.lethallevelloader"]))
				{
					Harmony.PatchAll(typeof(LLLConfigLoaderPatcher_v2));
				}
				else
				{
					Harmony.PatchAll(typeof(LLLConfigLoaderPatcher_v1));
				}
				if (value.Metadata.Version == new Version(PackDefinition.v81Mods["imabatby.lethallevelloader"]))
				{
					SceneManager.sceneLoaded += FixLevelGenerationRoot;
				}
				Harmony.PatchAll(typeof(SoundManagerPatcher));
			}
			Logger.LogDebug((object)"Finished patching!");
		}

		internal static void OnSceneLoad(Scene scene, LoadSceneMode mode)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (((Scene)(ref scene)).name == "TutorialMoonScene")
			{
				EditVerdanceScene(scene);
			}
		}

		internal static void FixLevelGenerationRoot(Scene scene, LoadSceneMode mode)
		{
			GameObject val = FindByName(((Scene)(ref scene)).GetRootGameObjects(), "Systems");
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Transform val2 = val.transform.Find("LevelGeneration");
			if (!((Object)(object)val2 == (Object)null))
			{
				Transform child = val2.GetChild(0);
				if (!((Object)(object)child == (Object)null) && ((Object)child).name == "LevelGenerationRoot")
				{
					child.SetAsLastSibling();
					Logger.LogDebug((object)"Reordered LevelGeneration child objects.");
				}
			}
		}

		internal static GameObject FindByName(GameObject[] gameObjects, string name)
		{
			string name2 = name;
			return Array.Find(gameObjects, (GameObject obj) => ((Object)obj).name == name2);
		}

		internal static void EditVerdanceScene(Scene scene)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogInfo((object)"Editing Verdance Scene.");
			Transform val = ((Scene)(ref scene)).GetRootGameObjects()[2].transform.Find("ItemShipAnimContainer/ItemShip/ItemSpawnPositions/DropshipSpawn (1)");
			val.position += new Vector3(0f, 0.15f, 0f);
		}
	}
	internal static class OtherPluginInfos
	{
		public const string HQFIXES_GUID = "chboo1.lethalcompany.hqfixes";

		public const string WEATHERREGISTRY_GUID = "mrov.WeatherRegistry";

		public const string LLL_GUID = "imabatby.lethallevelloader";

		public const string JLL_GUID = "JacobG5.JLL";

		public const string MROVLIB_GUID = "MrovLib";

		public const string FREEMOONS_GUID = "SlushyRH.LethalCompany.FreeMoons";

		public const string CULLFACTORY_GUID = "com.fumiko.CullFactory";

		public const string LETHALLIB_GUID = "evaisa.lethallib";

		public const string PATHFINDINGLIB_GUID = "Zaggy1024.PathfindingLib";

		public const string PATHFINDINGLAGFIX_GUID = "Zaggy1024.PathfindingLagFix";

		public const string STARLANCERAIFIX_GUID = "AudioKnight.StarlancerAIFix";

		public const string STREAMOVERLAYS_GUID = "com.github.zehsteam.StreamOverlays";

		public const string LOADSTONE_GUID = "com.adibtw.loadstone";

		public const string VLOG_GUID = "OreoM.VLog";

		public const string BLURANCEFIX_GUID = "Tomatobird.BluranceTerrainFix";

		public const string DERELICTFIX_GUID = "Tomatobird.DerelictFix";

		public const string LERTZFIX_GUID = "Tomatobird.LertzFix";

		public const string TANDRAUSFIX_GUID = "Tomatobird.TandrausFix";

		public const string DERELICT_MOON_PLUGIN_GUID = "DerelictMoonPlugin";
	}
	internal class PackDefinition
	{
		internal static Dictionary<string, string> commonRequiredMods = new Dictionary<string, string>
		{
			{ "Tomatobird.BluranceTerrainFix", "1.0.0" },
			{ "Tomatobird.LertzFix", "1.0.0" },
			{ "Tomatobird.TandrausFix", "1.1.0" }
		};

		internal static Dictionary<string, string> commonOptionalMods = new Dictionary<string, string> { { "SlushyRH.LethalCompany.FreeMoons", "1.0.2" } };

		internal static Dictionary<string, string> v56Mods = new Dictionary<string, string>
		{
			{ "imabatby.lethallevelloader", "1.3.8" },
			{ "Zaggy1024.PathfindingLagFix", "1.2.2" },
			{ "AudioKnight.StarlancerAIFix", "3.8.0" },
			{ "evaisa.lethallib", "0.16.2" },
			{ "com.adibtw.loadstone", "0.1.18" },
			{ "com.fumiko.CullFactory", "1.7.0" },
			{ "DerelictMoonPlugin", "1.0.0" }
		};

		internal static Dictionary<string, string> v62Mods = new Dictionary<string, string>
		{
			{ "imabatby.lethallevelloader", "1.3.13" },
			{ "Zaggy1024.PathfindingLagFix", "2.1.1" },
			{ "Zaggy1024.PathfindingLib", "0.0.14" },
			{ "AudioKnight.StarlancerAIFix", "3.8.4" },
			{ "evaisa.lethallib", "1.0.1" },
			{ "com.adibtw.loadstone", "0.1.23" },
			{ "com.fumiko.CullFactory", "2.0.4" },
			{ "DerelictMoonPlugin", "1.2.0" }
		};

		internal static Dictionary<string, string> v69Mods = new Dictionary<string, string>
		{
			{ "imabatby.lethallevelloader", "1.4.11" },
			{ "Zaggy1024.PathfindingLagFix", "2.2.4" },
			{ "Zaggy1024.PathfindingLib", "2.3.2" },
			{ "AudioKnight.StarlancerAIFix", "3.9.0" },
			{ "evaisa.lethallib", "1.0.1" },
			{ "com.adibtw.loadstone", "0.1.23" },
			{ "com.fumiko.CullFactory", "2.0.4" },
			{ "DerelictMoonPlugin", "1.2.0" }
		};

		internal static Dictionary<string, string> v72Mods = new Dictionary<string, string>
		{
			{ "imabatby.lethallevelloader", "1.4.11" },
			{ "Zaggy1024.PathfindingLagFix", "2.2.4" },
			{ "Zaggy1024.PathfindingLib", "2.3.2" },
			{ "AudioKnight.StarlancerAIFix", "3.11.1" },
			{ "evaisa.lethallib", "1.1.1" },
			{ "com.adibtw.loadstone", "0.1.23" },
			{ "com.fumiko.CullFactory", "2.0.4" },
			{ "Tomatobird.DerelictFix", "1.0.0" },
			{ "DerelictMoonPlugin", "1.2.0" }
		};

		internal static Dictionary<string, string> v73Mods = new Dictionary<string, string>
		{
			{ "imabatby.lethallevelloader", "1.6.8" },
			{ "Zaggy1024.PathfindingLagFix", "2.2.5" },
			{ "Zaggy1024.PathfindingLib", "2.4.1" },
			{ "AudioKnight.StarlancerAIFix", "3.11.1" },
			{ "evaisa.lethallib", "1.1.1" },
			{ "com.adibtw.loadstone", "0.1.23" },
			{ "com.fumiko.CullFactory", "2.0.4" },
			{ "DerelictMoonPlugin", "1.2.1" }
		};

		internal static Dictionary<string, string> v81Mods = new Dictionary<string, string>
		{
			{ "imabatby.lethallevelloader", "1.6.9" },
			{ "Zaggy1024.PathfindingLagFix", "2.4.2" },
			{ "Zaggy1024.PathfindingLib", "2.4.1" },
			{ "AudioKnight.StarlancerAIFix", "3.13.1" },
			{ "evaisa.lethallib", "1.2.0" },
			{ "com.fumiko.CullFactory", "2.0.10" },
			{ "DerelictMoonPlugin", "1.2.1" }
		};
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Tomatobird.ClassicMoonsHQModule";

		public const string PLUGIN_NAME = "ClassicMoonsHQModule";

		public const string PLUGIN_VERSION = "1.0.4";
	}
}
namespace ClassicMoonsHQModule.Patches
{
	[HarmonyPatch]
	internal class LLLConfigLoaderPatcher_v1
	{
		private static readonly List<string> vanillaLevels = new List<string>(12)
		{
			"Adamance", "Offense", "Assurance", "Experimentation", "Liquidation", "Embrion", "Vow", "March", "Artifice", "Dine",
			"Titan", "Rend"
		};

		[HarmonyPatch("LethalLevelLoader.Tools.ExtendedDungeonConfig, LethalLevelLoader, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", "BindConfigs")]
		[HarmonyPrefix]
		public static void PatchDungeon(object[] __args)
		{
			object obj = __args[0];
			Type type = obj.GetType();
			PropertyInfo property = type.GetProperty("GenerateAutomaticConfigurationOptions", BindingFlags.Instance | BindingFlags.Public);
			property.SetValue(obj, false);
		}

		[HarmonyPatch("LethalLevelLoader.Tools.ExtendedLevelConfig, LethalLevelLoader, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", "BindConfigs")]
		[HarmonyPrefix]
		public static void PatchMoon(object[] __args)
		{
			object obj = __args[0];
			Type type = obj.GetType();
			PropertyInfo property = type.GetProperty("GenerateAutomaticConfigurationOptions", BindingFlags.Instance | BindingFlags.Public);
			property.SetValue(obj, false);
			PropertyInfo property2 = type.GetProperty("NumberlessPlanetName", BindingFlags.Instance | BindingFlags.Public);
			if (vanillaLevels.Contains((string)property2.GetValue(obj)))
			{
				PropertyInfo property3 = type.GetProperty("IsRouteLocked", BindingFlags.Instance | BindingFlags.Public);
				PropertyInfo property4 = type.GetProperty("IsRouteHidden", BindingFlags.Instance | BindingFlags.Public);
				property3.SetValue(obj, true);
				property4.SetValue(obj, true);
			}
		}
	}
	[HarmonyPatch]
	internal class LLLConfigLoaderPatcher_v2
	{
		private static readonly List<string> vanillaLevels = new List<string>(12)
		{
			"Adamance", "Offense", "Assurance", "Experimentation", "Liquidation", "Embrion", "Vow", "March", "Artifice", "Dine",
			"Titan", "Rend"
		};

		[HarmonyPatch(typeof(ExtendedDungeonConfig), "BindConfigs")]
		[HarmonyPrefix]
		public static void PatchDungeon(ref ExtendedDungeonFlow extendedDungeonFlow)
		{
			extendedDungeonFlow.GenerateAutomaticConfigurationOptions = false;
		}

		[HarmonyPatch(typeof(ExtendedLevelConfig), "BindConfigs")]
		[HarmonyPrefix]
		public static void PatchMoon(ref ExtendedLevel extendedLevel)
		{
			extendedLevel.GenerateAutomaticConfigurationOptions = false;
			if (vanillaLevels.Contains(extendedLevel.NumberlessPlanetName))
			{
				extendedLevel.IsRouteLocked = true;
				extendedLevel.IsRouteHidden = true;
			}
		}
	}
	[HarmonyPatch(typeof(MenuManager))]
	internal class MenuManagerPatcher
	{
		private static Action<MenuManager, string, string, bool>? MenuNotif3;

		private static Action<MenuManager, string, string>? MenuNotif2;

		static MenuManagerPatcher()
		{
			MethodInfo methodInfo = AccessTools.Method(typeof(MenuManager), "DisplayMenuNotification", (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				if (methodInfo.GetParameters().Length == 3)
				{
					MenuNotif3 = AccessTools.MethodDelegate<Action<MenuManager, string, string, bool>>(methodInfo, (object)null, true);
				}
				else
				{
					MenuNotif2 = AccessTools.MethodDelegate<Action<MenuManager, string, string>>(methodInfo, (object)null, true);
				}
			}
		}

		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		internal static void Start_Prefix(MenuManager __instance)
		{
			if (__instance.isInitScene)
			{
				return;
			}
			string text = "";
			int gameVersionNum = GameNetworkManager.Instance.gameVersionNum;
			text += CheckModValidity(PackDefinition.commonRequiredMods, required: true);
			text = gameVersionNum switch
			{
				56 => text + CheckModValidity(PackDefinition.v56Mods, required: true), 
				62 => text + CheckModValidity(PackDefinition.v62Mods, required: true), 
				64 => text + CheckModValidity(PackDefinition.v69Mods, required: true), 
				69 => text + CheckModValidity(PackDefinition.v69Mods, required: true), 
				72 => text + CheckModValidity(PackDefinition.v72Mods, required: true), 
				73 => text + CheckModValidity(PackDefinition.v73Mods, required: true), 
				81 => text + CheckModValidity(PackDefinition.v81Mods, required: true), 
				_ => text + "Unsupported game version", 
			} + CheckModValidity(PackDefinition.commonOptionalMods, required: false);
			if (!ClassicMoonsHQModule.pluginInfos.ContainsKey("OreoM.VLog"))
			{
				text += "Vlog missing, ";
			}
			if (!Utility.IsNullOrWhiteSpace(text))
			{
				text = text.TrimEnd(',', ' ');
				if (MenuNotif3 != null)
				{
					MenuNotif3(__instance, "WARNING! Modpack misconfiguration: " + text, "[ OK ]", arg4: true);
				}
				else if (MenuNotif2 != null)
				{
					MenuNotif2(__instance, "WARNING! Modpack misconfiguration: " + text, "[ OK ]");
				}
				else
				{
					ClassicMoonsHQModule.Logger.LogError((object)"Displaying menu notification failed.");
				}
				ClassicMoonsHQModule.Logger.LogWarning((object)("WARNING! Modpack misconfiguration: " + text));
			}
		}

		internal static string CheckModValidity(Dictionary<string, string> dict, bool required)
		{
			string text = "";
			foreach (KeyValuePair<string, string> item in dict)
			{
				if (!ClassicMoonsHQModule.pluginInfos.ContainsKey(item.Key))
				{
					if (required)
					{
						text = text + item.Key + " v" + item.Value + " is misssing, ";
					}
				}
				else if (ClassicMoonsHQModule.pluginInfos[item.Key].Metadata.Version.ToString() != item.Value)
				{
					text = text + ClassicMoonsHQModule.pluginInfos[item.Key].Metadata.GUID + " v" + ClassicMoonsHQModule.pluginInfos[item.Key].Metadata.Version.ToString() + " didnt match required version v" + item.Value + ", ";
				}
			}
			return text;
		}
	}
	[HarmonyPatch(typeof(SoundManager))]
	internal class SoundManagerPatcher
	{
		[CompilerGenerated]
		private sealed class <FixChorusEffect>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SoundManager soundManager;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <FixChorusEffect>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					soundManager.SetDiageticMixerSnapshot(4, 1000f);
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					soundManager.SetDiageticMixerSnapshot(0, 1f);
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[HarmonyPatch("ResetValues")]
		[HarmonyPostfix]
		internal static void ResetValues_Postfix(SoundManager __instance)
		{
			ClassicMoonsHQModule.Logger.LogInfo((object)"Attempting to fix chorus effect bug in SoundManager.ResetValues.");
			((MonoBehaviour)__instance).StartCoroutine(FixChorusEffect(__instance));
		}

		[IteratorStateMachine(typeof(<FixChorusEffect>d__1))]
		private static IEnumerator FixChorusEffect(SoundManager soundManager)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FixChorusEffect>d__1(0)
			{
				soundManager = soundManager
			};
		}
	}
}