using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Logging;
using DiskCardGame;
using HarmonyLib;
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(".NETFramework,Version=v4.7.2", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("sap-players-encounters")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("sap-players-encounters")]
[assembly: AssemblyTitle("sap-players-encounters")]
[assembly: AssemblyVersion("1.0.0.0")]
[BepInPlugin("com.bigeidan.sapplayersencounters", "SAP Players Encounters", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
	private class CartaCombate
	{
		public string Nombre;

		public List<Ability> SellosExtras = new List<Ability>();

		public int AtaqueExtra;

		public int VidaExtra;

		public string Token()
		{
			string text = Nombre;
			if (SellosExtras != null && SellosExtras.Count > 0)
			{
				text = text + "@" + string.Join("&", SellosExtras.Select((Ability x) => ((int)x).ToString()).ToArray());
			}
			if (AtaqueExtra != 0 || VidaExtra != 0)
			{
				text = text + "~" + AtaqueExtra + "|" + VidaExtra;
			}
			return text;
		}
	}

	[CompilerGenerated]
	private sealed class <>c__DisplayClass25_0
	{
		public HashSet<CardSlot> slotsEnCola;

		internal bool <EncolarTurnoReal>b__0(CardSlot s)
		{
			return (Object)(object)s.Card != (Object)null || slotsEnCola.Contains(s);
		}
	}

	[CompilerGenerated]
	private sealed class <EjecutarTurnoCombate>d__24 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Opponent opponent;

		public bool doTween;

		public bool changeView;

		public Plugin <>4__this;

		private int <turnoActual>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <EjecutarTurnoCombate>d__24(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.UltimoSpawnConCartas = false;
				<turnoActual>5__1 = <>4__this.turnoSpawn;
				if (!<>4__this.combateActual.ContainsKey(<turnoActual>5__1))
				{
					<>4__this.turnoSpawn++;
					return false;
				}
				<>2__current = <>4__this.EncolarTurnoReal(opponent, <>4__this.combateActual[<turnoActual>5__1], doTween, changeView);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if (<>4__this.UltimoSpawnConCartas)
				{
					<>4__this.turnoSpawn++;
				}
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <EncolarTurnoReal>d__25 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Opponent opponent;

		public List<CartaCombate> cartasTurno;

		public bool doTween;

		public bool changeView;

		public Plugin <>4__this;

		private <>c__DisplayClass25_0 <>8__1;

		private List<CartaCombate> <cartasValidas>5__2;

		private List<CardSlot> <slots>5__3;

		private int <index>5__4;

		private int <cartasEncoladas>5__5;

		private List<CartaCombate>.Enumerator <>s__6;

		private CartaCombate <carta>5__7;

		private CardInfo <info>5__8;

		private List<CartaCombate>.Enumerator <>s__9;

		private CartaCombate <cartaTurno>5__10;

		private CardInfo <cartaBase>5__11;

		private bool <haySellos>5__12;

		private bool <hayStats>5__13;

		private CardInfo <cartaConExtras>5__14;

		private CardModificationInfo <modExtra>5__15;

		private PlayableCard <cartaEnCola>5__16;

		private int <ajusteAtkActual>5__17;

		private int <ajusteVidaActual>5__18;

		private int <ajusteAtkFaltante>5__19;

		private int <ajusteVidaFaltante>5__20;

		private List<Ability> <sellosFaltantes>5__21;

		private List<Ability>.Enumerator <>s__22;

		private Ability <sello>5__23;

		private CardModificationInfo <modExtraTemp>5__24;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <EncolarTurnoReal>d__25(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || num == 1)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<>8__1 = null;
			<cartasValidas>5__2 = null;
			<slots>5__3 = null;
			<>s__6 = default(List<CartaCombate>.Enumerator);
			<carta>5__7 = null;
			<info>5__8 = null;
			<>s__9 = default(List<CartaCombate>.Enumerator);
			<cartaTurno>5__10 = null;
			<cartaBase>5__11 = null;
			<cartaConExtras>5__14 = null;
			<modExtra>5__15 = null;
			<cartaEnCola>5__16 = null;
			<sellosFaltantes>5__21 = null;
			<>s__22 = default(List<Ability>.Enumerator);
			<modExtraTemp>5__24 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0553: Unknown result type (might be due to invalid IL or missing references)
			//IL_055d: Expected O, but got Unknown
			//IL_04c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Expected O, but got Unknown
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass25_0();
					if ((Object)(object)opponent == (Object)null)
					{
						Log.LogError((object)"Opponent NULL");
						return false;
					}
					<cartasValidas>5__2 = new List<CartaCombate>();
					<>s__6 = cartasTurno.GetEnumerator();
					try
					{
						while (<>s__6.MoveNext())
						{
							<carta>5__7 = <>s__6.Current;
							<info>5__8 = <>4__this.ResolverCartaPorNombre(<carta>5__7.Nombre);
							if ((Object)(object)<info>5__8 == (Object)null)
							{
								Log.LogWarning((object)("Carta no encontrada: " + <carta>5__7.Nombre));
								continue;
							}
							<cartasValidas>5__2.Add(<carta>5__7);
							<info>5__8 = null;
							<carta>5__7 = null;
						}
					}
					finally
					{
						((IDisposable)<>s__6).Dispose();
					}
					<>s__6 = default(List<CartaCombate>.Enumerator);
					if (<cartasValidas>5__2.Count == 0)
					{
						Log.LogWarning((object)"No hay cartas validas");
						return false;
					}
					<slots>5__3 = new List<CardSlot>(Singleton<BoardManager>.Instance.OpponentSlotsCopy);
					<>8__1.slotsEnCola = new HashSet<CardSlot>(opponent.QueuedSlots);
					<slots>5__3.RemoveAll((CardSlot s) => (Object)(object)s.Card != (Object)null || <>8__1.slotsEnCola.Contains(s));
					if (<slots>5__3.Count == 0)
					{
						return false;
					}
					<index>5__4 = 0;
					<cartasEncoladas>5__5 = 0;
					<>s__9 = <cartasValidas>5__2.GetEnumerator();
					<>1__state = -3;
					break;
				case 1:
					<>1__state = -3;
					if (<haySellos>5__12 | <hayStats>5__13)
					{
						<cartaEnCola>5__16 = opponent.Queue.LastOrDefault();
						if ((Object)(object)<cartaEnCola>5__16 != (Object)null)
						{
							<ajusteAtkActual>5__17 = <cartaEnCola>5__16.Attack - <cartaBase>5__11.Attack;
							<ajusteVidaActual>5__18 = <cartaEnCola>5__16.Health - <cartaBase>5__11.Health;
							<ajusteAtkFaltante>5__19 = <cartaTurno>5__10.AtaqueExtra - <ajusteAtkActual>5__17;
							<ajusteVidaFaltante>5__20 = <cartaTurno>5__10.VidaExtra - <ajusteVidaActual>5__18;
							<sellosFaltantes>5__21 = new List<Ability>();
							if (<haySellos>5__12)
							{
								<>s__22 = <cartaTurno>5__10.SellosExtras.GetEnumerator();
								try
								{
									while (<>s__22.MoveNext())
									{
										<sello>5__23 = <>s__22.Current;
										if (!<cartaEnCola>5__16.HasAbility(<sello>5__23))
										{
											<sellosFaltantes>5__21.Add(<sello>5__23);
										}
									}
								}
								finally
								{
									((IDisposable)<>s__22).Dispose();
								}
								<>s__22 = default(List<Ability>.Enumerator);
							}
							if (<sellosFaltantes>5__21.Count > 0 || <ajusteAtkFaltante>5__19 != 0 || <ajusteVidaFaltante>5__20 != 0)
							{
								<modExtraTemp>5__24 = new CardModificationInfo();
								if (<sellosFaltantes>5__21.Count > 0)
								{
									<modExtraTemp>5__24.abilities = <sellosFaltantes>5__21;
								}
								<modExtraTemp>5__24.attackAdjustment = <ajusteAtkFaltante>5__19;
								<modExtraTemp>5__24.healthAdjustment = <ajusteVidaFaltante>5__20;
								<cartaEnCola>5__16.AddTemporaryMod(<modExtraTemp>5__24);
								<modExtraTemp>5__24 = null;
							}
							<sellosFaltantes>5__21 = null;
						}
						<cartaEnCola>5__16 = null;
					}
					<index>5__4++;
					<cartasEncoladas>5__5++;
					changeView = false;
					<cartaBase>5__11 = null;
					<cartaConExtras>5__14 = null;
					<cartaTurno>5__10 = null;
					break;
				}
				while (<>s__9.MoveNext())
				{
					<cartaTurno>5__10 = <>s__9.Current;
					if (<index>5__4 >= <slots>5__3.Count)
					{
						break;
					}
					<cartaBase>5__11 = <>4__this.ResolverCartaPorNombre(<cartaTurno>5__10.Nombre);
					if ((Object)(object)<cartaBase>5__11 == (Object)null)
					{
						Log.LogWarning((object)("Carta no resoluble en spawn: " + <cartaTurno>5__10.Nombre));
						continue;
					}
					<haySellos>5__12 = <cartaTurno>5__10.SellosExtras != null && <cartaTurno>5__10.SellosExtras.Count > 0;
					<hayStats>5__13 = <cartaTurno>5__10.AtaqueExtra != 0 || <cartaTurno>5__10.VidaExtra != 0;
					<cartaConExtras>5__14 = <cartaBase>5__11;
					if (<haySellos>5__12 | <hayStats>5__13)
					{
						<cartaConExtras>5__14 = Object.Instantiate<CardInfo>(<cartaBase>5__11);
						<modExtra>5__15 = new CardModificationInfo();
						if (<haySellos>5__12)
						{
							<modExtra>5__15.abilities = new List<Ability>(<cartaTurno>5__10.SellosExtras);
						}
						<modExtra>5__15.attackAdjustment = <cartaTurno>5__10.AtaqueExtra;
						<modExtra>5__15.healthAdjustment = <cartaTurno>5__10.VidaExtra;
						if (<cartaConExtras>5__14.Mods != null)
						{
							<cartaConExtras>5__14.Mods.Add(<modExtra>5__15);
						}
						<modExtra>5__15 = null;
					}
					<>2__current = opponent.QueueCard(<cartaConExtras>5__14, <slots>5__3[<index>5__4], doTween, changeView, true);
					<>1__state = 1;
					return true;
				}
				<>m__Finally1();
				<>s__9 = default(List<CartaCombate>.Enumerator);
				<>4__this.UltimoSpawnConCartas = <cartasEncoladas>5__5 > 0;
				return false;
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void <>m__Finally1()
		{
			<>1__state = -1;
			((IDisposable)<>s__9).Dispose();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <FallbackColaInicialTrasSetup>d__28 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Plugin <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <FallbackColaInicialTrasSetup>d__28(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (<>4__this.colaInicialProcesada)
				{
					return false;
				}
				if ((Object)(object)Singleton<TurnManager>.Instance == (Object)null || (Object)(object)Singleton<TurnManager>.Instance.Opponent == (Object)null)
				{
					return false;
				}
				<>4__this.CargarCombate();
				<>2__current = <>4__this.EjecutarTurnoCombate(Singleton<TurnManager>.Instance.Opponent);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if (<>4__this.UltimoSpawnConCartas)
				{
					<>4__this.colaInicialProcesada = true;
				}
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public static Plugin Instance;

	public static ManualLogSource Log;

	private int turnoSpawn = 1;

	private int turnoGuardado = 1;

	private int ultimoTurnoJugadorGuardado = -1;

	private Dictionary<string, int> turnoAnterior = new Dictionary<string, int>();

	private List<string> turnos = new List<string>();

	private Dictionary<int, List<CartaCombate>> combateActual = new Dictionary<int, List<CartaCombate>>();

	private string slotElegido = "";

	private bool combateCargado = false;

	private int ultimoTurnoProcesadoQueue = -1;

	private bool colaInicialProcesada = false;

	public bool UltimoSpawnConCartas { get; private set; }

	private void Awake()
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Expected O, but got Unknown
		Instance = this;
		Log = ((BaseUnityPlugin)this).Logger;
		try
		{
			SacarDeWeb();
			Harmony val = new Harmony("com.bigeidan.sapplayersencounters");
			val.PatchAll();
		}
		catch (Exception ex)
		{
			Log.LogError((object)("ERROR EN AWAKE: " + ex));
		}
	}

	private void SacarDeWeb()
	{
		try
		{
			string directoryName = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			string address = "https://sap-players-ecounters-default-rtdb.europe-west1.firebasedatabase.app/.json";
			using WebClient webClient = new WebClient();
			string fileName = Path.Combine(directoryName, "combates.json");
			webClient.DownloadFile(address, fileName);
		}
		catch (Exception ex)
		{
			Log.LogError((object)("ERROR descargando JSON: " + ex));
		}
	}

	public void CargarCombate()
	{
		if (combateCargado)
		{
			return;
		}
		combateCargado = true;
		try
		{
			string path = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "combates.json");
			if (!File.Exists(path))
			{
				Log.LogError((object)"No existe combates.json");
				return;
			}
			string input = File.ReadAllText(path);
			slotElegido = "slot_" + Random.Range(1, 51);
			string pattern = "\"" + Regex.Escape(slotElegido) + "\"\\s*:\\s*\"((?:\\\\.|[^\"])*)\"";
			Match match = Regex.Match(input, pattern);
			if (!match.Success)
			{
				Log.LogWarning((object)"No hay combate en ese slot");
				return;
			}
			string text = Regex.Unescape(match.Groups[1].Value);
			if (string.IsNullOrWhiteSpace(text))
			{
				Log.LogWarning((object)"Combate vacio en slot");
			}
			else
			{
				ParsearCombate(text);
			}
		}
		catch (Exception ex)
		{
			Log.LogError((object)("Error cargando combate: " + ex));
		}
	}

	private void ParsearCombate(string combate)
	{
		combateActual.Clear();
		string[] array = combate.Split(new char[1] { ';' });
		string[] array2 = array;
		foreach (string text in array2)
		{
			if (string.IsNullOrWhiteSpace(text))
			{
				continue;
			}
			string[] array3 = text.Split(new char[1] { ':' }, 2);
			if (array3.Length < 2)
			{
				Log.LogWarning((object)("Turno mal formado: " + text));
				continue;
			}
			if (!int.TryParse(array3[0].Replace("turno", "").Trim(), out var result))
			{
				Log.LogWarning((object)("No se pudo parsear numero de turno en: " + text));
				continue;
			}
			List<CartaCombate> list = new List<CartaCombate>();
			string text2 = array3[1].Trim();
			if (!string.IsNullOrEmpty(text2))
			{
				string[] array4 = text2.Split(new char[1] { ',' });
				foreach (string token in array4)
				{
					if (TryParseCartaToken(token, out var carta))
					{
						list.Add(carta);
					}
				}
			}
			combateActual[result] = list;
		}
	}

	private bool TryParseCartaToken(string token, out CartaCombate carta)
	{
		//IL_013b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0174: Unknown result type (might be due to invalid IL or missing references)
		//IL_018b: Unknown result type (might be due to invalid IL or missing references)
		carta = null;
		if (string.IsNullOrWhiteSpace(token))
		{
			return false;
		}
		string text = token.Trim();
		string text2 = null;
		int num = text.IndexOf('~');
		if (num >= 0)
		{
			text2 = text.Substring(num + 1).Trim();
			text = text.Substring(0, num).Trim();
		}
		int num2 = text.IndexOf('@');
		CartaCombate cartaCombate = new CartaCombate();
		if (num2 < 0)
		{
			cartaCombate.Nombre = LimpiarNombreCarta(text);
			carta = cartaCombate;
			return !string.IsNullOrEmpty(cartaCombate.Nombre);
		}
		cartaCombate.Nombre = LimpiarNombreCarta(text.Substring(0, num2));
		if (string.IsNullOrEmpty(cartaCombate.Nombre))
		{
			return false;
		}
		string text3 = text.Substring(num2 + 1).Trim();
		if (!string.IsNullOrEmpty(text3))
		{
			string[] array = text3.Split(new char[1] { '&' });
			foreach (string text4 in array)
			{
				string text5 = text4.Trim();
				if (!string.IsNullOrEmpty(text5))
				{
					Ability result2;
					if (int.TryParse(text5, out var result))
					{
						result2 = (Ability)result;
					}
					else if (!Enum.TryParse<Ability>(text5, ignoreCase: true, out result2))
					{
						Log.LogWarning((object)("Sello extra no reconocido: " + text5));
						continue;
					}
					if (!cartaCombate.SellosExtras.Contains(result2))
					{
						cartaCombate.SellosExtras.Add(result2);
					}
				}
			}
		}
		if (!string.IsNullOrEmpty(text2))
		{
			string[] array2 = text2.Split(new char[1] { '|' });
			if (array2.Length != 0 && int.TryParse(array2[0].Trim(), out var result3))
			{
				cartaCombate.AtaqueExtra = result3;
			}
			if (array2.Length > 1 && int.TryParse(array2[1].Trim(), out var result4))
			{
				cartaCombate.VidaExtra = result4;
			}
		}
		carta = cartaCombate;
		return true;
	}

	private string LimpiarNombreCarta(string nombre)
	{
		if (string.IsNullOrWhiteSpace(nombre))
		{
			return string.Empty;
		}
		return nombre.Trim().Trim(new char[1] { '"' }).Replace("\\\"", "\"")
			.Replace("\\", "")
			.Trim();
	}

	private CardInfo ResolverCartaPorNombre(string nombre)
	{
		string text = LimpiarNombreCarta(nombre);
		if (string.IsNullOrEmpty(text))
		{
			return null;
		}
		CardInfo cardByName = CardLoader.GetCardByName(text);
		if ((Object)(object)cardByName != (Object)null)
		{
			return cardByName;
		}
		string text2 = text.Replace(" ", "");
		cardByName = CardLoader.GetCardByName(text2);
		if ((Object)(object)cardByName != (Object)null)
		{
			return cardByName;
		}
		string text3 = text.Replace(" ", "_");
		cardByName = CardLoader.GetCardByName(text3);
		if ((Object)(object)cardByName != (Object)null)
		{
			return cardByName;
		}
		return null;
	}

	[IteratorStateMachine(typeof(<EjecutarTurnoCombate>d__24))]
	public IEnumerator EjecutarTurnoCombate(Opponent opponent, bool doTween = true, bool changeView = false)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <EjecutarTurnoCombate>d__24(0)
		{
			<>4__this = this,
			opponent = opponent,
			doTween = doTween,
			changeView = changeView
		};
	}

	[IteratorStateMachine(typeof(<EncolarTurnoReal>d__25))]
	private IEnumerator EncolarTurnoReal(Opponent opponent, List<CartaCombate> cartasTurno, bool doTween, bool changeView)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <EncolarTurnoReal>d__25(0)
		{
			<>4__this = this,
			opponent = opponent,
			cartasTurno = cartasTurno,
			doTween = doTween,
			changeView = changeView
		};
	}

	public bool DebeProcesarColaTurno(out bool esColaInicial)
	{
		esColaInicial = false;
		if ((Object)(object)Singleton<TurnManager>.Instance == (Object)null)
		{
			return false;
		}
		if (Singleton<TurnManager>.Instance.IsSetupPhase)
		{
			if (colaInicialProcesada)
			{
				return false;
			}
			esColaInicial = true;
			return true;
		}
		if (Singleton<TurnManager>.Instance.IsPlayerTurn)
		{
			return false;
		}
		int turnNumber = Singleton<TurnManager>.Instance.TurnNumber;
		if (turnNumber <= 0)
		{
			return false;
		}
		if (ultimoTurnoProcesadoQueue == turnNumber)
		{
			return false;
		}
		ultimoTurnoProcesadoQueue = turnNumber;
		return true;
	}

	public void ConfirmarColaInicialProcesada()
	{
		colaInicialProcesada = true;
	}

	[IteratorStateMachine(typeof(<FallbackColaInicialTrasSetup>d__28))]
	public IEnumerator FallbackColaInicialTrasSetup()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <FallbackColaInicialTrasSetup>d__28(0)
		{
			<>4__this = this
		};
	}

	public List<PlayableCard> ObtenerCartasJugador()
	{
		List<PlayableCard> list = new List<PlayableCard>();
		if ((Object)(object)Singleton<BoardManager>.Instance == (Object)null || (Object)(object)Singleton<TurnManager>.Instance == (Object)null)
		{
			return list;
		}
		foreach (CardSlot item in Singleton<BoardManager>.Instance.PlayerSlotsCopy)
		{
			if ((Object)(object)item.Card != (Object)null && item.Card.TurnPlayed == Singleton<TurnManager>.Instance.TurnNumber)
			{
				list.Add(item.Card);
			}
		}
		return list;
	}

	private List<Ability> ObtenerSellosExtras(PlayableCard carta)
	{
		//IL_019d: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0118: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0120: Unknown result type (might be due to invalid IL or missing references)
		HashSet<Ability> hashSet = new HashSet<Ability>();
		if ((Object)(object)((Card)carta).Info != (Object)null && ((Card)carta).Info.Mods != null)
		{
			foreach (CardModificationInfo mod in ((Card)carta).Info.Mods)
			{
				if (mod == null || mod.abilities == null)
				{
					continue;
				}
				foreach (Ability ability in mod.abilities)
				{
					hashSet.Add(ability);
				}
			}
		}
		if (carta.TemporaryMods != null)
		{
			foreach (CardModificationInfo temporaryMod in carta.TemporaryMods)
			{
				if (temporaryMod == null || temporaryMod.abilities == null)
				{
					continue;
				}
				foreach (Ability ability2 in temporaryMod.abilities)
				{
					hashSet.Add(ability2);
				}
			}
		}
		CardInfo cardByName = CardLoader.GetCardByName(((Object)((Card)carta).Info).name);
		if ((Object)(object)cardByName != (Object)null && cardByName.Abilities != null)
		{
			foreach (Ability ability3 in cardByName.Abilities)
			{
				if (hashSet.Contains(ability3))
				{
					hashSet.Remove(ability3);
				}
			}
		}
		List<Ability> list = new List<Ability>(hashSet);
		list.Sort((Ability a, Ability b) => ((int)a).CompareTo((int)b));
		return list;
	}

	private void ObtenerAjustesEstadisticas(PlayableCard carta, out int ataqueExtra, out int vidaExtra)
	{
		ataqueExtra = 0;
		vidaExtra = 0;
		if ((Object)(object)((Card)carta).Info != (Object)null && ((Card)carta).Info.Mods != null)
		{
			foreach (CardModificationInfo mod in ((Card)carta).Info.Mods)
			{
				if (mod != null)
				{
					ataqueExtra += mod.attackAdjustment;
					vidaExtra += mod.healthAdjustment;
				}
			}
		}
		if (carta.TemporaryMods == null)
		{
			return;
		}
		foreach (CardModificationInfo temporaryMod in carta.TemporaryMods)
		{
			if (temporaryMod != null)
			{
				ataqueExtra += temporaryMod.attackAdjustment;
				vidaExtra += temporaryMod.healthAdjustment;
			}
		}
	}

	private string SerializarCarta(PlayableCard carta)
	{
		if ((Object)(object)carta == (Object)null || (Object)(object)((Card)carta).Info == (Object)null || string.IsNullOrEmpty(((Object)((Card)carta).Info).name))
		{
			return null;
		}
		List<Ability> list = ObtenerSellosExtras(carta);
		ObtenerAjustesEstadisticas(carta, out var ataqueExtra, out var vidaExtra);
		if (list.Count == 0 && ataqueExtra == 0 && vidaExtra == 0)
		{
			return ((Object)((Card)carta).Info).name;
		}
		string text = ((Object)((Card)carta).Info).name;
		if (list.Count > 0)
		{
			text = text + "@" + string.Join("&", list.Select((Ability x) => ((int)x).ToString()).ToArray());
		}
		if (ataqueExtra != 0 || vidaExtra != 0)
		{
			text = text + "~" + ataqueExtra + "|" + vidaExtra;
		}
		return text;
	}

	public void GuardarTurno(List<PlayableCard> cartasEnMesa)
	{
		Dictionary<string, int> dictionary = new Dictionary<string, int>();
		foreach (PlayableCard item2 in cartasEnMesa)
		{
			string text = SerializarCarta(item2);
			if (!string.IsNullOrEmpty(text))
			{
				if (!dictionary.ContainsKey(text))
				{
					dictionary[text] = 0;
				}
				dictionary[text]++;
			}
		}
		List<string> list = new List<string>();
		foreach (KeyValuePair<string, int> item3 in dictionary)
		{
			int num = (turnoAnterior.ContainsKey(item3.Key) ? turnoAnterior[item3.Key] : 0);
			int num2 = item3.Value - num;
			for (int i = 0; i < num2; i++)
			{
				list.Add(item3.Key);
			}
		}
		if (list.Count > 0)
		{
			string item = "turno" + turnoGuardado + ":" + string.Join(",", list);
			turnos.Add(item);
		}
		turnoAnterior = dictionary;
		turnoGuardado++;
	}

	public void GuardarTurnoJugadorActualSiNoGuardado()
	{
		if (!((Object)(object)Singleton<TurnManager>.Instance == (Object)null))
		{
			int turnNumber = Singleton<TurnManager>.Instance.TurnNumber;
			if (turnNumber > 0 && ultimoTurnoJugadorGuardado != turnNumber)
			{
				List<PlayableCard> cartasEnMesa = ObtenerCartasJugador();
				GuardarTurno(cartasEnMesa);
				ultimoTurnoJugadorGuardado = turnNumber;
			}
		}
	}

	public void EnviarCombate()
	{
		try
		{
			if (turnos.Count == 0)
			{
				Log.LogWarning((object)"No hay turnos que enviar");
				return;
			}
			string text = string.Join(";", turnos);
			string address = "https://sap-players-ecounters-default-rtdb.europe-west1.firebasedatabase.app/" + slotElegido + ".json";
			string data = "\"" + text.Replace("\"", "\\\"") + "\"";
			using WebClient webClient = new WebClient();
			webClient.Headers[HttpRequestHeader.ContentType] = "application/json";
			webClient.UploadString(address, "PUT", data);
		}
		catch (Exception ex)
		{
			Log.LogError((object)("ERROR subiendo combate: " + ex));
		}
	}

	public void ResetearCombate()
	{
		turnoSpawn = 1;
		turnoGuardado = 1;
		ultimoTurnoJugadorGuardado = -1;
		turnoAnterior.Clear();
		turnos.Clear();
		combateActual.Clear();
		combateCargado = false;
		ultimoTurnoProcesadoQueue = -1;
		colaInicialProcesada = false;
		UltimoSpawnConCartas = false;
	}
}
[HarmonyPatch(typeof(Opponent), "QueueNewCards")]
internal class QueueNewCardsPatch
{
	[CompilerGenerated]
	private sealed class <EjecutarDespuesDeQueueBase>d__1 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public IEnumerator original;

