using System;
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.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("RealmMix")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+59942507d246a95a40fc32d9b420ea14320890be")]
[assembly: AssemblyProduct("RealmMix")]
[assembly: AssemblyTitle("RealmMix")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[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 RealmMix
{
	internal static class HostConfig
	{
		private static ConfigFile cfg;

		private static string messageName;

		private static string[] personal;

		private static Dictionary<string, string> whenHostLacksMod;

		private static Func<bool> active;

		private static HandleNamedMessageDelegate handler;

		private static IntPtr registeredOn;

		private static float nextSend;

		private static float joinedAt;

		private static string lastSent;

		private static string lastApplied;

		private static bool overriding;

		private static bool heardFromHost;

		private static bool warnedMissing;

		private static bool savedFlag;

		private static bool savingPersonal;

		private static readonly Dictionary<ConfigEntryBase, string> originals = new Dictionary<ConfigEntryBase, string>();

		internal static bool FromHost
		{
			get
			{
				if (overriding)
				{
					return heardFromHost;
				}
				return false;
			}
		}

		internal static void Init(BasePlugin plugin, string guid, string[] personalKeys, Dictionary<string, string> offWithoutHost, Func<bool> isActive = null)
		{
			cfg = plugin.Config;
			messageName = guid + ".HostConfig";
			personal = personalKeys ?? Array.Empty<string>();
			whenHostLacksMod = offWithoutHost ?? new Dictionary<string, string>();
			active = isActive;
			cfg.SettingChanged += OnSettingChanged;
			plugin.AddComponent<HostConfigRunner>();
		}

		private static void OnSettingChanged(object sender, SettingChangedEventArgs e)
		{
			try
			{
				if (overriding && !savingPersonal && IsPersonal(e.ChangedSetting.Definition))
				{
					SavePersonal();
				}
			}
			catch
			{
			}
		}

		private static string Id(ConfigDefinition d)
		{
			return d.Section + "." + d.Key;
		}

		private static bool IsPersonal(ConfigDefinition d)
		{
			string[] array = personal;
			foreach (string text in array)
			{
				if (text.EndsWith(".*") ? (d.Section == text.Substring(0, text.Length - 2)) : (Id(d) == text))
				{
					return true;
				}
			}
			return false;
		}

		internal static void Tick()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			try
			{
				NetworkManager singleton = NetworkManager.Singleton;
				bool flag = (Object)(object)singleton != (Object)null && singleton.IsListening;
				if (!flag || singleton.IsServer || (active != null && !active()))
				{
					if (overriding)
					{
						Restore();
					}
					if (flag && singleton.IsServer)
					{
						HostTick(singleton);
					}
					if (!flag)
					{
						registeredOn = IntPtr.Zero;
					}
				}
				else
				{
					ClientTick(singleton);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag2 = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(15, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Host settings: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogError(val);
			}
		}

		private static void HostTick(NetworkManager nm)
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			if (Time.unscaledTime < nextSend || nm.CustomMessagingManager == null)
			{
				return;
			}
			nextSend = Time.unscaledTime + 1.5f;
			List<string> list = new List<string>();
			foreach (KeyValuePair<ConfigDefinition, ConfigEntryBase> item in cfg)
			{
				if (!IsPersonal(item.Key))
				{
					list.Add(item.Key.Section + "\u001f" + item.Key.Key + "\u001f" + item.Value.GetSerializedValue());
				}
			}
			string text = string.Join("\u001e", list);
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(text.Length * 2 + 64, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe(text, false);
				nm.CustomMessagingManager.SendNamedMessageToAll(messageName, val, (NetworkDelivery)4);
			}
			finally
			{
				((FastBufferWriter)(ref val)).Dispose();
			}
			if (text != lastSent)
			{
				lastSent = text;
				Plugin.Log.LogInfo((object)"Sending this game's settings to all players.");
			}
		}

		private static void ClientTick(NetworkManager nm)
		{
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			CustomMessagingManager customMessagingManager = nm.CustomMessagingManager;
			if (customMessagingManager != null && registeredOn != ((Il2CppObjectBase)customMessagingManager).Pointer)
			{
				if (handler == null)
				{
					handler = DelegateSupport.ConvertDelegate<HandleNamedMessageDelegate>((Delegate)new Action<ulong, FastBufferReader>(OnReceived));
				}
				customMessagingManager.RegisterNamedMessageHandler(messageName, handler);
				registeredOn = ((Il2CppObjectBase)customMessagingManager).Pointer;
			}
			if (!overriding)
			{
				Begin();
				joinedAt = Time.unscaledTime;
				foreach (KeyValuePair<string, string> item in whenHostLacksMod)
				{
					Set(item.Key, item.Value);
				}
			}
			if (!heardFromHost && !warnedMissing && Time.unscaledTime - joinedAt > 15f)
			{
				warnedMissing = true;
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(88, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("No settings from the host: the host doesn't seem to have ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("RealmMix");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", so it stays off in this game.");
				}
				log.LogWarning(val);
			}
		}

		private static void OnReceived(ulong sender, FastBufferReader reader)
		{
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			bool flag = default(bool);
			try
			{
				string text = default(string);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref text, false);
				if (!overriding)
				{
					Begin();
				}
				heardFromHost = true;
				if (text == lastApplied)
				{
					return;
				}
				lastApplied = text;
				int num = 0;
				string[] array = text.Split('\u001e');
				for (int i = 0; i < array.Length; i++)
				{
					string[] array2 = array[i].Split('\u001f');
					if (array2.Length == 3)
					{
						ConfigDefinition d = new ConfigDefinition(array2[0], array2[1]);
						if (!IsPersonal(d) && Set(Id(d), array2[2]))
						{
							num++;
						}
					}
				}
				ManualLogSource log = Plugin.Log;
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(36, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Using the host's settings (");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" values).");
				}
				log.LogInfo(val);
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(25, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Host settings (receive): ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
				}
				log2.LogError(val2);
			}
		}

		private static void Begin()
		{
			overriding = true;
			heardFromHost = false;
			warnedMissing = false;
			lastApplied = null;
			savedFlag = cfg.SaveOnConfigSet;
			cfg.SaveOnConfigSet = false;
		}

		private static bool Set(string id, string value)
		{
			foreach (KeyValuePair<ConfigDefinition, ConfigEntryBase> item in cfg)
			{
				if (!(Id(item.Key) != id))
				{
					ConfigEntryBase value2 = item.Value;
					if (!originals.ContainsKey(value2))
					{
						originals[value2] = value2.GetSerializedValue();
					}
					if (value2.GetSerializedValue() != value)
					{
						value2.SetSerializedValue(value);
					}
					return true;
				}
			}
			return false;
		}

		private static void SavePersonal()
		{
			savingPersonal = true;
			Dictionary<ConfigEntryBase, string> dictionary = new Dictionary<ConfigEntryBase, string>();
			try
			{
				foreach (KeyValuePair<ConfigEntryBase, string> original in originals)
				{
					dictionary[original.Key] = original.Key.GetSerializedValue();
					original.Key.SetSerializedValue(original.Value);
				}
				cfg.Save();
			}
			finally
			{
				foreach (KeyValuePair<ConfigEntryBase, string> item in dictionary)
				{
					try
					{
						item.Key.SetSerializedValue(item.Value);
					}
					catch
					{
					}
				}
				savingPersonal = false;
			}
		}

		private static void Restore()
		{
			foreach (KeyValuePair<ConfigEntryBase, string> original in originals)
			{
				try
				{
					original.Key.SetSerializedValue(original.Value);
				}
				catch
				{
				}
			}
			originals.Clear();
			overriding = false;
			heardFromHost = false;
			lastApplied = null;
			cfg.SaveOnConfigSet = savedFlag;
			try
			{
				cfg.Save();
			}
			catch
			{
			}
			Plugin.Log.LogInfo((object)"Left the game; back to this computer's own settings.");
		}
	}
	public class HostConfigRunner : MonoBehaviour
	{
		public HostConfigRunner(IntPtr ptr)
			: base(ptr)
		{
		}

		private void Update()
		{
			HostConfig.Tick();
		}
	}
	[HarmonyPatch]
	internal static class MixPatches
	{
		private const int Realms = 4;

		private static readonly HashSet<EnemyType> Capped = new HashSet<EnemyType>
		{
			(EnemyType)9,
			(EnemyType)31,
			(EnemyType)35,
			(EnemyType)20,
			(EnemyType)23,
			(EnemyType)21,
			(EnemyType)29,
			(EnemyType)36,
			(EnemyType)10,
			(EnemyType)19
		};

		private static readonly Dictionary<(IntPtr wave, bool variants), List<EnemyProbability>> mixed = new Dictionary<(IntPtr, bool), List<EnemyProbability>>();

		private static readonly HashSet<string> logged = new HashSet<string>();

		private static RunManager run;

		private static bool inElitePick;

		private static float nextErrorLog;

		private static bool Host
		{
			get
			{
				try
				{
					NetworkManager singleton = NetworkManager.Singleton;
					return (Object)(object)singleton == (Object)null || !singleton.IsListening || singleton.IsServer;
				}
				catch
				{
					return true;
				}
			}
		}

		private static RunManager Run
		{
			get
			{
				if (run == null || ((Il2CppObjectBase)run).WasCollected || (Object)(object)run == (Object)null)
				{
					run = Object.FindObjectOfType<RunManager>();
				}
				return run;
			}
		}

		private static RunConfiguration ConfigFor(RunManager rm, int world)
		{
			return (RunConfiguration)(world switch
			{
				0 => rm.verdantMeadowsConfiguration, 
				1 => rm.frozenAncientsConfiguration, 
				2 => rm.pyrestormPitConfiguration, 
				3 => rm.astralPlanesConfiguration, 
				_ => null, 
			});
		}

		private static int WorldOf(RunManager rm, RunConfiguration cfg)
		{
			if ((Object)(object)cfg == (Object)null)
			{
				return -1;
			}
			for (int i = 0; i < 4; i++)
			{
				RunConfiguration val = ConfigFor(rm, i);
				if ((Object)(object)val != (Object)null && ((Il2CppObjectBase)val).Pointer == ((Il2CppObjectBase)cfg).Pointer)
				{
					return i;
				}
			}
			return -1;
		}

		private static EnemyType Variant(EnemyType t, int world)
		{
			//IL_0000: 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_0020: Expected I4, but got Unknown
			//IL_004d: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			switch (t - 4)
			{
			case 4:
				if (world != 0)
				{
					break;
				}
				return (EnemyType)32;
			case 0:
				if (world != 1)
				{
					break;
				}
				return (EnemyType)33;
			case 2:
				if (world != 2)
				{
					break;
				}
				return (EnemyType)30;
			case 5:
				if (world != 3)
				{
					break;
				}
				return (EnemyType)31;
			}
			return t;
		}

		[HarmonyPatch(typeof(RunManager), "OnDestroy")]
		[HarmonyPostfix]
		private static void RunEnded()
		{
			mixed.Clear();
			run = null;
		}

		[HarmonyPatch(typeof(RunManager), "StartRun")]
		[HarmonyPrefix]
		private static void RunStarting()
		{
			mixed.Clear();
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		private static void WaveEnemies_Postfix(WaveConfiguration __instance, ref List<EnemyProbability> __result)
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				float value = Plugin.WaveMix.Value;
				if (!Plugin.Enabled.Value || value <= 0f || __result == null || !Host)
				{
					return;
				}
				bool flag = false;
				try
				{
					flag = new EnemyProbability().ShouldReplaceWithWorldSpecificVariant();
				}
				catch
				{
				}
				(IntPtr, bool) key = (((Il2CppObjectBase)__instance).Pointer, flag);
				if (mixed.TryGetValue(key, out var value2) && value2 != null)
				{
					__result = value2;
					return;
				}
				List<EnemyProbability> val = Build(__instance, __result, Math.Min(value, 1f), flag);
				if (val != null)
				{
					mixed[key] = val;
					__result = val;
				}
			}
			catch (Exception ex)
			{
				if (!(Time.unscaledTime < nextErrorLog))
				{
					nextErrorLog = Time.unscaledTime + 10f;
					ManualLogSource log = Plugin.Log;
					bool flag2 = default(bool);
					BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(15, 1, ref flag2);
					if (flag2)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Mixing a wave: ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<Exception>(ex);
					}
					log.LogError(val2);
				}
			}
		}

		private static List<EnemyProbability> Build(WaveConfiguration wave, List<EnemyProbability> own, float mix, bool variants)
		{
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_044a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0451: Expected O, but got Unknown
			RunManager val = Run;
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			RunConfiguration configuration = val.Configuration;
			int num = WorldOf(val, configuration);
			if (num < 0 || configuration.Waves == null)
			{
				return null;
			}
			int num2 = -1;
			for (int i = 0; i < configuration.Waves.Count; i++)
			{
				if ((Object)(object)configuration.Waves[i] != (Object)null && ((Il2CppObjectBase)configuration.Waves[i]).Pointer == ((Il2CppObjectBase)wave).Pointer)
				{
					num2 = i;
					break;
				}
			}
			if (num2 < 0)
			{
				return null;
			}
			double num3 = 0.0;
			for (int j = 0; j < own.Count; j++)
			{
				num3 += (double)Math.Max(0f, own[j].Probability);
			}
			if (num3 <= 0.0)
			{
				return null;
			}
			List<(int, List<EnemyProbability>, double)> list = new List<(int, List<EnemyProbability>, double)>();
			for (int k = 0; k < 4; k++)
			{
				if (k == num)
				{
					continue;
				}
				RunConfiguration val2 = ConfigFor(val, k);
				if (((val2 != null) ? val2.Waves : null) == null || val2.Waves.Count == 0)
				{
					continue;
				}
				WaveConfiguration obj = val2.Waves[Math.Min(num2, val2.Waves.Count - 1)];
				List<EnemyProbability> val3 = ((obj != null) ? obj.EnemyProbabilities : null);
				if (val3 != null)
				{
					double num4 = 0.0;
					for (int l = 0; l < val3.Count; l++)
					{
						num4 += (double)Math.Max(0f, val3[l].Probability);
					}
					if (num4 > 0.0)
					{
						list.Add((k, val3, num4));
					}
				}
			}
			if (list.Count == 0)
			{
				return null;
			}
			List<EnemyProbability> result = new List<EnemyProbability>();
			Dictionary<EnemyType, double> summary = new Dictionary<EnemyType, double>();
			for (int m = 0; m < own.Count; m++)
			{
				Add(own[m].Type, (double)own[m].Probability * (1.0 - (double)mix));
			}
			foreach (var item in list)
			{
				double num5 = num3 / item.Item3 * (double)mix / (double)list.Count;
				for (int n = 0; n < item.Item2.Count; n++)
				{
					EnemyType t = item.Item2[n].Type;
					if (variants)
					{
						t = Variant(t, item.Item1);
					}
					Add(t, (double)Math.Max(0f, item.Item2[n].Probability) * num5);
				}
			}
			List<EnemyProbability> val4 = new List<EnemyProbability>();
			for (int num6 = 0; num6 < 2; num6++)
			{
				for (int num7 = 0; num7 < result.Count; num7++)
				{
					if (Capped.Contains(result[num7].Type) == (num6 == 1))
					{
						val4.Add(result[num7]);
					}
				}
			}
			result = val4;
			if (Plugin.LogMix.Value && logged.Add($"{num}:{num2}:{variants}"))
			{
				List<string> list2 = new List<string>();
				foreach (KeyValuePair<EnemyType, double> item2 in summary)
				{
					list2.Add($"{item2.Key} {100.0 * item2.Value / num3:0}%");
				}
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val5 = new BepInExInfoLogInterpolatedStringHandler(13, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val5).AppendLiteral("Wave ");
					((BepInExLogInterpolatedStringHandler)val5).AppendFormatted<int>(num2 + 1);
					((BepInExLogInterpolatedStringHandler)val5).AppendLiteral(" mixed: ");
					((BepInExLogInterpolatedStringHandler)val5).AppendFormatted<string>(string.Join(", ", list2));
				}
				log.LogInfo(val5);
			}
			return result;
			void Add(EnemyType val7, double p)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Expected O, but got Unknown
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				if (!(p <= 0.0))
				{
					EnemyProbability val6 = new EnemyProbability();
					val6.Type = val7;
					val6.Probability = (float)p;
					result.Add(val6);
					summary.TryGetValue(val7, out var value);
					summary[val7] = value + p;
				}
			}
		}

		[HarmonyPatch(typeof(EliteEnemyConfiguration), "GetRandomEnemy")]
		[HarmonyPostfix]
		private static void EliteEnemy_Postfix(EliteEnemyConfiguration __instance, ref EnemyType __result)
		{
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Expected O, but got Unknown
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Expected I4, but got Unknown
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Expected O, but got Unknown
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			if (inElitePick)
			{
				return;
			}
			bool flag = default(bool);
			try
			{
				if (!Plugin.Enabled.Value || !Host || Random.value >= Plugin.EliteMix.Value)
				{
					return;
				}
				RunManager val = Run;
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				RunConfiguration configuration = val.Configuration;
				int num = WorldOf(val, configuration);
				if (num < 0 || configuration.EliteEnemies == null)
				{
					return;
				}
				int num2 = -1;
				for (int i = 0; i < configuration.EliteEnemies.Count; i++)
				{
					if ((Object)(object)configuration.EliteEnemies[i] != (Object)null && ((Il2CppObjectBase)configuration.EliteEnemies[i]).Pointer == ((Il2CppObjectBase)__instance).Pointer)
					{
						num2 = i;
						break;
					}
				}
				if (num2 < 0)
				{
					return;
				}
				List<EliteEnemyConfiguration> list = new List<EliteEnemyConfiguration>();
				for (int j = 0; j < 4; j++)
				{
					if (j == num)
					{
						continue;
					}
					RunConfiguration obj = ConfigFor(val, j);
					List<EliteEnemyConfiguration> val2 = ((obj != null) ? obj.EliteEnemies : null);
					if (val2 != null && val2.Count != 0)
					{
						EliteEnemyConfiguration val3 = val2[Math.Min(num2, val2.Count - 1)];
						if ((Object)(object)val3 != (Object)null)
						{
							list.Add(val3);
						}
					}
				}
				if (list.Count == 0)
				{
					return;
				}
				EliteEnemyConfiguration val4 = list[Random.Range(0, list.Count)];
				inElitePick = true;
				EnemyType randomEnemy;
				try
				{
					randomEnemy = val4.GetRandomEnemy();
				}
				finally
				{
					inElitePick = false;
				}
				if (Plugin.LogMix.Value)
				{
					ManualLogSource log = Plugin.Log;
					BepInExInfoLogInterpolatedStringHandler val5 = new BepInExInfoLogInterpolatedStringHandler(20, 4, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val5).AppendLiteral("Elite ");
						((BepInExLogInterpolatedStringHandler)val5).AppendFormatted<int>(num2 + 1);
						((BepInExLogInterpolatedStringHandler)val5).AppendLiteral(": ");
						((BepInExLogInterpolatedStringHandler)val5).AppendFormatted<EnemyType>(__result);
						((BepInExLogInterpolatedStringHandler)val5).AppendLiteral(" -> ");
						((BepInExLogInterpolatedStringHandler)val5).AppendFormatted<EnemyType>(randomEnemy);
						((BepInExLogInterpolatedStringHandler)val5).AppendLiteral(" (from ");
						((BepInExLogInterpolatedStringHandler)val5).AppendFormatted<string>(((Object)val4).name);
						((BepInExLogInterpolatedStringHandler)val5).AppendLiteral(")");
					}
					log.LogInfo(val5);
				}
				__result = (EnemyType)(int)randomEnemy;
			}
			catch (Exception ex)
			{
				inElitePick = false;
				ManualLogSource log2 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val6 = new BepInExErrorLogInterpolatedStringHandler(17, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val6).AppendLiteral("Mixing an elite: ");
					((BepInExLogInterpolatedStringHandler)val6).AppendFormatted<Exception>(ex);
				}
				log2.LogError(val6);
			}
		}

		[HarmonyPatch(typeof(EndBossObjective), "StartBossSequenceRpc")]
		[HarmonyPrefix]
		private static void BossRpc_Prefix(EndBossObjective __instance, ref BossType bossType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			try
			{
				if ((int)((NetworkBehaviour)__instance).__rpc_exec_stage != 1)
				{
					Boss_Pick(ref bossType);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(16, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Picking a boss: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
				}
				log.LogError(val);
			}
		}

		private static void Boss_Pick(ref BossType __result)
		{
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected I4, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			bool flag = default(bool);
			try
			{
				if (!Plugin.Enabled.Value || !Plugin.AnyBoss.Value || !Host)
				{
					return;
				}
				List<BossConfig> val = BossConfigRepository.Get();
				if (val == null || val.Count == 0)
				{
					return;
				}
				List<BossType> list = new List<BossType>();
				for (int i = 0; i < val.Count; i++)
				{
					BossConfig val2 = val[i];
					if ((Object)(object)val2 != (Object)null && (Object)(object)val2.BossPrefab != (Object)null && !list.Contains(val2.BossType))
					{
						list.Add(val2.BossType);
					}
				}
				if (list.Count == 0)
				{
					return;
				}
				BossType val3 = list[Random.Range(0, list.Count)];
				if (Plugin.LogMix.Value)
				{
					ManualLogSource log = Plugin.Log;
					BepInExInfoLogInterpolatedStringHandler val4 = new BepInExInfoLogInterpolatedStringHandler(10, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("Boss: ");
						((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<BossType>(__result);
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(" -> ");
						((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<BossType>(val3);
					}
					log.LogInfo(val4);
				}
				__result = (BossType)(int)val3;
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val5 = new BepInExErrorLogInterpolatedStringHandler(16, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val5).AppendLiteral("Picking a boss: ");
					((BepInExLogInterpolatedStringHandler)val5).AppendFormatted<Exception>(ex);
				}
				log2.LogError(val5);
			}
		}
	}
	[BepInPlugin("girthy_mods.RealmMix", "RealmMix", "1.0.1")]
	public class Plugin : BasePlugin
	{
		public const string Guid = "girthy_mods.RealmMix";

		public const string Name = "RealmMix";

		public const string Version = "1.0.1";

		internal static ManualLogSource Log;

		internal static ConfigEntry<bool> Enabled;

		internal static ConfigEntry<float> WaveMix;

		internal static ConfigEntry<float> EliteMix;

		internal static ConfigEntry<bool> AnyBoss;

		internal static ConfigEntry<bool> LogMix;

		public override void Load()
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			Log = ((BasePlugin)this).Log;
			HostConfig.Init((BasePlugin)(object)this, "girthy_mods.RealmMix", new string[1] { "Debug.LogMix" }, new Dictionary<string, string> { ["Mix.Enabled"] = "false" });
			Enabled = ((BasePlugin)this).Config.Bind<bool>("Mix", "Enabled", true, "Mix the realms' enemies into every run (host).");
			WaveMix = ((BasePlugin)this).Config.Bind<float>("Mix", "WaveMix", 0.6f, new ConfigDescription("How much of each wave comes from the other three realms. 0 = only this realm's enemies, 0.75 = all four realms equally, 1 = only the other realms.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			EliteMix = ((BasePlugin)this).Config.Bind<float>("Mix", "EliteMix", 0.6f, new ConfigDescription("Chance that an elite comes from another realm's elite list.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			AnyBoss = ((BasePlugin)this).Config.Bind<bool>("Mix", "AnyBoss", true, "The end boss can be any boss, including ones you haven't unlocked yet (the game normally picks from unlocked bosses).");
			LogMix = ((BasePlugin)this).Config.Bind<bool>("Debug", "LogMix", false, "Write each mixed wave, elite and boss to the BepInEx log.");
			new Harmony("girthy_mods.RealmMix").PatchAll(typeof(MixPatches));
			ManualLogSource log = Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(8, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("RealmMix");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("1.0.1");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ready.");
			}
			log.LogInfo(val);
		}
	}
}