using System;
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.Configuration;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using On.RoR2;
using R2API.Utils;
using RoR2;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;

[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("ShrineOfDisorder")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.5.0")]
[assembly: AssemblyInformationalVersion("1.1.5+6262c21f4e90eac30b9c107451b935ba9cef7043")]
[assembly: AssemblyProduct("ShrineOfDisorder")]
[assembly: AssemblyTitle("ShrineOfDisorder")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.5.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ShrineOfDisorder
{
	public enum ShrineBehavior
	{
		RandomizeEachStack,
		RandomizeEachItem,
		SwapOneInventory,
		SwapAllInventories
	}
	public class ShrineConfig
	{
		public ConfigEntry<bool> lunarItemsCfg;

		public ConfigEntry<bool> bossItemsCfg;

		public ConfigEntry<bool> voidItemsCfg;

		public ConfigEntry<bool> voidBossItemsCfg;

		public ConfigEntry<ShrineBehavior> shrineBehaviorCfg;

		public ConfigEntry<bool> preserveStackCountCfg;

		public ConfigEntry<bool> onlyObtainedItemsCfg;

		public ConfigEntry<bool> shrineOnAllMapsCfg;

		public ConfigEntry<float> shrineSpawnMultiplierCfg;

		public bool lunarItems => lunarItemsCfg.Value;

		public bool bossItems => bossItemsCfg.Value;

		public bool voidItems => voidItemsCfg.Value;

		public bool voidBossItems => voidBossItemsCfg.Value;

		public ShrineBehavior shrineBehavior => shrineBehaviorCfg.Value;

		public bool preserveStackCount => preserveStackCountCfg.Value;

		public bool onlyObtainedItems => onlyObtainedItemsCfg.Value;

		public bool shrineOnAllMaps => shrineOnAllMapsCfg.Value;

		public float shrineSpawnMultiplier => shrineSpawnMultiplierCfg.Value;

		public ShrineConfig(ConfigFile cfg)
		{
			lunarItemsCfg = cfg.Bind<bool>("Items", "LunarItems", false, "Allow the shrine to randomize lunar items.");
			voidItemsCfg = cfg.Bind<bool>("Items", "VoidItems", false, "Allow the shrine to randomize void items.");
			bossItemsCfg = cfg.Bind<bool>("Items", "BossItems", false, "Allow the shrine to randomize boss items.");
			voidBossItemsCfg = cfg.Bind<bool>("Items", "VoidBossItems", false, "Allow the shrine to randomize void items.");
			shrineBehaviorCfg = cfg.Bind<ShrineBehavior>("Behavior", "ShrineBehavior", ShrineBehavior.RandomizeEachStack, "The behavior of the shrine. The inventory swapping behavior is only enabled for games with 2 or more players. Otherwise, the default behavior will be used.");
			preserveStackCountCfg = cfg.Bind<bool>("Behavior", "PreserveStackCount", true, "Preserve the number of unique stacks when using the RandomizeEachStack behavior. If disabled, the same item can be randomly selected for multiple stacks, effectively merging them.");
			onlyObtainedItemsCfg = cfg.Bind<bool>("Behavior", "OnlyObtainedItems", false, "When determining which items to give the player, only pick from the list of items that they already have in their inventory.");
			shrineOnAllMapsCfg = cfg.Bind<bool>("Behavior", "ShrineOnAllMaps", true, "Allow the shrine to spawn on all maps.");
			shrineSpawnMultiplierCfg = cfg.Bind<float>("Behavior", "ShrineSpawnMultiplier", 1f, "A multiplier on the shrine's spawn weight.");
		}
	}
	internal static class Log
	{
		internal static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void LogDebug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void LogError(object data)
		{
			_logSource.LogError(data);
		}

		internal static void LogFatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void LogInfo(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void LogMessage(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void LogWarning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	public static class DccsExtensions
	{
		public static int FindCategoryIndexByName_WorkingVersion(this DirectorCardCategorySelection dccs, string categoryName)
		{
			for (int i = 0; i < dccs.categories.Length; i++)
			{
				if (dccs.categories[i].name == categoryName)
				{
					return i;
				}
			}
			return -1;
		}

		public static DirectorCard GetCard(this DirectorCardCategorySelection dccs, int categoryIndex, string cardName)
		{
			DirectorCard[] cards = dccs.categories[categoryIndex].cards;
			foreach (DirectorCard val in cards)
			{
				if (((Object)val.spawnCard).name.StartsWith(cardName))
				{
					return val;
				}
			}
			return null;
		}

		public static bool HasCard(this DirectorCardCategorySelection dccs, int categoryIndex, string cardName)
		{
			return dccs.GetCard(categoryIndex, cardName) != null;
		}

		public static int GetWeight(this DirectorCardCategorySelection dccs, int categoryIndex, string cardName)
		{
			return dccs.GetCard(categoryIndex, cardName)?.selectionWeight ?? (-1);
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("cbrl.ShrineOfDisorder", "ShrineOfDisorder", "1.0.0")]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class ShrineOfDisorder : BaseUnityPlugin
	{
		public const string PluginGUID = "cbrl.ShrineOfDisorder";

		public const string PluginAuthor = "cbrl";

		public const string PluginName = "ShrineOfDisorder";

		public const string PluginVersion = "1.0.0";

		public ShrineConfig config;

		private HashSet<ItemTier> enabledTiers = new HashSet<ItemTier>();

		private static Dictionary<ItemTier, List<ItemDef>> dropLists;

		private readonly string[] bannedStageNames = new string[4] { "bazaar", "artifactworld", "mysteryspace", "limbo" };

		private readonly string[] searchWeights = new string[3] { "iscShrineBoss", "iscShrineBlood", "iscShrineCombat" };

		private const int defaultShrineWeight = 3;

		public void Awake()
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			Log.Init(((BaseUnityPlugin)this).Logger);
			config = new ShrineConfig(((BaseUnityPlugin)this).Config);
			enabledTiers.Add((ItemTier)0);
			enabledTiers.Add((ItemTier)1);
			enabledTiers.Add((ItemTier)2);
			if (config.lunarItems)
			{
				enabledTiers.Add((ItemTier)3);
			}
			if (config.bossItems)
			{
				enabledTiers.Add((ItemTier)4);
			}
			if (config.voidBossItems)
			{
				enabledTiers.Add((ItemTier)9);
			}
			if (config.voidItems)
			{
				enabledTiers.Add((ItemTier)6);
				enabledTiers.Add((ItemTier)7);
				enabledTiers.Add((ItemTier)8);
			}
			Run.Start += new hook_Start(Run_Start);
			Inventory.ShrineRestackInventory += (hook_ShrineRestackInventory)delegate(orig_ShrineRestackInventory orig, Inventory self, Xoroshiro128Plus rng)
			{
				RestackBehavior(self, rng);
			};
			if (config.shrineOnAllMaps)
			{
				SceneDirector.onGenerateInteractableCardSelection += SceneDirector_onGenerateInteractableCardSelection;
			}
			Log.LogInfo("Awake done.");
		}

		private void SceneDirector_onGenerateInteractableCardSelection(SceneDirector director, DirectorCardCategorySelection selection)
		{
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			if (!NetworkServer.active || bannedStageNames.Contains(((Object)Stage.instance).name))
			{
				return;
			}
			int index = selection.FindCategoryIndexByName_WorkingVersion("Shrines");
			if (index >= 0 && !selection.HasCard(index, "iscShrineRestack"))
			{
				int num = searchWeights.Select((string search) => selection.GetWeight(index, search)).FirstOrDefault((int weight) => weight != -1);
				if (num == 0)
				{
					num = 3;
				}
				DirectorCard val = new DirectorCard
				{
					spawnCard = Addressables.LoadAssetAsync<SpawnCard>((object)"RoR2/Base/ShrineRestack/iscShrineRestack.asset").WaitForCompletion(),
					selectionWeight = (int)((float)num * config.shrineSpawnMultiplier)
				};
				selection.AddCard(index, val);
				Log.LogInfo($"Added card with weight: {val.selectionWeight}");
			}
			else if (index < 0)
			{
				Log.LogWarning("Could not find 'Shrines' category in stage " + ((Object)Stage.instance).name + ". The Shrine of Order will not be added to this stage.");
			}
			Category[] categories = selection.categories;
			for (int i = 0; i < categories.Length; i++)
			{
				Category cat = categories[i];
				string arg = string.Join("\n    ", cat.cards.Select((DirectorCard card) => $"{cat.name}.{((Object)card.spawnCard).name} weight: {card.selectionWeight}"));
				Log.LogDebug($"{cat.name} weight: {cat.selectionWeight}\n    {arg}");
			}
		}

		private void Run_Start(orig_Start orig, Run self)
		{
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			dropLists = new Dictionary<ItemTier, List<ItemDef>>
			{
				{
					(ItemTier)0,
					Run.instance.availableTier1DropList.ConvertAll(GetItemDef)
				},
				{
					(ItemTier)1,
					Run.instance.availableTier2DropList.ConvertAll(GetItemDef)
				},
				{
					(ItemTier)2,
					Run.instance.availableTier3DropList.ConvertAll(GetItemDef)
				},
				{
					(ItemTier)3,
					Run.instance.availableLunarItemDropList.ConvertAll(GetItemDef)
				},
				{
					(ItemTier)4,
					Run.instance.availableBossDropList.ConvertAll(GetItemDef)
				},
				{
					(ItemTier)6,
					Run.instance.availableVoidTier1DropList.ConvertAll(GetItemDef)
				},
				{
					(ItemTier)7,
					Run.instance.availableVoidTier2DropList.ConvertAll(GetItemDef)
				},
				{
					(ItemTier)8,
					Run.instance.availableVoidTier3DropList.ConvertAll(GetItemDef)
				},
				{
					(ItemTier)9,
					Run.instance.availableVoidBossDropList.ConvertAll(GetItemDef)
				}
			};
			foreach (KeyValuePair<ItemTier, List<ItemDef>> dropList in dropLists)
			{
				Log.LogDebug(string.Format("{0} Drop List: {1}", dropList.Key, string.Join(", ", dropList.Value)));
			}
		}

		private void Update()
		{
		}

		private void RestackBehavior(Inventory self, Xoroshiro128Plus rng)
		{
			if (!NetworkServer.active)
			{
				return;
			}
			if (NetworkUser.readOnlyInstancesList.Count < 2)
			{
				if (config.shrineBehavior == ShrineBehavior.RandomizeEachItem)
				{
					RandomizeItems(self, rng);
				}
				else
				{
					RandomizeItemStacks(self, rng);
				}
				return;
			}
			switch (config.shrineBehavior)
			{
			case ShrineBehavior.RandomizeEachItem:
				RandomizeItems(self, rng);
				break;
			case ShrineBehavior.RandomizeEachStack:
				RandomizeItemStacks(self, rng);
				break;
			case ShrineBehavior.SwapOneInventory:
				SwapOneInventory(self, rng);
				break;
			case ShrineBehavior.SwapAllInventories:
				SwapAllInventories(rng);
				break;
			default:
				RandomizeItemStacks(self, rng);
				break;
			}
		}

		private static void ResetItems(Inventory inventory, List<ItemDef> items)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			foreach (ItemDef item in items)
			{
				inventory.ResetItem(item);
				inventory.itemAcquisitionOrder.Remove(item.itemIndex);
			}
		}

		private static Dictionary<ItemDef, int> GiveRandomItems(Inventory inventory, List<ItemDef> dropList, int count, Xoroshiro128Plus rng)
		{
			Dictionary<ItemDef, int> dictionary = new Dictionary<ItemDef, int>();
			for (int i = 0; i < count; i++)
			{
				ItemDef val = rng.NextElementUniform<ItemDef>(dropList);
				inventory.GiveItem(val, 1);
				if (!dictionary.ContainsKey(val))
				{
					dictionary[val] = 0;
				}
				dictionary[val]++;
			}
			return dictionary;
		}

		private static ItemDef GiveRandomStack(Inventory inventory, List<ItemDef> dropList, int count, Xoroshiro128Plus rng)
		{
			ItemDef val = rng.NextElementUniform<ItemDef>(dropList);
			inventory.GiveItem(val, count);
			return val;
		}

		private Dictionary<ItemTier, Dictionary<ItemDef, int>> GetItemCounts(Inventory inventory)
		{
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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)
			Dictionary<ItemTier, Dictionary<ItemDef, int>> dictionary = new Dictionary<ItemTier, Dictionary<ItemDef, int>>();
			foreach (ItemTier key in dropLists.Keys)
			{
				foreach (ItemDef item in dropLists[key])
				{
					int itemCount = inventory.GetItemCount(item.itemIndex);
					if (itemCount > 0)
					{
						if (!dictionary.ContainsKey(key))
						{
							dictionary.Add(key, new Dictionary<ItemDef, int>());
						}
						dictionary[key][item] = itemCount;
					}
				}
			}
			return dictionary;
		}

		private void RandomizeItems(Inventory self, Xoroshiro128Plus rng)
		{
			//IL_0018: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ItemTier, Dictionary<ItemDef, int>> itemCounts = GetItemCounts(self);
			foreach (ItemTier enabledTier in enabledTiers)
			{
				ResetItems(self, dropLists[enabledTier]);
			}
			((NetworkBehaviour)self).SetDirtyBit(8u);
			foreach (KeyValuePair<ItemTier, Dictionary<ItemDef, int>> item in itemCounts.Where((KeyValuePair<ItemTier, Dictionary<ItemDef, int>> pair) => enabledTiers.Contains(pair.Key)))
			{
				List<ItemDef> dropList = (config.onlyObtainedItems ? item.Value.Keys.ToList() : dropLists[item.Key]);
				int count = item.Value.Sum((KeyValuePair<ItemDef, int> pair) => pair.Value);
				GiveRandomItems(self, dropList, count, rng);
			}
		}

		private void RandomizeItemStacks(Inventory self, Xoroshiro128Plus rng)
		{
			//IL_0018: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ItemTier, Dictionary<ItemDef, int>> itemCounts = GetItemCounts(self);
			foreach (ItemTier enabledTier in enabledTiers)
			{
				ResetItems(self, dropLists[enabledTier]);
			}
			((NetworkBehaviour)self).SetDirtyBit(8u);
			foreach (KeyValuePair<ItemTier, Dictionary<ItemDef, int>> item2 in itemCounts.Where((KeyValuePair<ItemTier, Dictionary<ItemDef, int>> pair) => enabledTiers.Contains(pair.Key)))
			{
				ItemTier key = item2.Key;
				Dictionary<ItemDef, int> value = item2.Value;
				List<ItemDef> list = null;
				list = ((!config.preserveStackCount) ? (config.onlyObtainedItems ? value.Keys.ToList() : dropLists[key]) : new List<ItemDef>(config.onlyObtainedItems ? value.Keys.ToList() : dropLists[key]));
				foreach (KeyValuePair<ItemDef, int> item3 in value)
				{
					ItemDef item = GiveRandomStack(self, list, item3.Value, rng);
					if (config.preserveStackCount)
					{
						list.Remove(item);
					}
				}
			}
		}

		private void SwapOneInventory(Inventory self, Xoroshiro128Plus rng)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			List<Inventory> list = PlayerCharacterMasterController.instances.Select((PlayerCharacterMasterController user) => user.master.inventory).ToList();
			Inventory val = new Inventory();
			Inventory val2 = rng.NextElementUniform<Inventory>(list);
			val.CopyItemsFrom(self);
			self.CopyItemsFrom(val2);
			val2.CopyItemsFrom(val);
		}

		private void SwapAllInventories(Xoroshiro128Plus rng)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			List<Inventory> list = PlayerCharacterMasterController.instances.Select((PlayerCharacterMasterController user) => user.master.inventory).ToList();
			Inventory val = new Inventory();
			IOrderedEnumerable<Inventory> second = list.OrderBy((Inventory n) => rng.Next());
			foreach (var (val2, val3) in list.Zip(second, (Inventory a, Inventory b) => (a, b)))
			{
				val.CopyItemsFrom(val2);
				val2.CopyItemsFrom(val3);
				val3.CopyItemsFrom(val);
			}
		}

		private static ItemDef GetItemDef(PickupIndex index)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return ItemCatalog.GetItemDef(PickupCatalog.GetPickupDef(index).itemIndex);
		}
	}
}