using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.XR;

namespace BlockSpace.Voxels
{
	[DefaultExecutionOrder(-100)]
	[DisallowMultipleComponent]
	public sealed class VRGroupSelector : MonoBehaviour
	{
		private sealed class GrabbedGroupState
		{
			public VoxelGroup group;

			public Vector3 startWorldPosition;

			public byte startPackedRotation;

			public bool colliderWasEnabled;

			public float lastPreviewSentAt = float.NegativeInfinity;
		}

		private struct GroupMergeAnimationState
		{
			public VoxelGroup group;

			public Vector3 startTransformPosition;

			public Vector3 startBoundsCenter;

			public Vector3 burstStartCenter;

			public Vector3 burstPeakCenter;
		}

		private const string GroupTickClipResourcePath = "Click";

		private const string GroupImpactClipResourcePath = "Thock";

		[SerializeField]
		private XRNode rightHand = XRNode.RightHand;

		[SerializeField]
		private XRNode leftHand = XRNode.LeftHand;

		[SerializeField]
		private Transform selectorOrigin;

		[SerializeField]
		private float selectionRadius = 0.1f;

		[SerializeField]
		private KeyCode keyboardSelectKey = KeyCode.G;

		[SerializeField]
		private KeyCode keyboardMergeKey = KeyCode.F;

		[SerializeField]
		private KeyCode keyboardDuplicateKey = KeyCode.D;

		[SerializeField]
		private KeyCode keyboardPaintSelectionKey = KeyCode.Q;

		[SerializeField]
		private KeyCode keyboardInventoryKey = KeyCode.I;

		[SerializeField]
		private KeyCode keyboardDeleteKey = KeyCode.Delete;

		[SerializeField]
		private float gripGrabThreshold = 0.85f;

		[SerializeField]
		private float deleteTriggerThreshold = 0.7f;

		[SerializeField]
		private float undoChordWindow = 0.12f;

		[SerializeField]
		private float grabPositionSnap = 0.125f;

		[SerializeField]
		private float grabRotationSnapDegrees = 90f;

		[SerializeField]
		private float movePreviewSendInterval = 0.05f;

		[Header("Grouping Audio")]
		[SerializeField]
		private AudioClip groupingClickClip;

		[SerializeField]
		private AudioClip groupingThockClip;

		[SerializeField]
		private VoxelGroupManager groupManager;

		private readonly HashSet<VoxelGroup> selectedGroups = new HashSet<VoxelGroup>();

		private readonly List<VoxelGroup> selectionBuffer = new List<VoxelGroup>();

		private readonly List<VoxelGroup> cleanupBuffer = new List<VoxelGroup>();

		private readonly List<GrabbedGroupState> grabbedGroupStates = new List<GrabbedGroupState>();

		private InputDevice rightHandDevice;

		private InputDevice leftHandDevice;

		private bool mergeButtonPrevious;

		private bool duplicateButtonPrevious;

		private bool thumbstickClickPrevious;

		private bool inventoryButtonPrevious;

		private bool selectionHeld;

		private bool selectionInputHeld;

		private bool undoChordActive;

		private bool suppressRightHandActionsUntilNeutral;

		private bool interactionSuppressed;

		private bool selectModeLatchedThisHold;

		private bool gripHeldPrevious;

		private bool triggerHeldPrevious;

		private float lastGripPressTime = float.NegativeInfinity;

		private float lastTriggerPressTime = float.NegativeInfinity;

		private Transform trackingOrigin;

		private bool groupingAnimationActive;

		private bool selectionGrabActive;

		private Vector3 grabStartReferencePosition;

		private Quaternion grabStartReferenceRotation;

		private Vector3 grabStartSelectionCenter;

		private Vector3 grabStartSelectionOffset;

		public static VRGroupSelector Instance { get; private set; }

		public bool IsSelecting => selectionHeld;

		public bool HasSelection => selectedGroups.Count > 0;

		public float SelectionRadius => selectionRadius;

		public bool BlocksRightHandActions
		{
			get
			{
				if (!undoChordActive && !suppressRightHandActionsUntilNeutral && !groupingAnimationActive)
				{
					return selectionGrabActive;
				}
				return true;
			}
		}

