using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using HellWeather.Helpers;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("HellWeather")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("HellWeather")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4ba09a9d-299a-4967-aeac-399f036eb7ec")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace HellWeather
{
	[BepInPlugin("stormytuna.HellWeather", "HellWeather", "1.0.3")]
	public class HellWeatherBase : BaseUnityPlugin
	{
		public const string ModGUID = "stormytuna.HellWeather";

		public const string ModName = "HellWeather";

		public const string ModVersion = "1.0.3";

		public static ManualLogSource Log = Logger.CreateLogSource("stormytuna.HellWeather");

		public static HellWeatherBase Instance;

		public static LevelWeatherType HellWeather;

		private readonly Harmony harmony = new Harmony("stormytuna.HellWeather");

		public static ConfigEntry<bool> AllowRainyWeather;

		public static ConfigEntry<bool> AllowFoggyWeather;

		public static ConfigEntry<bool> AllowFloodedWeather;

		public static ConfigEntry<bool> AllowStormyWeather;

		public static ConfigEntry<bool> AllowEclipsedWeather;

		public static ConfigEntry<bool> AlwaysHellWeather;

		private void Awake()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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)
			if (Instance == null)
			{
				Instance = this;
			}
			HellWeather = (LevelWeatherType)(Enum.GetValues(typeof(LevelWeatherType)).Cast<LevelWeatherType>().Max() + 1);
			Log.LogInfo((object)"Hell Weather has awoken!");
			LoadConfigs();
			harmony.PatchAll();
		}

		public void LoadConfigs()
		{
			AllowRainyWeather = ((BaseUnityPlugin)this).Config.Bind<bool>("AllowedWeathers", "AllowRainyWeather", true, "Whether or not to allow the Rainy weather type to appear in Hell weather planets");
			AllowFoggyWeather = ((BaseUnityPlugin)this).Config.Bind<bool>("AllowedWeathers", "AllowFoggyWeather", true, "Whether or not to allow the Foggy weather type to appear in Hell weather planets");
			AllowFloodedWeather = ((BaseUnityPlugin)this).Config.Bind<bool>("AllowedWeathers", "AllowFloodedWeather", true, "Whether or not to allow the Flooded weather type to appear in Hell weather planets");
			AllowStormyWeather = ((BaseUnityPlugin)this).Config.Bind<bool>("AllowedWeathers", "AllowStormyWeather", true, "Whether or not to allow the Stormy weather type to appear in Hell weather planets");
			AllowEclipsedWeather = ((BaseUnityPlugin)this).Config.Bind<bool>("AllowedWeathers", "AllowEclipsedWeather", true, "Whether or not to allow the Eclipsed weather type to appear in Hell weather planets");
			AlwaysHellWeather = ((BaseUnityPlugin)this).Config.Bind<bool>("HellWeatherRarity", "AlwaysHellWeather", false, "Whether all planets will always have Hell weather");
		}

		public static bool CanApplyChangesToWeather(LevelWeatherType weather)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected I4, but got Unknown
			return (weather - 1) switch
			{
				0 => AllowRainyWeather.Value, 
				2 => AllowFoggyWeather.Value, 
				3 => AllowFloodedWeather.Value, 
				1 => AllowStormyWeather.Value, 
				4 => AllowEclipsedWeather.Value, 
				_ => false, 
			};
		}
	}
}
namespace HellWeather.Patches
{
	[HarmonyPatch]
	public class EnableDisableWeatherEffectsPatches
	{
		private static void EnablePossibleWeatherEffects()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			foreach (RandomWeatherWithVariables vanillaRandomWeathersWithEffect in WeatherHelpers.GetVanillaRandomWeathersWithEffects(StartOfRound.Instance.currentLevel))
			{
				if (HellWeatherBase.CanApplyChangesToWeather(vanillaRandomWeathersWithEffect.weatherType))
				{
					WeatherEffect val = TimeOfDay.Instance.effects[vanillaRandomWeathersWithEffect.weatherType];
					val.effectEnabled = true;
					if ((Object)(object)val.effectPermanentObject != (Object)null)
					{
						val.effectPermanentObject.SetActive(true);
					}
				}
			}
		}

		private static void DisableWeatherEffects()
		{
			foreach (WeatherEffect vanillaWeatherEffect in WeatherHelpers.GetVanillaWeatherEffects())
			{
				vanillaWeatherEffect.effectEnabled = false;
				if ((Object)(object)vanillaWeatherEffect.effectPermanentObject != (Object)null)
				{
					vanillaWeatherEffect.effectPermanentObject.SetActive(false);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "openingDoorsSequence")]
		public static void EnableWeathersAtStartOfGame()
		{
			//IL_000b: 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)
			if (StartOfRound.Instance.currentLevel.currentWeather == HellWeatherBase.HellWeather)
			{
				EnablePossibleWeatherEffects();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(AudioReverbTrigger), "ChangeAudioReverbForPlayer")]
		public static void EnableWeathersOnChangeAudioReverb(AudioReverbTrigger __instance)
		{
			//IL_000e: 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)
			if (__instance.enableCurrentLevelWeather && TimeOfDay.Instance.currentLevelWeather == HellWeatherBase.HellWeather)
			{
				EnablePossibleWeatherEffects();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "EndOfGame")]
		public static void DisableWeathers()
		{
			//IL_000b: 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)
			if (StartOfRound.Instance.currentLevel.currentWeather == HellWeatherBase.HellWeather)
			{
				DisableWeatherEffects();
			}
		}
	}
	[HarmonyPatch]
	public class CurrentLevelWeatherPatches
	{
		private static bool changeBackToHellWeather;

