using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("galfarious.ThirdHand")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Third Hand Mod")]
[assembly: AssemblyTitle("galfarious.ThirdHand")]
[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 ThirdHand
{
	public static class LogManager
	{
		private static ManualLogSource _log;

		public static void Init(ManualLogSource log)
		{
			_log = log;
		}

		public static void Info(object message)
		{
			_log.LogInfo(message);
		}

		public static void Error(object message)
		{
			_log.LogError(message);
		}

		public static void Debug(object message)
		{
			_log.LogDebug(message);
		}

		public static void Warn(object message)
		{
			_log.LogWarning(message);
		}
	}
	[BepInPlugin("galfarious.ThirdHand", "Third Hand Mod", "1.0.0")]
	public class ThirdHandMod : BaseUnityPlugin
	{
		private void Awake()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			LogManager.Init(((BaseUnityPlugin)this).Logger);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin galfarious.ThirdHand is loaded!");
			SceneManager.sceneLoaded += OnSceneLoaded;
			Harmony val = new Harmony("galfarious.ThirdHand.patches");
			val.PatchAll();
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			if (((Scene)(ref scene)).name == "Game-Main")
			{
				GameObject.Find("CL_Player").AddComponent<ThirdHandController>();
			}
		}
	}
	public class ThirdHandController : MonoBehaviour
	{
		private GameObject _handsParent;

		private Transform _middleHand;

		private Image _middleUiHand;

		private bool _isInitialized = false;

		private void Awake()
		{
			CL_GameManager.gMan.allowScores = false;
			if (!_isInitialized)
			{
				_handsParent = GameObject.Find("CL_Player/Main Cam Root/Main Camera Shake Root/Main Camera/Inventory Camera/Inventory-Root");
				SetupContainer();
			}
		}

		private void SetupContainer()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Expected O, but got Unknown
			Hand[] hands = ENT_Player.playerObject.hands;
			GameObject val = new GameObject("Middle_Hand_Item");
			val.transform.SetParent(_handsParent.transform);
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			Hand val2 = new Hand();
			val2.fireButton = "Hand-Swap";
			val2.throwButton = "Rotate";
			GameObject val3 = new GameObject("Middle_Hand_Target");
			val3.transform.SetParent(_handsParent.transform);
			val3.transform.localPosition = new Vector3(0f, 0f, 0f);
			val3.transform.localRotation = Quaternion.identity;
			val3.transform.localScale = Vector3.one;
			val3.layer = LayerMask.NameToLayer("Player");
			GameObject val4 = new GameObject("Item_Hand_Middle");
			val4.transform.SetParent(val3.transform);
			val4.transform.localPosition = new Vector3(0f, 0f, 0f);
			val4.layer = LayerMask.NameToLayer("Player");
			ViewSway val5 = val4.AddComponent<ViewSway>();
			val5.targetOffset = new Vector3(0f, 0f, 0f);
			val5.Initialize(val2);
			Transform val6 = _handsParent.transform.Find("Right_Hand_Target/Item_Hand_Right/Item_Hands_Right");
			_middleHand = Object.Instantiate<Transform>(val6, val4.transform);
			((Object)_middleHand).name = "Item_Hands_Middle";
			((Component)_middleHand).transform.localPosition = new Vector3(0f, 0f, 0f);
			((Component)_middleHand).gameObject.layer = LayerMask.NameToLayer("Player");
			val2.handModel = val4.transform;
			val2.handSprite = ((Component)_middleHand).GetComponent<SpriteRenderer>();
			val2.dragMult = 10f;
			val2.grabSprite = ((IEnumerable<Sprite>)Resources.FindObjectsOfTypeAll<Sprite>()).FirstOrDefault((Func<Sprite, bool>)((Sprite x) => ((Object)x).name == "Hands_grip"));
			val2.id = 2;
			val2.normalSprite = ((IEnumerable<Sprite>)Resources.FindObjectsOfTypeAll<Sprite>()).FirstOrDefault((Func<Sprite, bool>)((Sprite x) => ((Object)x).name == "Hands_idle"));
			val2.openSprite = ((IEnumerable<Sprite>)Resources.FindObjectsOfTypeAll<Sprite>()).FirstOrDefault((Func<Sprite, bool>)((Sprite x) => ((Object)x).name == "HandsReach"));
			val2.memoryTime = 0.2f;
			val2.uiInteract = SetupUIHand();
			Inventory component = ((Component)ENT_Player.playerObject).GetComponent<Inventory>();
			ItemHand[] itemHands = component.itemHands;
			ItemHand val7 = new ItemHand();
			val7.hand = val2;
			val7.handInventoryRoot = val.transform;
			val7.handModel = val5;
			val7.currentItem = null;
			val7.currentItemNumber = -1;
			val2.inventoryHand = val7;
			component.itemHands = (ItemHand[])(object)new ItemHand[3]
			{
				itemHands[0],
				itemHands[1],
				val7
			};
			val2.gripStrength = ENT_Player.playerObject.gripStrengthTimer;
			val2.Initialize(ENT_Player.playerObject);
			ENT_Player.playerObject.hands = (Hand[])(object)new Hand[3]
			{
				hands[0],
				hands[1],
				val2
			};
			SetupFakeHandhold();
			SetupPocket();
			_isInitialized = true;
		}

		private void SetupFakeHandhold()
		{
			Transform transform = GameObject.Find("CL_Player/Fake Handholds").transform;
			Transform val = transform.Find("Player_Fake_Handhold.01");
			Transform val2 = Object.Instantiate<Transform>(val, transform);
			((Object)val2).name = "Player_Fake_Handhold.02";
			CL_Handhold component = ((Component)val2).GetComponent<CL_Handhold>();
			CL_Handhold[] grabAnywhereFakeHandholds = ENT_Player.playerObject.grabAnywhereFakeHandholds;
			ENT_Player.playerObject.grabAnywhereFakeHandholds = (CL_Handhold[])(object)new CL_Handhold[3]
			{
				grabAnywhereFakeHandholds[0],
				grabAnywhereFakeHandholds[1],
				component
			};
		}

		private Image SetupUIHand()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.Find("GameManager/Canvas/Game UI/Crosshairs/InteractHands");
			Transform val2 = val.transform.Find("Interact_L");
			Transform val3 = Object.Instantiate<Transform>(val2, val.transform);
			Object.Destroy((Object)(object)((Component)val3).GetComponent<UT_Wiggle>());
			((Object)val3).name = "Interact_M";
			((Component)val3).transform.localPosition = new Vector3(0f, 40f, 0f);
			UT_Wiggle val4 = ((Component)val3).gameObject.AddComponent<UT_Wiggle>();
			val4.wiggleAmplitude = 1.5f;
			val4.wiggleSpeed = 4f;
			val4.wiggleOffset = 3f;
			_middleUiHand = ((Component)val3).gameObject.GetComponent<Image>();
			return _middleUiHand;
		}

		private void SetupPocket()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			GameObject val = GameObject.Find("CL_Player/Main Cam Root/Main Camera Shake Root/Main Camera/Inventory Camera/InventoryBagCamera/Inventory-Bag/Homing Circle");
			val.SetActive(true);
			val.transform.localPosition = new Vector3(0f, -1f, 1.25f);
			GameObject val2 = new GameObject("Middle Pocket");
			val2.transform.SetParent(val.transform);
			val2.transform.localPosition = Vector3.zero;
			val2.transform.localScale = Vector3.one;
			Pocket val3 = new Pocket();
			val3.key = "Pocket-Right";
			val3.targetHandID = 2;
			val3.transform = val2.transform;
			Inventory.instance.pockets.Add(val3);
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "galfarious.ThirdHand";

		public const string PLUGIN_NAME = "Third Hand Mod";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace ThirdHand.Patches
{
	[HarmonyPatch]
	public class EntPlayerPatches
	{
		[HarmonyPatch(typeof(ENT_Player), "Awake")]
		[HarmonyPrefix]
		private static bool AwakePatch(ENT_Player __instance)
		{
			Traverse.Create((object)__instance).Field<Vector3[]>("grabAnywherePosition").Value = (Vector3[])(object)new Vector3[3];
			Traverse.Create((object)__instance).Field<Transform[]>("grabAnywhereHit").Value = (Transform[])(object)new Transform[3];
			return true;
		}

		[HarmonyPatch(typeof(ENT_Player), "Actions")]
		[HarmonyPrefix]
		private static bool ActionsPatch(ENT_Player __instance)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Invalid comparison between Unknown and I4
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Invalid comparison between Unknown and I4
			if ((int)__instance.hands[0].interactState == 4 && (int)__instance.hands[1].interactState == 4 && (int)__instance.hands[2].interactState == 4)
			{
				Traverse.Create((object)__instance).Field<float>("gripStrengthLossRate").Value = 0.33f;
			}
			else if ((int)__instance.hands[0].interactState == 4 && (int)__instance.hands[1].interactState == 4)
			{
				Traverse.Create((object)__instance).Field<float>("gripStrengthLossRate").Value = 0.5f;
			}
			else
			{
				Traverse.Create((object)__instance).Field<float>("gripStrengthLossRate").Value = 1f;
			}
			((Component)__instance.aimCircle).gameObject.SetActive(false);
			if (!Traverse.Create((object)__instance).Field<CL_GameManager>("gMan").Value.isPaused)
			{
				MethodInfo method = ((object)__instance).GetType().GetMethod("InteractCheck", BindingFlags.Instance | BindingFlags.NonPublic);
				if (method != null)
				{
					method.Invoke(__instance, new object[1] { 0 });
					method.Invoke(__instance, new object[1] { 1 });
					method.Invoke(__instance, new object[1] { 2 });
				}
			}
			AudioSet set = __instance.clipHandler.GetGroup("fatigue").GetSet("level");
			if (__instance.IsHanging())
			{
				set.SetVolume(Mathf.Lerp(set.GetCurrentVolume(), (1f - __instance.GetLowestGripStrength() / __instance.gripStrengthTimer - 0.5f) * 2f * set.maxVolume, Time.deltaTime * 3f));
				return false;
			}
			set.SetVolume(Mathf.Lerp(set.GetCurrentVolume(), 0f, Time.deltaTime * 3f));
			return false;
		}

		[HarmonyPatch(typeof(ENT_Player), "DropEverything")]
		[HarmonyPrefix]
		private static bool DropEverythingPatch(ENT_Player __instance)
		{
			__instance.DropHang(5f);
			Hand[] hands = __instance.hands;
			foreach (Hand val in hands)
			{
				val.DestroyItem();
				((Component)val.uiInteract).gameObject.SetActive(false);
			}
			return false;
		}

		[HarmonyPatch(typeof(ENT_Player), "StashItemsInHand")]
		[HarmonyPrefix]
		private static bool StashItemPatch(ENT_Player __instance)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			Inventory value = Traverse.Create((object)__instance).Field<Inventory>("inventory").Value;
			for (int i = 0; i < __instance.hands.Length; i++)
			{
				value.DropItemFromHand(value.inventoryCenterLocator.position, i, true);
			}
			return false;
		}
	}
	[HarmonyPatch]
	public class InventoryPatches
	{
		[HarmonyPatch(typeof(Inventory), "SwapHands")]
		[HarmonyPrefix]
		private static bool SwapHandsPatch(Inventory __instance)
		{
			return false;
		}
	}
	[HarmonyPatch]
	public class OSManagerPatches
	{
		[HarmonyPatch(typeof(OS_Computer_Interface), "Start")]
		[HarmonyPrefix]
		private static void OSComputerInterfaceStartPatch(OS_Computer_Interface __instance)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("MiddleHandPosition");
			val.transform.SetParent(((Component)__instance).transform);
			val.transform.localPosition = new Vector3(0.371f, -0.7f, 1.4f);
			Transform[] array = ObjectExtensions.Copy<Transform[]>(__instance.handPositions);
			__instance.handPositions = (Transform[])(object)new Transform[3]
			{
				array[0],
				array[1],
				val.transform
			};
		}

		[HarmonyPatch(typeof(OS_Computer_Interface), "Update")]
		[HarmonyPrefix]
		private static bool OSComputerInterfaceUpdatePatch(OS_Computer_Interface __instance)
		{
			return false;
		}
	}
}