		public void SetInteractionSuppressed(bool suppressed)
		{
			if (interactionSuppressed == suppressed)
			{
				return;
			}
			interactionSuppressed = suppressed;
			if (interactionSuppressed)
			{
				if (HasSelection)
				{
					ClearSelectionInternal(suppressUntilNeutral: false);
				}
				selectionHeld = false;
				selectionInputHeld = false;
				undoChordActive = false;
				suppressRightHandActionsUntilNeutral = false;
				selectModeLatchedThisHold = false;
				EndSelectionGrab();
			}
		}

		public void Configure(VoxelGroupManager manager, Transform origin, Transform handAnchor)
		{
			if (manager != null)
			{
				groupManager = manager;
			}
			trackingOrigin = origin;
			if (handAnchor != null)
			{
				selectorOrigin = handAnchor;
			}
		}

		public bool TryGetSelectionCenter(out Vector3 worldPosition)
		{
			return TryGetSelectorPosition(out worldPosition);
		}

		public void SetSelectionRadius(float radius)
		{
			selectionRadius = Mathf.Max(0.001f, radius);
		}

		public void ClearSelectionForToolUse()
		{
			if (HasSelection)
			{
				ClearSelectionInternal(suppressUntilNeutral: false);
			}
		}

		private void Awake()
		{
			if (Instance != null && Instance != this)
			{
				Debug.LogError("Multiple VRGroupSelector instances found.", this);
				return;
			}
			Instance = this;
			if (groupManager == null)
			{
				groupManager = ((VoxelGroupManager.Instance != null) ? VoxelGroupManager.Instance : UnityEngine.Object.FindObjectOfType<VoxelGroupManager>());
			}
			selectionRadius = Mathf.Max(0.001f, selectionRadius);
			gripGrabThreshold = Mathf.Clamp(gripGrabThreshold, 0.5f, 1f);
			undoChordWindow = Mathf.Max(0.01f, undoChordWindow);
			grabPositionSnap = Mathf.Max(0.001f, grabPositionSnap);
			grabRotationSnapDegrees = Mathf.Max(1f, grabRotationSnapDegrees);
			EnsureGroupingClipsAssigned();
		}

		private void OnEnable()
		{
			rightHandDevice = InputDevices.GetDeviceAtXRNode(rightHand);
			leftHandDevice = InputDevices.GetDeviceAtXRNode(leftHand);
		}

		private void OnDestroy()
		{
			if (Instance == this)
			{
				Instance = null;
			}
		}

