using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
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 HarmonyLib;
using JLL.Components;
using JLL.Components.Filters;
using LethalLevelLoader;
using LethalLevelLoader.Tools;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.SceneManagement;
using WesleyMoonScripts;
using WesleyMoonScripts.Components;
using WesleysMoonsHQModule.Patches;
using WesleysWeatherStuff.Stuff;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("LethalLevelLoader")]
[assembly: IgnoresAccessChecksTo("WesleysWeatherStuff")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Tomatobird.WesleysMoonsHQModule")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.1.2.0")]
[assembly: AssemblyInformationalVersion("1.1.2+90b6e16ce5d8f270742472833bff3af8115da543")]
[assembly: AssemblyProduct("WesleysMoonsHQModule")]
[assembly: AssemblyTitle("Tomatobird.WesleysMoonsHQModule")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.2.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 WesleysMoonsHQModule
{
	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 JLL_WMS_GUID = "JacobG5.WesleyMoonScripts";

		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";
	}
	internal class PackDefinition
	{
		internal static Dictionary<string, string> commonRequiredMods = new Dictionary<string, string> { { "com.adibtw.loadstone", "0.1.23" } };

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

		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" }
		};

		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" }
		};

		internal static Dictionary<string, string> v73Mods = new Dictionary<string, string>
		{
			{ "imabatby.lethallevelloader", "1.6.8" },
			{ "mrov.WeatherRegistry", "0.7.5" },
			{ "MrovLib", "0.4.2" },
			{ "Zaggy1024.PathfindingLagFix", "2.2.5" },
			{ "Zaggy1024.PathfindingLib", "2.4.1" },
			{ "AudioKnight.StarlancerAIFix", "3.11.1" },
			{ "evaisa.lethallib", "1.1.1" }
		};
	}
	[BepInPlugin("Tomatobird.WesleysMoonsHQModule", "WesleysMoonsHQModule", "1.1.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class WesleysMoonsHQModule : BaseUnityPlugin
	{
		internal static List<string> allowedItemNames = new List<string>(2) { "Bury the child videotape", "Teach the disloyal videotape" };

		internal static List<string> scenesToSkip = new List<string>(3) { "MainMenu", "InitScene", "InitSceneLaunchOptions" };

		internal static Dictionary<string, PluginInfo> pluginInfos = new Dictionary<string, PluginInfo>();

		public static WesleysMoonsHQModule 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)("Pack launched in " + (WesleyScripts.LockMoons.Value ? "High Quota" : "Single Moon High Quota") + " mode!"));
			Logger.LogInfo((object)"Tomatobird.WesleysMoonsHQModule v1.1.2 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.WesleysMoonsHQModule");
			}
			Logger.LogDebug((object)"Patching...");
			Harmony.PatchAll(typeof(StartOfRoundPatcher));
			Harmony.PatchAll(typeof(MenuManagerPatcher));
			Harmony.PatchAll(typeof(SoundManagerPatcher));
			if (Chainloader.PluginInfos.TryGetValue("imabatby.lethallevelloader", out var value))
			{
				if (value.Metadata.Version >= new Version(PackDefinition.v73Mods["imabatby.lethallevelloader"]))
				{
					Harmony.PatchAll(typeof(LLLConfigLoaderPatcher_v2));
					Harmony.PatchAll(typeof(WesleysWeatherStuffPatcher));
				}
				else
				{
					Harmony.PatchAll(typeof(LLLConfigLoaderPatcher_v1));
				}
			}
			Logger.LogDebug((object)"Finished patching!");
		}

		internal static void OnSceneLoad(Scene scene, LoadSceneMode mode)
		{
			//IL_0018: 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_0062: 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)
			if (!scenesToSkip.Contains(((Scene)(ref scene)).name))
			{
				RemoveAprilFools(scene);
				if (((Scene)(ref scene)).name == "MusemaScene")
				{
					EditMusemaScene(scene);
				}
				if (((Scene)(ref scene)).name == "Asteroid14Scene" && WesleyScripts.LockMoons.Value)
				{
					EditHyveScene(scene);
				}
				if (((Scene)(ref scene)).name == "CalistScene")
				{
					EditCalistScene(scene);
				}
			}
		}

		internal static GameObject GetRootGameObject(Scene scene, string name)
		{
			string name2 = name;
			return ((IEnumerable<GameObject>)((Scene)(ref scene)).GetRootGameObjects()).FirstOrDefault((Func<GameObject, bool>)((GameObject g) => ((Object)g).name == name2));
		}

		internal static void EditMusemaScene(Scene scene)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogInfo((object)"Editing Galetry Scene.");
			GameObject rootGameObject = GetRootGameObject(scene, "Environment");
			ItemShop[] componentsInChildren = ((Component)rootGameObject.transform.Find("Giftshop/Itemshop")).GetComponentsInChildren<ItemShop>();
			foreach (ItemShop val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && val.Catalogue[0].ItemName == "Mortar hammer")
				{
					val.Catalogue = val.Catalogue.Where((WeightedItemRefrence item) => allowedItemNames.Contains(item.ItemName)).ToArray();
					break;
				}
			}
		}

		internal static void EditHyveScene(Scene scene)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//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_002b: Expected O, but got Unknown
			Logger.LogInfo((object)"Editing Galetry Scene.");
			GameObject rootGameObject = GetRootGameObject(scene, "Environment");
			WeightedEnemyRefrence item = new WeightedEnemyRefrence
			{
				rarity = 99
			};
			EnemySpawner[] componentsInChildren = rootGameObject.GetComponentsInChildren<EnemySpawner>();
			foreach (EnemySpawner val in componentsInChildren)
			{
				if (!(((Object)val).name != "Spawner"))
				{
					val.randomPool = new List<WeightedEnemyRefrence>(1) { item };
				}
			}
		}

		internal static void EditCalistScene(Scene scene)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogInfo((object)"Editing Calist Scene.");
			Transform transform = GetRootGameObject(scene, "Environment").transform;
			Transform val = transform.Find("Lighting/BrightDay/Sun");
			Transform[] array = (Transform[])(object)new Transform[3]
			{
				((Component)val).transform.Find("SunAnimContainer/GameObject"),
				((Component)val).transform.Find("SunAnimContainer/AsteroidsPAck"),
				((Component)val).transform.Find("SunAnimContainer/Sphere")
			};
			Transform[] array2 = array;
			foreach (Transform val2 in array2)
			{
				val2.SetParent(((Component)val).transform);
			}
		}

		internal static void RemoveAprilFools(Scene scene)
		{
			DateFilter[] array = Object.FindObjectsOfType<DateFilter>();
			DateFilter[] array2 = array;
			foreach (DateFilter val in array2)
			{
				if (((Object)((Component)val).gameObject).name != "randomAprilEffect")
				{
					break;
				}
				Logger.LogInfo((object)"Removing randomAprilEffect...");
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Tomatobird.WesleysMoonsHQModule";

		public const string PLUGIN_NAME = "WesleysMoonsHQModule";

		public const string PLUGIN_VERSION = "1.1.2";
	}
}
namespace WesleysMoonsHQModule.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
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		internal static void Start_Postfix(MenuManager __instance)
		{
			string text = "";
			int gameVersionNum = GameNetworkManager.Instance.gameVersionNum;
			WesleysMoonsHQModule.Logger.LogInfo((object)("Game version: " + gameVersionNum));
			text += CheckModValidity(PackDefinition.commonRequiredMods, required: true);
			text = gameVersionNum switch
			{
				69 => text + CheckModValidity(PackDefinition.v69Mods, required: true), 
				72 => text + CheckModValidity(PackDefinition.v72Mods, required: true), 
				73 => text + CheckModValidity(PackDefinition.v73Mods, required: true), 
				_ => text + "Unsupported game version", 
			} + CheckModValidity(PackDefinition.commonOptionalMods, required: false);
			if (WesleysMoonsHQModule.pluginInfos.ContainsKey("SlushyRH.LethalCompany.FreeMoons") && WesleyScripts.LockMoons.Value)
			{
				text += "Freemoons installed in non-SMHQ mode, ";
			}
			else if (!WesleysMoonsHQModule.pluginInfos.ContainsKey("SlushyRH.LethalCompany.FreeMoons") && !WesleyScripts.LockMoons.Value)
			{
				text += "Freemoons missing in SMHQ mode, ";
			}
			if (!WesleysMoonsHQModule.pluginInfos.ContainsKey("OreoM.VLog"))
			{
				text += "Vlog missing, ";
			}
			if (!Utility.IsNullOrWhiteSpace(text))
			{
				text = text.TrimEnd(',', ' ');
				__instance.DisplayMenuNotification("WARNING! Modpack misconfiguration: " + text, "[ OK ]");
				WesleysMoonsHQModule.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 (!WesleysMoonsHQModule.pluginInfos.ContainsKey(item.Key))
				{
					if (required)
					{
						text = text + item.Key + " v" + item.Value + " is misssing, ";
					}
				}
				else if (WesleysMoonsHQModule.pluginInfos[item.Key].Metadata.Version.ToString() != item.Value)
				{
					text = text + WesleysMoonsHQModule.pluginInfos[item.Key].Metadata.GUID + " v" + WesleysMoonsHQModule.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)
		{
			WesleysMoonsHQModule.Logger.LogInfo((object)"Attempting to fix chorus effect bug in SoundManager.ResetsValues.");
			((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
			};
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatcher
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		internal static void Start_Postfix(StartOfRound __instance)
		{
			if (WesleyScripts.LockMoons.Value)
			{
				LungProp[] array = Resources.FindObjectsOfTypeAll<LungProp>();
				LungProp[] array2 = array;
				foreach (LungProp val in array2)
				{
					if (((Object)val).name == "CosmicLungApparatus" || ((Object)val).name == "CosmicLungApparatusDisabled")
					{
						((GrabbableObject)val).scrapValue = 214;
					}
				}
			}
			SelectableLevel[] levels = __instance.levels;
			foreach (SelectableLevel val2 in levels)
			{
				val2.DaySpeedMultiplier = Mathf.Max(val2.DaySpeedMultiplier, 1f);
				if (((Object)val2).name == "CosmocosLevel")
				{
					val2.DaySpeedMultiplier = 0.959f;
					if (WesleyScripts.LockMoons.Value)
					{
						val2.maxScrap = 55;
					}
				}
				if (((Object)val2).name == "EmpraLevel")
				{
					val2.DaySpeedMultiplier = 0.875f;
				}
			}
		}
	}
	[HarmonyPatch(typeof(WeatherObjectContainer))]
	internal class WesleysWeatherStuffPatcher
	{
		[HarmonyPatch("DestroyObjects")]
		[HarmonyPrefix]
		private static void DestroyObjectsPatch(WeatherObjectContainer __instance)
		{
			__instance.weatherObjects = Object.FindObjectsOfType<WeatherObject>().ToList();
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}