using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using CardChoiceSpawnUniqueCardPatch.CustomCategories;
using HarmonyLib;
using ModdingUtils.Extensions;
using Photon.Pun;
using TMPro;
using UnboundLib;
using UnboundLib.GameModes;
using UnboundLib.Networking;
using UnboundLib.Utils;
using UnboundLib.Utils.UI;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using WillsWackyManagers.Utils;

[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("DynamicCardMods")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+b074370664c496c64eded515bb6cb756266d26b4")]
[assembly: AssemblyProduct("DynamicCardMods")]
[assembly: AssemblyTitle("DynamicCardMods")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace DynamicCardMods;

internal class CurseHandler
{
	public static bool IsACurse(CardInfo cardToTest)
	{
		for (int i = 0; i < cardToTest.categories.Length; i++)
		{
			if ((Object)(object)cardToTest.categories[i] == (Object)(object)CurseManager.instance.curseCategory)
			{
				return true;
			}
		}
		return false;
	}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("com.HibouGlorieux.Rounds.DynamicCardMods", "DynamicCardMods", "0.1.0")]
[BepInProcess("Rounds.exe")]
public class DynamicCardMods : BaseUnityPlugin
{
	private const string ModId = "com.HibouGlorieux.Rounds.DynamicCardMods";

	internal const string ModName = "DynamicCardMods";

	public const string Version = "0.1.0";

	internal bool bCurseActivated;

	internal Dictionary<CardCategory, int> cardsPerMod = new Dictionary<CardCategory, int>();

	internal Dictionary<Player, CardCategory[]> blacklistedCategories = new Dictionary<Player, CardCategory[]>();

	public ConfigEntry<bool> bIsActive;

	public ConfigEntry<bool> bPoolIsShared;

	public ConfigEntry<int> minimumAmountOfCardsPerPlayer;

	public ConfigEntry<int> minimumDifferentMods;

	public ConfigEntry<bool> bKeepSameOnRematch;

	private Random random = new Random();

	public List<ConfigEntry<string>> baseCardMods = new List<ConfigEntry<string>>(10);

	internal int seed;

	public static DynamicCardMods instance { get; private set; }

	private void Awake()
	{
		//IL_0100: Unknown result type (might be due to invalid IL or missing references)
		instance = this;
		bIsActive = ((BaseUnityPlugin)this).Config.Bind<bool>("DynamicCardMods", "bIsActive", true, "Activate/deactive the mod");
		minimumAmountOfCardsPerPlayer = ((BaseUnityPlugin)this).Config.Bind<int>("DynamicCardMods", "minimumAmountOfCardsPerPlayer", 150, "Minimum amount of cards for each player");
		minimumDifferentMods = ((BaseUnityPlugin)this).Config.Bind<int>("DynamicCardMods", "minimumDifferentMods", 1, "Minimum amount of card mods to be active");
		bPoolIsShared = ((BaseUnityPlugin)this).Config.Bind<bool>("DynamicCardMods", "bPoolIsShared", false, "Makes all player share the same pool of cards");
		bKeepSameOnRematch = ((BaseUnityPlugin)this).Config.Bind<bool>("DynamicCardMods", "bKeepSameOnRematch", false, "Keep the same card mods upon rematch");
		for (int i = 0; i < baseCardMods.Capacity; i++)
		{
			baseCardMods.Add(((BaseUnityPlugin)this).Config.Bind<string>("DynamicCardMods", "baseCardMods" + i, "", "Mod that should always be here"));
		}
		new Harmony("com.HibouGlorieux.Rounds.DynamicCardMods").PatchAll();
	}

	private void Start()
	{
		bCurseActivated = Chainloader.PluginInfos.ContainsKey("com.willuwontu.rounds.managers");
		OptionMenu.RegisterMenu();
		seed = Random.Range(0, int.MaxValue);
		random = new Random(seed);
		Unbound.RegisterHandshake("com.HibouGlorieux.Rounds.DynamicCardMods", (Action)OnHandshakeCompleted);
		GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)OnGameStart);
		GameModeManager.AddHook("GameEnd", (Func<IGameModeHandler, IEnumerator>)OnGameEnd);
	}

	private void OnHandshakeCompleted()
	{
		if (PhotonNetwork.IsMasterClient)
		{
			seed = Random.Range(0, int.MaxValue);
			random = new Random(seed);
			string[] array = baseCardMods.Select((ConfigEntry<string> configEntry) => configEntry.Value).ToArray();
			NetworkingManager.RPC_Others(typeof(DynamicCardMods), "SyncSettings", new object[7] { seed, bIsActive.Value, bPoolIsShared.Value, bKeepSameOnRematch.Value, minimumAmountOfCardsPerPlayer.Value, minimumDifferentMods.Value, array });
		}
	}

	[UnboundRPC]
	private static void SyncSettings(int syncSeed, bool bActive, bool bPoolShared, bool bKeepSameOnRematch, int minCards, int minMods, string[] baseMods)
	{
		instance.seed = syncSeed;
		instance.bIsActive.Value = bActive;
		instance.bPoolIsShared.Value = bPoolShared;
		instance.bKeepSameOnRematch.Value = bKeepSameOnRematch;
		instance.minimumAmountOfCardsPerPlayer.Value = minCards;
		instance.minimumDifferentMods.Value = minMods;
		for (int i = 0; i < baseMods.Length; i++)
		{
			instance.baseCardMods[i].Value = baseMods[i];
		}
		instance.random = new Random(instance.seed);
	}

	internal void GatherCardModsInfo()
	{
		blacklistedCategories.Clear();
		cardsPerMod.Clear();
		foreach (Card item in CardManager.cards.Values.ToList())
		{
			CardCategory val = CustomCardCategories.instance.CardCategory("__pack-" + item.category);
			if (!item.cardInfo.categories.Contains(val))
			{
				item.cardInfo.categories = item.cardInfo.categories.Append(val).ToArray();
			}
			if (item.enabled && (!bCurseActivated || !CurseHandler.IsACurse(item.cardInfo)))
			{
				if (!cardsPerMod.ContainsKey(val))
				{
					cardsPerMod[val] = 1;
				}
				else
				{
					cardsPerMod[val]++;
				}
			}
		}
		int i;
		for (i = 0; i < baseCardMods.Count; i++)
		{
			if (!cardsPerMod.Any((KeyValuePair<CardCategory, int> tuple) => ((Object)tuple.Key).name == baseCardMods[i].Value))
			{
				baseCardMods[i].Value = "";
			}
		}
	}

	private IEnumerator OnGameStart(IGameModeHandler gm)
	{
		if (!bIsActive.Value)
		{
			yield break;
		}
		GatherCardModsInfo();
		if (bKeepSameOnRematch.Value)
		{
			random = new Random(seed);
		}
		if (bKeepSameOnRematch.Value)
		{
			random = new Random(seed);
		}
		if (bPoolIsShared.Value)
		{
			List<CardCategory> list = MakeBlacklistedCategories(minimumAmountOfCardsPerPlayer.Value);
			{
				foreach (Player player in PlayerManager.instance.players)
				{
					Log("for player: " + player.playerID + " whitelist is: ");
					blacklistedCategories.Add(player, list.ToArray());
					CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories.AddRange(list);
				}
				yield break;
			}
		}
		foreach (Player player2 in PlayerManager.instance.players)
		{
			Log("for player: " + player2.playerID + " whitelist is: ");
			List<CardCategory> list2 = MakeBlacklistedCategories(minimumAmountOfCardsPerPlayer.Value);
			blacklistedCategories.Add(player2, list2.ToArray());
			CharacterStatModifiersExtension.GetAdditionalData(player2.data.stats).blacklistedCategories.AddRange(list2);
		}
	}

	private IEnumerator OnGameEnd(IGameModeHandler handler)
	{
		foreach (KeyValuePair<Player, CardCategory[]> blacklistedCategory in blacklistedCategories)
		{
			blacklistedCategory.Deconstruct(out var key, out var value);
			Player val = key;
			CardCategory[] array = value;
			if (Object.op_Implicit((Object)(object)val))
			{
				value = array;
				foreach (CardCategory item in value)
				{
					CharacterStatModifiersExtension.GetAdditionalData(val.data.stats).blacklistedCategories.Remove(item);
				}
			}
		}
		blacklistedCategories.Clear();
		yield break;
	}

	private int GetTotalActiveCards()
	{
		int num = 0;
		foreach (KeyValuePair<CardCategory, int> item in cardsPerMod)
		{
			var (category, num3) = (KeyValuePair<CardCategory, int>)(ref item);
			if (!baseCardMods.Any((ConfigEntry<string> configEntry) => configEntry.Value == ((Object)category).name))
			{
				num += num3;
			}
		}
		return num;
	}

	private List<CardCategory> MakeBlacklistedCategories(int minimumAmountOfCards)
	{
		List<CardCategory> result = new List<CardCategory>();
		int num = 0;
		List<CardCategory> list = cardsPerMod.Keys.OrderBy((CardCategory k) => ((Object)k).name).ToList();
		for (int i = 0; i < baseCardMods.Count; i++)
		{
			list.Remove(CustomCardCategories.instance.CardCategory(baseCardMods[i].Value));
		}
		if (GetTotalActiveCards() <= minimumAmountOfCards)
		{
			return result;
		}
		int num2 = 0;
		while ((num < minimumAmountOfCards || num2 < minimumDifferentMods.Value) && list.Count > 0)
		{
			int index = random.Next(list.Count);
			CardCategory val = list[index];
			Log(((Object)val).name);
			num += cardsPerMod[val];
			list.RemoveAt(index);
			if (cardsPerMod[val] > 0)
			{
				num2++;
			}
		}
		return list;
	}

	internal static void Log(string message)
	{
	}

	private void OnDestroy()
	{
		GameModeManager.RemoveHook("GameStart", (Func<IGameModeHandler, IEnumerator>)OnGameStart);
	}
}
internal static class OptionMenu
{
	[Serializable]
	[CompilerGenerated]
	private sealed class <>c
	{
		public static readonly <>c <>9 = new <>c();