		private void Update()
		{
			if (groupManager == null)
			{
				return;
			}
			if (!groupManager.CreatorMode || groupManager.EditingLocked)
			{
				if (HasSelection)
				{
					ClearSelectionInternal(suppressUntilNeutral: false);
				}
				selectionHeld = false;
				selectionInputHeld = false;
				undoChordActive = false;
				suppressRightHandActionsUntilNeutral = false;
				selectModeLatchedThisHold = false;
				EndSelectionGrab();
				return;
			}
			VRVoxelBrush instance = VRVoxelBrush.Instance;
			bool flag = instance == null || instance.UsingXRInput;
			if (!rightHandDevice.isValid)
			{
				rightHandDevice = InputDevices.GetDeviceAtXRNode(rightHand);
			}
			if (!leftHandDevice.isValid)
			{
				leftHandDevice = InputDevices.GetDeviceAtXRNode(leftHand);
			}
			if (groupingAnimationActive)
			{
				return;
			}
			if (interactionSuppressed)
			{
				bool flag2 = ((!flag) ? (Input.GetMouseButton(2) || Input.GetKey(keyboardSelectKey)) : (ReadBool(rightHandDevice, CommonUsages.primary2DAxisClick) || Input.GetKey(keyboardSelectKey)));
				bool flag3 = (flag ? ReadGrabHeld(rightHandDevice) : Input.GetMouseButton(1));
				bool flag4 = flag && ReadFloat(rightHandDevice, CommonUsages.trigger) >= deleteTriggerThreshold;
				bool flag5 = flag && ReadBool(rightHandDevice, CommonUsages.primaryButton);
				bool flag6 = flag && ReadBool(leftHandDevice, CommonUsages.primaryButton);
				bool flag7 = flag && ReadBool(rightHandDevice, CommonUsages.secondaryButton);
				selectionHeld = false;
				selectionInputHeld = false;
				thumbstickClickPrevious = flag2;
				mergeButtonPrevious = flag5;
				duplicateButtonPrevious = flag6;
				inventoryButtonPrevious = flag7;
				gripHeldPrevious = flag3;
				triggerHeldPrevious = flag4;
				if (!flag3 && !flag4)
				{
					undoChordActive = false;
					suppressRightHandActionsUntilNeutral = false;
				}
				return;
			}
			CleanupDestroyedSelections();
			Vector3 worldPosition;
			bool num = TryGetSelectorPosition(out worldPosition);
			selectionBuffer.Clear();
			if (num)
			{
				selectionBuffer.AddRange(groupManager.GetGroupsInRadius(worldPosition, selectionRadius));
			}
			bool flag8 = ((!flag) ? (Input.GetMouseButton(2) || Input.GetKey(keyboardSelectKey)) : (ReadBool(rightHandDevice, CommonUsages.primary2DAxisClick) || Input.GetKey(keyboardSelectKey)));
			bool flag9 = (flag ? ReadGrabHeld(rightHandDevice) : Input.GetMouseButton(1));
			bool flag10 = flag && ReadFloat(rightHandDevice, CommonUsages.trigger) >= deleteTriggerThreshold;
			bool flag11 = flag && ReadBool(rightHandDevice, CommonUsages.primaryButton);
			bool flag12 = flag && ReadBool(leftHandDevice, CommonUsages.primaryButton);
			bool flag13 = flag && ReadBool(rightHandDevice, CommonUsages.secondaryButton);
			bool flag14 = Input.GetKeyDown(keyboardDuplicateKey) && (Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl));
			if (flag9 && !gripHeldPrevious)
			{
				lastGripPressTime = Time.unscaledTime;
			}
			if (flag10 && !triggerHeldPrevious)
			{
				lastTriggerPressTime = Time.unscaledTime;
			}
			if (flag8 && !thumbstickClickPrevious)
			{
				selectModeLatchedThisHold = false;
			}
			if (!flag8 && thumbstickClickPrevious)
			{
				selectModeLatchedThisHold = false;
			}
			if (flag8 && selectionBuffer.Count > 0)
			{
				selectModeLatchedThisHold = true;
			}
			selectionInputHeld = flag8 && selectModeLatchedThisHold;
			if (!undoChordActive && flag9 && flag10)
			{
				float num2 = Mathf.Max(lastGripPressTime, lastTriggerPressTime);
				if (num2 > float.NegativeInfinity && Mathf.Abs(lastGripPressTime - lastTriggerPressTime) <= undoChordWindow && Time.unscaledTime - num2 <= undoChordWindow)
				{
					undoChordActive = true;
					selectionHeld = false;
					EndSelectionGrab();
					groupManager.UndoLastOperation();
				}
			}
			if (!undoChordActive && !suppressRightHandActionsUntilNeutral && HasSelection && ((flag12 && !duplicateButtonPrevious) || flag14))
			{
				DuplicateSelectedGroups();
			}
			if (!undoChordActive && HasSelection && flag9 && !flag10)
			{
				if (!selectionGrabActive)
				{
					BeginSelectionGrab();
				}
				UpdateSelectionGrab();
			}
			else if (selectionGrabActive)
			{
				EndSelectionGrab();
			}
			if (!selectionInputHeld && !flag9 && !flag10 && !flag11 && !flag12 && !flag13)
			{
				undoChordActive = false;
				suppressRightHandActionsUntilNeutral = false;
			}
			selectionHeld = selectionInputHeld && !undoChordActive && !suppressRightHandActionsUntilNeutral && !selectionGrabActive;
			if (selectionHeld)
			{
				for (int i = 0; i < selectionBuffer.Count; i++)
				{
					VoxelGroup voxelGroup = selectionBuffer[i];
					if (!(voxelGroup == null) && selectedGroups.Add(voxelGroup))
					{
						voxelGroup.SetSelected(selected: true);
						VRHaptics.Pulse(rightHandDevice, 0.18f, 0.035f);
					}
				}
			}
			if (!undoChordActive && !suppressRightHandActionsUntilNeutral && ((flag11 && !mergeButtonPrevious) || Input.GetKeyDown(keyboardMergeKey)) && HasSelection)
			{
				BeginMergeSelectedGroups();
				suppressRightHandActionsUntilNeutral = true;
			}
			if (!undoChordActive && HasSelection && flag13 && !inventoryButtonPrevious)
			{
				PaintSelectedGroups();
			}
			if (!undoChordActive && HasSelection && Input.GetKeyDown(keyboardPaintSelectionKey))
			{
				PaintSelectedGroups();
			}
			if (!undoChordActive && Input.GetKeyDown(keyboardInventoryKey))
			{
				SendSelectedGroupsToInventory();
			}
			if (!undoChordActive && Input.GetKeyDown(keyboardDeleteKey) && HasSelection)
			{
				DeleteSelectedGroups();
				suppressRightHandActionsUntilNeutral = true;
			}
			mergeButtonPrevious = flag11;
			duplicateButtonPrevious = flag12;
			thumbstickClickPrevious = flag8;
			inventoryButtonPrevious = flag13;
			gripHeldPrevious = flag9;
			triggerHeldPrevious = flag10;
		}