		private static void FuckCurrentLevelWeatherType(LevelWeatherType newWeatherType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_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)
			if (TimeOfDay.Instance.currentLevelWeather == HellWeatherBase.HellWeather && HellWeatherBase.CanApplyChangesToWeather(newWeatherType))
			{
				TimeOfDay.Instance.currentLevelWeather = newWeatherType;
				changeBackToHellWeather = true;
			}
		}

		private static void UnfuckCurrentLevelWeatherType()
		{
			//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)
			if (changeBackToHellWeather)
			{
				TimeOfDay.Instance.currentLevelWeather = HellWeatherBase.HellWeather;
				changeBackToHellWeather = false;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(EnemyAI), "CheckLineOfSightForPlayer")]
		[HarmonyPatch(typeof(EnemyAI), "CheckLineOfSightForClosestPlayer")]
		[HarmonyPatch(typeof(EnemyAI), "GetAllPlayersInLineOfSight")]
		public static void PreCheckLineOfSight()
		{
			FuckCurrentLevelWeatherType((LevelWeatherType)3);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(EnemyAI), "CheckLineOfSightForPlayer")]
		[HarmonyPatch(typeof(EnemyAI), "CheckLineOfSightForClosestPlayer")]
		[HarmonyPatch(typeof(EnemyAI), "GetAllPlayersInLineOfSight")]
		public static void PostCheckLineOfSight()
		{
			UnfuckCurrentLevelWeatherType();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(RoundManager), "SpawnOutsideHazards")]
		public static void PreSpawnOutsideHazards()
		{
			FuckCurrentLevelWeatherType((LevelWeatherType)1);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(RoundManager), "SpawnOutsideHazards")]
		public static void PostSpawnOutsideHazards()
		{
			UnfuckCurrentLevelWeatherType();
		}
	}
	[HarmonyPatch(typeof(Enum))]
	public class LevelWeatherTypePatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("ToString", new Type[] { })]
		public static bool GetHellWeatherString(ref string __result, Enum __instance)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			if (__instance is LevelWeatherType val && val == HellWeatherBase.HellWeather)
			{
				__result = "Hell";
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public class StartOfRoundPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		public static void Awake(SelectableLevel[] ___levels)
		{
			//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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			foreach (SelectableLevel val in ___levels)
			{
				val.randomWeathers = CollectionExtensions.AddToArray<RandomWeatherWithVariables>(val.randomWeathers, new RandomWeatherWithVariables
				{
					weatherType = HellWeatherBase.HellWeather
				});
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("SetPlanetsWeather")]
		public static bool MakeAllPlanetsHell(SelectableLevel[] ___levels)
		{
			//IL_0026: 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)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!HellWeatherBase.AlwaysHellWeather.Value)
			{
				return true;
			}
			foreach (SelectableLevel val in ___levels)
			{
				val.currentWeather = HellWeatherBase.HellWeather;
				HellWeatherBase.Log.LogInfo((object)$"Current weather: {val.currentWeather}");
			}
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch("OnShipLandedMiscEvents")]
		public static void DisplayHellWeatherPopup()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (TimeOfDay.Instance.currentLevelWeather == HellWeatherBase.HellWeather)
			{
				IEnumerable<RandomWeatherWithVariables> source = TimeOfDay.Instance.currentLevel.randomWeathers.Where((RandomWeatherWithVariables rw) => rw.weatherType != HellWeatherBase.HellWeather && HellWeatherBase.CanApplyChangesToWeather(rw.weatherType));
				IEnumerable<LevelWeatherType> values = source.Select((RandomWeatherWithVariables rw) => rw.weatherType);
				string text = string.Join(", ", values);
				HUDManager.Instance.DisplayTip("Weather alert!", "You have landed in some severe weather anomalies. Good luck.\nWeathers active: " + text, true, false, "LC_Tip1");
			}
		}
	}
	[HarmonyPatch(typeof(TimeOfDay))]
	public class TimeOfDayPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		public static void Awake(ref WeatherEffect[] ___effects)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			___effects = CollectionExtensions.AddToArray<WeatherEffect>(___effects, new WeatherEffect
			{
				name = "hell",
				sunAnimatorBool = (HellWeatherBase.AllowEclipsedWeather.Value ? "eclipse" : "")
			});
		}
	}
	[HarmonyPatch]
	public class CurrentWeatherVariablePatches
	{
		private static float[] currentWeatherVariables = new float[7];

		private static float[] currentWeatherVariables2 = new float[7];

		private static LevelWeatherType? weatherTypeToUnfuck;

		private static void FuckCurrentWeatherVariable(LevelWeatherType weatherType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_002a: 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)
			if (TimeOfDay.Instance.currentLevelWeather == HellWeatherBase.HellWeather && HellWeatherBase.CanApplyChangesToWeather(weatherType))
			{
				TimeOfDay.Instance.currentWeatherVariable = currentWeatherVariables[weatherType];
				weatherTypeToUnfuck = weatherType;
			}
		}

		private static void FuckCurrentWeatherVariable2(LevelWeatherType weatherType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_002a: 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)
			if (TimeOfDay.Instance.currentLevelWeather == HellWeatherBase.HellWeather && HellWeatherBase.CanApplyChangesToWeather(weatherType))
			{
				TimeOfDay.Instance.currentWeatherVariable2 = currentWeatherVariables2[weatherType];
				weatherTypeToUnfuck = weatherType;
			}
		}

		private static void UnfuckCurrentWeatherVariable()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (weatherTypeToUnfuck.HasValue)
			{
				currentWeatherVariables[weatherTypeToUnfuck.Value] = TimeOfDay.Instance.currentWeatherVariable;
				weatherTypeToUnfuck = null;
			}
		}

		private static void UnfuckCurrentWeatherVariable2()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (weatherTypeToUnfuck.HasValue)
			{
				currentWeatherVariables2[weatherTypeToUnfuck.Value] = TimeOfDay.Instance.currentWeatherVariable2;
				weatherTypeToUnfuck = null;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(RoundManager), "SetToCurrentLevelWeather")]
		public static void SetupCurrentWeatherVariables(RoundManager __instance)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			foreach (RandomWeatherWithVariables vanillaRandomWeathersWithEffect in WeatherHelpers.GetVanillaRandomWeathersWithEffects(__instance.currentLevel))
			{
				currentWeatherVariables[vanillaRandomWeathersWithEffect.weatherType] = vanillaRandomWeathersWithEffect.weatherVariable;
				currentWeatherVariables2[vanillaRandomWeathersWithEffect.weatherType] = vanillaRandomWeathersWithEffect.weatherVariable2;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "EndOfGame")]
		public static void ResetCurrentWeatherVariables()
		{
			currentWeatherVariables = new float[7];
			currentWeatherVariables2 = new float[7];
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(EclipseWeather), "OnEnable")]
		public static void FuckEclipsedWeatherVariables()
		{
			FuckCurrentWeatherVariable((LevelWeatherType)5);
			FuckCurrentWeatherVariable2((LevelWeatherType)5);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(EclipseWeather), "OnEnable")]
		public static void UnfuckEclipsedWeatherVariables()
		{
			UnfuckCurrentWeatherVariable();
			UnfuckCurrentWeatherVariable2();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(FloodWeather), "OnEnable")]
		[HarmonyPatch(typeof(FloodWeather), "Update")]
		[HarmonyPatch(typeof(FloodWeather), "OnGlobalTimeSync")]
		public static void FuckFloodedWeatherVariables()
		{
			FuckCurrentWeatherVariable((LevelWeatherType)4);
			FuckCurrentWeatherVariable2((LevelWeatherType)4);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(FloodWeather), "OnEnable")]
		[HarmonyPatch(typeof(FloodWeather), "Update")]
		[HarmonyPatch(typeof(FloodWeather), "OnGlobalTimeSync")]
		public static void UnfuckFloodedWeatherVariables()
		{
			UnfuckCurrentWeatherVariable();
			UnfuckCurrentWeatherVariable2();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(StormyWeather), "DetermineNextStrikeInterval")]
		[HarmonyPatch(typeof(StormyWeather), "LightningStrikeRandom")]
		public static void FuckStormyWeatherVariables()
		{
			FuckCurrentWeatherVariable((LevelWeatherType)2);
			FuckCurrentWeatherVariable2((LevelWeatherType)2);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(StormyWeather), "DetermineNextStrikeInterval")]
		[HarmonyPatch(typeof(StormyWeather), "LightningStrikeRandom")]
		public static void UnfuckStormyWeatherVariables()
		{
			FuckCurrentWeatherVariable((LevelWeatherType)2);
			FuckCurrentWeatherVariable2((LevelWeatherType)2);
		}
	}
}
namespace HellWeather.Helpers
{
	public static class WeatherHelpers
	{
		public static bool IsVanillaWeather(LevelWeatherType weatherType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			return (int)weatherType >= -1 && (int)weatherType <= 5;
		}

		public static bool IsVanillaWeatherWithEffect(LevelWeatherType weatherType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			return (int)weatherType > -1 && (int)weatherType <= 5;
		}

		public static IEnumerable<RandomWeatherWithVariables> GetVanillaRandomWeathersWithEffects(SelectableLevel level)
		{
			return level.randomWeathers.Where((RandomWeatherWithVariables rw) => IsVanillaWeatherWithEffect(rw.weatherType));
		}

		public static IEnumerable<WeatherEffect> GetVanillaWeatherEffects()
		{
			for (int weatherType = 0; weatherType <= 5; weatherType++)
			{
				yield return TimeOfDay.Instance.effects[weatherType];
			}
		}
	}
}