		public static UnityAction <>9__2_0;

		public static Func<ConfigEntry<string>, bool> <>9__3_0;

		public static UnityAction<bool> <>9__5_0;

		public static UnityAction<float> <>9__5_3;

		public static UnityAction<float> <>9__5_4;

		public static UnityAction<bool> <>9__5_1;

		public static UnityAction<bool> <>9__5_2;

		public static Func<CardCategory, string> <>9__5_5;

		internal void <RegisterMenu>b__2_0()
		{
		}

		internal bool <UpdateUI>b__3_0(ConfigEntry<string> configEntry)
		{
			return configEntry.Value != "";
		}

		internal void <CreateMenuUI>b__5_0(bool bNewValue)
		{
			DynamicCardMods.instance.bIsActive.Value = bNewValue;
			UpdateUI();
		}

		internal void <CreateMenuUI>b__5_3(float newValue)
		{
			DynamicCardMods.instance.minimumAmountOfCardsPerPlayer.Value = (int)newValue;
			UpdateUI();
		}

		internal void <CreateMenuUI>b__5_4(float newValue)
		{
			DynamicCardMods.instance.minimumDifferentMods.Value = (int)newValue;
		}

		internal void <CreateMenuUI>b__5_1(bool bNewValue)
		{
			DynamicCardMods.instance.bPoolIsShared.Value = !bNewValue;
		}