		public void ClearSelection()
		{
			ClearSelectionInternal(suppressUntilNeutral: true);
		}

		private void ClearSelectionInternal(bool suppressUntilNeutral)
		{
			cleanupBuffer.Clear();
			cleanupBuffer.AddRange(selectedGroups);
			for (int i = 0; i < cleanupBuffer.Count; i++)
			{
				VoxelGroup voxelGroup = cleanupBuffer[i];
				if (voxelGroup != null)
				{
					voxelGroup.SetSelected(selected: false);
				}
			}
			selectedGroups.Clear();
			cleanupBuffer.Clear();
			selectionHeld = false;
			selectionInputHeld = false;
			if (suppressUntilNeutral)
			{
				suppressRightHandActionsUntilNeutral = true;
			}
		}

		private void BeginMergeSelectedGroups()
		{
			CleanupDestroyedSelections();
			if (selectedGroups.Count >= 2)
			{
				selectionBuffer.Clear();
				selectionBuffer.AddRange(selectedGroups);
				StartCoroutine(AnimateAndMergeSelectedGroups(new List<VoxelGroup>(selectionBuffer)));
				selectionBuffer.Clear();
			}
		}

		private void DuplicateSelectedGroups()
		{
			CleanupDestroyedSelections();
			if (selectedGroups.Count == 0)
			{
				return;
			}
			selectionBuffer.Clear();
			selectionBuffer.AddRange(selectedGroups);
			ClearSelectionInternal(suppressUntilNeutral: false);
			for (int i = 0; i < selectionBuffer.Count; i++)
			{
				VoxelGroup voxelGroup = groupManager.DuplicateGroup(selectionBuffer[i], Vector3Int.zero);
				if (!(voxelGroup == null))
				{
					voxelGroup.SetSelected(selected: true);
					selectedGroups.Add(voxelGroup);
				}
			}
			selectionBuffer.Clear();
			VRHaptics.Pulse(leftHandDevice, 0.32f, 0.055f);
		}

		private void BeginSelectionGrab()
		{
			CleanupDestroyedSelections();
			if (selectedGroups.Count == 0 || !TryGetGrabReferencePose(out grabStartReferencePosition, out grabStartReferenceRotation) || !TryGetSelectedBounds(out var bounds))
			{
				return;
			}
			grabbedGroupStates.Clear();
			foreach (VoxelGroup selectedGroup in selectedGroups)
			{
				if (!(selectedGroup == null))
				{
					grabbedGroupStates.Add(new GrabbedGroupState
					{
						group = selectedGroup,
						startWorldPosition = selectedGroup.transform.position,
						startPackedRotation = selectedGroup.packedRotation,
						colliderWasEnabled = (selectedGroup.meshCollider == null || selectedGroup.meshCollider.enabled)
					});
					groupManager.SetGroupColliderEnabled(selectedGroup, enabled: false);
					groupManager.BroadcastMovePreview(selectedGroup);
				}
			}
			if (grabbedGroupStates.Count != 0)
			{
				grabStartSelectionCenter = bounds.center;
				grabStartSelectionOffset = grabStartSelectionCenter - grabStartReferencePosition;
				selectionGrabActive = true;
				selectionHeld = false;
				selectionInputHeld = false;
			}
		}