		public Opponent opponent;

		public bool doTween;

		public bool changeView;

		private Plugin <plugin>5__1;

		private bool <esColaInicial>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <EjecutarDespuesDeQueueBase>d__1(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<plugin>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				goto IL_0051;
			case 1:
				<>1__state = -1;
				goto IL_0051;
			case 2:
				{
					<>1__state = -1;
					if (<esColaInicial>5__2 && <plugin>5__1.UltimoSpawnConCartas)
					{
						<plugin>5__1.ConfirmarColaInicialProcesada();
					}
					return false;
				}
				IL_0051:
				if (original.MoveNext())
				{
					<>2__current = original.Current;
					<>1__state = 1;
					return true;
				}
				<plugin>5__1 = Plugin.Instance;
				if ((Object)(object)<plugin>5__1 == (Object)null)
				{
					return false;
				}
				if (!<plugin>5__1.DebeProcesarColaTurno(out <esColaInicial>5__2))
				{
					return false;
				}
				<plugin>5__1.CargarCombate();
				<>2__current = <plugin>5__1.EjecutarTurnoCombate(opponent, doTween);
				<>1__state = 2;
				return true;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private static void Postfix(Opponent __instance, bool __0, bool __1, ref IEnumerator __result)
	{
		__result = EjecutarDespuesDeQueueBase(__result, __instance, __0, __1);
	}

	[IteratorStateMachine(typeof(<EjecutarDespuesDeQueueBase>d__1))]
	private static IEnumerator EjecutarDespuesDeQueueBase(IEnumerator original, Opponent opponent, bool doTween, bool changeView)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <EjecutarDespuesDeQueueBase>d__1(0)
		{
			original = original,
			opponent = opponent,
			doTween = doTween,
			changeView = changeView
		};
	}
}
[HarmonyPatch(typeof(TurnManager), "SetupPhase")]
internal class SetupPhasePatch
{
	[CompilerGenerated]
	private sealed class <EjecutarDespuesDeSetup>d__1 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public IEnumerator original;

