using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Photon.Pun;
using UnityEngine;
using Zorro.Core;
using Zorro.Core.Serizalization;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyTitle("Splice Spools")]
[assembly: AssemblyDescription("PEAK BepInEx plugin that splices matching inventory rope spools into one longer spool.")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Splice Spools")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4006febd-7a9f-457c-865d-a3d4e2a97d25")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace Splice_Spools
{
	[BepInPlugin("tony4twentys.Splice_Spools", "Splice_Spools", "1.0.0")]
	[BepInProcess("PEAK.exe")]
	public class SpliceSpoolsPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "tony4twentys.Splice_Spools";

		public const string PluginName = "Splice_Spools";

		public const string PluginVersion = "1.0.0";

		internal static ConfigEntry<KeyCode> SpliceKeyConfig;

		internal static ConfigEntry<bool> IncludeBackpackConfig;

		private Harmony _harmony;

		private string _toastText;

		private float _toastUntil;

		internal static bool PendingWeightRefresh;

		internal static SpliceSpoolsPlugin Instance { get; private set; }

		internal static ManualLogSource Log { get; private set; }

		private void Awake()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			SpliceKeyConfig = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Splice", "Splice Key", (KeyCode)103, "Press this key to splice matching rope spools in your inventory into one longer spool per rope type.");
			IncludeBackpackConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Splice", "Include Backpack", true, "When true, leftover rope in a worn backpack is included when splicing.");
			_harmony = new Harmony("tony4twentys.Splice_Spools");
			_harmony.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)($"Splice Spools loaded. Splice key: {SpliceKeyConfig.Value}. " + "Backpack: " + (IncludeBackpackConfig.Value ? "included" : "ignored") + "."));
		}

		private void Update()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (PendingWeightRefresh)
			{
				PendingWeightRefresh = false;
				TryRefreshLocalWeight();
			}
			if ((int)SpliceKeyConfig.Value != 0 && Input.GetKeyDown(SpliceKeyConfig.Value) && !IsGameplayInputBlocked())
			{
				Character localCharacter = Character.localCharacter;
				if (!((Object)(object)((localCharacter != null) ? localCharacter.player : null) == (Object)null) && localCharacter.IsLocal)
				{
					SpliceExecutor.TrySplice(localCharacter, out var message);
					ShowToast(message);
					((BaseUnityPlugin)this).Logger.LogInfo((object)message);
				}
			}
		}

		private void OnGUI()
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrEmpty(_toastText) && !(Time.unscaledTime > _toastUntil))
			{
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(((float)Screen.width - 520f) * 0.5f, 72f, 520f, 36f);
				GUI.color = new Color(0f, 0f, 0f, 0.55f);
				GUI.Box(val, GUIContent.none);
				GUI.color = Color.white;
				GUIStyle val2 = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)4,
					fontSize = 16,
					fontStyle = (FontStyle)1
				};
				GUI.Label(val, _toastText, val2);
			}
		}

		private void OnDestroy()
		{
			if (_harmony != null)
			{
				_harmony.UnpatchSelf();
			}
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
			Log = null;
		}

		internal static void TryRefreshLocalWeight()
		{
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter?.refs?.items == (Object)null)
			{
				return;
			}
			try
			{
				localCharacter.refs.items.RefreshAllCharacterCarryWeightRPC();
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Weight refresh skipped: " + ex.Message));
				}
			}
		}

		internal void ShowToast(string text)
		{
			_toastText = text;
			_toastUntil = Time.unscaledTime + 2.5f;
		}

		private static bool IsGameplayInputBlocked()
		{
			if (GUIManager.InPauseMenu)
			{
				return true;
			}
			GUIManager instance = GUIManager.instance;
			return (Object)(object)instance != (Object)null && instance.windowBlockingInput;
		}
	}
	internal static class GameItemIds
	{
		public const ushort AntiRopeSpoolItemId = 1;

		public const ushort RopeSpoolItemId = 65;
	}
	internal static class RopeSpoolLengthHelper
	{
		public const float MetersPerSegment = 0.25f;

		public const float OutOfRopeSegmentThreshold = 2f;

		public const float DefaultSpoolStartFuel = 60f;

		public const float SegmentEpsilon = 0.01f;

		public static float SegmentsToMeters(float segments)
		{
			return segments * 0.25f;
		}

		public static float GetSpoolStartFuel(Item prefab)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return 60f;
			}
			RopeSpool component = ((Component)prefab).GetComponent<RopeSpool>();
			return ((Object)(object)component != (Object)null) ? component.ropeStartFuel : 60f;
		}

		public static float GetSpoolStartFuel(ItemSlot slot)
		{
			return GetSpoolStartFuel((slot != null) ? slot.prefab : null);
		}

		public static float GetRemainingSegments(Item prefab, ItemInstanceData data)
		{
			float spoolStartFuel = GetSpoolStartFuel(prefab);
			if (data == null)
			{
				return spoolStartFuel;
			}
			FloatItemData val = default(FloatItemData);
			if (data.TryGetDataEntry<FloatItemData>((DataEntryKey)10, ref val))
			{
				return Mathf.Max(0f, val.Value);
			}
			FloatItemData val2 = default(FloatItemData);
			if (data.TryGetDataEntry<FloatItemData>((DataEntryKey)11, ref val2))
			{
				return Mathf.Max(0f, val2.Value * spoolStartFuel);
			}
			return spoolStartFuel;
		}

		public static float GetRemainingSegments(ItemSlot slot)
		{
			if (slot == null || slot.IsEmpty())
			{
				return 0f;
			}
			return GetRemainingSegments(slot.prefab, slot.data);
		}

		public static float GetRemainingMeters(Item prefab, ItemInstanceData data)
		{
			return SegmentsToMeters(GetRemainingSegments(prefab, data));
		}

		public static int GetScaledCarryWeight(Item prefab, ItemInstanceData data)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return 0;
			}
			int carryWeight = prefab.CarryWeight;
			if (!SpliceInventory.IsRopeSpoolPrefab(prefab))
			{
				return carryWeight;
			}
			float spoolStartFuel = GetSpoolStartFuel(prefab);
			if (spoolStartFuel <= 0.01f)
			{
				return carryWeight;
			}
			float remainingSegments = GetRemainingSegments(prefab, data);
			return Mathf.RoundToInt((float)carryWeight * (remainingSegments / spoolStartFuel));
		}

		public static bool HasSplicableLength(float segments)
		{
			return segments > 2.01f;
		}
	}
	internal static class ItemDataHelper
	{
		public static void SetFloatEntry(ItemInstanceData data, DataEntryKey key, float value)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			FloatItemData val = default(FloatItemData);
			if (data.TryGetDataEntry<FloatItemData>(key, ref val))
			{
				val.Value = value;
				return;
			}
			FloatItemData val2 = new FloatItemData();
			((DataEntryValue)val2).Init();
			val2.Value = value;
			data.RegisterEntry<FloatItemData>(key, val2);
		}
	}
	internal static class SpliceInventory
	{
		private const byte TempInventorySlotId = 250;

		public static bool IsRopeSpoolPrefab(Item prefab)
		{
			if ((Object)(object)prefab == (Object)null || (Object)(object)((Component)prefab).GetComponent<RopeShooter>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)prefab).GetComponent<RopeSpool>() != (Object)null)
			{
				return true;
			}
			if (prefab.itemID == 65 || prefab.itemID == 1)
			{
				return true;
			}
			string text = ((Object)((Component)prefab).gameObject).name ?? string.Empty;
			return text.IndexOf("Rope Spool", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		public static bool IsAntiRopeSpoolPrefab(Item prefab)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return false;
			}
			RopeSpool component = ((Component)prefab).GetComponent<RopeSpool>();
			if ((Object)(object)component != (Object)null && component.isAntiRope)
			{
				return true;
			}
			if (prefab.itemID == 1)
			{
				return true;
			}
			string text = ((Object)((Component)prefab).gameObject).name ?? string.Empty;
			return text.IndexOf("Anti-Rope Spool", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		public static List<ItemSlot> GetRopeSpoolSlots(Character character)
		{
			List<ItemSlot> list = new List<ItemSlot>();
			if ((Object)(object)((character != null) ? character.player : null) == (Object)null)
			{
				return list;
			}
			AppendRopeSlots(character.player.itemSlots, list);
			if (character.player.tempFullSlot != null && !character.player.tempFullSlot.IsEmpty() && IsRopeSpoolPrefab(character.player.tempFullSlot.prefab))
			{
				list.Add(character.player.tempFullSlot);
			}
			if (SpliceSpoolsPlugin.IncludeBackpackConfig.Value)
			{
				AppendBackpackRopeSlots(character, list);
			}
			return list;
		}

		private static void AppendRopeSlots(ItemSlot[] slots, List<ItemSlot> ropeSlots)
		{
			if (slots == null)
			{
				return;
			}
			foreach (ItemSlot val in slots)
			{
				if (val != null && !val.IsEmpty() && IsRopeSpoolPrefab(val.prefab))
				{
					ropeSlots.Add(val);
				}
			}
		}

		private static void AppendBackpackRopeSlots(Character character, List<ItemSlot> ropeSlots)
		{
			if (character.player.backpackSlot != null && !((ItemSlot)character.player.backpackSlot).IsEmpty())
			{
				ItemInstanceData data = ((ItemSlot)character.player.backpackSlot).data;
				BackpackData val = default(BackpackData);
				if (data != null && data.TryGetDataEntry<BackpackData>((DataEntryKey)7, ref val))
				{
					AppendRopeSlots(val.itemSlots, ropeSlots);
				}
			}
		}

		public static bool IsBackpackSlot(Character character, ItemSlot slot)
		{
			if ((Object)(object)((character != null) ? character.player : null) == (Object)null || slot == null || character.player.backpackSlot == null || ((ItemSlot)character.player.backpackSlot).IsEmpty())
			{
				return false;
			}
			ItemInstanceData data = ((ItemSlot)character.player.backpackSlot).data;
			BackpackData val = default(BackpackData);
			if (data == null || !data.TryGetDataEntry<BackpackData>((DataEntryKey)7, ref val) || val.itemSlots == null)
			{
				return false;
			}
			ItemSlot[] itemSlots = val.itemSlots;
			foreach (ItemSlot val2 in itemSlots)
			{
				if (val2 == slot)
				{
					return true;
				}
			}
			return false;
		}

		public static bool TryGetHeldSpool(Character character, out Item item, out RopeSpool spool)
		{
			object obj;
			if (character == null)
			{
				obj = null;
			}
			else
			{
				CharacterData data = character.data;
				obj = ((data != null) ? data.currentItem : null);
			}
			item = (Item)obj;
			spool = (((Object)(object)item != (Object)null) ? ((Component)item).GetComponent<RopeSpool>() : null);
			return (Object)(object)spool != (Object)null;
		}

		public static bool IsHeldSpoolBusy(Character character, bool isAntiRope)
		{
			if (!TryGetHeldSpool(character, out var item, out var spool))
			{
				return false;
			}
			if (spool.isAntiRope != isAntiRope)
			{
				return false;
			}
			return (Object)(object)spool.ropeInstance != (Object)null || (Object)(object)spool.rope != (Object)null || item.isUsingPrimary;
		}

		public static ItemSlot FindSlotForItem(Character character, Item item)
		{
			if ((Object)(object)((character != null) ? character.player : null) == (Object)null || (Object)(object)item == (Object)null)
			{
				return null;
			}
			if (item.data != null && item.data.guid != Guid.Empty)
			{
				ItemSlot val = FindSlotByGuid(character, item.data.guid);
				if (val != null)
				{
					return val;
				}
			}
			foreach (ItemSlot ropeSpoolSlot in GetRopeSpoolSlots(character))
			{
				if (SlotMatchesHeldItem(character, ropeSpoolSlot))
				{
					return ropeSpoolSlot;
				}
			}
			return null;
		}

		private static ItemSlot FindSlotByGuid(Character character, Guid guid)
		{
			ItemSlot val = FindSlotByGuid(character.player.itemSlots, guid);
			if (val != null)
			{
				return val;
			}
			if (SlotHasGuid(character.player.tempFullSlot, guid))
			{
				return character.player.tempFullSlot;
			}
			BackpackData val2 = default(BackpackData);
			if (character.player.backpackSlot != null && !((ItemSlot)character.player.backpackSlot).IsEmpty() && ((ItemSlot)character.player.backpackSlot).data != null && ((ItemSlot)character.player.backpackSlot).data.TryGetDataEntry<BackpackData>((DataEntryKey)7, ref val2))
			{
				return FindSlotByGuid(val2.itemSlots, guid);
			}
			return null;
		}

		private static ItemSlot FindSlotByGuid(ItemSlot[] slots, Guid guid)
		{
			if (slots == null)
			{
				return null;
			}
			foreach (ItemSlot val in slots)
			{
				if (SlotHasGuid(val, guid))
				{
					return val;
				}
			}
			return null;
		}

		private static bool SlotHasGuid(ItemSlot slot, Guid guid)
		{
			return slot != null && !slot.IsEmpty() && slot.data != null && slot.data.guid == guid;
		}

		public static bool SlotMatchesHeldItem(Character character, ItemSlot slot)
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			object obj;
			if (character == null)
			{
				obj = null;
			}
			else
			{
				CharacterData data = character.data;
				obj = ((data != null) ? data.currentItem : null);
			}
			Item val = (Item)obj;
			if ((Object)(object)val == (Object)null || slot == null || slot.IsEmpty() || (Object)(object)slot.prefab == (Object)null)
			{
				return false;
			}
			if (val.data != null && slot.data != null && val.data.guid != Guid.Empty && val.data.guid == slot.data.guid)
			{
				return true;
			}
			Optionable<byte> valueOrDefault = (character.refs?.items?.currentSelectedSlot).GetValueOrDefault();
			return valueOrDefault.IsSome && valueOrDefault.Value == slot.itemSlotID && slot.prefab.itemID == val.itemID;
		}

		public static void ApplyFuelToSlot(ItemSlot slot, float remaining, float startFuel)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			if (slot.data == null)
			{
				slot.data = new ItemInstanceData(Guid.NewGuid());
			}
			ItemDataHelper.SetFloatEntry(slot.data, (DataEntryKey)10, remaining);
			float value = ((startFuel > 0f) ? Mathf.Clamp01(remaining / startFuel) : 0f);
			ItemDataHelper.SetFloatEntry(slot.data, (DataEntryKey)11, value);
		}

		public static void ApplyFuelToHeldItem(Item item, float remaining, float startFuel)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			if (!((Object)(object)item == (Object)null))
			{
				if (item.data == null)
				{
					item.data = new ItemInstanceData(Guid.NewGuid());
				}
				ItemDataHelper.SetFloatEntry(item.data, (DataEntryKey)10, remaining);
				RopeSpool component = ((Component)item).GetComponent<RopeSpool>();
				if ((Object)(object)component != (Object)null)
				{
					((ItemComponent)component).OnInstanceDataSet();
				}
				float useRemainingPercentage = ((startFuel > 0f) ? Mathf.Clamp01(remaining / startFuel) : 0f);
				item.SetUseRemainingPercentage(useRemainingPercentage);
			}
		}

		public static void EmptySlotLocal(Character character, ItemSlot slot)
		{
			if (slot == null)
			{
				return;
			}
			if (IsBackpackSlot(character, slot) || slot.itemSlotID == 250)
			{
				slot.EmptyOut();
				return;
			}
			ItemSlot itemSlot = character.player.GetItemSlot(slot.itemSlotID);
			if (itemSlot != null)
			{
				itemSlot.EmptyOut();
			}
		}

		public static void SyncInventory(Character character)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)((character != null) ? character.player : null) == (Object)null || !PhotonNetwork.InRoom)
			{
				return;
			}
			PhotonView component = ((Component)character.player).GetComponent<PhotonView>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			try
			{
				InventorySyncData val = default(InventorySyncData);
				((InventorySyncData)(ref val))..ctor(character.player.itemSlots, character.player.backpackSlot, character.player.tempFullSlot);
				byte[] array = IBinarySerializable.ToManagedArray<InventorySyncData>(val);
				component.RPC("SyncInventoryRPC", (RpcTarget)1, new object[2]
				{
					array,
					!PhotonNetwork.IsMasterClient
				});
				if (!PhotonNetwork.IsMasterClient)
				{
					component.RPC("SyncInventoryRPC", (RpcTarget)2, new object[2] { array, true });
				}
			}
			catch (Exception ex)
			{
				SpliceSpoolsPlugin.Log.LogWarning((object)("Inventory sync skipped: " + ex.Message));
			}
		}

		public static void PushHeldItemData(Item item)
		{
			if (item?.data == null || !PhotonNetwork.InRoom)
			{
				return;
			}
			PhotonView component = ((Component)item).GetComponent<PhotonView>();
			if ((Object)(object)component == (Object)null || (!component.IsMine && !PhotonNetwork.IsMasterClient))
			{
				return;
			}
			try
			{
				component.RPC("SetItemInstanceDataRPC", (RpcTarget)1, new object[1] { item.data });
			}
			catch (Exception ex)
			{
				SpliceSpoolsPlugin.Log.LogWarning((object)("Held spool sync skipped: " + ex.Message));
			}
		}
	}
	internal static class SpliceExecutor
	{
		public static bool TrySplice(Character character, out string message)
		{
			List<ItemSlot> ropeSpoolSlots = SpliceInventory.GetRopeSpoolSlots(character);
			List<ItemSlot> list = new List<ItemSlot>();
			List<ItemSlot> list2 = new List<ItemSlot>();
			CollectSplicable(ropeSpoolSlots, list, list2);
			bool flag = false;
			bool flag2 = false;
			float combinedMeters = 0f;
			float combinedMeters2 = 0f;
			int spoolCount = 0;
			int spoolCount2 = 0;
			if (list.Count >= 2)
			{
				if (SpliceInventory.IsHeldSpoolBusy(character, isAntiRope: false))
				{
					message = "Finish placing your rope before splicing.";
					return false;
				}
				flag = TrySpliceGroup(character, list, isAntiRope: false, out combinedMeters, out spoolCount);
			}
			if (list2.Count >= 2)
			{
				if (SpliceInventory.IsHeldSpoolBusy(character, isAntiRope: true))
				{
					if (flag)
					{
						SyncAfterSplice(character, null);
						message = BuildResultMessage(splicedNormal: true, spoolCount, combinedMeters, splicedAnti: false, 0, 0f) + " Anti-grav spool is in use.";
						return true;
					}
					message = "Finish placing your anti-grav rope before splicing.";
					return false;
				}
				flag2 = TrySpliceGroup(character, list2, isAntiRope: true, out combinedMeters2, out spoolCount2);
			}
			if (!flag && !flag2)
			{
				message = ((list.Count + list2.Count == 0) ? "No leftover rope spools to splice." : "Need at least two matching rope spools to splice.");
				return false;
			}
			SpliceInventory.TryGetHeldSpool(character, out var item, out var _);
			SyncAfterSplice(character, item);
			message = BuildResultMessage(flag, spoolCount, combinedMeters, flag2, spoolCount2, combinedMeters2);
			return true;
		}

		private static void CollectSplicable(List<ItemSlot> allSpools, List<ItemSlot> normal, List<ItemSlot> anti)
		{
			foreach (ItemSlot allSpool in allSpools)
			{
				float remainingSegments = RopeSpoolLengthHelper.GetRemainingSegments(allSpool);
				if (RopeSpoolLengthHelper.HasSplicableLength(remainingSegments))
				{
					if (SpliceInventory.IsAntiRopeSpoolPrefab(allSpool.prefab))
					{
						anti.Add(allSpool);
					}
					else
					{
						normal.Add(allSpool);
					}
				}
			}
		}

		private static bool TrySpliceGroup(Character character, List<ItemSlot> slots, bool isAntiRope, out float combinedMeters, out int spoolCount)
		{
			combinedMeters = 0f;
			spoolCount = slots.Count;
			if (slots.Count < 2)
			{
				return false;
			}
			ItemSlot val = ChooseTargetSlot(character, slots, isAntiRope);
			if (val == null)
			{
				return false;
			}
			float num = 0f;
			foreach (ItemSlot slot in slots)
			{
				num += RopeSpoolLengthHelper.GetRemainingSegments(slot);
			}
			if (!RopeSpoolLengthHelper.HasSplicableLength(num))
			{
				return false;
			}
			float spoolStartFuel = RopeSpoolLengthHelper.GetSpoolStartFuel(val);
			SpliceInventory.ApplyFuelToSlot(val, num, spoolStartFuel);
			if (SpliceInventory.SlotMatchesHeldItem(character, val))
			{
				SpliceInventory.ApplyFuelToHeldItem(character.data.currentItem, num, spoolStartFuel);
			}
			foreach (ItemSlot slot2 in slots)
			{
				if (slot2 != val)
				{
					SpliceInventory.EmptySlotLocal(character, slot2);
				}
			}
			combinedMeters = RopeSpoolLengthHelper.SegmentsToMeters(num);
			return true;
		}

		private static ItemSlot ChooseTargetSlot(Character character, List<ItemSlot> slots, bool isAntiRope)
		{
			foreach (ItemSlot slot in slots)
			{
				if (SpliceInventory.SlotMatchesHeldItem(character, slot) && SpliceInventory.IsAntiRopeSpoolPrefab(slot.prefab) == isAntiRope)
				{
					return slot;
				}
			}
			return slots[0];
		}

		private static void SyncAfterSplice(Character character, Item held)
		{
			SpliceInventory.SyncInventory(character);
			if ((Object)(object)held != (Object)null)
			{
				SpliceInventory.PushHeldItemData(held);
			}
			if ((Object)(object)character.refs?.items != (Object)null)
			{
				character.refs.items.RefreshAllCharacterCarryWeightRPC();
			}
			if (character.player?.itemsChangedAction != null)
			{
				character.player.itemsChangedAction(character.player.itemSlots);
			}
		}

		private static string BuildResultMessage(bool splicedNormal, int normalCount, float normalMeters, bool splicedAnti, int antiCount, float antiMeters)
		{
			if (splicedNormal && splicedAnti)
			{
				return $"Spliced {normalCount} rope spools into {normalMeters:0.##}m and {antiCount} anti-grav spools into {antiMeters:0.##}m.";
			}
			if (splicedAnti)
			{
				return $"Spliced {antiCount} anti-grav spools into {antiMeters:0.##}m.";
			}
			return $"Spliced {normalCount} rope spools into {normalMeters:0.##}m.";
		}
	}
	[HarmonyPatch(typeof(Item), "GetItemName")]
	internal static class Item_GetItemName_Splice_Patch
	{
		private static void Postfix(Item __instance, ItemInstanceData data, ref string __result)
		{
			try
			{
				if (SpliceInventory.IsRopeSpoolPrefab(__instance) && !string.IsNullOrEmpty(__result))
				{
					ItemInstanceData data2 = data ?? __instance.data;
					float remainingMeters = RopeSpoolLengthHelper.GetRemainingMeters(__instance, data2);
					__result = $"{__result} ({remainingMeters:0.#}m)";
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = SpliceSpoolsPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Name patch skipped: " + ex.Message));
				}
			}
		}
	}
	[HarmonyPatch(typeof(CharacterAfflictions), "UpdateWeight")]
	internal static class CharacterAfflictions_UpdateWeight_Splice_Patch
	{
		private static void Postfix(CharacterAfflictions __instance)
		{
			try
			{
				Character character = __instance.character;
				if (!((Object)(object)((character != null) ? character.player : null) == (Object)null))
				{
					int vanilla = 0;
					int scaled = 0;
					AddSpoolWeights(character.player.itemSlots, ref vanilla, ref scaled);
					AddSpoolWeights(GetBackpackInnerSlots(character), ref vanilla, ref scaled);
					AddSpoolWeights((ItemSlot[])(object)new ItemSlot[1] { character.player.GetItemSlot((byte)250) }, ref vanilla, ref scaled);
					if (vanilla != scaled)
					{
						float currentStatus = __instance.GetCurrentStatus((STATUSTYPE)7);
						int num = Mathf.RoundToInt(currentStatus / 0.025f);
						__instance.SetStatus((STATUSTYPE)7, 0.025f * (float)(num - vanilla + scaled), true);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = SpliceSpoolsPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Weight patch skipped: " + ex.Message));
				}
			}
		}

		private static void AddSpoolWeights(ItemSlot[] slots, ref int vanilla, ref int scaled)
		{
			if (slots == null)
			{
				return;
			}
			foreach (ItemSlot val in slots)
			{
				if (val != null && !val.IsEmpty() && SpliceInventory.IsRopeSpoolPrefab(val.prefab))
				{
					vanilla += val.prefab.CarryWeight;
					scaled += RopeSpoolLengthHelper.GetScaledCarryWeight(val.prefab, val.data);
				}
			}
		}

		private static ItemSlot[] GetBackpackInnerSlots(Character character)
		{
			if (character.player.backpackSlot == null || ((ItemSlot)character.player.backpackSlot).IsEmpty())
			{
				return null;
			}
			ItemInstanceData data = ((ItemSlot)character.player.backpackSlot).data;
			BackpackData val = default(BackpackData);
			if (data == null || !data.TryGetDataEntry<BackpackData>((DataEntryKey)7, ref val))
			{
				return null;
			}
			return val.itemSlots;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal static class RopeSpool_RopeFuel_Splice_Patch
	{
		private static void Postfix(RopeSpool __instance, float value)
		{
			try
			{
				Item item = ((ItemComponent)__instance).item;
				Character val = (((Object)(object)item != (Object)null) ? item.holderCharacter : null);
				if (!((Object)(object)val == (Object)null) && val.IsLocal)
				{
					ItemSlot val2 = SpliceInventory.FindSlotForItem(val, item);
					if (val2 != null && val2.data != item.data)
					{
						SpliceInventory.ApplyFuelToSlot(val2, value, RopeSpoolLengthHelper.GetSpoolStartFuel(val2));
					}
					SpliceSpoolsPlugin.PendingWeightRefresh = true;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = SpliceSpoolsPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Fuel sync skipped: " + ex.Message));
				}
			}
		}
	}
}