using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BPHider;
using HarmonyLib;
using Il2CppRUMBLE.Managers;
using Il2CppRUMBLE.Players.Subsystems;
using Il2CppRUMBLE.Social;
using Il2CppRUMBLE.Social.Phone;
using Il2CppRUMBLE.Utilities;
using Il2CppTMPro;
using MatchInfo;
using MelonLoader;
using MelonLoader.Preferences;
using RumbleModdingAPI.RMAPI;
using UIFramework;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Main), "BPHider", "1.2.1", "UlvakSkillz", null)]
[assembly: MelonGame("Buckethead Entertainment", "RUMBLE")]
[assembly: MelonColor(255, 195, 0, 255)]
[assembly: MelonAuthorColor(255, 195, 0, 255)]
[assembly: VerifyLoaderVersion(0, 7, 2, true)]
[assembly: MelonAdditionalDependencies(new string[] { "UIFramework" })]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("BPHider")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+da6e04ed0c7687f76b3a26ea40adb0168844b97d")]
[assembly: AssemblyProduct("BPHider")]
[assembly: AssemblyTitle("BPHider")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace BPHider;

public static class BuildInfo
{
	public const string ModName = "BPHider";

	public const string ModVersion = "1.2.1";

	public const string Author = "UlvakSkillz";
}
public class Main : MelonMod
{
	[HarmonyPatch(typeof(Main), "Log", new Type[] { typeof(string) })]
	public static class LoggedInitializedPatch
	{
		private static void Postfix(ref Main __instance, string msg)
		{
			if (msg != "Initialized")
			{
				return;
			}
			hasMatchInfo = true;
			try
			{
				matchInfoPlayer1BP = Main.player1BPComponent;
			}
			catch
			{
				return;
			}
			try
			{
				matchInfoPlayer2BP = Main.player2BPComponent;
			}
			catch
			{
			}
		}
	}

	[HarmonyPatch(typeof(PlayerNameTag), "UpdatePlayerBPText", new Type[] { })]
	public static class UpdatePlayerBPText
	{
		private static void Postfix(ref PlayerNameTag __instance)
		{
			UpdateBP(__instance);
		}
	}

	[HarmonyPatch(typeof(PlayerTag), "RefreshFriendIcon", new Type[]
	{
		typeof(UserData),
		typeof(FriendStatus),
		typeof(bool)
	})]
	public static class RefreshFriendIcon
	{
		private static void Postfix(ref PlayerTag __instance, UserData userData, FriendStatus friendStatus, bool sendEvent)
		{
			playerTags.Add(__instance);
			UpdateBP(__instance);
		}
	}

	[HarmonyPatch(typeof(ScrollableList), "PageDown", new Type[] { })]
	public static class PageDown
	{
		private static void Postfix(ref ScrollableList __instance)
		{
			UpdateBPs();
		}
	}

	[HarmonyPatch(typeof(ScrollableList), "PageUp", new Type[] { })]
	public static class PageUp
	{
		private static void Postfix(ref ScrollableList __instance)
		{
			UpdateBPs();
		}
	}

	[HarmonyPatch(typeof(ScrollableList), "ScrollDown", new Type[] { })]
	public static class ScrollDown
	{
		private static void Postfix(ref ScrollableList __instance)
		{
			UpdateBPs();
		}
	}

	[HarmonyPatch(typeof(ScrollableList), "ScrollUp", new Type[] { })]
	public static class ScrollUp
	{
		private static void Postfix(ref ScrollableList __instance)
		{
			UpdateBPs();
		}
	}

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

		private object <>2__current;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if (Preferences.enabledInMatches.Value)
				{
					((TMP_Text)matchInfoPlayer1BP).text = "??????";
				}
				if (Preferences.hideOwn.Value)
				{
					((TMP_Text)matchInfoPlayer2BP).text = "??????";
				}
				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 bool hasMatchInfo = false;

	private static TextMeshPro matchInfoPlayer1BP;

	private static TextMeshPro matchInfoPlayer2BP;

	private static readonly List<PlayerTag> playerTags = new List<PlayerTag>();

	public override void OnLateInitializeMelon()
	{
		Actions.onMapInitialized += MapInit;
	}

	public override void OnInitializeMelon()
	{
		Preferences.InitPrefs();
		((ModelModItem)UI.Register((MelonBase)(object)this, (MelonPreferences_Category[])(object)new MelonPreferences_Category[1] { Preferences.BPHiderMainCategory })).OnModSaved += Save;
	}

	private void MapInit(string map)
	{
		playerTags.Clear();
		if (hasMatchInfo && map.Contains("Map"))
		{
			MelonCoroutines.Start(HideMatchInfoBP());
		}
	}

	[IteratorStateMachine(typeof(<HideMatchInfoBP>d__7))]
	private static IEnumerator HideMatchInfoBP()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <HideMatchInfoBP>d__7(0);
	}

	private static void Save()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		Scene activeScene = SceneManager.GetActiveScene();
		string name = ((Scene)(ref activeScene)).name;
		bool flag = Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.hideOwn);
		bool flag2 = Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.enabledInMatches);
		bool flag3 = Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.enabledInGym);
		bool flag4 = Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.enabledInParks);
		Preferences.StoreLastSavedPrefs();
		if (!name.Contains("Map") && (flag || flag3 || flag4))
		{
			UpdateBPs();
		}
		else
		{
			if (!name.Contains("Map") || !(flag2 || flag))
			{
				return;
			}
			for (int i = 1; i < Singleton<PlayerManager>.instance.AllPlayers.Count; i++)
			{
				UpdateBP(Singleton<PlayerManager>.instance.AllPlayers[i].Controller.PlayerNameTag);
			}
			if (hasMatchInfo)
			{
				try
				{
					((TMP_Text)matchInfoPlayer1BP).text = (Preferences.enabledInMatches.Value ? "????? BP" : Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.BattlePoints.ToString());
				}
				catch
				{
					return;
				}
				try
				{
					((TMP_Text)matchInfoPlayer2BP).text = (Preferences.hideOwn.Value ? "????? BP" : Singleton<PlayerManager>.instance.localPlayer.Data.GeneralData.BattlePoints.ToString());
				}
				catch
				{
				}
			}
		}
	}

	private static void UpdateBPs()
	{
		foreach (PlayerTag playerTag in playerTags)
		{
			UpdateBP(playerTag);
		}
	}

	private static void UpdateBP(PlayerNameTag nameTag)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		Scene activeScene = SceneManager.GetActiveScene();
		string name = ((Scene)(ref activeScene)).name;
		if (Singleton<PlayerManager>.instance.localPlayer.Data.GeneralData.PublicUsername == nameTag.playerNameText.text)
		{
			nameTag.playerBPAmountText.text = (Preferences.hideOwn.Value ? "??????" : ((PlayerControllerSubsystem)nameTag).parentController.assignedPlayer.Data.GeneralData.BattlePoints.ToString());
			return;
		}
		switch (name)
		{
		case "Gym":
			nameTag.playerBPAmountText.text = (Preferences.enabledInGym.Value ? "??????" : ((PlayerControllerSubsystem)nameTag).parentController.assignedPlayer.Data.GeneralData.BattlePoints.ToString());
			break;
		case "Park":
			nameTag.playerBPAmountText.text = (Preferences.enabledInParks.Value ? "??????" : ((PlayerControllerSubsystem)nameTag).parentController.assignedPlayer.Data.GeneralData.BattlePoints.ToString());
			break;
		case "Map0":
		case "Map1":
			nameTag.playerBPAmountText.text = (Preferences.enabledInMatches.Value ? "??????" : ((PlayerControllerSubsystem)nameTag).parentController.assignedPlayer.Data.GeneralData.BattlePoints.ToString());
			break;
		}
	}

	private static void UpdateBP(PlayerTag playerTag)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		Scene activeScene = SceneManager.GetActiveScene();
		string name = ((Scene)(ref activeScene)).name;
		if (playerTag.UserData.publicName == Singleton<PlayerManager>.instance.localPlayer.Data.GeneralData.PublicUsername)
		{
			playerTag.battlePoints.text = (Preferences.hideOwn.Value ? "??????" : playerTag.UserData.battlePoints.ToString());
			return;
		}
		switch (name)
		{
		case "Gym":
			playerTag.battlePoints.text = (Preferences.enabledInGym.Value ? "??????" : playerTag.UserData.battlePoints.ToString());
			break;
		case "Park":
			playerTag.battlePoints.text = (Preferences.enabledInParks.Value ? "??????" : playerTag.UserData.battlePoints.ToString());
			break;
		case "Map0":
		case "Map1":
			playerTag.battlePoints.text = (Preferences.enabledInMatches.Value ? "??????" : playerTag.UserData.battlePoints.ToString());
			break;
		}
	}
}
public class Preferences
{
	private const string CONFIG_FILE = "config.cfg";