		private void UpdateSelectionGrab()
		{
			if (!selectionGrabActive || groupManager == null || !TryGetGrabReferencePose(out var worldPosition, out var worldRotation))
			{
				return;
			}
			float voxelSize = groupManager.VoxelSize;
			float step = Mathf.Max(0.001f, grabPositionSnap);
			Quaternion quaternion = SnapRotation(worldRotation * Quaternion.Inverse(grabStartReferenceRotation));
			Vector3 vector = SnapVector(worldPosition + grabStartSelectionOffset, step);
			for (int num = grabbedGroupStates.Count - 1; num >= 0; num--)
			{
				GrabbedGroupState grabbedGroupState = grabbedGroupStates[num];
				if (grabbedGroupState == null || grabbedGroupState.group == null || !selectedGroups.Contains(grabbedGroupState.group))
				{
					if (grabbedGroupState != null && grabbedGroupState.group != null)
					{
						groupManager.SetGroupColliderEnabled(grabbedGroupState.group, grabbedGroupState.colliderWasEnabled);
						groupManager.BroadcastMoveFinal(grabbedGroupState.group);
					}
					grabbedGroupStates.RemoveAt(num);
				}
				else
				{
					Vector3 vector2 = grabbedGroupState.startWorldPosition - grabStartSelectionCenter;
					Vector3Int gridPosition = WorldToGrid(vector + quaternion * vector2, voxelSize);
					byte rotation = PackSnappedRotation(quaternion * GridRotationUtility.ToQuaternion(grabbedGroupState.startPackedRotation));
					if (groupManager.TransformGroup(grabbedGroupState.group, gridPosition, rotation, sendNetworkUpdate: false))
					{
						grabbedGroupState.group.SetSelected(selected: true);
						if (Time.unscaledTime - grabbedGroupState.lastPreviewSentAt >= Mathf.Max(0.01f, movePreviewSendInterval))
						{
							groupManager.BroadcastMovePreview(grabbedGroupState.group);
							grabbedGroupState.lastPreviewSentAt = Time.unscaledTime;
						}
					}
				}
			}
		}

		private void EndSelectionGrab()
		{
			if (!selectionGrabActive)
			{
				grabbedGroupStates.Clear();
				return;
			}
			selectionGrabActive = false;
			for (int i = 0; i < grabbedGroupStates.Count; i++)
			{
				GrabbedGroupState grabbedGroupState = grabbedGroupStates[i];
				if (grabbedGroupState != null && !(grabbedGroupState.group == null))
				{
					groupManager.SetGroupColliderEnabled(grabbedGroupState.group, grabbedGroupState.colliderWasEnabled);
					groupManager.BroadcastMoveFinal(grabbedGroupState.group);
				}
			}
			grabbedGroupStates.Clear();
		}

		private void DeleteSelectedGroups()
		{
			CleanupDestroyedSelections();
			if (selectedGroups.Count == 0)
			{
				return;
			}
			selectionBuffer.Clear();
			selectionBuffer.AddRange(selectedGroups);
			ClearSelectionInternal(suppressUntilNeutral: true);
			for (int i = 0; i < selectionBuffer.Count; i++)
			{
				VoxelGroup voxelGroup = selectionBuffer[i];
				if (voxelGroup != null)
				{
					groupManager.RemoveGroup(voxelGroup);
				}
			}
			selectionBuffer.Clear();
		}

		private void SendSelectedGroupsToInventory()
		{
			CleanupDestroyedSelections();
			if (selectedGroups.Count != 0)
			{
				SendSelectedGroupsToInventoryStub(selectedGroups.Count);
			}
		}

		public List<VoxelGroup> GetSelectedGroupsSnapshot()
		{
			CleanupDestroyedSelections();
			if (selectedGroups.Count == 0)
			{
				return new List<VoxelGroup>();
			}
			List<VoxelGroup> list = new List<VoxelGroup>(selectedGroups.Count);
			foreach (VoxelGroup selectedGroup in selectedGroups)
			{
				if (selectedGroup != null)
				{
					list.Add(selectedGroup);
				}
			}
			return list;
		}

		private void PaintSelectedGroups()
		{
			CleanupDestroyedSelections();
			if (selectedGroups.Count == 0)
			{
				return;
			}
			VRVoxelBrush instance = VRVoxelBrush.Instance;
			byte voxelValue = ((instance != null) ? instance.GetSelectedVoxelValue() : PackedVoxel.Create(16, VoxelMaterial.Lit));
			selectionBuffer.Clear();
			selectionBuffer.AddRange(selectedGroups);
			for (int i = 0; i < selectionBuffer.Count; i++)
			{
				VoxelGroup voxelGroup = selectionBuffer[i];
				if (voxelGroup != null && groupManager.PaintWholeGroup(voxelGroup, voxelValue))
				{
					VRHaptics.Pulse(rightHandDevice, 0.32f, 0.055f);
				}
			}
			selectionBuffer.Clear();
		}