		private Plugin <plugin>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <EjecutarDespuesDeSetup>d__1(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<plugin>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				goto IL_004e;
			case 1:
				<>1__state = -1;
				goto IL_004e;
			case 2:
				{
					<>1__state = -1;
					return false;
				}
				IL_004e:
				if (original.MoveNext())
				{
					<>2__current = original.Current;
					<>1__state = 1;
					return true;
				}
				<plugin>5__1 = Plugin.Instance;
				if ((Object)(object)<plugin>5__1 == (Object)null)
				{
					return false;
				}
				<>2__current = <plugin>5__1.FallbackColaInicialTrasSetup();
				<>1__state = 2;
				return true;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private static void Postfix(ref IEnumerator __result)
	{
		__result = EjecutarDespuesDeSetup(__result);
	}

	[IteratorStateMachine(typeof(<EjecutarDespuesDeSetup>d__1))]
	private static IEnumerator EjecutarDespuesDeSetup(IEnumerator original)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <EjecutarDespuesDeSetup>d__1(0)
		{
			original = original
		};
	}
}
[HarmonyPatch(typeof(TurnManager), "PlayerTurn")]
internal class PlayerTurnPatch
{
	[CompilerGenerated]
	private sealed class <EjecutarDespuesDePlayerTurn>d__1 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public IEnumerator original;

