using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
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.Logging;
using DiskCardGame;
using HarmonyLib;
using InscryptionAPI.Card;
using Pixelplacement;
using UnityEngine;

[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.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("MLP_Sigils")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Sigils for the My Little Pony Cardpack.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("MLP_Sigils")]
[assembly: AssemblyTitle("MLP_Sigils")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace MLP_Sigils;

[HarmonyPatch]
public class BoardSetAndCleanUp
{
	[HarmonyPatch(typeof(TurnManager), "CleanupPhase")]
	[HarmonyPostfix]
	public static void CleanupPhasePostFix()
	{
		foreach (Tuple<GameObject, Surprise, int> item in Surprise.DisappearedCards.Keys.ToList())
		{
			Object.Destroy((Object)(object)item.Item1);
		}
		Surprise.DisappearedCards.Clear();
	}

	[HarmonyPatch(typeof(TurnManager), "SetupPhase")]
	[HarmonyPostfix]
	public static void SetupPhasePostFix()
	{
		foreach (Tuple<GameObject, Surprise, int> item in Surprise.DisappearedCards.Keys.ToList())
		{
			Object.Destroy((Object)(object)item.Item1);
		}
		Surprise.DisappearedCards.Clear();
	}
}
[HarmonyPatch(typeof(TurnManager), "DoUpkeepPhase")]
public class OnUpkeep
{
	[HarmonyPrefix]
	public static void Prefix(bool playerUpkeep)
	{
		//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_0169: Unknown result type (might be due to invalid IL or missing references)
		//IL_016e: Unknown result type (might be due to invalid IL or missing references)
		//IL_018d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0140: Unknown result type (might be due to invalid IL or missing references)
		if (!playerUpkeep)
		{
			return;
		}
		foreach (Tuple<GameObject, Surprise, int> item in Surprise.DisappearedCards.Keys.ToList())
		{
			Surprise.DisappearedCards[item]++;
			if (Surprise.DisappearedCards[item] == item.Item3)
			{
				PlayableCard component = item.Item1.GetComponent<PlayableCard>();
				List<CardSlot> list = (component.OpponentCard ? Singleton<BoardManager>.Instance.opponentSlots : Singleton<BoardManager>.Instance.playerSlots);
				List<CardSlot> list2 = list.Where((CardSlot x) => (Object)(object)x.Card == (Object)null).ToList();
				Random random = new Random();
				CardSlot val = ((list2.Count <= 0) ? list[random.Next(list.Count)] : list2[random.Next(list2.Count)]);
				if ((Object)(object)val.Card != (Object)null)
				{
					((Card)val.Card).ExitBoard(0f, new Vector3(0f, 0f, 0f));
				}
				((Component)component).transform.position = ((Component)val).transform.position + Vector3.up * 0.025f;
				((Component)component).transform.rotation = ((Component)val).transform.GetChild(0).rotation;
				component.Slot = val;
				val.Card = component;
				item.Item2.AttackCount = Surprise.DisappearedCards[item];
				Surprise.DisappearedCards.Remove(item);
			}
		}
	}
}
[BepInPlugin("MLP_Sigils", "MLP Sigils", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
	public const string PluginGuid = "MLP_Sigils";

	private const string PluginName = "MLP Sigils";

	private const string PluginVersion = "1.0.0";

	public static string Directory;

	internal static ManualLogSource Log;

	public void Awake()
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Expected O, but got Unknown
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Loaded MLP Sigils mod! - Made by Lily");
		Log = ((BaseUnityPlugin)this).Logger;
		Harmony val = new Harmony("MLP_Sigils");
		val.PatchAll();
		AddSurprise();
		AddDevStuff();
	}

	private void AddDevStuff()
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Expected I4, but got Unknown
		CardInfo val = CardExtensions.CardByName((IEnumerable<CardInfo>)CardManager.BaseGameCards, "Stoat_Talking");
		CardExtensions.AddSpecialAbilities(val, (SpecialTriggeredAbility[])(object)new SpecialTriggeredAbility[1] { (SpecialTriggeredAbility)(int)Surprise.ability });
	}

	public Texture2D GetTexture(string path)
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Expected O, but got Unknown
		byte[] array = File.ReadAllBytes(Path.Combine(((BaseUnityPlugin)this).Info.Location.Replace("MLP_Sigils.dll", ""), "Artwork/" + path));
		Texture2D val = new Texture2D(2, 2);
		ImageConversion.LoadImage(val, array);
		((Texture)val).filterMode = (FilterMode)0;
		return val;
	}

	public void AddSurprise()
	{
		//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)
		Surprise.ability = SpecialTriggeredAbilityManager.Add("MLP_Sigils", "Surprise", typeof(Surprise)).Id;
	}
}
public class Surprise : SpecialCardBehaviour
{
	public static SpecialTriggeredAbility ability;