		internal void <CreateMenuUI>b__5_2(bool bNewValue)
		{
			DynamicCardMods.instance.bKeepSameOnRematch.Value = bNewValue;
		}

		internal string <CreateMenuUI>b__5_5(CardCategory elem)
		{
			return ((Object)elem).name;
		}
	}

	private static List<GameObject> options = new List<GameObject>();

	private static int[] warningOnCardAmountIndexes = null;

	public static void RegisterMenu()
	{
		//IL_0019: 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)
		//IL_0024: Expected O, but got Unknown
		object obj = <>c.<>9__2_0;
		if (obj == null)
		{
			UnityAction val = delegate
			{
			};
			<>c.<>9__2_0 = val;
			obj = (object)val;
		}
		Unbound.RegisterMenu("Dynamic CardMods", (UnityAction)obj, (Action<GameObject>)CreateMenuUI, (GameObject)null);
	}

	private static void UpdateUI()
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		bool value = DynamicCardMods.instance.bIsActive.Value;
		foreach (GameObject option in options)
		{
			option.transform.localScale = (value ? Vector3.one : Vector3.zero);
		}
		bool active = DynamicCardMods.instance.baseCardMods.Count((ConfigEntry<string> configEntry) => configEntry.Value != "") < 1 && DynamicCardMods.instance.minimumAmountOfCardsPerPlayer.Value < 60;
		int[] array = warningOnCardAmountIndexes;
		foreach (int index in array)
		{
			options[index].SetActive(active);
		}
	}

	private static void UpdateBaseCardMods(bool shoulBeBase, string cardCategoryName, int toggleIndex)
	{
		if (!shoulBeBase)
		{
			for (int i = 0; i < DynamicCardMods.instance.baseCardMods.Count; i++)
			{
				if (DynamicCardMods.instance.baseCardMods[i].Value == cardCategoryName)
				{
					DynamicCardMods.instance.baseCardMods[i].Value = "";
				}
			}
		}
		if (!shoulBeBase)
		{
			return;
		}
		bool flag = false;
		for (int j = 0; j < DynamicCardMods.instance.baseCardMods.Count; j++)
		{
			if (DynamicCardMods.instance.baseCardMods[j].Value == "")
			{
				DynamicCardMods.instance.baseCardMods[j].Value = cardCategoryName;
				flag = true;
				break;
			}
		}
		if (!flag)
		{
			options[toggleIndex].GetComponent<Toggle>().isOn = false;
			DynamicCardMods.Log("Only " + DynamicCardMods.instance.baseCardMods.Count + " max base card mods");
		}
	}

	private static void CreateMenuUI(GameObject menu)
	{
		options.Clear();
		warningOnCardAmountIndexes = new int[3];
		TextMeshProUGUI val = default(TextMeshProUGUI);
		MenuHandler.CreateText("DynamicCardMods Options", menu, ref val, 60, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
		MenuHandler.CreateText("", menu, ref val, 60, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
		MenuHandler.CreateText("", menu, ref val, 60, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
		MenuHandler.CreateToggle(DynamicCardMods.instance.bIsActive.Value, "Active", menu, (UnityAction<bool>)delegate(bool bNewValue)
		{
			DynamicCardMods.instance.bIsActive.Value = bNewValue;
			UpdateUI();
		}, 60, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
		warningOnCardAmountIndexes[0] = options.Count;
		options.Add(MenuHandler.CreateText("Warning: very low amount can result in almost no choice if you", menu, ref val, 30, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null));
		warningOnCardAmountIndexes[1] = options.Count;
		options.Add(MenuHandler.CreateText("have no card mods enabled at all time", menu, ref val, 30, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null));
		warningOnCardAmountIndexes[2] = options.Count;
		options.Add(MenuHandler.CreateText("(minimum amount should be around 60 without no card mods enabled at all time)", menu, ref val, 20, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null));
		Slider val2 = default(Slider);
		options.Add(MenuHandler.CreateSlider("Minimum amount of cards in players card pool", menu, 30, 1f, 2000f, (float)DynamicCardMods.instance.minimumAmountOfCardsPerPlayer.Value, (UnityAction<float>)delegate(float newValue)
		{
			DynamicCardMods.instance.minimumAmountOfCardsPerPlayer.Value = (int)newValue;
			UpdateUI();
		}, ref val2, true, (Color?)null, (Direction)0, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null));
		MenuHandler.CreateText("", menu, ref val, 60, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
		MenuHandler.CreateText("", menu, ref val, 60, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
		options.Add(MenuHandler.CreateSlider("Minimum amount of different mods in players card pool", menu, 30, 1f, 10f, (float)DynamicCardMods.instance.minimumDifferentMods.Value, (UnityAction<float>)delegate(float newValue)
		{
			DynamicCardMods.instance.minimumDifferentMods.Value = (int)newValue;
		}, ref val2, true, (Color?)null, (Direction)0, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null));
		MenuHandler.CreateText("", menu, ref val, 60, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
		options.Add(MenuHandler.CreateToggle(!DynamicCardMods.instance.bPoolIsShared.Value, "Each player has their own individual pool of cards", menu, (UnityAction<bool>)delegate(bool bNewValue)
		{
			DynamicCardMods.instance.bPoolIsShared.Value = !bNewValue;
		}, 60, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null));
		MenuHandler.CreateText("", menu, ref val, 60, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
		options.Add(MenuHandler.CreateToggle(DynamicCardMods.instance.bKeepSameOnRematch.Value, "Keep the same card mods pool on rematch", menu, (UnityAction<bool>)delegate(bool bNewValue)
		{
			DynamicCardMods.instance.bKeepSameOnRematch.Value = bNewValue;
		}, 60, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null));
		MenuHandler.CreateText("", menu, ref val, 60, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
		options.Add(MenuHandler.CreateText("Chose card mods to be there at all time", menu, ref val, 50, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null));
		options.Add(MenuHandler.CreateText("(these mods are not taken into account for minimum values above)", menu, ref val, 25, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null));
		options.Add(MenuHandler.CreateText("(maximum amount is " + DynamicCardMods.instance.baseCardMods.Count + ")", menu, ref val, 25, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null));
		DynamicCardMods.instance.GatherCardModsInfo();
		int num = options.Count;
		CardCategory[] array = DynamicCardMods.instance.cardsPerMod.Keys.OrderBy((CardCategory elem) => ((Object)elem).name).ToArray();
		foreach (CardCategory val3 in array)
		{
			int indexOfToggle = num;
			string categoryName = ((Object)val3).name;
			options.Add(MenuHandler.CreateToggle(DynamicCardMods.instance.baseCardMods.Any((ConfigEntry<string> configEntry) => configEntry.Value == categoryName), ((Object)val3).name.Substring("__pack-".Length), menu, (UnityAction<bool>)delegate(bool bNewValue)
			{
				UpdateBaseCardMods(bNewValue, categoryName, indexOfToggle);
				UpdateUI();
			}, 60, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null));
			num++;
		}
		UpdateUI();
	}
}