using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using FMODUnity;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using SuperFantasyKingdom;
using SuperFantasyKingdom.TitleScreen;
using SuperFantasyKingdom.UI;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("UnlimitedJail")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0+14a22b142920a276e529c9edd73b255a4bf0cc56")]
[assembly: AssemblyProduct("Unlimited Jail")]
[assembly: AssemblyTitle("UnlimitedJail")]
[assembly: AssemblyVersion("1.1.0.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 UnlimitedJail
{
	[BepInPlugin("ownly.unlimitedjail", "Unlimited Jail", "1.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Log;

		private void Awake()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID).PatchAll();
		}
	}
	internal static class Filter
	{
		public static void Apply(UnlockedUnitsManager manager)
		{
			List<string> stashed = Stash.Units;
			Traverse obj = Traverse.Create((object)manager);
			List<string> value = obj.Field("m_UnlockedUnits").GetValue<List<string>>();
			List<string> value2 = obj.Field("m_Banned").GetValue<List<string>>();
			foreach (string item in stashed)
			{
				value.Remove(item);
				if (!value2.Contains(item))
				{
					value2.Add(item);
				}
			}
			value2.RemoveAll((string id) => id != "empty" && !stashed.Contains(id));
		}
	}
	[HarmonyPatch(typeof(UnlockedUnitsManager), "Awake")]
	internal static class Patch_UnlockedUnitsAwake
	{
		private static void Postfix(UnlockedUnitsManager __instance)
		{
			try
			{
				Filter.Apply(__instance);
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(UnlockedUnitsManager), "SetBannedUnits")]
	internal static class Patch_SetBannedUnits
	{
		private static void Postfix(UnlockedUnitsManager __instance)
		{
			try
			{
				Filter.Apply(__instance);
			}
			catch
			{
			}
		}
	}
	internal static class Jail
	{
		internal const string Empty = "empty";

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

		public static string Force(string jailed)
		{
			if (!string.IsNullOrEmpty(jailed) && jailed != "empty" && s_Warned.Add(jailed))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("jail slot held " + jailed + " - the mod frees it, jail it from the selection screen to keep it held back"));
				}
			}
			return "empty";
		}

		public static void Paint(TitleScreenJail jail, int index)
		{
			List<string> units = Stash.Units;
			Traverse val = Traverse.Create((object)jail);
			GameObject value = val.Field("jail" + index).GetValue<GameObject>();
			GameObject value2 = val.Field("jail" + index + "Rubble").GetValue<GameObject>();
			Image value3 = val.Field("jail" + index + "Door").GetValue<Image>();
			ImageAnimator value4 = val.Field("jail" + index + "Jailed").GetValue<ImageAnimator>();
			if (units.Count < index)
			{
				return;
			}
			Unit unit = AddressablesManager.Instance.GetUnit(units[index - 1]);
			if ((Object)(object)unit == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("stashed unit has no prefab: " + units[index - 1]));
				}
			}
			else
			{
				value.SetActive(true);
				value2.SetActive(false);
				value3.sprite = val.Field("spriteDoorClosed").GetValue<Sprite>();
				value4.SetSprites(((UnitBase)unit).GetIdleSprites());
				((Component)value4).gameObject.SetActive(true);
			}
		}
	}
	[HarmonyPatch(typeof(RaceDataManager), "GetJail1")]
	internal static class Patch_GetJail1
	{
		private static void Postfix(ref string __result)
		{
			__result = Jail.Force(__result);
		}
	}
	[HarmonyPatch(typeof(RaceDataManager), "GetJail2")]
	internal static class Patch_GetJail2
	{
		private static void Postfix(ref string __result)
		{
			__result = Jail.Force(__result);
		}
	}
	[HarmonyPatch(typeof(RaceDataManager), "GetJail3")]
	internal static class Patch_GetJail3
	{
		private static void Postfix(ref string __result)
		{
			__result = Jail.Force(__result);
		}
	}
	[HarmonyPatch(typeof(TitleScreenJail), "ShowJail1")]
	internal static class Patch_ShowJail1
	{
		private static void Postfix(TitleScreenJail __instance)
		{
			try
			{
				Jail.Paint(__instance, 1);
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(TitleScreenJail), "ShowJail2")]
	internal static class Patch_ShowJail2
	{
		private static void Postfix(TitleScreenJail __instance)
		{
			try
			{
				Jail.Paint(__instance, 2);
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(TitleScreenJail), "ShowJail3")]
	internal static class Patch_ShowJail3
	{
		private static void Postfix(TitleScreenJail __instance)
		{
			try
			{
				Jail.Paint(__instance, 3);
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(TitleScreenJail), "SetJailed")]
	internal static class Patch_SetJailed
	{
		private static bool Prefix(TitleScreenJail __instance)
		{
			try
			{
				Traverse val = Traverse.Create((object)__instance);
				int value = val.Field("m_SelectedCell").GetValue<int>();
				if (value >= 1 && value <= 3)
				{
					Button value2 = val.Field("jail" + value + "Button").GetValue<Button>();
					if ((Object)(object)value2 != (Object)null)
					{
						GamepadManager.Instance.SetGameObjectToSelect(((Component)value2).gameObject, true);
					}
				}
				val.Field("m_SelectedCell").SetValue((object)0);
				__instance.Decorate();
			}
			catch
			{
			}
			return false;
		}
	}
	internal static class Catalog
	{
		private static readonly Color JailedTile = new Color(0.6f, 0.24f, 0.22f, 1f);

		private static readonly Color JailedIcon = new Color(0.38f, 0.16f, 0.15f, 1f);

		private static readonly Dictionary<string, GameObject> s_Entries = new Dictionary<string, GameObject>();

		public static void Track(string key, GameObject button)
		{
			s_Entries[key] = button;
			Paint(key);
		}

		public static void Paint(string key)
		{
			//IL_003b: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (s_Entries.TryGetValue(key, out var value) && !((Object)(object)value == (Object)null))
			{
				bool flag = Stash.Contains(key);
				Image component = value.GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = (flag ? JailedTile : Color.white);
				}
				Transform val = value.transform.Find("Icon");
				if ((Object)(object)val != (Object)null)
				{
					((Graphic)((Component)val).GetComponent<Image>()).color = (flag ? JailedIcon : Color.white);
				}
			}
		}
	}
	[HarmonyPatch(typeof(UICatalogJail), "Unit")]
	internal static class Patch_CatalogUnit
	{
		private static void Postfix(string key, GameObject button)
		{
			try
			{
				Catalog.Track(key, button);
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(UICatalogJail), "CanAddUnit")]
	internal static class Patch_CanAddUnit
	{
		private static void Postfix(Unit unit, ref bool __result)
		{
			try
			{
				if (!__result && Stash.Contains(((Entity)unit).GetEntityIdentifier()))
				{
					__result = true;
				}
			}
			catch
			{
			}
		}
	}
	internal static class Coins
	{
		private const float Margin = 14f;

		private const int WalkLimit = 4;

		private static GameObject s_Widget;

		private static Text s_Text;

		public static void Show()
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)s_Widget != (Object)null)
			{
				return;
			}
			TitleScreenHeroSelectionManager instance = TitleScreenHeroSelectionManager.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Traverse val = Traverse.Create((object)instance);
			Text value = val.Field("coins").GetValue<Text>();
			GameObject value2 = Traverse.Create((object)AchievementManager.Instance).Field("achievementOverlay").GetValue<GameObject>();
			if ((Object)(object)value == (Object)null || (Object)(object)value2 == (Object)null || (Object)(object)value2.GetComponent<RectTransform>() == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"no coin widget to clone, the catalog opens without a counter");
				}
				return;
			}
			Transform obj = WidgetRoot(val, ((Component)value).transform);
			if ((Object)(object)obj == (Object)(object)((Component)value).transform)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)"the coin counter has no widget around it, cloning the number alone");
				}
			}
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			? val2;
			if (!((Object)(object)component != (Object)null))
			{
				val2 = Vector2.zero;
			}
			else
			{
				Rect rect = component.rect;
				float width = ((Rect)(ref rect)).width;
				rect = component.rect;
				val2 = new Vector2(width, ((Rect)(ref rect)).height);
			}
			Vector2 sizeDelta = (Vector2)val2;
			s_Widget = Object.Instantiate<GameObject>(((Component)obj).gameObject, value2.transform);
			((Object)s_Widget).name = "UnlimitedJailCoins";
			RectTransform component2 = s_Widget.GetComponent<RectTransform>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.anchorMin = new Vector2(0f, 1f);
				component2.anchorMax = new Vector2(0f, 1f);
				component2.pivot = new Vector2(0f, 1f);
				component2.sizeDelta = sizeDelta;
				component2.anchoredPosition = new Vector2(14f, -14f);
			}
			Graphic[] componentsInChildren = s_Widget.GetComponentsInChildren<Graphic>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].raycastTarget = false;
			}
			s_Text = s_Widget.GetComponentInChildren<Text>(true);
			Refresh();
		}

		public static void Hide()
		{
			if ((Object)(object)s_Widget != (Object)null)
			{
				Object.Destroy((Object)(object)s_Widget);
				s_Widget = null;
				s_Text = null;
			}
		}

		public static void Refresh()
		{
			if ((Object)(object)s_Text != (Object)null)
			{
				s_Text.text = TitleScreenHeroSelectionManager.Instance.GetCoinsRemaining().ToString();
			}
		}

		private static Transform WidgetRoot(Traverse throne, Transform coins)
		{
			Transform[] array = (Transform[])(object)new Transform[3]
			{
				Counter(throne, "shards"),
				Counter(throne, "faith"),
				Counter(throne, "superMetal")
			};
			if ((Object)(object)array[0] == (Object)null && (Object)(object)array[1] == (Object)null && (Object)(object)array[2] == (Object)null)
			{
				return coins;
			}
			Transform val = coins;
			for (int i = 0; i < 4; i++)
			{
				Transform parent = val.parent;
				if ((Object)(object)parent == (Object)null || (Object)(object)((Component)parent).GetComponent<Canvas>() != (Object)null || Holds(parent, array))
				{
					break;
				}
				val = parent;
			}
			return val;
		}

		private static bool Holds(Transform parent, Transform[] siblings)
		{
			foreach (Transform val in siblings)
			{
				if ((Object)(object)val != (Object)null && val.IsChildOf(parent))
				{
					return true;
				}
			}
			return false;
		}

		private static Transform Counter(Traverse throne, string field)
		{
			Text value = throne.Field(field).GetValue<Text>();
			if (!((Object)(object)value != (Object)null))
			{
				return null;
			}
			return ((Component)value).transform;
		}
	}
	[HarmonyPatch(typeof(AchievementManager), "OpenJail")]
	internal static class Patch_OpenJail
	{
		private static void Postfix()
		{
			try
			{
				Coins.Show();
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)("could not build the coin counter: " + ex));
				}
			}
		}
	}
	[HarmonyPatch(typeof(AchievementManager), "Close")]
	internal static class Patch_AchievementClose
	{
		private static void Postfix(bool __result)
		{
			try
			{
				if (__result)
				{
					Coins.Hide();
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(TitleScreenHeroSelectionManager), "CloseJailSelection")]
	internal static class Patch_CloseJailSelection
	{
		private static bool Prefix()
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				UICatalogManager instance = UICatalogManager.Instance;
				if ((Object)(object)instance == (Object)null || !instance.IsUnitDetailsOpen())
				{
					return true;
				}
				Traverse obj = Traverse.Create((object)instance);
				obj.Method("CloseUnitDetails", Array.Empty<object>()).GetValue();
				obj.Method("Generate", new Type[2]
				{
					typeof(CatalogType),
					typeof(int)
				}, new object[2]
				{
					(object)(CatalogType)7,
					0
				}).GetValue();
				RuntimeManager.PlayOneShot("event:/SFX/UI/Cancel", default(Vector3));
				return false;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)("could not step back to the selection: " + ex));
				}
				return true;
			}
		}
	}
	[HarmonyPatch(typeof(TitleScreenHeroSelectionManager), "SelectJailedUnit")]
	internal static class Patch_SelectJailedUnit
	{
		private static bool Prefix(string key)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Stash.Toggle(key);
				Catalog.Paint(key);
				RuntimeManager.PlayOneShot(Stash.Contains(key) ? "event:/SFX/UI/Confirm" : "event:/SFX/UI/Cancel", default(Vector3));
				UICatalogManager.Instance.OnSelect(key, false);
				TitleScreenHeroSelectionManager.Instance.UpdateKingdomData();
				Coins.Refresh();
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)("could not toggle " + key + ": " + ex));
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(TitleScreenHeroSelectionManager), "GetCoinsRemaining")]
	internal static class Patch_CoinsRemaining
	{
		private static void Postfix(ref int __result)
		{
			try
			{
				__result = Mathf.Max(0, __result - Stash.CoinCost);
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(ResourceManager), "GiveStartingResources")]
	internal static class Patch_StartingCoins
	{
		private static void Postfix(ResourceManager __instance)
		{
			try
			{
				int num = Mathf.Min(Stash.CoinCost, __instance.GetCoins());
				if (num > 0)
				{
					__instance.SpendResource((ResourceType)12, num);
				}
			}
			catch
			{
			}
		}
	}
	internal static class Stash
	{
		private static readonly List<string> s_Units = new List<string>();

		private static string s_Key;

		public static List<string> Units
		{
			get
			{
				Reload();
				return s_Units;
			}
		}

		public static int CoinCost => Mathf.Max(0, Units.Count - 3);

		public static bool Contains(string entityIdentifier)
		{
			return Units.Contains(entityIdentifier);
		}

		public static void Toggle(string entityIdentifier)
		{
			Reload();
			if (!s_Units.Remove(entityIdentifier))
			{
				s_Units.Add(entityIdentifier);
			}
			Write();
		}

		private static void Reload()
		{
			string text = CurrentKey();
			if (text == s_Key)
			{
				return;
			}
			s_Key = text;
			s_Units.Clear();
			try
			{
				string path = PathFor(text);
				if (!File.Exists(path))
				{
					return;
				}
				string[] array = File.ReadAllLines(path);
				for (int i = 0; i < array.Length; i++)
				{
					string text2 = array[i].Trim();
					if (text2.Length > 0 && !s_Units.Contains(text2))
					{
						s_Units.Add(text2);
					}
				}
			}
			catch
			{
			}
		}

		private static void Write()
		{
			try
			{
				string path = PathFor(s_Key);
				Directory.CreateDirectory(Path.GetDirectoryName(path));
				File.WriteAllLines(path, s_Units.ToArray());
			}
			catch
			{
			}
		}

		private static string CurrentKey()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return Helper.Instance.GetRaceString(MainManager.Instance.GetSelectedKingdom(), false) + "_" + (SettingsManager.Instance.GetProfile() + 1);
			}
			catch
			{
				return "unknown";
			}
		}

		private static string PathFor(string key)
		{
			return Path.Combine(Path.Combine(Paths.ConfigPath, "UnlimitedJail"), key + ".txt");
		}
	}
}