using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("TrueWeatherSwamp")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.3.0")]
[assembly: AssemblyInformationalVersion("1.1.3+db1399b94a522d615b5273f7c4efa8dd7bc83680")]
[assembly: AssemblyProduct("TrueWeatherSwamp")]
[assembly: AssemblyTitle("TrueWeatherSwamp")]
[assembly: AssemblyVersion("1.1.3.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 TrueWeatherSwamp
{
	[BepInPlugin("com.trueweatherswamp.plugin", "True Weather Swamp", "1.1.3")]
	public sealed class TrueWeatherSwampPlugin : BaseUnityPlugin
	{
		private const string PluginGuid = "com.trueweatherswamp.plugin";

		private const string PluginName = "True Weather Swamp";

		private const string PluginVersion = "1.1.3";

		internal static ManualLogSource ModLogger;

		private void Awake()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			ModLogger = ((BaseUnityPlugin)this).Logger;
			new Harmony("com.trueweatherswamp.plugin").PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Installed explicit Swamp weather pool.");
		}
	}
	internal static class SwampWeatherPool
	{
		private static bool hasLoggedAppliedPool;

		private static bool hasLoggedMissingPatterns;

		internal static void Apply(EnvMan envMan, List<EnvEntry> availableEnvironments)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_0071: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			List<EnvEntry> list = new List<EnvEntry>(2);
			List<string> list2 = new List<string>();
			EnvSetup val = FindEnvironment(envMan.m_environments, "Clear");
			if (val == null)
			{
				val = FindEnvironment(envMan.m_environments, "Heath_clear");
			}
			if (val == null)
			{
				list2.Add("Clear (or Heath_clear)");
				LogMissingPatterns(envMan, list2);
				return;
			}
			list.Add(new EnvEntry
			{
				m_environment = val.m_name,
				m_weight = 67f,
				m_env = val
			});
			EnvSetup val2 = FindEnvironment(envMan.m_environments, "SwampRain");
			if (val2 == null)
			{
				list2.Add("SwampRain");
			}
			else
			{
				list.Add(new EnvEntry
				{
					m_environment = val2.m_name,
					m_weight = 33f,
					m_env = val2
				});
			}
			LogMissingPatterns(envMan, list2);
			availableEnvironments.Clear();
			availableEnvironments.AddRange(list);
			if (hasLoggedAppliedPool)
			{
				return;
			}
			List<string> list3 = new List<string>(list.Count);
			foreach (EnvEntry item in list)
			{
				list3.Add($"{item.m_environment} ({item.m_weight})");
			}
			TrueWeatherSwampPlugin.ModLogger.LogInfo((object)("Applied Swamp weather pool: " + string.Join(", ", list3) + "."));
			hasLoggedAppliedPool = true;
		}

		private static EnvSetup FindEnvironment(List<EnvSetup> environments, string name)
		{
			foreach (EnvSetup environment in environments)
			{
				if (environment.m_name == name)
				{
					return environment;
				}
			}
			return null;
		}

		private static void LogMissingPatterns(EnvMan envMan, List<string> missingPatterns)
		{
			if (hasLoggedMissingPatterns || missingPatterns.Count == 0)
			{
				return;
			}
			List<string> list = new List<string>(envMan.m_environments.Count);
			foreach (EnvSetup environment in envMan.m_environments)
			{
				list.Add(environment.m_name);
			}
			TrueWeatherSwampPlugin.ModLogger.LogWarning((object)("Weather patterns not found: " + string.Join(", ", missingPatterns) + ". Loaded environments: " + string.Join(", ", list) + "."));
			hasLoggedMissingPatterns = true;
		}
	}
	[HarmonyPatch(typeof(EnvMan), "GetAvailableEnvironments")]
	internal static class GetAvailableEnvironmentsPatch
	{
		[HarmonyPostfix]
		private static void Postfix(EnvMan __instance, BiomeSector biome, List<EnvEntry> __result)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)biome.Biome == 2 && __result != null)
			{
				SwampWeatherPool.Apply(__instance, __result);
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "TrueWeatherSwamp";

		public const string PLUGIN_NAME = "TrueWeatherSwamp";

		public const string PLUGIN_VERSION = "1.1.3";
	}
}