		private void CleanupDestroyedSelections()
		{
			cleanupBuffer.Clear();
			foreach (VoxelGroup selectedGroup in selectedGroups)
			{
				if (selectedGroup == null)
				{
					cleanupBuffer.Add(selectedGroup);
				}
			}
			for (int i = 0; i < cleanupBuffer.Count; i++)
			{
				selectedGroups.Remove(cleanupBuffer[i]);
			}
			cleanupBuffer.Clear();
		}

		private bool TryGetSelectorPosition(out Vector3 worldPosition)
		{
			VRVoxelBrush instance = VRVoxelBrush.Instance;
			if (instance != null && !instance.UsingXRInput && instance.TryGetDesktopSelectionPoint(out worldPosition))
			{
				return true;
			}
			if (selectorOrigin != null)
			{
				worldPosition = selectorOrigin.position;
				return true;
			}
			if (rightHandDevice.isValid && rightHandDevice.TryGetFeatureValue(CommonUsages.devicePosition, out var value) && rightHandDevice.TryGetFeatureValue(CommonUsages.deviceRotation, out var value2))
			{
				if (trackingOrigin != null)
				{
					worldPosition = trackingOrigin.TransformPoint(value);
					_ = trackingOrigin.rotation * value2;
				}
				else
				{
					worldPosition = value;
				}
				return true;
			}
			worldPosition = base.transform.position;
			return true;
		}

		private bool TryGetGrabReferencePose(out Vector3 worldPosition, out Quaternion worldRotation)
		{
			VRVoxelBrush instance = VRVoxelBrush.Instance;
			if (instance != null && !instance.UsingXRInput)
			{
				Camera main = Camera.main;
				if (main != null)
				{
					worldPosition = main.transform.position;
					worldRotation = main.transform.rotation;
					return true;
				}
			}
			if (selectorOrigin != null)
			{
				worldPosition = selectorOrigin.position;
				worldRotation = selectorOrigin.rotation;
				return true;
			}
			if (rightHandDevice.isValid && rightHandDevice.TryGetFeatureValue(CommonUsages.devicePosition, out var value) && rightHandDevice.TryGetFeatureValue(CommonUsages.deviceRotation, out var value2))
			{
				if (trackingOrigin != null)
				{
					worldPosition = trackingOrigin.TransformPoint(value);
					worldRotation = trackingOrigin.rotation * value2;
				}
				else
				{
					worldPosition = value;
					worldRotation = value2;
				}
				return true;
			}
			worldPosition = base.transform.position;
			worldRotation = base.transform.rotation;
			return true;
		}

		private bool TryGetSelectedBounds(out Bounds bounds)
		{
			CleanupDestroyedSelections();
			bounds = default(Bounds);
			bool flag = false;
			foreach (VoxelGroup selectedGroup in selectedGroups)
			{
				if (!(selectedGroup == null))
				{
					if (!flag)
					{
						bounds = selectedGroup.GetWorldBounds();
						flag = true;
					}
					else
					{
						bounds.Encapsulate(selectedGroup.GetWorldBounds());
					}
				}
			}
			return flag;
		}

		private Vector3 SnapVector(Vector3 value, float step)
		{
			return new Vector3(Mathf.Round(value.x / step) * step, Mathf.Round(value.y / step) * step, Mathf.Round(value.z / step) * step);
		}

		private Quaternion SnapRotation(Quaternion rotation)
		{
			Vector3 eulerAngles = rotation.eulerAngles;
			return Quaternion.Euler(SnapAngle(eulerAngles.x), SnapAngle(eulerAngles.y), SnapAngle(eulerAngles.z));
		}

		private float SnapAngle(float angle)
		{
			return Mathf.Round(NormalizeSignedAngle(angle) / grabRotationSnapDegrees) * grabRotationSnapDegrees;
		}

		private static float NormalizeSignedAngle(float angle)
		{
			angle %= 360f;
			if (angle > 180f)
			{
				angle -= 360f;
			}
			else if (angle < -180f)
			{
				angle += 360f;
			}
			return angle;
		}

		private static Vector3Int WorldToGrid(Vector3 worldPosition, float voxelSize)
		{
			return new Vector3Int(Mathf.RoundToInt(worldPosition.x / voxelSize), Mathf.RoundToInt(worldPosition.y / voxelSize), Mathf.RoundToInt(worldPosition.z / voxelSize));
		}