		private Plugin <plugin>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <EjecutarDespuesDePlayerTurn>d__1(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<plugin>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (original.MoveNext())
			{
				<>2__current = original.Current;
				<>1__state = 1;
				return true;
			}
			<plugin>5__1 = Plugin.Instance;
			if ((Object)(object)<plugin>5__1 == (Object)null)
			{
				return false;
			}
			<plugin>5__1.GuardarTurnoJugadorActualSiNoGuardado();
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private static void Postfix(ref IEnumerator __result)
	{
		__result = EjecutarDespuesDePlayerTurn(__result);
	}

	[IteratorStateMachine(typeof(<EjecutarDespuesDePlayerTurn>d__1))]
	private static IEnumerator EjecutarDespuesDePlayerTurn(IEnumerator original)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <EjecutarDespuesDePlayerTurn>d__1(0)
		{
			original = original
		};
	}
}
[HarmonyPatch(typeof(TurnManager), "CleanupPhase")]
internal class EndCombatPatch
{
	private static void Postfix()
	{
		Plugin instance = Plugin.Instance;
		if ((Object)(object)instance != (Object)null)
		{
			instance.GuardarTurnoJugadorActualSiNoGuardado();
			instance.EnviarCombate();
			instance.ResetearCombate();
		}
	}
}