	private const string USER_DATA = "UserData/BPHider/";

	internal static MelonPreferences_Category BPHiderMainCategory;

	internal static MelonPreferences_Entry<bool> hideOwn;

	internal static MelonPreferences_Entry<bool> enabledInMatches;

	internal static MelonPreferences_Entry<bool> enabledInGym;

	internal static MelonPreferences_Entry<bool> enabledInParks;

	internal static Dictionary<MelonPreferences_Entry, object> LastSavedValues = new Dictionary<MelonPreferences_Entry, object>();

	internal static void InitPrefs()
	{
		if (!Directory.Exists("UserData/BPHider/"))
		{
			Directory.CreateDirectory("UserData/BPHider/");
		}
		BPHiderMainCategory = MelonPreferences.CreateCategory("BPHider", "Settings");
		BPHiderMainCategory.SetFilePath(Path.Combine("UserData/BPHider/", "config.cfg"));
		hideOwn = BPHiderMainCategory.CreateEntry<bool>("HideYourBP", true, "Hide Your BP", "Toggles Your BPs On/Off", false, false, (ValueValidator)null, (string)null);
		enabledInMatches = BPHiderMainCategory.CreateEntry<bool>("Hide in Matches", true, "Hide in Matches", "Toggles BPs On/Off in Matches", false, false, (ValueValidator)null, (string)null);
		enabledInGym = BPHiderMainCategory.CreateEntry<bool>("HideInGym", true, "Hide in Gym", "Toggles BPs On/Off in the Gym", false, false, (ValueValidator)null, (string)null);
		enabledInParks = BPHiderMainCategory.CreateEntry<bool>("Hide in Parks", true, "Hide in Parks", "Toggles BPs On/Off in Parks", false, false, (ValueValidator)null, (string)null);
		StoreLastSavedPrefs();
	}

	internal static void StoreLastSavedPrefs()
	{
		List<MelonPreferences_Entry> list = new List<MelonPreferences_Entry>();
		list.AddRange(BPHiderMainCategory.Entries);
		foreach (MelonPreferences_Entry item in list)
		{
			LastSavedValues[item] = item.BoxedValue;
		}
	}

	public static bool AnyPrefsChanged()
	{
		foreach (KeyValuePair<MelonPreferences_Entry, object> lastSavedValue in LastSavedValues)
		{
			if (!lastSavedValue.Key.BoxedValue.Equals(lastSavedValue.Value))
			{
				return true;
			}
		}
		return false;
	}

	public static bool IsPrefChanged(MelonPreferences_Entry entry)
	{
		if (LastSavedValues.TryGetValue(entry, out var value))
		{
			return !entry.BoxedValue.Equals(value);
		}
		return false;
	}
}