using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;
using Jotunn.Utils;
using ModdingUtils.Utils;
using Photon.Pun;
using RoundsTBH.Cards;
using RoundsTBH.MonoBehaviors;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.Networking;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("RoundsTBH")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("RoundsTBH")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("fd2f46f9-5c1c-4ebb-bd53-18e7bb0a7cc4")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace RoundsTBH
{
	[HarmonyPatch(typeof(CardChoice), "Pick")]
	internal class PickTimerCardChoicePatch
	{
		private static bool Prefix(CardChoice __instance, ref GameObject pickedCard, bool clear)
		{
			MethodBase method = new StackTrace().GetFrame(1).GetMethod();
			string text = method.DeclaringType.FullName + "." + method.Name;
			if (text == "PickTimer.Util.PickTimerController.StartPickTimer")
			{
				Debug.Log("Called from PickTimerController, modifying pickedCard.");
				Traverse obj = Traverse.Create((object)__instance);
				List<GameObject> list = (List<GameObject>)obj.Field("spawnedCards").GetValue();
				int num = (int)obj.Field("currentlySelectedCard").GetValue();
				if (list != null && list.Count > 0 && num >= 0 && num < list.Count)
				{
					pickedCard = list[num];
				}
			}
			else
			{
				Debug.Log("Pick card called from " + text);
			}
			return true;
		}
	}
	[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.tbh.rounds", "TBH", "1.0.1")]
	[BepInProcess("Rounds.exe")]
	public class TehBroHouse : BaseUnityPlugin
	{
		public const string ModId = "com.tbh.rounds";

		public const string ModName = "TBH";

		public const string Version = "1.0.1";

		private string[] CardsOnlyOnce = new string[1] { "star" };

		public static AssetBundle ArtAssets { get; private set; }

		private void Awake()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			new Harmony("com.tbh.rounds").PatchAll();
		}

		private void Start()
		{
			Cards.instance.AddCardValidationFunction((Func<Player, CardInfo, bool>)OnValidateCardForPlayer);
			ArtAssets = AssetUtils.LoadAssetBundleFromResources("tbh", typeof(TehBroHouse).Assembly);
			if ((Object)(object)ArtAssets == (Object)null)
			{
				Debug.Log((object)"Failed to load tbh art asset bundle!");
			}
			CustomCard.BuildCard<LeckEierCard>();
		}

		private bool OnValidateCardForPlayer(Player player, CardInfo currentCardInfo)
		{
			string[] cardsOnlyOnce = CardsOnlyOnce;
			foreach (string text in cardsOnlyOnce)
			{
				if (!text.Equals(currentCardInfo.cardName.ToLower()))
				{
					continue;
				}
				foreach (CardInfo currentCard in player.data.currentCards)
				{
					if (text.Equals(currentCard.cardName.ToLower()))
					{
						return false;
					}
				}
			}
			return true;
		}
	}
}
namespace RoundsTBH.Cards
{
	internal class LeckEierCard : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.allowMultiple = false;
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			block.cdAdd += 0.25f;
			if ((Object)(object)((Component)player).gameObject.GetComponent<LeckEierMono>() == (Object)null)
			{
				((Component)player).gameObject.AddComponent<LeckEierMono>();
			}
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			LeckEierMono component = ((Component)player).gameObject.GetComponent<LeckEierMono>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
		}

		protected override string GetTitle()
		{
			return "Leck Eier";
		}

		protected override string GetDescription()
		{
			return "Every couple of seconds pushes nearby people away.";
		}

		protected override GameObject GetCardArt()
		{
			return TehBroHouse.ArtAssets.LoadAsset<GameObject>("C_LeckEier");
		}

		protected override Rarity GetRarity()
		{
			return (Rarity)1;
		}

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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)
			//IL_002a: 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)
			//IL_0032: Expected O, but got Unknown
			return (CardInfoStat[])(object)new CardInfoStat[1]
			{
				new CardInfoStat
				{
					positive = false,
					stat = "Block Cooldown",
					amount = "+0.25s",
					simepleAmount = (SimpleAmount)0
				}
			};
		}

		protected override CardThemeColorType GetTheme()
		{
			return (CardThemeColorType)2;
		}

		public override string GetModName()
		{
			return "TBH";
		}
	}
}
namespace RoundsTBH.MonoBehaviors
{
	internal class LeckEierMono : MonoBehaviour
	{
		private Player player;

		private static GameObject Asset;

		public float startTime;

