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.InteropServices;
using System.Runtime.Versioning;
using Il2CppRUMBLE.Managers;
using Il2CppRUMBLE.Players.Scaling;
using Il2CppRUMBLE.Utilities;
using Il2CppTMPro;
using LoaderSkipper;
using MelonLoader;
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), "LoaderSkipper", "3.1.1", "UlvakSkillz", null)]
[assembly: MelonGame("Buckethead Entertainment", "RUMBLE")]
[assembly: MelonColor(255, 195, 0, 255)]
[assembly: MelonAuthorColor(255, 195, 0, 255)]
[assembly: VerifyLoaderVersion(0, 6, 2, true)]
[assembly: AssemblyTitle("LoaderSkipper")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LoaderSkipper")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("924f355c-9d5e-4b6d-9104-9e3d94766e61")]
[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 LoaderSkipper;

public class main : MelonMod
{
	[CompilerGenerated]
	private sealed class <CheckIfFileExists>d__25 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public string filePath;

		public string fileName;

		public main <>4__this;

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

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

		[DebuggerHidden]
		public <CheckIfFileExists>d__25(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 (!File.Exists(filePath + "\\" + fileName) || !File.Exists(FILEPATHLastTPose))
				{
					if (!Directory.Exists(filePath))
					{
						MelonLogger.Msg("Folder Not Found, Creating Folder: " + filePath);
						Directory.CreateDirectory(filePath);
					}
					if (!File.Exists(filePath + "\\" + fileName))
					{
						MelonLogger.Msg("Creating File " + filePath + "\\" + fileName);
						File.Create(filePath + "\\" + fileName);
					}
					if (!File.Exists(FILEPATHLastTPose))
					{
						MelonLogger.Msg("Creating File " + FILEPATHLastTPose);
						File.Create(FILEPATHLastTPose);
					}
				}
				else
				{
					<>4__this.fileText = <>4__this.ReadFileText(filePath + "\\" + fileName);
				}
				<>2__current = null;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				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 <StartGymLoad>d__19 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public main <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				Singleton<SceneManager>.instance.PerformStartupGymLoad();
				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 GameObject status;

	private string currentScene = "Loader";

	private bool sceneChanged = false;

	private bool init = false;

	private string[] fileText;

	private string FILEPATH = "UserData\\LoaderSkipper";

	private string FILENAME = "OverrideLastTpose.txt";

	private static string FILEPATHLastTPose = "UserData\\LoaderSkipper\\LastTpose.txt";

	private bool tPoseSet = false;

	private static Transform[] measurements = (Transform[])(object)new Transform[4];

	private GameObject head;

	private GameObject lController;

	private GameObject rController;

	private GameObject root;

	private PlayerMeasurement playerMeasurement;

	private bool measurementGot = false;

	private bool loading = false;

	public override void OnFixedUpdate()
	{
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: Unknown result type (might be due to invalid IL or missing references)
		//IL_0168: Unknown result type (might be due to invalid IL or missing references)
		//IL_016d: 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)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		if (sceneChanged)
		{
			try
			{
				if (currentScene == "Loader")
				{
					status = GameObject.Find("________________SCENE_________________/Text/Measuring/TextCanvas/Status");
					init = true;
				}
			}
			catch
			{
				return;
			}
			if (currentScene == "Gym")
			{
				if (measurementGot || Singleton<PlayerManager>.instance.localPlayer == null || Singleton<PlayerManager>.instance.localPlayer.Data == null)
				{
					return;
				}
				playerMeasurement = Singleton<PlayerManager>.instance.localPlayer.Data.PlayerMeasurement;
				measurementGot = true;
			}
			if (!tPoseSet && currentScene == "Gym")
			{
				SetTPose();
				tPoseSet = true;
			}
			sceneChanged = false;
		}
		if (measurementGot && (playerMeasurement.ArmSpan != Singleton<PlayerManager>.instance.localPlayer.Data.PlayerMeasurement.ArmSpan || playerMeasurement.Length != Singleton<PlayerManager>.instance.localPlayer.Data.PlayerMeasurement.Length))
		{
			StoreTPose();
			playerMeasurement = Singleton<PlayerManager>.instance.localPlayer.Data.PlayerMeasurement;
		}
		if (init && !loading && currentScene == "Loader" && ((TMP_Text)status.GetComponent<TextMeshProUGUI>()).text == "Ready to RUMBLE!")
		{
			loading = true;
			MelonCoroutines.Start(StartGymLoad());
		}
	}

	private void Log(string msg)
	{
		MelonLogger.Msg(msg);
	}

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

	public void SetTPose()
	{
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Expected O, but got Unknown
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Expected O, but got Unknown
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Expected O, but got Unknown
		//IL_012c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0138: Unknown result type (might be due to invalid IL or missing references)
		//IL_0142: Expected O, but got Unknown
		//IL_0177: Unknown result type (might be due to invalid IL or missing references)
		//IL_01be: Unknown result type (might be due to invalid IL or missing references)
		//IL_01da: Unknown result type (might be due to invalid IL or missing references)
		//IL_01df: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			fileText = File.ReadAllLines(FILEPATH + "\\" + FILENAME);
			if (fileText.Length < 12)
			{
				MelonLogger.Msg("Override not Set, Loading Last T-Pose");
				fileText = File.ReadAllLines(FILEPATHLastTPose);
			}
			else
			{
				MelonLogger.Msg("Override Found, Loading Override Measurements");
			}
			head = new GameObject();
			head.transform.position = new Vector3(float.Parse(fileText[0]), float.Parse(fileText[1]), float.Parse(fileText[2]));
			lController = new GameObject();
			lController.transform.position = new Vector3(float.Parse(fileText[3]), float.Parse(fileText[4]), float.Parse(fileText[5]));
			rController = new GameObject();
			rController.transform.position = new Vector3(float.Parse(fileText[6]), float.Parse(fileText[7]), float.Parse(fileText[8]));
			root = new GameObject();
			root.transform.position = new Vector3(float.Parse(fileText[9]), float.Parse(fileText[10]), float.Parse(fileText[11]));
			Singleton<PlayerManager>.instance.localPlayer.Data.SetMeasurement(PlayerMeasurement.Create(head.transform, lController.transform, rController.transform, root.transform, true), true);
			playerMeasurement = Singleton<PlayerManager>.instance.localPlayer.Data.PlayerMeasurement;
			Object.Destroy((Object)(object)head);
			Object.Destroy((Object)(object)lController);
			Object.Destroy((Object)(object)rController);
			Object.Destroy((Object)(object)root);
			MelonLogger.Msg("TPose Loaded: " + ((object)(PlayerMeasurement)(ref playerMeasurement)).ToString());
		}
		catch (Exception ex)
		{
			MelonLogger.Error("Error Setting TPose, Please T-Pose In Game: " + ex);
		}
	}

	public static void StoreTPose()
	{
		//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0112: Unknown result type (might be due to invalid IL or missing references)
		//IL_0129: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0145: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0161: Unknown result type (might be due to invalid IL or missing references)
		//IL_0166: Unknown result type (might be due to invalid IL or missing references)
		//IL_017d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0182: Unknown result type (might be due to invalid IL or missing references)
		//IL_0199: Unknown result type (might be due to invalid IL or missing references)
		//IL_019e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_0212: Unknown result type (might be due to invalid IL or missing references)
		//IL_0217: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			measurements[0] = ((Component)Singleton<PlayerManager>.instance.localPlayer.Controller).gameObject.transform.GetChild(2).GetChild(0).GetChild(0);
			measurements[1] = ((Component)Singleton<PlayerManager>.instance.localPlayer.Controller).gameObject.transform.GetChild(2).GetChild(1).GetChild(0);
			measurements[2] = ((Component)Singleton<PlayerManager>.instance.localPlayer.Controller).gameObject.transform.GetChild(2).GetChild(2).GetChild(0);
			measurements[3] = ((Component)Singleton<PlayerManager>.instance.localPlayer.Controller).gameObject.transform.GetChild(2).GetChild(3);
			WriteToFile(new string[12]
			{
				measurements[0].position.x.ToString(),
				measurements[0].position.y.ToString(),
				measurements[0].position.z.ToString(),
				measurements[1].position.x.ToString(),
				measurements[1].position.y.ToString(),
				measurements[1].position.z.ToString(),
				measurements[2].position.x.ToString(),
				measurements[2].position.y.ToString(),
				measurements[2].position.z.ToString(),
				measurements[3].position.x.ToString(),
				(measurements[3].position.y - 0.06f).ToString(),
				measurements[3].position.z.ToString()
			}, FILEPATHLastTPose);
		}
		catch (Exception ex)
		{
			MelonLogger.Error((object)ex);
		}
	}

	public override void OnLateInitializeMelon()
	{
		MelonCoroutines.Start(CheckIfFileExists(FILEPATH, FILENAME));
	}

	public override void OnSceneWasLoaded(int buildIndex, string sceneName)
	{
		if (sceneName == "Loader")
		{
			loading = false;
		}
		currentScene = sceneName;
		sceneChanged = true;
	}

	public static void WriteToFile(string[] text, string outputFile)
	{
		if (File.Exists(outputFile))
		{
			try
			{
				List<string> list = new List<string>();
				File.WriteAllLines(outputFile, text);
				return;
			}
			catch (Exception ex)
			{
				MelonLogger.Error((object)ex);
				return;
			}
		}
		MelonLogger.Error("File not Found: Check Game Folder for " + outputFile);
	}

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

	public string[] ReadFileText(string inputFile)
	{
		if (File.Exists(inputFile))
		{
			try
			{
				List<string> list = new List<string>();
				return File.ReadAllLines(inputFile);
			}
			catch (Exception ex)
			{
				MelonLogger.Error((object)ex);
			}
		}
		else
		{
			MelonLogger.Error("File not Found: Check Game Folder for " + inputFile);
		}
		return null;
	}
}