		private static byte PackSnappedRotation(Quaternion rotation)
		{
			Vector3 eulerAngles = rotation.eulerAngles;
			return GridRotationUtility.Pack(new Vector3Int(AngleToQuarterTurns(eulerAngles.x), AngleToQuarterTurns(eulerAngles.y), AngleToQuarterTurns(eulerAngles.z)));
		}

		private static int AngleToQuarterTurns(float angle)
		{
			int num = Mathf.RoundToInt(NormalizeSignedAngle(angle) / 90f) % 4;
			if (num >= 0)
			{
				return num;
			}
			return num + 4;
		}

		private static bool ReadBool(InputDevice device, InputFeatureUsage<bool> usage)
		{
			bool value = default(bool);
			return device.isValid && device.TryGetFeatureValue(usage, out value) && value;
		}

		private bool ReadGrabHeld(InputDevice device)
		{
			if (!device.isValid)
			{
				return false;
			}
			bool value;
			bool num = device.TryGetFeatureValue(CommonUsages.gripButton, out value) && value;
			bool flag = ReadFloat(device, CommonUsages.grip) >= gripGrabThreshold;
			return num || flag;
		}

		private static float ReadFloat(InputDevice device, InputFeatureUsage<float> usage)
		{
			if (!device.isValid || !device.TryGetFeatureValue(usage, out var value))
			{
				return 0f;
			}
			return value;
		}

		private IEnumerator AnimateAndMergeSelectedGroups(List<VoxelGroup> groupsToMerge)
		{
			groupingAnimationActive = true;
			float num = Mathf.Max(((groupManager != null) ? groupManager.VoxelSize : 0.125f) * 0.9f, 0.12f);
			List<GroupMergeAnimationState> states = new List<GroupMergeAnimationState>(groupsToMerge.Count);
			Vector3 mergeCenter = Vector3.zero;
			int num2 = 0;
			for (int i = 0; i < groupsToMerge.Count; i++)
			{
				VoxelGroup voxelGroup = groupsToMerge[i];
				if (!(voxelGroup == null))
				{
					mergeCenter += voxelGroup.GetWorldBounds().center;
					num2++;
				}
			}
			if (num2 < 2)
			{
				groupingAnimationActive = false;
				yield break;
			}
			mergeCenter /= (float)num2;
			PlayGroupingClip(groupingClickClip, mergeCenter, 0.85f);
			VRHaptics.Pulse(rightHandDevice, 0.18f, 0.035f);
			VRHaptics.Pulse(rightHandDevice, 0.65f, 0.11f);
			for (int j = 0; j < groupsToMerge.Count; j++)
			{
				VoxelGroup voxelGroup2 = groupsToMerge[j];
				if (!(voxelGroup2 == null))
				{
					Vector3 center = voxelGroup2.GetWorldBounds().center;
					Vector3 vector = center - mergeCenter;
					if (vector.sqrMagnitude < 0.0001f)
					{
						float f = MathF.PI * 2f * (float)j / (float)Mathf.Max(1, num2);
						vector = new Vector3(Mathf.Cos(f), 0f, Mathf.Sin(f));
					}
					vector.Normalize();
					GroupMergeAnimationState item = new GroupMergeAnimationState
					{
						group = voxelGroup2,
						startTransformPosition = voxelGroup2.transform.position,
						startBoundsCenter = center,
						burstStartCenter = center,
						burstPeakCenter = center + vector * num
					};
					states.Add(item);
				}
			}
			float elapsed = 0f;
			while (elapsed < 0.18f)
			{
				elapsed += Time.unscaledDeltaTime;
				float num3 = Mathf.Clamp01(elapsed / 0.18f);
				for (int k = 0; k < states.Count; k++)
				{
					GroupMergeAnimationState state = states[k];
					if (!(state.group == null))
					{
						float t = 1f - Mathf.Pow(1f - num3, 2f);
						Vector3 animatedCenter = Vector3.LerpUnclamped(state.burstStartCenter, state.burstPeakCenter, t);
						SetAnimatedGroupCenter(state, animatedCenter);
					}
				}
				yield return null;
			}
			elapsed = 0f;
			while (elapsed < 0.17f)
			{
				elapsed += Time.unscaledDeltaTime;
				float num4 = Mathf.Clamp01(elapsed / 0.17f);
				for (int l = 0; l < states.Count; l++)
				{
					GroupMergeAnimationState state2 = states[l];
					if (!(state2.group == null))
					{
						float t2 = num4 * num4 * (3f - 2f * num4);
						Vector3 animatedCenter2 = Vector3.LerpUnclamped(state2.burstPeakCenter, state2.startBoundsCenter, t2);
						SetAnimatedGroupCenter(state2, animatedCenter2);
					}
				}
				yield return null;
			}
			for (int m = 0; m < states.Count; m++)
			{
				GroupMergeAnimationState groupMergeAnimationState = states[m];
				if (!(groupMergeAnimationState.group == null))
				{
					groupMergeAnimationState.group.transform.position = groupMergeAnimationState.startTransformPosition;
				}
			}
			selectionBuffer.Clear();
			for (int n = 0; n < states.Count; n++)
			{
				if (states[n].group != null)
				{
					selectionBuffer.Add(states[n].group);
				}
			}
			ClearSelectionInternal(suppressUntilNeutral: true);
			VoxelGroup mergedGroup = groupManager.MergeGroups(selectionBuffer);
			selectionBuffer.Clear();
			PlayGroupingClip(groupingThockClip, mergeCenter, 1f);
			VRHaptics.Pulse(rightHandDevice, 0.65f, 0.11f);
			if (mergedGroup != null)
			{
				float mergedVoxelSize = ((groupManager != null) ? groupManager.VoxelSize : 0.125f);
				Vector3 mergedCenter = mergedGroup.GetWorldBounds().center;
				Quaternion mergedRotation = mergedGroup.transform.rotation;
				Vector3 mergedLocalBoundsCenter = new Vector3(mergedGroup.size.x, mergedGroup.size.y, mergedGroup.size.z) * (mergedVoxelSize * 0.5f);
				float impactElapsed = 0f;
				while (impactElapsed < 0.05f)
				{
					impactElapsed += Time.unscaledDeltaTime;
					float num5 = Mathf.Clamp01(impactElapsed / 0.05f);
					float uniformScale = ((!(num5 < 0.5f)) ? Mathf.LerpUnclamped(1.05f, 1f, (num5 - 0.5f) / 0.5f) : Mathf.LerpUnclamped(0.95f, 1.05f, num5 / 0.5f));
					ApplyCenteredGroupScale(mergedGroup, mergedCenter, mergedRotation, mergedLocalBoundsCenter, uniformScale);
					yield return null;
				}
				ResetMergedGroupTransform(mergedGroup, mergedVoxelSize);
			}
			groupingAnimationActive = false;
		}