	public static Dictionary<Tuple<GameObject, Surprise, int>, int> DisappearedCards = new Dictionary<Tuple<GameObject, Surprise, int>, int>();

	public int TurnsInPlay = 0;

	public int TurnsUntilDisappearance;

	public int? AttackCount = null;

	public static List<string> SurpriseLines = new List<string> { "[e:1]Miss me?!?", "[e:4]Suuurprise!!!!", "I like this game!", "Don't forget about me!" };

	public void Start()
	{
		Random random = new Random();
		TurnsUntilDisappearance = random.Next(2, 6);
	}

	public override bool RespondsToUpkeep(bool playerUpkeep)
	{
		return playerUpkeep;
	}

	public override IEnumerator OnUpkeep(bool playerUpkeep)
	{
		TurnsInPlay++;
		if (TurnsInPlay == TurnsUntilDisappearance)
		{
			Random random = new Random();
			DisappearedCards[new Tuple<GameObject, Surprise, int>(((Component)this).gameObject, this, random.Next(2, 5))] = 0;
			((SpecialCardBehaviour)this).PlayableCard.UnassignFromSlot();
			Transform transform = ((Component)this).gameObject.transform;
			transform.position += Vector3.up * -10f;
		}
		if (AttackCount.HasValue)
		{
			yield return AttackSlotXTimes(((SpecialCardBehaviour)this).PlayableCard, AttackCount.Value);
			AttackCount = null;
		}
	}

	public static IEnumerator AttackSlotXTimes(PlayableCard card, int count)
	{
		yield return (object)new WaitForSeconds(0.1f);
		Singleton<ViewManager>.Instance.SwitchToView((View)4, true, false);
		yield return (object)new WaitForSeconds(0.1f);
		TalkingCard TalkingComponent = ((Component)card).GetComponent<TalkingCard>();
		if ((Object)(object)TalkingComponent != (Object)null)
		{
			Random random = new Random();
			Line line = new Line
			{
				text = SurpriseLines[random.Next(SurpriseLines.Count)]
			};
			yield return TalkingComponent.PlayLine(line);
		}
		yield return (object)new WaitForSeconds(0.2f);
		FakeCombatHandler.FakeCombatThing fakecombat = new FakeCombatHandler.FakeCombatThing();
		for (int i = 0; i < count; i++)
		{
			yield return fakecombat.FakeCombat(!card.OpponentCard, null, card.Slot);
			yield return (object)new WaitForSeconds(0.1f);
		}
		yield return (object)new WaitForSeconds(0.1f);
		Singleton<ViewManager>.Instance.Controller.LockState = (ViewLockState)0;
	}
}
public class FakeCombatHandler
{
	public class FakeCombatThing
	{
		public static Ability ability;

		public static bool isCombatPhase;

		public int DamageDealtThisPhase { get; private set; }

