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 Il2CppRUMBLE.Managers;
using Il2CppRUMBLE.Players.Subsystems;
using Il2CppRUMBLE.Poses;
using Il2CppRUMBLE.Utilities;
using Il2CppSystem.Collections.Generic;
using MelonLoader;
using MelonLoader.Preferences;
using MoveLimiter;
using UIFramework;
using UnityEngine;

[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), "MoveLimiter", "2.3.0", "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: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("MoveLimiter")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+665463085857c61d86eb48776e5f2f78633d6eb2")]
[assembly: AssemblyProduct("MoveLimiter")]
[assembly: AssemblyTitle("MoveLimiter")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace MoveLimiter;

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

	public const string ModVersion = "2.3.0";

	public const string Author = "UlvakSkillz";
}
public class Main : MelonMod
{
	[CompilerGenerated]
	private sealed class <WaitASecondBeforePlayerCheck>d__10 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public int sceneCount;

		public Main <>4__this;

		private bool <enabled>5__1;

		private int <i>5__2;

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

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

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

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

		private bool MoveNext()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<i>5__2 = 0;
				goto IL_006a;
			case 1:
				<>1__state = -1;
				<i>5__2++;
				goto IL_006a;
			case 2:
				<>1__state = -1;
				goto IL_009a;
			case 3:
				{
					<>1__state = -1;
					break;
				}
				IL_006a:
				if (<i>5__2 < 300)
				{
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 1;
					return true;
				}
				goto IL_009a;
				IL_009a:
				if ((Object)(object)Singleton<PlayerManager>.instance.localPlayer.Controller == (Object)null)
				{
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 2;
					return true;
				}
				<enabled>5__1 = ((Behaviour)((Component)((Component)Singleton<PlayerManager>.instance.localPlayer.Controller).gameObject.transform).GetComponentInChildren<PlayerPoseSystem>()).enabled;
				break;
			}
			if (!<enabled>5__1 && sceneCount == <>4__this.sceneChangeCount)
			{
				<enabled>5__1 = ((Behaviour)((Component)((Component)Singleton<PlayerManager>.instance.localPlayer.Controller).gameObject.transform).GetComponentInChildren<PlayerPoseSystem>()).enabled;
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 3;
				return true;
			}
			if (<enabled>5__1 && Singleton<PlayerManager>.instance.AllPlayers.Count == 2)
			{
				<>4__this.inAMatch = true;
				if (Preferences.PrefEnabled.Value)
				{
					<>4__this.ChangeAvailableMoves(Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.BattlePoints);
				}
			}
			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 bool sceneChanged = false;

	private string currentScene = "";

	private int sceneChangeCount = 0;

	private List<PoseInputSource> storedMoves = new List<PoseInputSource>();

	private bool inAMatch = false;

	public override void OnSceneWasLoaded(int buildIndex, string sceneName)
	{
		currentScene = sceneName;
		sceneChanged = true;
		inAMatch = false;
		sceneChangeCount++;
	}

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

	public void Save()
	{
		if (Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefEnabled))
		{
			UpdateAvailableMoves();
		}
	}

	public override void OnFixedUpdate()
	{
		if (sceneChanged)
		{
			if (currentScene == "Map0" || currentScene == "Map1")
			{
				MelonCoroutines.Start(WaitASecondBeforePlayerCheck(sceneChangeCount));
			}
			sceneChanged = false;
		}
	}

	private void UpdateAvailableMoves()
	{
		if (!inAMatch)
		{
			return;
		}
		if (Preferences.PrefEnabled.Value)
		{
			ChangeAvailableMoves(Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.BattlePoints);
			return;
		}
		string text = "";
		int num;
		for (num = 0; num < storedMoves.Count; num++)
		{
			List<PoseInputSource> currentInputPoses = ((Component)((Component)Singleton<PlayerManager>.instance.localPlayer.Controller).gameObject.transform).GetComponentInChildren<PlayerPoseSystem>().currentInputPoses;
			if (text != "")
			{
				text += ", ";
			}
			text += ((Object)storedMoves[num].poseSet).name;
			currentInputPoses.Add(storedMoves[num]);
			storedMoves.RemoveAt(num);
			num--;
		}
		if (text != "")
		{
			Melon<Main>.Logger.Msg("Restored Moves: " + text);
		}
	}

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

	public void ChangeAvailableMoves(int opponentBP)
	{
		if (opponentBP >= 156 || opponentBP >= Singleton<PlayerManager>.instance.localPlayer.Data.GeneralData.BattlePoints)
		{
			return;
		}
		List<string> list = new List<string>();
		string text = "White Belt";
		list.Add("PoseSetDisc");
		list.Add("PoseSetSpawnPillar");
		list.Add("PoseSetStraight");
		list.Add("SprintingPoseSet");
		if (opponentBP >= 12)
		{
			text = "Yellow Belt";
			list.Add("PoseSetBall");
			list.Add("PoseSetKick");
			list.Add("PoseSetStomp");
		}
		if (opponentBP >= 30)
		{
			text = "Green Belt";
			list.Add("PoseSetWall_Grounded");
			list.Add("PoseSetRockjump");
			list.Add("PoseSetUppercut");
		}
		if (opponentBP >= 54)
		{
			text = "Blue Belt";
			list.Add("PoseSetSpawnCube");
			list.Add("PoseSetDash");
		}
		if (opponentBP >= 96)
		{
			text = "Red Belt";
			list.Add("PoseSetParry");
			list.Add("PoseSetHoldLeft");
			list.Add("PoseSetHoldRight");
		}
		List<PoseInputSource> currentInputPoses = ((Component)((Component)Singleton<PlayerManager>.instance.localPlayer.Controller).gameObject.transform).GetComponentInChildren<PlayerPoseSystem>().currentInputPoses;
		string text2 = "";
		for (int i = 0; i < currentInputPoses.Count; i++)
		{
			bool flag = false;
			for (int j = 0; j < list.Count; j++)
			{
				if (((Object)currentInputPoses[i].poseSet).name == list[j])
				{
					flag = true;
				}
			}
			if (!flag)
			{
				if (text2 != "")
				{
					text2 += ", ";
				}
				text2 += ((Object)currentInputPoses[i].poseSet).name;
				storedMoves.Add(currentInputPoses[i]);
				currentInputPoses.RemoveAt(i);
				i--;
			}
		}
		if (text2 != "")
		{
			Melon<Main>.Logger.Msg("Facing " + text + ", Removing Poses: " + text2);
		}
	}
}
public class Preferences
{
	private const string CONFIG_FILE = "config.cfg";

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

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

	internal static MelonPreferences_Category SettingsCategory;

	internal static MelonPreferences_Entry<bool> PrefEnabled;

	internal static void InitPrefs()
	{
		if (!Directory.Exists("UserData/MoveLimiter/"))
		{
			Directory.CreateDirectory("UserData/MoveLimiter/");
		}
		SettingsCategory = MelonPreferences.CreateCategory("MoveLimiter", "Settings");
		SettingsCategory.SetFilePath(Path.Combine("UserData/MoveLimiter/", "config.cfg"));
		PrefEnabled = SettingsCategory.CreateEntry<bool>("Enabled", true, "Enabled", "Toggles the Mod On/Off", false, false, (ValueValidator)null, (string)null);
		StoreLastSavedPrefs();
	}

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

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