		private void SetAnimatedGroupCenter(GroupMergeAnimationState state, Vector3 animatedCenter)
		{
			if (!(state.group == null))
			{
				Vector3 vector = animatedCenter - state.startBoundsCenter;
				state.group.transform.position = state.startTransformPosition + vector;
			}
		}

		private static void ApplyCenteredGroupScale(VoxelGroup group, Vector3 worldCenter, Quaternion rotation, Vector3 localBoundsCenter, float uniformScale)
		{
			if (!(group == null))
			{
				Vector3 vector = localBoundsCenter * uniformScale;
				Vector3 position = worldCenter - rotation * vector;
				group.transform.SetPositionAndRotation(position, rotation);
				group.transform.localScale = Vector3.one * uniformScale;
			}
		}

		private static void ResetMergedGroupTransform(VoxelGroup group, float voxelSize)
		{
			if (!(group == null))
			{
				group.transform.localScale = Vector3.one;
				group.transform.SetPositionAndRotation((Vector3)group.position * voxelSize, GridRotationUtility.ToQuaternion(group.packedRotation));
			}
		}

		private void PlayGroupingClip(AudioClip clip, Vector3 position, float volume)
		{
			if (!(clip == null))
			{
				AudioSource.PlayClipAtPoint(clip, position, volume);
			}
		}

		private void EnsureGroupingClipsAssigned()
		{
			if (groupingClickClip == null)
			{
				groupingClickClip = Resources.Load<AudioClip>("Click");
			}
			if (groupingThockClip == null)
			{
				groupingThockClip = Resources.Load<AudioClip>("Thock");
			}
		}

		private void SendSelectedGroupsToInventoryStub(int selectedGroupCount)
		{
			if (selectedGroupCount > 0)
			{
				Debug.Log($"BlockSpace inventory send stub for {selectedGroupCount} selected groups.", this);
			}
		}
	}
}