using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Permissions;
using BepInEx;
using On.RoR2;
using R2API;
using RoR2;
using UnityEngine;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("ConfigurableBenthic")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ConfigurableBenthic")]
[assembly: AssemblyTitle("ConfigurableBenthic")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ConfigurableBenthic;

public enum OverspillBonus
{
	None,
	PlusOne,
	Duplicate
}
public enum SelectMethod
{
	Random,
	LeastStacks,
	MostStacks
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("com.kking117.ConfigurableBenthic", "ConfigurableBenthic", "1.1.0")]
public class MainPlugin : BaseUnityPlugin
{
	public const string MODUID = "com.kking117.ConfigurableBenthic";

	public const string MODNAME = "ConfigurableBenthic";

	public const string MODTOKEN = "KKING117_CONFIGBENTHIC_";

	public const string MODVERSION = "1.1.0";

	public static int Config_BaseCount = 3;

	public static int Config_StackCount = 3;

	public static string Config_BlackList = "";

	public static bool Config_WholeStack = true;

	public static SelectMethod Config_Select_Method = SelectMethod.Random;

	public static bool Config_Select_PreferScrap = false;

	public static bool Config_Select_AllowVoid = false;

	public static bool Config_Select_AllowSelf = true;

	public static bool Config_RefreshOnUpgrade;

	public static bool Config_Overspill_Enable = false;

	public static OverspillBonus Config_Overspill_Bonus = OverspillBonus.PlusOne;

	private static bool NewDesc = false;

	public static List<ItemDef> BanList;

	private void Awake()
	{
		ReadConfig();
		if (Config_BaseCount != 3 || Config_StackCount != 3)
		{
			UpdateText();
		}
		Hooks();
	}

	private static void Hooks()
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Expected O, but got Unknown
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Expected O, but got Unknown
		ItemCatalog.Init += new hook_Init(ItemCatalog_Init);
		CharacterMaster.TryCloverVoidUpgrades += new hook_TryCloverVoidUpgrades(CloverVoidUpgrade);
	}

	private static void UpdateText()
	{
		string text = $"<style=cIsUtility>Upgrades {Config_BaseCount}</style> <style=cStack>(+{Config_StackCount} per stack)</style> random items to items of the next <style=cIsUtility>higher rarity</style> at the <style=cIsUtility>start of each stage</style>. <style=cIsVoid>Corrupts all 57 Leaf Clovers</style>.";
		LanguageAPI.Add("KKING117_CONFIGBENTHIC_ITEM_CLOVERVOID_DESC", text);
		NewDesc = true;
	}

	private static void ItemCatalog_Init(orig_Init orig)
	{
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Invalid comparison between Unknown and I4
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		orig.Invoke();
		if (NewDesc)
		{
			Items.CloverVoid.descriptionToken = "KKING117_CONFIGBENTHIC_ITEM_CLOVERVOID_DESC";
		}
		BanList = new List<ItemDef>();
		string[] array = Config_BlackList.Split(',');
		for (int i = 0; i < array.Length; i++)
		{
			array[i] = array[i].Trim();
			ItemIndex val = ItemCatalog.FindItemIndex(array[i]);
			if ((int)val > -1)
			{
				ItemDef itemDef = ItemCatalog.GetItemDef(val);
				if (Object.op_Implicit((Object)(object)itemDef))
				{
					BanList.Add(itemDef);
				}
			}
		}
	}

	private static void CloverVoidUpgrade(orig_TryCloverVoidUpgrades orig, CharacterMaster self)
	{
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0115: Unknown result type (might be due to invalid IL or missing references)
		//IL_011b: Invalid comparison between Unknown and I4
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Invalid comparison between Unknown and I4
		//IL_0218: Unknown result type (might be due to invalid IL or missing references)
		//IL_021f: Unknown result type (might be due to invalid IL or missing references)
		if (!NetworkServer.active)
		{
			return;
		}
		int itemCount = self.inventory.GetItemCount(Items.CloverVoid);
		if (itemCount <= 0)
		{
			return;
		}
		int num = Config_BaseCount + Math.Max(0, itemCount - 1) * Config_StackCount;
		if (num <= 0)
		{
			return;
		}
		List<ItemIndex> andSortInventory = GetAndSortInventory(self);
		int num2 = 0;
		int num3 = 0;
		int num4 = 0;
		List<ItemIndex> list = new List<ItemIndex>();
		while (num2 < num && num3 < andSortInventory.Count)
		{
			bool flag = false;
			ItemDef itemDef = ItemCatalog.GetItemDef(andSortInventory[num3]);
			ItemDef val = null;
			List<ItemIndex> upgradeList = GetUpgradeList(itemDef);
			if (upgradeList != null && upgradeList.Count > 0)
			{
				Util.ShuffleList<ItemIndex>(upgradeList, self.cloverVoidRng);
				upgradeList.Sort(CompareTags);
				val = ItemCatalog.GetItemDef(upgradeList[0]);
			}
			if ((Object)(object)val != (Object)null)
			{
				num4 = 0;
				num2++;
				int num5 = 0;
				int num6 = 1;
				if ((int)itemDef.tier == 2 || (int)itemDef.tier == 8)
				{
					if (Config_Overspill_Bonus == OverspillBonus.PlusOne)
					{
						num5 = 1;
					}
					if (Config_Overspill_Bonus == OverspillBonus.Duplicate)
					{
						num6 = 2;
					}
				}
				if (Config_WholeStack)
				{
					int itemCount2 = self.inventory.GetItemCount(itemDef);
					int num7 = itemCount2 * num6 + num5;
					self.inventory.GiveItem(val, num7);
					self.inventory.RemoveItem(itemDef, itemCount2);
					andSortInventory.RemoveAt(num3);
				}
				else
				{
					int num8 = num6 + num5;
					self.inventory.GiveItem(val, num8);
					self.inventory.RemoveItem(itemDef, 1);
					if (self.inventory.GetItemCount(itemDef) < 1)
					{
						andSortInventory.RemoveAt(num3);
					}
				}
				num3 = -1;
				CharacterMasterNotificationQueue.PushItemTransformNotification(self, itemDef.itemIndex, val.itemIndex, (TransformationType)2);
				if (Config_Select_PreferScrap && (val.ContainsTag((ItemTag)10) || val.ContainsTag((ItemTag)14)))
				{
					flag = true;
				}
				if (Config_Select_Method > SelectMethod.Random && Config_WholeStack)
				{
					if (andSortInventory.Count < 1)
					{
						num4++;
						if (num4 > 3)
						{
							break;
						}
						flag = true;
					}
				}
				else
				{
					flag = true;
				}
				if (flag)
				{
					andSortInventory = GetAndSortInventory(self);
				}
			}
			num3++;
			int CompareTags(ItemIndex lhs, ItemIndex rhs)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				int num9 = 0;
				int num10 = 0;
				ItemDef itemDef2 = ItemCatalog.GetItemDef(lhs);
				ItemDef itemDef3 = ItemCatalog.GetItemDef(rhs);
				if (itemDef.ContainsTag((ItemTag)1))
				{
					if (itemDef2.ContainsTag((ItemTag)1))
					{
						num9 = 1;
					}
					if (itemDef3.ContainsTag((ItemTag)1))
					{
						num10 = 1;
					}
				}
				if (itemDef.ContainsTag((ItemTag)2))
				{
					if (itemDef2.ContainsTag((ItemTag)2))
					{
						num9 = 1;
					}
					if (itemDef3.ContainsTag((ItemTag)2))
					{
						num10 = 1;
					}
				}
				if (itemDef.ContainsTag((ItemTag)3))
				{
					if (itemDef2.ContainsTag((ItemTag)3))
					{
						num9 = 1;
					}
					if (itemDef3.ContainsTag((ItemTag)3))
					{
						num10 = 1;
					}
				}
				return num10 - num9;
			}
		}
		if (num2 > 0)
		{
			GameObject bodyInstanceObject = self.bodyInstanceObject;
			if (Object.op_Implicit((Object)(object)bodyInstanceObject))
			{
				Util.PlaySound("Play_item_proc_extraLife", bodyInstanceObject);
			}
		}
	}

	private static List<ItemIndex> GetAndSortInventory(CharacterMaster master)
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Expected O, but got Unknown
		List<ItemIndex> itemList = new List<ItemIndex>(master.inventory.itemAcquisitionOrder);
		itemList = RemoveClutter(itemList);
		if (master.cloverVoidRng == null)
		{
			master.cloverVoidRng = new Xoroshiro128Plus(Run.instance.seed);
		}
		switch (Config_Select_Method)
		{
		case SelectMethod.LeastStacks:
			itemList = SortItemList_ByLowest(itemList, master);
			break;
		case SelectMethod.MostStacks:
			itemList = SortItemList_ByHighest(itemList, master);
			break;
		default:
			Util.ShuffleList<ItemIndex>(itemList, master.cloverVoidRng);
			break;
		}
		if (Config_Select_PreferScrap)
		{
			itemList = SortItemList_ByScrap(itemList);
		}
		return itemList;
	}

	private static List<ItemIndex> RemoveClutter(List<ItemIndex> itemList)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < itemList.Count; i++)
		{
			ItemDef itemDef = ItemCatalog.GetItemDef(itemList[i]);
			if (Object.op_Implicit((Object)(object)itemDef) && !IsItemUpgradeable(itemDef))
			{
				itemList.RemoveAt(i);
				i--;
			}
		}
		return itemList;
	}

	private static List<ItemIndex> RemoveClutter_PickupList(List<PickupIndex> pickupList)
	{
		//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)
		//IL_0016: 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)
		List<ItemIndex> list = new List<ItemIndex>();
		for (int i = 0; i < pickupList.Count; i++)
		{
			PickupIndex val = pickupList[i];
			ItemDef itemDef = ItemCatalog.GetItemDef(((PickupIndex)(ref val)).itemIndex);
			if (Object.op_Implicit((Object)(object)itemDef) && (BanList == null || !BanList.Contains(itemDef)))
			{
				list.Add(itemDef.itemIndex);
			}
		}
		return list;
	}

	private static List<ItemIndex> GetUpgradeList(ItemDef oldItemDef)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Invalid comparison between Unknown and I4
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Invalid comparison between Unknown and I4
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Invalid comparison between Unknown and I4
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Invalid comparison between Unknown and I4
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Invalid comparison between Unknown and I4
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Invalid comparison between Unknown and I4
		List<ItemIndex> result = null;
		if ((int)oldItemDef.tier == 2)
		{
			return RemoveClutter_PickupList(Run.instance.availableTier1DropList);
		}
		if ((int)oldItemDef.tier == 1)
		{
			return RemoveClutter_PickupList(Run.instance.availableTier3DropList);
		}
		if ((int)oldItemDef.tier == 0)
		{
			return RemoveClutter_PickupList(Run.instance.availableTier2DropList);
		}
		if ((int)oldItemDef.tier == 8)
		{
			return RemoveClutter_PickupList(Run.instance.availableVoidTier1DropList);
		}
		if ((int)oldItemDef.tier == 7)
		{
			return RemoveClutter_PickupList(Run.instance.availableVoidTier3DropList);
		}
		if ((int)oldItemDef.tier == 6)
		{
			return RemoveClutter_PickupList(Run.instance.availableVoidTier2DropList);
		}
		return result;
	}

	private static bool IsItemUpgradeable(ItemDef item)
	{
		//IL_0023: 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_0031: Invalid comparison between Unknown and I4
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Invalid comparison between Unknown and I4
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Invalid comparison between Unknown and I4
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Invalid comparison between Unknown and I4
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Invalid comparison between Unknown and I4
		if (!Config_Select_AllowSelf && (Object)(object)item == (Object)(object)Items.CloverVoid)
		{
			return false;
		}
		if ((int)item.tier == 0 || (int)item.tier == 1)
		{
			return true;
		}
		if ((int)item.tier == 2 && Config_Overspill_Enable)
		{
			return true;
		}
		if (Config_Select_AllowVoid)
		{
			if ((int)item.tier == 6 || (int)item.tier == 7)
			{
				return true;
			}
			if ((int)item.tier == 8 && Config_Overspill_Enable)
			{
				return true;
			}
		}
		return false;
	}

	private static List<ItemIndex> SortItemList_ByLowest(List<ItemIndex> itemList, CharacterMaster master)
	{
		itemList.Sort(CompareStackSize);
		return itemList;
		int CompareStackSize(ItemIndex lhs, ItemIndex rhs)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			int itemCount = master.inventory.GetItemCount(lhs);
			int itemCount2 = master.inventory.GetItemCount(rhs);
			return itemCount - itemCount2;
		}
	}

	private static List<ItemIndex> SortItemList_ByHighest(List<ItemIndex> itemList, CharacterMaster master)
	{
		itemList.Sort(CompareStackSize);
		return itemList;
		int CompareStackSize(ItemIndex lhs, ItemIndex rhs)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			int itemCount = master.inventory.GetItemCount(lhs);
			int itemCount2 = master.inventory.GetItemCount(rhs);
			return itemCount2 - itemCount;
		}
	}

	private static List<ItemIndex> SortItemList_ByScrap(List<ItemIndex> itemList)
	{
		itemList.Sort(ByIsScrap);
		return itemList;
		static int ByIsScrap(ItemIndex lhs, ItemIndex rhs)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int num2 = 0;
			ItemDef itemDef = ItemCatalog.GetItemDef(lhs);
			ItemDef itemDef2 = ItemCatalog.GetItemDef(rhs);
			if (itemDef.ContainsTag((ItemTag)14))
			{
				num = 2;
			}
			else if (itemDef.ContainsTag((ItemTag)10))
			{
				num = 1;
			}
			if (itemDef2.ContainsTag((ItemTag)14))
			{
				num2 = 2;
			}
			else if (itemDef2.ContainsTag((ItemTag)10))
			{
				num2 = 1;
			}
			return num2 - num;
		}
	}

	private void ReadConfig()
	{
		Config_BaseCount = ((BaseUnityPlugin)this).Config.Bind<int>("Stacking", "Base Upgrade Count", 3, "How many items to upgrade at a single stack.").Value;
		Config_StackCount = ((BaseUnityPlugin)this).Config.Bind<int>("Stacking", "Stack Upgrade Count", 3, "How many items to upgrade for each additional stack.").Value;
		Config_BlackList = ((BaseUnityPlugin)this).Config.Bind<string>("Upgrading", "Upgrade Blacklist", "", "Prevents upgrading into these specific items. (Example = Clover, ExtraLife, MoreMissile)").Value;
		Config_WholeStack = ((BaseUnityPlugin)this).Config.Bind<bool>("Upgrading", "Upgrade Entire Stack", true, "Should the entire stack get upgraded or a single instance of the selected item?").Value;
		Config_Select_Method = ((BaseUnityPlugin)this).Config.Bind<SelectMethod>("Item Selection", "Selection Method", SelectMethod.Random, "The method to use when selecting items for upgrading.").Value;
		Config_Select_PreferScrap = ((BaseUnityPlugin)this).Config.Bind<bool>("Item Selection", "Prioritise Scrap", false, "Should Scrap have priority over the selection method?").Value;
		Config_Select_AllowVoid = ((BaseUnityPlugin)this).Config.Bind<bool>("Item Selection", "Allow Void", false, "Allow Void items to be selected for upgrading?").Value;
		Config_Select_AllowSelf = ((BaseUnityPlugin)this).Config.Bind<bool>("Item Selection", "Allow Self", false, "Allow Benthic Bloom to be selected for upgrading?").Value;
		Config_Overspill_Enable = ((BaseUnityPlugin)this).Config.Bind<bool>("Overflow", "Enable", false, "Allows Legendary items to be selected and 'upgraded' into Common items.").Value;
		Config_Overspill_Bonus = ((BaseUnityPlugin)this).Config.Bind<OverspillBonus>("Overflow", "Bonus Gain", OverspillBonus.PlusOne, "Gain extra items when 'upgrading' an item.").Value;
	}
}