using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using FirstPersonGB;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Reflection;
using MelonLoader;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(FirstPersonGBMod), "FirstPersonGB", "1.2.1", "KMK And Zooks", null)]
[assembly: MelonGame("Boneloaf", "Gang Beasts")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("FirstPersonGB")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("First Person for GB")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("FirstPersonGB")]
[assembly: AssemblyTitle("FirstPersonGB")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace FirstPersonGB
{
	public class FirstPersonGBMod : MelonMod
	{
		private bool isFirstPerson;

		private bool wantsFirstPerson;

		private string currentSceneName = "";

		private float sceneLoadTimer;

		private float audioScanTimer;

		private float retrySearchTimer;

		private Transform playerHead;

		private Camera mainCamera;

		private Transform mainCamTransform;

		private float originalFOV;

		private float originalNearClip;

		private float pitch;

		private float yaw;

		private readonly float mouseSensitivity = 0.16f;

		private readonly float controllerSensitivity = 145f;

		private readonly float positionSmoothSpeed = 48f;

		private bool justToggled;

		private Dictionary<Renderer, bool> hiddenRenderers = new Dictionary<Renderer, bool>();

		private Dictionary<SkinnedMeshRenderer, bool> originalUpdateOffscreen = new Dictionary<SkinnedMeshRenderer, bool>();

		private Dictionary<SkinnedMeshRenderer, Bounds> originalMeshBounds = new Dictionary<SkinnedMeshRenderer, Bounds>();

		private List<MonoBehaviour> disabledScripts = new List<MonoBehaviour>();

		private static readonly string[] headKeywords = new string[40]
		{
			"actor_head_collider", "actor_head_skinnedMesh", "helper_voiceBox", "head", "skull", "face", "eye", "eyeball", "pupil", "iris",
			"eyelid", "eyebrow", "brow", "mouth", "lip", "teeth", "tooth", "tongue", "jaw", "chin",
			"nose", "ear", "hair", "wig", "hat", "cap", "helmet", "helm", "hardhat", "hood",
			"beanie", "mask", "visor", "glasses", "goggles", "beard", "mustache", "stache", "collar", "neck"
		};

		public override void OnInitializeMelon()
		{
			MelonLogger.Msg("FirstPersonGB v1.2.1 P Loaded (Optimized).");
			MelonLogger.Msg("Toggle Key: K (Keyboard) or Right-Stick-Click (Controller).");
		}

		public override void OnUpdate()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				if (currentSceneName != name)
				{
					MelonLogger.Msg($"[Scene Management] Loading Scene Change: '{currentSceneName}' -> '{name}'");
					currentSceneName = name;
					if (isFirstPerson)
					{
						ForceDisableFirstPerson();
					}
					if (wantsFirstPerson)
					{
						sceneLoadTimer = 1.5f;
					}
				}
				if (sceneLoadTimer > 0f)
				{
					sceneLoadTimer -= Time.deltaTime;
					if (sceneLoadTimer <= 0f && wantsFirstPerson)
					{
						TryEnableFirstPerson();
					}
				}
				if (wantsFirstPerson && !isFirstPerson && sceneLoadTimer <= 0f)
				{
					retrySearchTimer += Time.deltaTime;
					if (retrySearchTimer >= 0.25f)
					{
						retrySearchTimer = 0f;
						TryEnableFirstPerson();
					}
				}
				audioScanTimer += Time.deltaTime;
				if (audioScanTimer >= 1.5f)
				{
					audioScanTimer = 0f;
					ScanAndBoostWarpAudio();
				}
				bool flag = false;
				if (Keyboard.current != null && ((ButtonControl)Keyboard.current.kKey).wasPressedThisFrame)
				{
					flag = true;
				}
				if (Gamepad.current != null && Gamepad.current.rightStickButton.wasPressedThisFrame)
				{
					flag = true;
				}
				if (flag)
				{
					if (!isFirstPerson)
					{
						wantsFirstPerson = true;
						TryEnableFirstPerson();
					}
					else
					{
						wantsFirstPerson = false;
						ForceDisableFirstPerson();
					}
				}
				if (isFirstPerson && ((Object)(object)playerHead == (Object)null || !((Component)playerHead).gameObject.activeInHierarchy))
				{
					MelonLogger.Warning("[FP Safety] Target Lost. Reverting to Third Person.");
					ForceDisableFirstPerson();
					if (wantsFirstPerson)
					{
						retrySearchTimer = 0f;
					}
				}
			}
			catch (Exception value)
			{
				MelonLogger.Error($"[OnUpdate Error] Exception: {value}");
			}
		}

		public override void OnFixedUpdate()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (isFirstPerson && (Object)(object)mainCamTransform != (Object)null)
			{
				mainCamTransform.rotation = Quaternion.Euler(pitch, yaw, 0f);
			}
		}

		public override void OnLateUpdate()
		{
			if (isFirstPerson)
			{
				UpdateVisualCamera();
			}
		}

		private void ScanAndBoostWarpAudio()
		{
			try
			{
				AudioSource[] array = Il2CppArrayBase<AudioSource>.op_Implicit(Object.FindObjectsOfType<AudioSource>());
				int num = array.Length;
				for (int i = 0; i < num; i++)
				{
					AudioSource val = array[i];
					if (!((Object)(object)val == (Object)null) && !((Object)(object)val.clip == (Object)null) && ((Object)val.clip).name.IndexOf("Warp 1", StringComparison.OrdinalIgnoreCase) >= 0 && val.volume < 1f)
					{
						val.volume = 1f;
						MelonLogger.Msg($"[Audio Match] Boosted '{((Object)val.clip).name}' on [{((Object)((Component)val).gameObject).name}] to 100% volume.");
					}
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Error("[Audio Error] Scan registry failure: " + ex.Message);
			}
		}

		private void TryEnableFirstPerson()
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				mainCamera = Camera.main;
				if ((Object)(object)mainCamera == (Object)null)
				{
					MelonLogger.Error("[FP Mode] Main Camera is null!");
					return;
				}
				mainCamTransform = ((Component)mainCamera).transform;
				SmartFindLocalPlayer();
				if (!((Object)(object)playerHead == (Object)null))
				{
					MelonLogger.Msg("[FP Mode] Found local actor head '" + ((Object)playerHead).name + "'. Mounting camera...");
					originalFOV = mainCamera.fieldOfView;
					originalNearClip = mainCamera.nearClipPlane;
					mainCamera.fieldOfView = 125f;
					mainCamera.nearClipPlane = 0.01f;
					disabledScripts.Clear();
					Transform parent = mainCamTransform;
					while ((Object)(object)parent != (Object)null)
					{
						DisableTrackingScripts(((Component)parent).gameObject);
						parent = parent.parent;
					}
					Quaternion rotation = playerHead.rotation;
					Vector3 eulerAngles = ((Quaternion)(ref rotation)).eulerAngles;
					yaw = eulerAngles.y;
					pitch = eulerAngles.x;
					Cursor.lockState = (CursorLockMode)1;
					Cursor.visible = false;
					ApplyHighlyOptimizedRendering();
					isFirstPerson = true;
					justToggled = true;
					MelonLogger.Msg("[FP Mode] Mounted successfully.");
				}
			}
			catch (Exception value)
			{
				MelonLogger.Error($"[FP Mode Error] Activation failure: {value}");
			}
		}

		private void ForceDisableFirstPerson()
		{
			try
			{
				isFirstPerson = false;
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
				RestoreVisibility();
				if ((Object)(object)mainCamera != (Object)null)
				{
					mainCamera.fieldOfView = originalFOV;
					mainCamera.nearClipPlane = originalNearClip;
					int count = disabledScripts.Count;
					for (int i = 0; i < count; i++)
					{
						if ((Object)(object)disabledScripts[i] != (Object)null)
						{
							((Behaviour)disabledScripts[i]).enabled = true;
						}
					}
				}
				disabledScripts.Clear();
				playerHead = null;
				mainCamTransform = null;
				MelonLogger.Msg("[FP Mode] Restored system back to Third Person.");
			}
			catch (Exception value)
			{
				MelonLogger.Error($"[FP Mode Error] Restoration failure: {value}");
			}
		}

		private void DisableTrackingScripts(GameObject obj)
		{
			MonoBehaviour[] array = Il2CppArrayBase<MonoBehaviour>.op_Implicit(obj.GetComponents<MonoBehaviour>());
			int num = array.Length;
			for (int i = 0; i < num; i++)
			{
				MonoBehaviour val = array[i];
				if (!((Object)(object)val == (Object)null))
				{
					string text = ((MemberInfo)((Object)val).GetIl2CppType()).Name.ToLower();
					if (!text.Contains("postprocess") && !text.Contains("volume") && !text.Contains("amplify") && !text.Contains("layer") && !text.Contains("audio") && ((Behaviour)val).enabled)
					{
						((Behaviour)val).enabled = false;
						disabledScripts.Add(val);
						MelonLogger.Msg($"[FP Camera] Disabled camera scripts: {((Object)val).GetIl2CppType().FullName} on [{((Object)obj).name}]");
					}
				}
			}
		}

		private void SmartFindLocalPlayer()
		{
			playerHead = null;
			try
			{
				Component[] array = Il2CppArrayBase<Component>.op_Implicit(Object.FindObjectsOfType<Component>());
				Component val = null;
				int num = array.Length;
				for (int i = 0; i < num; i++)
				{
					Component val2 = array[i];
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					string name = ((MemberInfo)((Object)val2).GetIl2CppType()).Name;
					if (!(name == "Actor") && !(name == "ActorCore") && !name.EndsWith(".Actor"))
					{
						continue;
					}
					Type type = ((object)val2).GetType();
					PropertyInfo propertyInfo = type.GetProperty("IsAI") ?? type.GetProperty("isAI");
					if (propertyInfo != null)
					{
						try
						{
							if ((bool)propertyInfo.GetValue(val2, null))
							{
								continue;
							}
						}
						catch
						{
						}
					}
					PropertyInfo propertyInfo2 = type.GetProperty("isLocalPlayer") ?? type.GetProperty("IsLocal") ?? type.GetProperty("IsLocalPlayer");
					if (!(propertyInfo2 != null))
					{
						continue;
					}
					try
					{
						if ((bool)propertyInfo2.GetValue(val2, null))
						{
							val = val2;
							break;
						}
					}
					catch
					{
					}
				}
				if ((Object)(object)val != (Object)null)
				{
					Rigidbody[] array2 = Il2CppArrayBase<Rigidbody>.op_Implicit(((Component)val.transform.root).GetComponentsInChildren<Rigidbody>(true));
					int num2 = array2.Length;
					for (int j = 0; j < num2; j++)
					{
						Rigidbody val3 = array2[j];
						if ((Object)(object)val3 != (Object)null && ((Object)((Component)val3).gameObject).name.Equals("actor_head_collider", StringComparison.OrdinalIgnoreCase))
						{
							playerHead = ((Component)val3).transform;
							return;
						}
					}
				}
				Rigidbody[] array3 = Il2CppArrayBase<Rigidbody>.op_Implicit(Object.FindObjectsOfType<Rigidbody>());
				int num3 = array3.Length;
				for (int k = 0; k < num3; k++)
				{
					Rigidbody val4 = array3[k];
					if (!((Object)(object)val4 == (Object)null) && ((Object)((Component)val4).gameObject).name.Equals("actor_head_collider", StringComparison.OrdinalIgnoreCase))
					{
						Transform root = ((Component)val4).transform.root;
						if (((Object)root).name.IndexOf("[PlayerID: 0]", StringComparison.OrdinalIgnoreCase) >= 0 || ((Object)root).name.IndexOf("PlayerID: 0", StringComparison.OrdinalIgnoreCase) >= 0)
						{
							playerHead = ((Component)val4).transform;
							break;
						}
					}
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Error("[SmartFind Error] Local Player discovery failed: " + ex.Message);
			}
		}

		private void ApplyHighlyOptimizedRendering()
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			hiddenRenderers.Clear();
			originalUpdateOffscreen.Clear();
			originalMeshBounds.Clear();
			if ((Object)(object)playerHead == (Object)null)
			{
				return;
			}
			Renderer[] array = Il2CppArrayBase<Renderer>.op_Implicit(((Component)playerHead.root).GetComponentsInChildren<Renderer>(true));
			int num = array.Length;
			for (int i = 0; i < num; i++)
			{
				Renderer val = array[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				bool flag = false;
				string name = ((Object)((Component)val).gameObject).name;
				SkinnedMeshRenderer val2 = ((Il2CppObjectBase)val).TryCast<SkinnedMeshRenderer>();
				if ((Object)(object)val2 != (Object)null)
				{
					originalUpdateOffscreen[val2] = val2.updateWhenOffscreen;
					originalMeshBounds[val2] = ((Renderer)val2).localBounds;
					val2.updateWhenOffscreen = true;
					((Renderer)val2).localBounds = new Bounds(Vector3.zero, Vector3.one * 50f);
				}
				if (IsHeadRelated(name))
				{
					flag = true;
				}
				if (!flag)
				{
					Transform parent = ((Component)val).transform.parent;
					while ((Object)(object)parent != (Object)null && (Object)(object)parent != (Object)(object)playerHead.root)
					{
						if (IsHeadRelated(((Object)parent).name))
						{
							flag = true;
							break;
						}
						parent = parent.parent;
					}
				}
				if (!flag && (Object)(object)val2 != (Object)null && (Object)(object)val2.sharedMesh != (Object)null && IsHeadRelated(((Object)val2.sharedMesh).name))
				{
					flag = true;
				}
				if (flag)
				{
					hiddenRenderers[val] = val.enabled;
					val.enabled = false;
					MelonLogger.Msg("[Renderer Manager] Completely Hid Head Component: [" + name + "]");
				}
			}
		}

		private bool IsHeadRelated(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			int num = headKeywords.Length;
			for (int i = 0; i < num; i++)
			{
				if (name.IndexOf(headKeywords[i], StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		private void RestoreVisibility()
		{
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				foreach (KeyValuePair<Renderer, bool> hiddenRenderer in hiddenRenderers)
				{
					if ((Object)(object)hiddenRenderer.Key != (Object)null)
					{
						hiddenRenderer.Key.enabled = hiddenRenderer.Value;
					}
				}
				hiddenRenderers.Clear();
				foreach (KeyValuePair<SkinnedMeshRenderer, bool> item in originalUpdateOffscreen)
				{
					if ((Object)(object)item.Key != (Object)null)
					{
						item.Key.updateWhenOffscreen = item.Value;
					}
				}
				originalUpdateOffscreen.Clear();
				foreach (KeyValuePair<SkinnedMeshRenderer, Bounds> originalMeshBound in originalMeshBounds)
				{
					if ((Object)(object)originalMeshBound.Key != (Object)null)
					{
						((Renderer)originalMeshBound.Key).localBounds = originalMeshBound.Value;
					}
				}
				originalMeshBounds.Clear();
				MelonLogger.Msg("[FP Mode] Meshes and visibility states completely restored.");
			}
			catch (Exception value)
			{
				MelonLogger.Error($"[Restoration Error] Reverting pipeline states failed: {value}");
			}
		}

		private void UpdateVisualCamera()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			if (!isFirstPerson || (Object)(object)mainCamTransform == (Object)null || (Object)(object)playerHead == (Object)null)
			{
				return;
			}
			Vector3 val = playerHead.up * 0.48f + playerHead.forward * 0.07f;
			Vector3 val2 = playerHead.position + val;
			if (Mouse.current != null)
			{
				Vector2 val3 = ((InputControl<Vector2>)(object)((Pointer)Mouse.current).delta).ReadValue();
				yaw += val3.x * mouseSensitivity;
				pitch -= val3.y * mouseSensitivity;
			}
			if (Gamepad.current != null)
			{
				Vector2 val4 = ((InputControl<Vector2>)(object)Gamepad.current.rightStick).ReadValue();
				if (((Vector2)(ref val4)).sqrMagnitude > 0.005f)
				{
					yaw += val4.x * controllerSensitivity * Time.deltaTime;
					pitch -= val4.y * controllerSensitivity * Time.deltaTime;
				}
			}
			pitch = Mathf.Clamp(pitch, -85f, 85f);
			Quaternion rotation = Quaternion.Euler(pitch, yaw, 0f);
			if (pitch > 0f)
			{
				float num = Mathf.InverseLerp(0f, 85f, pitch);
				val2 += mainCamTransform.forward * (num * 0.18f);
			}
			if (justToggled)
			{
				mainCamTransform.position = val2;
				mainCamTransform.rotation = rotation;
				justToggled = false;
			}
			else
			{
				mainCamTransform.position = Vector3.Lerp(mainCamTransform.position, val2, Time.deltaTime * positionSmoothSpeed);
				mainCamTransform.rotation = rotation;
			}
		}
	}
}