		public IEnumerator FakeCombat(bool playerIsAttacker, SpecialBattleSequencer specialSequencer, CardSlot attacker, List<CardSlot> overrideTargets = null, int overrideDMG = -1)
		{
			DamageDealtThisPhase = 0;
			yield return SlotAttackSequence(attacker, overrideTargets, overrideDMG);
			if (DamageDealtThisPhase > 0 && !isCombatPhase)
			{
				yield return (object)new WaitForSeconds(0.4f);
				int excessDamage = 0;
				if (playerIsAttacker)
				{
					excessDamage = Singleton<LifeManager>.Instance.Balance + DamageDealtThisPhase - 5;
					excessDamage = Mathf.Max(0, excessDamage);
				}
				int damage = DamageDealtThisPhase - excessDamage;
				if (DamageDealtThisPhase >= 666)
				{
					AchievementManager.Unlock((Achievement)25);
				}
				if ((Object)(object)specialSequencer == (Object)null || !specialSequencer.PreventDamageAddedToScales)
				{
					yield return Singleton<LifeManager>.Instance.ShowDamageSequence(damage, damage, !playerIsAttacker, 0f, (GameObject)null, 0f, true);
				}
				if ((Object)(object)specialSequencer != (Object)null)
				{
					yield return specialSequencer.DamageAddedToScale(damage + excessDamage, playerIsAttacker);
				}
				if ((!((Object)(object)specialSequencer != (Object)null) || !specialSequencer.PreventDamageAddedToScales) && excessDamage > 0 && Singleton<TurnManager>.Instance.Opponent.NumLives == 1 && Singleton<TurnManager>.Instance.Opponent.GiveCurrencyOnDefeat)
				{
					yield return Singleton<TurnManager>.Instance.Opponent.TryRevokeSurrender();
					RunState run = RunState.Run;
					run.currency += excessDamage;
				}
				Singleton<ViewManager>.Instance.Controller.LockState = (ViewLockState)0;
				DamageDealtThisPhase = 0;
			}
		}

		public IEnumerator SlotAttackSlot(CardSlot attackingSlot, CardSlot opposingSlot, float waitAfter = 0f, int overrideDMG = -1)
		{
			yield return Singleton<GlobalTriggerHandler>.Instance.TriggerCardsOnBoard((Trigger)6, false, new object[2] { opposingSlot, attackingSlot.Card });
			yield return (object)new WaitForSeconds(0.025f);
			if (!((Object)(object)attackingSlot.Card != (Object)null))
			{
				yield break;
			}
			if (((Card)attackingSlot.Card).Anim.DoingAttackAnimation)
			{
				yield return (object)new WaitUntil((Func<bool>)(() => !((Card)attackingSlot.Card).Anim.DoingAttackAnimation));
				yield return (object)new WaitForSeconds(0.25f);
			}
			if ((Object)(object)opposingSlot.Card != (Object)null && attackingSlot.Card.AttackIsBlocked(opposingSlot))
			{
				ProgressionData.SetAbilityLearned((Ability)21);
				yield return Singleton<CombatPhaseManager>.Instance.ShowCardBlocked(attackingSlot.Card);
			}
			else if (attackingSlot.Card.CanAttackDirectly(opposingSlot))
			{
				DamageDealtThisPhase += ((overrideDMG > -1) ? overrideDMG : attackingSlot.Card.Attack);
				yield return Singleton<CombatPhaseManager>.Instance.VisualizeCardAttackingDirectly(attackingSlot, opposingSlot, 0);
				if (attackingSlot.Card.TriggerHandler.RespondsToTrigger((Trigger)20, new object[1] { (overrideDMG > -1) ? overrideDMG : attackingSlot.Card.Attack }))
				{
					yield return attackingSlot.Card.TriggerHandler.OnTrigger((Trigger)20, new object[1] { (overrideDMG > -1) ? overrideDMG : attackingSlot.Card.Attack });
				}
			}
			else
			{
				float heightOffset = (((Object)(object)opposingSlot.Card == (Object)null) ? 0f : opposingSlot.Card.SlotHeightOffset);
				if (heightOffset > 0f)
				{
					Tween.Position(((Component)attackingSlot.Card).transform, ((Component)attackingSlot.Card).transform.position + Vector3.up * heightOffset, 0.05f, 0f, Tween.EaseInOut, (LoopType)0, (Action)null, (Action)null, true);
				}
				((Card)attackingSlot.Card).Anim.PlayAttackAnimation(attackingSlot.Card.IsFlyingAttackingReach(), opposingSlot, (Action)null);
				yield return (object)new WaitForSeconds(0.07f);
				((Card)attackingSlot.Card).Anim.SetAnimationPaused(true);
				PlayableCard attackingCard = attackingSlot.Card;
				yield return Singleton<GlobalTriggerHandler>.Instance.TriggerCardsOnBoard((Trigger)7, false, new object[1] { opposingSlot.Card });
				if ((Object)(object)attackingCard != (Object)null && (Object)(object)attackingCard.Slot != (Object)null)
				{
					attackingSlot = attackingCard.Slot;
					if (attackingSlot.Card.IsFlyingAttackingReach())
					{
						((Card)opposingSlot.Card).Anim.PlayJumpAnimation();
						yield return (object)new WaitForSeconds(0.3f);
						((Card)attackingSlot.Card).Anim.PlayAttackInAirAnimation();
					}
					((Card)attackingSlot.Card).Anim.SetAnimationPaused(false);
					yield return (object)new WaitForSeconds(0.05f);
					int overkillDamage = ((overrideDMG > -1) ? overrideDMG : (attackingSlot.Card.Attack - opposingSlot.Card.Health));
					yield return opposingSlot.Card.TakeDamage((overrideDMG > -1) ? overrideDMG : attackingSlot.Card.Attack, attackingSlot.Card);
					yield return DealOverkillDamage(overkillDamage, attackingSlot, opposingSlot);
					if ((Object)(object)attackingSlot.Card != (Object)null && heightOffset > 0f)
					{
						yield return Singleton<BoardManager>.Instance.AssignCardToSlot(attackingSlot.Card, attackingSlot.Card.Slot, 0.1f, (Action)null, false);
					}
				}
			}
			yield return (object)new WaitForSeconds(waitAfter);
		}