		public readonly float cooldown = 3.8f;

		private const float pushForce = 1050f;

		private readonly float updateDelay = 0.1f;

		private readonly float maxDistance = 8.1f;

		private const bool pushIgnoreBlock = false;

		private float activatePushTime;

		public void Start()
		{
			player = ((Component)this).GetComponent<Player>();
			if ((Object)(object)Asset == (Object)null)
			{
				Asset = TehBroHouse.ArtAssets.LoadAsset<GameObject>("A_LeckEier");
			}
		}

		public void Destroy()
		{
			Object.Destroy((Object)(object)this);
		}

		public void Update()
		{
			if (Time.time >= startTime + cooldown + updateDelay)
			{
				List<Player> enemyPlayersInRange = GetEnemyPlayersInRange(player, maxDistance);
				if (enemyPlayersInRange != null && enemyPlayersInRange.Count > 0)
				{
					activatePushTime = Time.time + 0.28f;
					ResetTimer();
				}
			}
			if (activatePushTime > 0.1f && Time.time >= activatePushTime)
			{
				activatePushTime = 0f;
				ExecAbility();
			}
		}

		private bool ExecAbility()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			List<Player> enemyPlayersInRange = GetEnemyPlayersInRange(player, maxDistance);
			if (enemyPlayersInRange != null && enemyPlayersInRange.Count > 0)
			{
				Vector2 val = Vector2.op_Implicit(((Component)player).transform.position);
				foreach (Player item in enemyPlayersInRange)
				{
					Vector2 val2 = Vector2.op_Implicit(((Component)item).transform.position) - val;
					Vector2 val3 = ((Vector2)(ref val2)).normalized * 1050f;
					if (PhotonNetwork.OfflineMode)
					{
						item.data.healthHandler.TakeForce(val3 * 1050f, (ForceMode2D)0, false, false, 0f);
					}
					else if (((Component)player).GetComponent<PhotonView>().IsMine)
					{
						flag = true;
					}
				}
				if (flag)
				{
					int[] array = enemyPlayersInRange.Select((Player p) => p.playerID).ToArray();
					NetworkingManager.RPC(typeof(LeckEierMono), "SyncPush", new object[2] { player.playerID, array });
				}
				else
				{
					SpawnEffect(player);
				}
				return true;
			}
			return false;
		}

		[UnboundRPC]
		public static void SyncPush(int invokerId, int[] targetIds)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			Player val = PlayerManager.instance.players.Find((Player p) => p.playerID == invokerId);
			if (!((Object)(object)val != (Object)null))
			{
				return;
			}
			Vector2 val2 = Vector2.op_Implicit(((Component)val).transform.position);
			foreach (int targetId in targetIds)
			{
				Player val3 = PlayerManager.instance.players.Find((Player p) => p.playerID == targetId);
				if ((Object)(object)val3 != (Object)null)
				{
					Vector2 val4 = Vector2.op_Implicit(((Component)val3).transform.position) - val2;
					Vector2 val5 = ((Vector2)(ref val4)).normalized * 1050f;
					val3.data.healthHandler.TakeForce(val5 * 1050f, (ForceMode2D)0, false, false, 0f);
				}
			}
			SpawnEffect(val);
		}

		private static void SpawnEffect(Player player)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Asset == (Object)null))
			{
				GameObject val = Object.Instantiate<GameObject>(Asset);
				if (!((Object)(object)val == (Object)null))
				{
					Object.Destroy((Object)(object)val, 0.35f);
					val.transform.position = ((Component)player).transform.position;
				}
			}
		}

		private void ResetTimer()
		{
			startTime = Time.time;
		}

		private static List<Player> GetEnemyPlayersInRange(Player localplayer, float range)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			List<Player> list = null;
			Vector2 val = Vector2.op_Implicit(((Component)localplayer).transform.position);
			_ = localplayer.teamID;
			for (int i = 0; i < PlayerManager.instance.players.Count; i++)
			{
				if (!PlayerManager.instance.players[i].data.dead && PlayerManager.instance.players[i].teamID != localplayer.teamID && PlayerManager.instance.CanSeePlayer(val, PlayerManager.instance.players[i]).canSee && Vector2.Distance(val, PlayerManager.instance.players[i].data.playerVel.position) <= range)
				{
					if (list == null)
					{
						list = new List<Player>();
					}
					list.Add(PlayerManager.instance.players[i]);
				}
			}
			return list;
		}
	}
}