using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using MelonLoader;
using ModThatIsNotMod;
using UnityEngine;
using UpperArmCollision;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(Main), "uppercollision", "1.0.0", "ffba", null)]
[assembly: MelonGame("Stress Level Zero", "BONEWORKS")]
[assembly: AssemblyTitle("upperarmscollision")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("HP")]
[assembly: AssemblyProduct("upperarmscollision")]
[assembly: AssemblyCopyright("Copyright © HP 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("250b7369-899e-43b5-856f-89a43d9767b0")]
[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 UpperArmCollision;

public class Main : MelonMod
{
	[CompilerGenerated]
	private sealed class <SetupCollidersCoroutine>d__4 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Main <>4__this;

		private GameObject <rigManager>5__2;

		private int <attempts>5__3;

		private int <i>5__4;

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

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

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

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

		private bool MoveNext()
		{
			int num = <>1__state;
			Main main = <>4__this;
			switch (num)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				MelonLogger.Msg("Starting collider setup...");
				<i>5__4 = 0;
				goto IL_0069;
			case 1:
				<>1__state = -1;
				<i>5__4++;
				goto IL_0069;
			case 2:
				<>1__state = -1;
				goto IL_00b7;
			case 3:
				{
					<>1__state = -1;
					<i>5__4++;
					break;
				}
				IL_0069:
				if (<i>5__4 < 10)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				<rigManager>5__2 = null;
				<attempts>5__3 = 0;
				goto IL_00b7;
				IL_00b7:
				if ((Object)(object)<rigManager>5__2 == (Object)null && <attempts>5__3 < 300)
				{
					<rigManager>5__2 = Player.GetRigManager();
					<attempts>5__3++;
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				if ((Object)(object)<rigManager>5__2 == (Object)null)
				{
					MelonLogger.Error("Failed to find RigManager!");
					return false;
				}
				MelonLogger.Msg("Found RigManager: " + ((Object)<rigManager>5__2).name);
				<i>5__4 = 0;
				break;
			}
			if (<i>5__4 < 5)
			{
				<>2__current = null;
				<>1__state = 3;
				return true;
			}
			Transform val = main.FindChildRecursive(<rigManager>5__2.transform, "r_Arm_ShoulderSHJnt");
			if ((Object)(object)val != (Object)null)
			{
				MelonLogger.Msg("Found right shoulder: " + ((Object)val).name);
				main.AddArmCollider(val, isLeft: false);
			}
			else
			{
				MelonLogger.Error("Right shoulder bone not found!");
			}
			Transform val2 = main.FindChildRecursive(<rigManager>5__2.transform, "l_Arm_ShoulderSHJnt");
			if ((Object)(object)val2 != (Object)null)
			{
				MelonLogger.Msg("Found left shoulder: " + ((Object)val2).name);
				main.AddArmCollider(val2, isLeft: true);
			}
			else
			{
				MelonLogger.Error("Left shoulder bone not found!");
			}
			Transform val3 = main.FindChildRecursive(<rigManager>5__2.transform, "r_Arm_Elbow_CurveSHJnt");
			if ((Object)(object)val3 != (Object)null)
			{
				MelonLogger.Msg("Found right elbow: " + ((Object)val3).name);
				main.AddElbowCollider(val3, isLeft: false);
			}
			else
			{
				MelonLogger.Error("Right elbow bone not found!");
			}
			Transform val4 = main.FindChildRecursive(<rigManager>5__2.transform, "l_Arm_Elbow_CurveSHJnt");
			if ((Object)(object)val4 != (Object)null)
			{
				MelonLogger.Msg("Found left elbow: " + ((Object)val4).name);
				main.AddElbowCollider(val4, isLeft: true);
			}
			else
			{
				MelonLogger.Error("Left elbow bone not found!");
			}
			GameObject val5 = main.FindGameObjectRecursive(<rigManager>5__2.transform, "r_foreArm_col");
			if ((Object)(object)val5 != (Object)null)
			{
				CapsuleCollider component = val5.GetComponent<CapsuleCollider>();
				if ((Object)(object)component != (Object)null)
				{
					if (main.prefRedoneElbows != null && main.prefRedoneElbows.Value)
					{
						((Collider)component).enabled = false;
						MelonLogger.Msg("Disabled r_foreArm_col (Redone Elbows enabled)");
					}
					else
					{
						((Collider)component).enabled = true;
						MelonLogger.Msg("Enabled r_foreArm_col");
					}
				}
			}
			GameObject val6 = main.FindGameObjectRecursive(<rigManager>5__2.transform, "l_foreArm_col");
			if ((Object)(object)val6 != (Object)null)
			{
				CapsuleCollider component2 = val6.GetComponent<CapsuleCollider>();
				if ((Object)(object)component2 != (Object)null)
				{
					if (main.prefRedoneElbows != null && main.prefRedoneElbows.Value)
					{
						((Collider)component2).enabled = false;
						MelonLogger.Msg("Disabled l_foreArm_col (Redone Elbows enabled)");
					}
					else
					{
						((Collider)component2).enabled = true;
						MelonLogger.Msg("Enabled l_foreArm_col");
					}
				}
			}
			MelonLogger.Msg("Collider setup complete!");
			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 MelonPreferences_Category prefCategory;

	public MelonPreferences_Entry<bool> prefRedoneElbows;

	public override void OnUpdate()
	{
	}

	public override void OnSceneWasLoaded(int buildIndex, string sceneName)
	{
		MelonLogger.Msg("Scene loaded: " + sceneName);
		MelonCoroutines.Start(SetupCollidersCoroutine());
	}

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

	private void AddArmCollider(Transform bone, bool isLeft)
	{
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		CapsuleCollider val = ((Component)bone).gameObject.AddComponent<CapsuleCollider>();
		val.direction = 0;
		val.radius = 0.036f;
		val.height = 0.3f;
		if (isLeft)
		{
			val.center = new Vector3(-0.175f, 0f, 0f);
		}
		else
		{
			val.center = new Vector3(0.175f, 0f, 0f);
		}
		((Component)bone).gameObject.layer = 16;
	}

	private void AddElbowCollider(Transform bone, bool isLeft)
	{
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		CapsuleCollider val = ((Component)bone).gameObject.AddComponent<CapsuleCollider>();
		val.direction = 0;
		if (prefRedoneElbows != null && prefRedoneElbows.Value)
		{
			val.radius = 0.0355f;
			val.height = 0.295f;
			val.center = (isLeft ? new Vector3(-0.1f, 0f, 0f) : new Vector3(0.1f, 0f, 0f));
		}
		else
		{
			val.radius = 0.035f;
			val.height = 0.16f;
			val.center = new Vector3(0f, 0f, 0f);
		}
		((Component)bone).gameObject.layer = 16;
	}

	private Transform FindChildRecursive(Transform parent, string childName)
	{
		if (((Object)parent).name == childName)
		{
			return parent;
		}
		for (int i = 0; i < parent.childCount; i++)
		{
			Transform val = FindChildRecursive(parent.GetChild(i), childName);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
		}
		return null;
	}

	private GameObject FindGameObjectRecursive(Transform parent, string objectName)
	{
		if (((Object)((Component)parent).gameObject).name == objectName)
		{
			return ((Component)parent).gameObject;
		}
		for (int i = 0; i < parent.childCount; i++)
		{
			GameObject val = FindGameObjectRecursive(parent.GetChild(i), objectName);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
		}
		return null;
	}
}