		private IEnumerator SlotAttackSequence(CardSlot slot, List<CardSlot> overrideTargets = null, int overrideDMG = -1)
		{
			List<CardSlot> opposingSlots = slot.Card.GetOpposingSlots();
			if (overrideTargets != null)
			{
				opposingSlots = overrideTargets;
			}
			Singleton<ViewManager>.Instance.SwitchToView(Singleton<BoardManager>.Instance.CombatView, false, false);
			foreach (CardSlot opposingSlot in opposingSlots)
			{
				Singleton<ViewManager>.Instance.SwitchToView(Singleton<BoardManager>.Instance.CombatView, false, false);
				yield return SlotAttackSlot(slot, opposingSlot, (opposingSlots.Count > 1) ? 0.1f : 0f, overrideDMG);
			}
			Singleton<CombatPhaseManager>.Instance.VisualizeClearSniperAbility();
		}

		protected virtual IEnumerator DealOverkillDamage(int damage, CardSlot attackingSlot, CardSlot opposingSlot)
		{
			if (!((Object)(object)attackingSlot.Card != (Object)null) || !attackingSlot.IsPlayerSlot || damage <= 0)
			{
				yield break;
			}
			PlayableCard queuedCard = Singleton<BoardManager>.Instance.GetCardQueuedForSlot(opposingSlot);
			if ((Object)(object)queuedCard != (Object)null)
			{
				yield return (object)new WaitForSeconds(0.1f);
				Singleton<ViewManager>.Instance.SwitchToView(Singleton<BoardManager>.Instance.QueueView, false, false);
				yield return (object)new WaitForSeconds(0.3f);
				if (queuedCard.HasAbility((Ability)21))
				{
					yield return Singleton<CombatPhaseManager>.Instance.ShowCardBlocked(attackingSlot.Card);
					yield break;
				}
				yield return Singleton<CombatPhaseManager>.Instance.PreOverkillDamage(queuedCard);
				yield return queuedCard.TakeDamage(damage, attackingSlot.Card);
				yield return Singleton<CombatPhaseManager>.Instance.PostOverkillDamage(queuedCard);
			}
		}
	}

	public static IEnumerator DoSimpleFakeCombat(int damage, CardSlot attacker, CardSlot target)
	{
		yield return HandleSimpleFakeCombat(damage, attacker, target);
	}

	private static IEnumerator HandleSimpleFakeCombat(int damage, CardSlot attacker, CardSlot target)
	{
		bool impactFrameReached = false;
		((Card)attacker.Card).Anim.PlayAttackAnimation(false, target, (Action)delegate
		{
			impactFrameReached = true;
		});
		yield return (object)new WaitUntil((Func<bool>)(() => impactFrameReached));
		yield return target.Card.TakeDamage(damage, attacker.Card);
	}
}
public static class PluginInfo
{
	public const string PLUGIN_GUID = "MLP_Sigils";

	public const string PLUGIN_NAME = "MLP_Sigils";

	public const string PLUGIN_VERSION = "1.0.0";
}