using System;
using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using BlockSpace.Account;
using BlockSpace.Nodes;
using BlockSpace.Worlds;
using Photon.Pun;
using Photon.Realtime;
using Photon.VR;
using Photon.VR.Player;
using UnityEngine;

namespace BlockSpace.Voxels
{
	[DisallowMultipleComponent]
	[RequireComponent(typeof(PhotonView))]
	public sealed class VoxelGroupPhotonSync : MonoBehaviourPunCallbacks
	{
		private sealed class StrokePreviewState
		{
			public VoxelGroup group;

			public byte voxelValue;

			public float radius;

			public float forwardOffset;

			public Vector3 lastPoint;

			public readonly HashSet<Vector3Int> cells = new HashSet<Vector3Int>();
		}

		private sealed class ErasePreviewState
		{
			public float radius;

			public float forwardOffset;

			public Vector3 lastPoint;

			public readonly Dictionary<ushort, VoxelGroupManager.SavedGroupData> beforeByGroupId = new Dictionary<ushort, VoxelGroupManager.SavedGroupData>();
		}

		private sealed class MovePreviewState
		{
			public VoxelGroup group;

			public Vector3 targetPosition;

			public Quaternion targetRotation;

			public Vector3 velocity;

			public float lastPacketTime;
		}

		[SerializeField]
		private VoxelGroupManager groupManager;

		[SerializeField]
		private NodeGraphManager nodeGraphManager;

		[SerializeField]
		private float lateJoinReplayDelay = 0.5f;

		[Header("World Persistence")]
		[SerializeField]
		private bool enableWorldPersistence = true;

		[SerializeField]
		private string backendBaseUrl = "https://blockspacebackend-production.up.railway.app";

		[SerializeField]
		private float autoSaveIntervalSeconds = 30f;

		[SerializeField]
		private float permissionRefreshIntervalSeconds = 5f;

		[Header("World Sync")]
		[SerializeField]
		private float authoritySnapshotIntervalSeconds = 5f;

		[SerializeField]
		private float localEditSnapshotGraceSeconds = 3f;

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

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

		private readonly Dictionary<int, StrokePreviewState> strokePreviews = new Dictionary<int, StrokePreviewState>();

		private readonly Dictionary<int, ErasePreviewState> erasePreviews = new Dictionary<int, ErasePreviewState>();

		private readonly Dictionary<int, Transform> rightHandCache = new Dictionary<int, Transform>();

		private readonly Dictionary<ushort, MovePreviewState> movePreviews = new Dictionary<ushort, MovePreviewState>();

		private readonly List<ushort> movePreviewCleanup = new List<ushort>();

		private PhotonView cachedPhotonView;

		private Coroutine worldJoinCoroutine;

		private Coroutine worldAutoSaveCoroutine;

		private Coroutine worldPermissionRefreshCoroutine;

		private Coroutine worldTeleportCoroutine;

		private bool pendingWorldTeleportRestart;

		private bool currentTeleportShouldCompleteLoading;

		private bool pendingTeleportShouldCompleteLoading;

		private Coroutine authoritySnapshotCoroutine;

		private WorldBackendClient worldBackendClient;

		private string currentWorldId = string.Empty;

		private bool currentWorldExists;

		private bool isCreatorForCurrentWorld;

		private bool worldDirty;

		private bool suppressWorldDirty;

		private string cachedPlayerId = string.Empty;

		private string cachedBaseWorldName = string.Empty;

		private float lastLocalNetworkEditSentAt = float.NegativeInfinity;

		private void Reset()
		{
			groupManager = GetComponent<VoxelGroupManager>();
			nodeGraphManager = GetComponent<NodeGraphManager>();
		}

		private void Awake()
		{
			cachedPhotonView = GetComponent<PhotonView>();
			if (groupManager == null)
			{
				groupManager = GetComponent<VoxelGroupManager>();
				if (groupManager == null)
				{
					groupManager = UnityEngine.Object.FindAnyObjectByType<VoxelGroupManager>();
				}
			}
			if (nodeGraphManager == null)
			{
				nodeGraphManager = GetComponent<NodeGraphManager>();
				if (nodeGraphManager == null)
				{
					nodeGraphManager = UnityEngine.Object.FindAnyObjectByType<NodeGraphManager>();
				}
			}
			groupManager?.RegisterNetworkSync(this);
		}

		public override void OnEnable()
		{
			base.OnEnable();
			groupManager?.RegisterNetworkSync(this);
		}

		public override void OnDisable()
		{
			ClearStrokePreviews();
			ClearMovePreviews(restoreColliders: true);
			rightHandCache.Clear();
			StopWorldCoroutines();
			base.OnDisable();
		}

		private void Update()
		{
			UpdateMovePreviews();
		}

		public override void OnJoinedRoom()
		{
			Debug.Log($"[VoxelGroupPhotonSync] OnJoinedRoom: joined room '{PhotonNetwork.CurrentRoom?.Name}', isMaster={PhotonNetwork.IsMasterClient}.");
			SetLoadingCheckpoint(0.68f);
			if (!(groupManager == null))
			{
				ClearStrokePreviews();
				ClearMovePreviews(restoreColliders: false);
				rightHandCache.Clear();
				lastLocalNetworkEditSentAt = float.NegativeInfinity;
				if (!PhotonNetwork.IsMasterClient)
				{
					groupManager.ClearAllGroupsForNetworkSync();
				}
				if (enableWorldPersistence)
				{
					StopWorldCoroutines();
					worldJoinCoroutine = StartCoroutine(WorldResolveAndMaybeLoad());
				}
				StartAuthoritySnapshotLoopIfNeeded();
			}
		}

		public override void OnLeftRoom()
		{
			StopWorldCoroutines();
			StopAuthoritySnapshotLoop();
			ClearMovePreviews(restoreColliders: false);
			lastLocalNetworkEditSentAt = float.NegativeInfinity;
			if (groupManager != null)
			{
				groupManager.ClearAllGroupsForNetworkSync();
			}
			base.OnLeftRoom();
		}

		public override void OnMasterClientSwitched(Player newMasterClient)
		{
			base.OnMasterClientSwitched(newMasterClient);
			if (enableWorldPersistence && newMasterClient != null && newMasterClient == PhotonNetwork.LocalPlayer)
			{
				StartWorldAutoSaveIfNeeded();
			}
		}

		public override void OnPlayerEnteredRoom(Player newPlayer)
		{
			if (PhotonNetwork.IsMasterClient && !(groupManager == null) && newPlayer != null)
			{
				StartCoroutine(SendExistingGroupsToPlayerAfterDelay(newPlayer));
			}
		}

		public override void OnPlayerLeftRoom(Player otherPlayer)
		{
			if (otherPlayer != null)
			{
				EndStrokePreview(otherPlayer.ActorNumber);
				EndErasePreview(otherPlayer.ActorNumber);
				rightHandCache.Remove(otherPlayer.ActorNumber);
			}
		}

		private IEnumerator SendExistingGroupsToPlayerAfterDelay(Player newPlayer)
		{
			float num = Mathf.Max(0f, lateJoinReplayDelay);
			if (num > 0f)
			{
				yield return new WaitForSecondsRealtime(num);
			}
			else
			{
				yield return null;
			}
			if (!PhotonNetwork.InRoom || !PhotonNetwork.IsMasterClient || groupManager == null || newPlayer == null)
			{
				yield break;
			}
			syncBuffer.Clear();
			syncBuffer.AddRange(groupManager.GetAllGroups());
			for (int i = 0; i < syncBuffer.Count; i++)
			{
				if (!IsStrokePreviewGroup(syncBuffer[i]))
				{
					BroadcastCreate(syncBuffer[i], newPlayer, playSpawnAnimation: false, playSpawnParticles: false);
				}
			}
		}

		internal void BroadcastCreate(VoxelGroup group, bool playSpawnAnimation, bool playSpawnParticles = true)
		{
			BroadcastCreate(group, null, playSpawnAnimation, playSpawnParticles);
		}

		internal void BroadcastModify(VoxelGroup group)
		{
			if (CanSendRpc() && !(group == null))
			{
				MarkLocalNetworkEditSent();
				MarkWorldDirty();
				byte[] array = ((group.voxels != null) ? ((byte[])group.voxels.Clone()) : new byte[0]);
				cachedPhotonView.RPC("RPC_ModifyGroup", RpcTarget.Others, (int)group.id, group.position.x, group.position.y, group.position.z, group.zoneID, (int)group.packedRotation, group.size.x, group.size.y, group.size.z, array);
			}
		}

		internal void BroadcastMovePreview(VoxelGroup group)
		{
			if (CanSendRpc() && !(group == null) && PhotonNetwork.LocalPlayer != null)
			{
				MarkLocalNetworkEditSent();
				cachedPhotonView.RPC("RPC_MovePreview", RpcTarget.Others, PhotonNetwork.LocalPlayer.ActorNumber, (int)group.id, group.position.x, group.position.y, group.position.z, (int)group.packedRotation);
			}
		}

		internal void BroadcastMoveFinal(VoxelGroup group)
		{
			BroadcastModify(group);
		}

		internal void BroadcastSetColliderEnabled(VoxelGroup group, bool enabled)
		{
			if (CanSendRpc() && !(group == null))
			{
				MarkLocalNetworkEditSent();
				MarkWorldDirty();
				cachedPhotonView.RPC("RPC_SetGroupColliderEnabled", RpcTarget.Others, (int)group.id, enabled);
			}
		}

		internal void BroadcastDestroy(ushort groupId, bool playDestroyAnimation = true, bool playDestroyParticles = true)
		{
			if (CanSendRpc() && groupId != 0)
			{
				MarkLocalNetworkEditSent();
				MarkWorldDirty();
				cachedPhotonView.RPC("RPC_DestroyGroup", RpcTarget.Others, (int)groupId, playDestroyAnimation, playDestroyParticles);
			}
		}

		internal void BroadcastStrokePreviewBegin(byte voxelValue, float radius, float forwardOffset, Vector3 startPoint)
		{
			if (CanSendStrokePreviewRpc(voxelValue, radius))
			{
				MarkLocalNetworkEditSent();
				cachedPhotonView.RPC("RPC_BeginStrokePreview", RpcTarget.Others, PhotonNetwork.LocalPlayer.ActorNumber, (int)voxelValue, radius, forwardOffset, startPoint.x, startPoint.y, startPoint.z);
			}
		}

		internal void BroadcastStrokePreviewUpdate(byte voxelValue, float radius, float forwardOffset, Vector3 point)
		{
			if (CanSendStrokePreviewRpc(voxelValue, radius))
			{
				MarkLocalNetworkEditSent();
				cachedPhotonView.RPC("RPC_UpdateStrokePreview", RpcTarget.Others, PhotonNetwork.LocalPlayer.ActorNumber, (int)voxelValue, radius, forwardOffset, point.x, point.y, point.z);
			}
		}

		internal void BroadcastStrokePreviewEnd()
		{
			if (CanSendRpc() && PhotonNetwork.LocalPlayer != null)
			{
				MarkLocalNetworkEditSent();
				cachedPhotonView.RPC("RPC_EndStrokePreview", RpcTarget.Others, PhotonNetwork.LocalPlayer.ActorNumber);
			}
		}

		internal void BroadcastErasePreviewBegin(float radius, float forwardOffset, Vector3 startPoint)
		{
			if (CanSendRpc() && PhotonNetwork.LocalPlayer != null && !(radius <= 0f))
			{
				MarkLocalNetworkEditSent();
				cachedPhotonView.RPC("RPC_BeginErasePreview", RpcTarget.Others, PhotonNetwork.LocalPlayer.ActorNumber, radius, forwardOffset, startPoint.x, startPoint.y, startPoint.z);
			}
		}

		internal void BroadcastErasePreviewUpdate(float radius, float forwardOffset, Vector3 point)
		{
			if (CanSendRpc() && PhotonNetwork.LocalPlayer != null && !(radius <= 0f))
			{
				MarkLocalNetworkEditSent();
				cachedPhotonView.RPC("RPC_UpdateErasePreview", RpcTarget.Others, PhotonNetwork.LocalPlayer.ActorNumber, radius, forwardOffset, point.x, point.y, point.z);
			}
		}

		internal void BroadcastErasePreviewEnd()
		{
			if (CanSendRpc() && PhotonNetwork.LocalPlayer != null)
			{
				MarkLocalNetworkEditSent();
				cachedPhotonView.RPC("RPC_EndErasePreview", RpcTarget.Others, PhotonNetwork.LocalPlayer.ActorNumber);
			}
		}

		[PunRPC]
		private void RPC_CreateGroup(int groupId, int posX, int posY, int posZ, int zoneId, int packedRotation, int sizeX, int sizeY, int sizeZ, byte[] voxelData, bool playSpawnAnimation, bool playSpawnParticles, PhotonMessageInfo info)
		{
			if (!(groupManager == null))
			{
				EndPreviewForIncomingGroupEdit(groupId, info, includeStrokePreview: true);
				groupManager.ApplyNetworkCreateOrReplace((ushort)groupId, new Vector3Int(posX, posY, posZ), (byte)packedRotation, new Vector3Int(sizeX, sizeY, sizeZ), voxelData, zoneId, playSpawnAnimation, playSpawnParticles);
				EndMovePreview((ushort)groupId, restoreCollider: true);
				if (PhotonNetwork.IsMasterClient)
				{
					MarkWorldDirty();
				}
			}
		}

		[PunRPC]
		private void RPC_ModifyGroup(int groupId, int posX, int posY, int posZ, int zoneId, int packedRotation, int sizeX, int sizeY, int sizeZ, byte[] voxelData, PhotonMessageInfo info)
		{
			if (!(groupManager == null))
			{
				EndPreviewForIncomingGroupEdit(groupId, info, includeStrokePreview: false);
				groupManager.ApplyNetworkCreateOrReplace((ushort)groupId, new Vector3Int(posX, posY, posZ), (byte)packedRotation, new Vector3Int(sizeX, sizeY, sizeZ), voxelData, zoneId, playSpawnAnimation: false, playSpawnParticles: false);
				EndMovePreview((ushort)groupId, restoreCollider: true);
				if (PhotonNetwork.IsMasterClient)
				{
					MarkWorldDirty();
				}
			}
		}

		[PunRPC]
		private void RPC_MovePreview(int actorNumber, int groupId, int posX, int posY, int posZ, int packedRotation, PhotonMessageInfo info)
		{
			if (!(groupManager == null) && groupId > 0 && (PhotonNetwork.LocalPlayer == null || actorNumber != PhotonNetwork.LocalPlayer.ActorNumber) && groupManager.TryGetGroup((ushort)groupId, out var group) && !(group == null))
			{
				ushort key = (ushort)groupId;
				Vector3 vector = new Vector3(posX, posY, posZ) * groupManager.VoxelSize;
				Quaternion targetRotation = GridRotationUtility.ToQuaternion((byte)packedRotation);
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				if (!movePreviews.TryGetValue(key, out var value) || value.group == null)
				{
					value = new MovePreviewState
					{
						group = group,
						targetPosition = group.transform.position,
						targetRotation = group.transform.rotation,
						lastPacketTime = realtimeSinceStartup
					};
					movePreviews[key] = value;
				}
				float num = Mathf.Max(0.001f, realtimeSinceStartup - value.lastPacketTime);
				value.velocity = (vector - value.targetPosition) / num;
				value.targetPosition = vector;
				value.targetRotation = targetRotation;
				value.lastPacketTime = realtimeSinceStartup;
				groupManager.SetGroupColliderEnabled(group, enabled: false);
			}
		}

		[PunRPC]
		private void RPC_DestroyGroup(int groupId, bool playDestroyAnimation, bool playDestroyParticles, PhotonMessageInfo info)
		{
			if (!(groupManager == null))
			{
				EndPreviewForIncomingGroupEdit(groupId, info, includeStrokePreview: false);
				groupManager.ApplyNetworkDestroy((ushort)groupId, playDestroyAnimation, playDestroyParticles);
				EndMovePreview((ushort)groupId, restoreCollider: false);
				if (PhotonNetwork.IsMasterClient)
				{
					MarkWorldDirty();
				}
			}
		}

		[PunRPC]
		private void RPC_BeginStrokePreview(int actorNumber, int voxelValue, float radius, float forwardOffset, float pointX, float pointY, float pointZ)
		{
			if (!ShouldIgnoreStrokePreview(actorNumber, voxelValue, radius))
			{
				EndStrokePreview(actorNumber);
				byte voxelValue2 = (byte)voxelValue;
				Vector3 fallbackPoint = new Vector3(pointX, pointY, pointZ);
				Vector3 vector = ResolveRightHandStrokePoint(actorNumber, fallbackPoint, forwardOffset);
				VoxelGroup voxelGroup = groupManager.BeginStrokeGroup(0);
				StrokePreviewState strokePreviewState = new StrokePreviewState
				{
					group = voxelGroup,
					voxelValue = voxelValue2,
					radius = radius,
					forwardOffset = forwardOffset,
					lastPoint = vector
				};
				strokePreviews[actorNumber] = strokePreviewState;
				groupManager.RasterizeStrokeSegment(voxelGroup, vector, vector, radius, voxelValue2, strokePreviewState.cells);
			}
		}

		[PunRPC]
		private void RPC_UpdateStrokePreview(int actorNumber, int voxelValue, float radius, float forwardOffset, float pointX, float pointY, float pointZ)
		{
			if (!ShouldIgnoreStrokePreview(actorNumber, voxelValue, radius))
			{
				byte voxelValue2 = (byte)voxelValue;
				Vector3 fallbackPoint = new Vector3(pointX, pointY, pointZ);
				Vector3 vector = ResolveRightHandStrokePoint(actorNumber, fallbackPoint, forwardOffset);
				if (!strokePreviews.TryGetValue(actorNumber, out var value) || value.group == null)
				{
					RPC_BeginStrokePreview(actorNumber, voxelValue, radius, forwardOffset, pointX, pointY, pointZ);
					return;
				}
				value.voxelValue = voxelValue2;
				value.radius = radius;
				value.forwardOffset = forwardOffset;
				groupManager.RasterizeStrokeSegment(value.group, value.lastPoint, vector, radius, voxelValue2, value.cells);
				value.lastPoint = vector;
			}
		}

		[PunRPC]
		private void RPC_EndStrokePreview(int actorNumber)
		{
			EndStrokePreview(actorNumber);
		}

		[PunRPC]
		private void RPC_BeginErasePreview(int actorNumber, float radius, float forwardOffset, float pointX, float pointY, float pointZ)
		{
			if (!ShouldIgnoreErasePreview(actorNumber, radius))
			{
				EndErasePreview(actorNumber);
				Vector3 fallbackPoint = new Vector3(pointX, pointY, pointZ);
				Vector3 vector = ResolveRightHandStrokePoint(actorNumber, fallbackPoint, forwardOffset);
				ErasePreviewState erasePreviewState = new ErasePreviewState
				{
					radius = radius,
					forwardOffset = forwardOffset,
					lastPoint = vector
				};
				erasePreviews[actorNumber] = erasePreviewState;
				ApplyErasePreviewSegment(erasePreviewState, vector, vector);
			}
		}

		[PunRPC]
		private void RPC_UpdateErasePreview(int actorNumber, float radius, float forwardOffset, float pointX, float pointY, float pointZ)
		{
			if (!ShouldIgnoreErasePreview(actorNumber, radius))
			{
				Vector3 fallbackPoint = new Vector3(pointX, pointY, pointZ);
				Vector3 vector = ResolveRightHandStrokePoint(actorNumber, fallbackPoint, forwardOffset);
				if (!erasePreviews.TryGetValue(actorNumber, out var value))
				{
					RPC_BeginErasePreview(actorNumber, radius, forwardOffset, pointX, pointY, pointZ);
					return;
				}
				value.radius = radius;
				value.forwardOffset = forwardOffset;
				ApplyErasePreviewSegment(value, value.lastPoint, vector);
				value.lastPoint = vector;
			}
		}

		[PunRPC]
		private void RPC_EndErasePreview(int actorNumber)
		{
			EndErasePreview(actorNumber);
		}

		private void BroadcastCreate(VoxelGroup group, Player targetPlayer, bool playSpawnAnimation, bool playSpawnParticles)
		{
			if (CanSendRpc() && !(group == null))
			{
				byte[] array = ((group.voxels != null) ? ((byte[])group.voxels.Clone()) : new byte[0]);
				if (targetPlayer == null)
				{
					MarkLocalNetworkEditSent();
					MarkWorldDirty();
					cachedPhotonView.RPC("RPC_CreateGroup", RpcTarget.Others, (int)group.id, group.position.x, group.position.y, group.position.z, group.zoneID, (int)group.packedRotation, group.size.x, group.size.y, group.size.z, array, playSpawnAnimation, playSpawnParticles);
				}
				else
				{
					cachedPhotonView.RPC("RPC_CreateGroup", targetPlayer, (int)group.id, group.position.x, group.position.y, group.position.z, group.zoneID, (int)group.packedRotation, group.size.x, group.size.y, group.size.z, array, playSpawnAnimation, playSpawnParticles);
				}
			}
		}

		private void StopWorldCoroutines()
		{
			if (worldJoinCoroutine != null)
			{
				StopCoroutine(worldJoinCoroutine);
				worldJoinCoroutine = null;
			}
			if (worldAutoSaveCoroutine != null)
			{
				StopCoroutine(worldAutoSaveCoroutine);
				worldAutoSaveCoroutine = null;
			}
			if (worldPermissionRefreshCoroutine != null)
			{
				StopCoroutine(worldPermissionRefreshCoroutine);
				worldPermissionRefreshCoroutine = null;
			}
			if (worldTeleportCoroutine != null)
			{
				StopCoroutine(worldTeleportCoroutine);
				worldTeleportCoroutine = null;
			}
			pendingWorldTeleportRestart = false;
			currentTeleportShouldCompleteLoading = false;
			pendingTeleportShouldCompleteLoading = false;
			StopAuthoritySnapshotLoop();
			currentWorldId = string.Empty;
			currentWorldExists = false;
			isCreatorForCurrentWorld = false;
			worldDirty = false;
			suppressWorldDirty = false;
			cachedBaseWorldName = string.Empty;
		}

		private void StartAuthoritySnapshotLoopIfNeeded()
		{
			if (authoritySnapshotCoroutine == null && PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient && !(groupManager == null))
			{
				authoritySnapshotCoroutine = StartCoroutine(AuthoritySnapshotLoop());
			}
		}

		private void StopAuthoritySnapshotLoop()
		{
			if (authoritySnapshotCoroutine != null)
			{
				StopCoroutine(authoritySnapshotCoroutine);
				authoritySnapshotCoroutine = null;
			}
		}

		private IEnumerator AuthoritySnapshotLoop()
		{
			while (PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient && cachedPhotonView != null && groupManager != null)
			{
				float time = Mathf.Clamp(authoritySnapshotIntervalSeconds, 1.5f, 30f);
				yield return new WaitForSecondsRealtime(time);
				if (PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient && !(groupManager == null))
				{
					List<VoxelGroup> persistableWorldGroups = GetPersistableWorldGroups();
					int[] array = new int[persistableWorldGroups.Count];
					int[] array2 = new int[persistableWorldGroups.Count];
					for (int i = 0; i < persistableWorldGroups.Count; i++)
					{
						VoxelGroup voxelGroup = persistableWorldGroups[i];
						array[i] = ((voxelGroup != null) ? voxelGroup.id : 0);
						array2[i] = ((voxelGroup != null) ? ComputeFastGroupHash(voxelGroup) : 0);
					}
					cachedPhotonView.RPC("RPC_AuthoritySnapshot", RpcTarget.Others, array, array2);
				}
			}
			authoritySnapshotCoroutine = null;
		}

		private List<VoxelGroup> GetPersistableWorldGroups()
		{
			persistBuffer.Clear();
			if (groupManager == null)
			{
				return persistBuffer;
			}
			syncBuffer.Clear();
			syncBuffer.AddRange(groupManager.GetAllGroups());
			for (int i = 0; i < syncBuffer.Count; i++)
			{
				VoxelGroup voxelGroup = syncBuffer[i];
				if (!(voxelGroup == null) && !IsStrokePreviewGroup(voxelGroup) && voxelGroup.id < 60000)
				{
					persistBuffer.Add(voxelGroup);
				}
			}
			return persistBuffer;
		}

		[PunRPC]
		private void RPC_SetGroupColliderEnabled(int groupId, bool enabled, PhotonMessageInfo info)
		{
			if (!(groupManager == null) && groupId > 0)
			{
				if (groupManager.TryGetGroup((ushort)groupId, out var group) && group != null)
				{
					groupManager.SetGroupColliderEnabled(group, enabled);
				}
				if (PhotonNetwork.IsMasterClient)
				{
					MarkWorldDirty();
				}
			}
		}

		private static Dictionary<int, int> BuildGroupSaveIndexMap(IList<VoxelGroup> groups)
		{
			Dictionary<int, int> dictionary = new Dictionary<int, int>();
			if (groups == null)
			{
				return dictionary;
			}
			for (int i = 0; i < groups.Count; i++)
			{
				VoxelGroup voxelGroup = groups[i];
				if (voxelGroup != null)
				{
					dictionary[voxelGroup.id] = i;
				}
			}
			return dictionary;
		}

		private static int ComputeFastGroupHash(VoxelGroup group)
		{
			uint num = 2166136261u;
			num = (num ^ (uint)group.position.x) * 16777619;
			num = (num ^ (uint)group.position.y) * 16777619;
			num = (num ^ (uint)group.position.z) * 16777619;
			num = (num ^ group.packedRotation) * 16777619;
			num = (num ^ (uint)group.size.x) * 16777619;
			num = (num ^ (uint)group.size.y) * 16777619;
			num = (num ^ (uint)group.size.z) * 16777619;
			byte[] voxels = group.voxels;
			int num2 = ((voxels != null) ? voxels.Length : 0);
			num = (num ^ (uint)num2) * 16777619;
			if (num2 <= 0)
			{
				return (int)num;
			}
			int num3 = Mathf.Max(1, num2 / 256);
			for (int i = 0; i < num2; i += num3)
			{
				num = (num ^ voxels[i]) * 16777619;
			}
			num = (num ^ voxels[0]) * 16777619;
			return (int)((num ^ voxels[num2 - 1]) * 16777619);
		}

		[PunRPC]
		private void RPC_AuthoritySnapshot(int[] groupIds, int[] hashes, PhotonMessageInfo info)
		{
			if (groupManager == null || PhotonNetwork.IsMasterClient || groupIds == null || hashes == null || groupIds.Length != hashes.Length || ShouldDeferAuthoritySnapshot())
			{
				return;
			}
			int num = 0;
			for (int i = 0; i < groupIds.Length; i++)
			{
				int num2 = groupIds[i];
				if (num2 > 0 && num2 < 60000)
				{
					if (!groupManager.TryGetGroup((ushort)num2, out var group) || group == null)
					{
						num++;
					}
					else if (ComputeFastGroupHash(group) != hashes[i])
					{
						num++;
					}
				}
			}
			if (num <= 0 || cachedPhotonView == null)
			{
				return;
			}
			if (num > 6 || groupIds.Length > 64)
			{
				groupManager.ClearAllGroupsForNetworkSync();
				cachedPhotonView.RPC("RPC_RequestFullSnapshot", RpcTarget.MasterClient, PhotonNetwork.LocalPlayer.ActorNumber);
				return;
			}
			for (int j = 0; j < groupIds.Length; j++)
			{
				int num3 = groupIds[j];
				if (num3 > 0 && num3 < 60000 && (!groupManager.TryGetGroup((ushort)num3, out var group2) || group2 == null || ComputeFastGroupHash(group2) != hashes[j]))
				{
					cachedPhotonView.RPC("RPC_RequestGroupSnapshot", RpcTarget.MasterClient, num3, PhotonNetwork.LocalPlayer.ActorNumber);
				}
			}
		}

		[PunRPC]
		private void RPC_RequestFullSnapshot(int actorNumber, PhotonMessageInfo info)
		{
			if (PhotonNetwork.IsMasterClient && !(groupManager == null))
			{
				Player player = ((PhotonNetwork.CurrentRoom != null) ? PhotonNetwork.CurrentRoom.GetPlayer(actorNumber) : null);
				if (player != null)
				{
					StartCoroutine(SendExistingGroupsToPlayerAfterDelay(player));
				}
			}
		}

		[PunRPC]
		private void RPC_RequestGroupSnapshot(int groupId, int actorNumber, PhotonMessageInfo info)
		{
			if (PhotonNetwork.IsMasterClient && !(groupManager == null) && groupId > 0)
			{
				Player player = ((PhotonNetwork.CurrentRoom != null) ? PhotonNetwork.CurrentRoom.GetPlayer(actorNumber) : null);
				if (player != null && groupManager.TryGetGroup((ushort)groupId, out var group) && !(group == null))
				{
					BroadcastCreate(group, player, playSpawnAnimation: false, playSpawnParticles: false);
				}
			}
		}

		private void MarkLocalNetworkEditSent()
		{
			lastLocalNetworkEditSentAt = Time.realtimeSinceStartup;
		}

		private void EndPreviewForIncomingGroupEdit(int groupId, PhotonMessageInfo info, bool includeStrokePreview)
		{
			int num = ((info.Sender != null) ? info.Sender.ActorNumber : 0);
			if (num <= 0)
			{
				num = GetActorNumberFromGroupId(groupId);
			}
			if (num > 0)
			{
				EndErasePreview(num);
				if (includeStrokePreview)
				{
					EndStrokePreview(num);
				}
			}
		}

		private bool ShouldDeferAuthoritySnapshot()
		{
			if (strokePreviews.Count > 0 || erasePreviews.Count > 0)
			{
				return true;
			}
			float num = Mathf.Clamp(localEditSnapshotGraceSeconds, 0f, 10f);
			if (num <= 0f)
			{
				return false;
			}
			return Time.realtimeSinceStartup - lastLocalNetworkEditSentAt < num;
		}

		private void MarkWorldDirty()
		{
			if (!suppressWorldDirty && enableWorldPersistence && currentWorldExists && !string.IsNullOrEmpty(currentWorldId))
			{
				worldDirty = true;
			}
		}

		private void EnsureWorldBackendClient()
		{
			if (worldBackendClient == null)
			{
				worldBackendClient = new WorldBackendClient(backendBaseUrl);
			}
		}

		private void ScheduleTeleportAfterWorldLoad(bool isMaster, bool forceRestart = false, bool completeLoading = false)
		{
			Debug.Log($"[VoxelGroupPhotonSync] ScheduleTeleportAfterWorldLoad: isMaster={isMaster}, forceRestart={forceRestart}, completeLoading={completeLoading}, alreadyScheduled={worldTeleportCoroutine != null}.");
			SetLoadingCheckpoint(forceRestart ? 0.95f : 0.82f);
			if (forceRestart && worldTeleportCoroutine != null)
			{
				pendingWorldTeleportRestart = true;
				pendingTeleportShouldCompleteLoading = completeLoading;
				return;
			}
			if (worldTeleportCoroutine != null)
			{
				currentTeleportShouldCompleteLoading |= completeLoading;
				return;
			}
			pendingWorldTeleportRestart = false;
			pendingTeleportShouldCompleteLoading = false;
			currentTeleportShouldCompleteLoading = completeLoading;
			float delaySeconds = (isMaster ? 0.5f : Mathf.Clamp(lateJoinReplayDelay + 0.5f, 0.5f, 5f));
			worldTeleportCoroutine = StartCoroutine(TeleportLocalPlayerAfterDelay(delaySeconds));
		}

		private IEnumerator TeleportLocalPlayerAfterDelay(float delaySeconds)
		{
			Debug.Log($"[VoxelGroupPhotonSync] TeleportLocalPlayerAfterDelay: waiting for Photon lobby/room connectivity. delay={delaySeconds}.");
			SetLoadingCheckpoint(0.84f);
			float connectionWaitStart = Time.realtimeSinceStartup;
			while (!PhotonNetwork.IsConnectedAndReady || (!PhotonNetwork.InLobby && !PhotonNetwork.InRoom))
			{
				if (Time.realtimeSinceStartup - connectionWaitStart > 10f)
				{
					Debug.LogWarning($"[VoxelGroupPhotonSync] TeleportLocalPlayerAfterDelay: timed out waiting for Photon connection. state={PhotonNetwork.NetworkClientState}, inRoom={PhotonNetwork.InRoom}, inLobby={PhotonNetwork.InLobby}.");
					if (currentTeleportShouldCompleteLoading)
					{
						CompleteLoadingScreen();
					}
					FinishTeleportCoroutine();
					yield break;
				}
				yield return null;
			}
			Debug.Log($"[VoxelGroupPhotonSync] TeleportLocalPlayerAfterDelay: Photon connected. InLobby={PhotonNetwork.InLobby}, InRoom={PhotonNetwork.InRoom}.");
			SetLoadingCheckpoint(0.86f);
			yield return new WaitForSecondsRealtime(Mathf.Max(0f, delaySeconds));
			if (!PhotonNetwork.InRoom || PhotonNetwork.LocalPlayer == null)
			{
				Debug.LogWarning("[VoxelGroupPhotonSync] TeleportLocalPlayerAfterDelay: aborting because not in room or local player is missing after delay.");
				if (currentTeleportShouldCompleteLoading && PhotonNetwork.InRoom)
				{
					CompleteLoadingScreen();
				}
				FinishTeleportCoroutine();
				yield break;
			}
			PhotonVRPlayer localPlayer = null;
			float playerWaitStart = Time.realtimeSinceStartup;
			while (localPlayer == null && Time.realtimeSinceStartup - playerWaitStart < 3f)
			{
				PhotonVRPlayer[] array = UnityEngine.Object.FindObjectsByType<PhotonVRPlayer>(FindObjectsInactive.Include);
				foreach (PhotonVRPlayer photonVRPlayer in array)
				{
					if (!(photonVRPlayer == null))
					{
						PhotonView component = photonVRPlayer.GetComponent<PhotonView>();
						if (!(component == null) && component.OwnerActorNr == PhotonNetwork.LocalPlayer.ActorNumber)
						{
							localPlayer = photonVRPlayer;
							break;
						}
					}
				}
				if (localPlayer != null)
				{
					break;
				}
				yield return null;
			}
			if (localPlayer == null)
			{
				Debug.LogWarning($"[VoxelGroupPhotonSync] TeleportLocalPlayerAfterDelay: no local PhotonVRPlayer found after {Time.realtimeSinceStartup - playerWaitStart:F2}s.");
				if (currentTeleportShouldCompleteLoading)
				{
					CompleteLoadingScreen();
				}
				FinishTeleportCoroutine();
				yield break;
			}
			SetLoadingCheckpoint(0.9f);
			Vector3 vector = new Vector3(0f, 5f, 0f);
			Transform localVrTeleportRoot = GetLocalVrTeleportRoot();
			if (localVrTeleportRoot != null)
			{
				MoveTransformTo(localVrTeleportRoot, vector);
				Debug.Log($"[VoxelGroupPhotonSync] TeleportLocalPlayerAfterDelay: teleported VR root '{localVrTeleportRoot.name}' to {vector}.");
				NotifyLoadingPlayerTeleported(currentTeleportShouldCompleteLoading);
				FinishTeleportCoroutine();
				yield break;
			}
			Debug.LogWarning("[VoxelGroupPhotonSync] TeleportLocalPlayerAfterDelay: no VR root found; teleporting local PhotonVRPlayer only.");
			if (localPlayer != null)
			{
				MoveTransformTo(localPlayer.transform, vector);
				Debug.Log($"[VoxelGroupPhotonSync] TeleportLocalPlayerAfterDelay: teleported local PhotonVRPlayer '{localPlayer.name}' to {vector}.");
				NotifyLoadingPlayerTeleported(currentTeleportShouldCompleteLoading);
			}
			FinishTeleportCoroutine();
		}

		private void FinishTeleportCoroutine()
		{
			worldTeleportCoroutine = null;
			currentTeleportShouldCompleteLoading = false;
			if (pendingWorldTeleportRestart)
			{
				bool completeLoading = pendingTeleportShouldCompleteLoading;
				pendingWorldTeleportRestart = false;
				pendingTeleportShouldCompleteLoading = false;
				ScheduleTeleportAfterWorldLoad(isMaster: true, forceRestart: false, completeLoading);
			}
		}

		private static void MoveTransformTo(Transform target, Vector3 position)
		{
			if (target == null)
			{
				return;
			}
			CharacterController component = target.GetComponent<CharacterController>();
			if (component != null)
			{
				bool flag = component.enabled;
				component.enabled = false;
				target.position = position;
				component.enabled = flag;
				Rigidbody component2 = target.GetComponent<Rigidbody>();
				if (component2 != null)
				{
					component2.linearVelocity = Vector3.zero;
					component2.angularVelocity = Vector3.zero;
				}
			}
			else
			{
				target.position = position;
				Rigidbody component3 = target.GetComponent<Rigidbody>();
				if (component3 != null)
				{
					component3.linearVelocity = Vector3.zero;
					component3.angularVelocity = Vector3.zero;
				}
			}
		}

		private static Transform GetLocalVrTeleportRoot()
		{
			if (PhotonVRManager.Manager == null || PhotonVRManager.Manager.Head == null)
			{
				return null;
			}
			Transform head = PhotonVRManager.Manager.Head;
			if (head.parent == null)
			{
				return head;
			}
			Transform parent = head.parent;
			while (parent != null)
			{
				if (parent.GetComponent<CharacterController>() != null)
				{
					return parent;
				}
				if (parent.parent == null)
				{
					return parent;
				}
				parent = parent.parent;
			}
			return head;
		}

		private static string GetBaseWorldName(string roomName)
		{
			string text = (roomName ?? string.Empty).Trim();
			if (string.IsNullOrEmpty(text))
			{
				return text;
			}
			int num = text.LastIndexOf('|');
			if (num <= 0)
			{
				return text;
			}
			string text2 = text.Substring(num + 1);
			if (text2.Length == 3 && Regex.IsMatch(text2, "^[A-Za-z0-9]{3}$"))
			{
				return text.Substring(0, num);
			}
			return text;
		}

		private IEnumerator WorldResolveAndMaybeLoad()
		{
			Debug.Log("[VoxelGroupPhotonSync] WorldResolveAndMaybeLoad: starting world resolve and load.");
			SetLoadingCheckpoint(0.7f);
			if (groupManager == null || !PhotonNetwork.InRoom)
			{
				Debug.LogWarning("[VoxelGroupPhotonSync] WorldResolveAndMaybeLoad: aborted because groupManager is null or not in room.");
				yield break;
			}
			string text = ((PhotonNetwork.CurrentRoom != null) ? PhotonNetwork.CurrentRoom.Name : string.Empty);
			Debug.Log("[VoxelGroupPhotonSync] WorldResolveAndMaybeLoad: current room name='" + text + "'.");
			SetLoadingCheckpoint(0.72f);
			string baseWorldName = GetBaseWorldName(text);
			if (string.IsNullOrEmpty(baseWorldName))
			{
				Debug.LogWarning("[VoxelGroupPhotonSync] WorldResolveAndMaybeLoad: could not determine base world name from room.");
				yield break;
			}
			cachedPlayerId = BlockSpaceAccountPrefs.GetUserFolderId();
			cachedBaseWorldName = baseWorldName;
			EnsureWorldBackendClient();
			WorldBackendClient.ResolveWorldResponse resolve = null;
			SetLoadingCheckpoint(0.74f);
			yield return worldBackendClient.ResolveWorld(baseWorldName, cachedPlayerId, delegate(WorldBackendClient.ResolveWorldResponse r)
			{
				resolve = r;
			});
			if (resolve == null || !resolve.ok)
			{
				Debug.LogWarning("[VoxelGroupPhotonSync] WorldResolveAndMaybeLoad: resolve failed. resolve=" + ((resolve == null) ? "null" : resolve.ok.ToString()) + ", worldId=" + ((resolve != null) ? resolve.worldId : "<null>") + ", error=" + ((resolve != null) ? resolve.error : "<null>"));
				groupManager.SetEditingLocked(locked: true);
				ScheduleTeleportAfterWorldLoad(PhotonNetwork.IsMasterClient, forceRestart: false, completeLoading: true);
				yield break;
			}
			currentWorldExists = resolve.exists;
			currentWorldId = resolve.worldId ?? string.Empty;
			isCreatorForCurrentWorld = resolve.isCreator;
			bool flag = string.Equals(cachedBaseWorldName, "Lobby", StringComparison.OrdinalIgnoreCase);
			groupManager.SetEditingLocked(!isCreatorForCurrentWorld && !flag);
			Debug.Log($"[VoxelGroupPhotonSync] WorldResolveAndMaybeLoad: resolved baseWorldName='{cachedBaseWorldName}', worldExists={currentWorldExists}, worldId='{currentWorldId}', isCreator={isCreatorForCurrentWorld}.");
			SetLoadingCheckpoint(0.78f);
			StartWorldAutoSaveIfNeeded();
			StartWorldPermissionRefreshIfNeeded();
			Debug.Log("[VoxelGroupPhotonSync] WorldResolveAndMaybeLoad: scheduling teleport after world load.");
			ScheduleTeleportAfterWorldLoad(PhotonNetwork.IsMasterClient, forceRestart: false, !PhotonNetwork.IsMasterClient);
			if (!currentWorldExists || string.IsNullOrEmpty(currentWorldId) || !PhotonNetwork.IsMasterClient)
			{
				ScheduleTeleportAfterWorldLoad(PhotonNetwork.IsMasterClient, forceRestart: false, completeLoading: true);
				yield break;
			}
			groupManager.ClearAllGroupsForNetworkSync();
			byte[] gzipBytes = null;
			SetLoadingCheckpoint(0.88f);
			yield return worldBackendClient.DownloadGroups(currentWorldId, delegate(byte[] bytes)
			{
				gzipBytes = bytes;
			});
			if (gzipBytes == null)
			{
				gzipBytes = Array.Empty<byte>();
			}
			if (!WorldGroupsCodec.TryDecodeGzip(gzipBytes, out WorldGroupsCodec.WorldSaveData saveData))
			{
				Debug.LogWarning("[VoxelGroupPhotonSync] Failed to decode world groups; starting with an empty world.");
				ScheduleTeleportAfterWorldLoad(isMaster: true, forceRestart: false, completeLoading: true);
				yield break;
			}
			List<WorldGroupsCodec.WorldGroupRecord> list = saveData.groupRecords ?? new List<WorldGroupsCodec.WorldGroupRecord>();
			Debug.Log($"[VoxelGroupPhotonSync] WorldResolveAndMaybeLoad: decoded {list.Count} world group records.");
			SetLoadingCheckpoint(0.91f);
			if (list.Count == 0)
			{
				Debug.Log("[VoxelGroupPhotonSync] WorldResolveAndMaybeLoad: world contains no saved groups.");
			}
			suppressWorldDirty = true;
			try
			{
				Dictionary<int, int> dictionary = new Dictionary<int, int>();
				for (int num = 0; num < list.Count; num++)
				{
					WorldGroupsCodec.WorldGroupRecord worldGroupRecord = list[num];
					VoxelGroupManager.SavedGroupData data = new VoxelGroupManager.SavedGroupData
					{
						position = worldGroupRecord.position,
						packedRotation = worldGroupRecord.packedRotation,
						size = worldGroupRecord.size,
						voxels = worldGroupRecord.voxels
					};
					VoxelGroup voxelGroup = groupManager.SpawnSavedGroup(data, worldGroupRecord.position);
					if (voxelGroup != null)
					{
						dictionary[num] = voxelGroup.id;
					}
				}
				if (nodeGraphManager != null)
				{
					nodeGraphManager.ApplySavedGraph(saveData.nodeRecords, saveData.wireRecords, clearExisting: true, broadcast: false, Vector3.zero, dictionary);
					(nodeGraphManager.GetComponent<NodeWorldDefaultSpawner>() ?? nodeGraphManager.gameObject.AddComponent<NodeWorldDefaultSpawner>()).EnsureDefaultNodesSpawnedIfEmpty(saveData.nodeRecords, PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient);
				}
				worldDirty = false;
				SetLoadingCheckpoint(0.93f);
			}
			finally
			{
				suppressWorldDirty = false;
			}
			WorldBackendClient.VisitResponse visit = null;
			yield return worldBackendClient.IncrementVisit(currentWorldId, delegate(WorldBackendClient.VisitResponse r)
			{
				visit = r;
			});
			SetLoadingCheckpoint(0.94f);
			ScheduleTeleportAfterWorldLoad(isMaster: true, forceRestart: true, completeLoading: true);
		}

		private static void SetLoadingCheckpoint(float progress)
		{
			((WorldLoadingScreenController.Instance != null) ? WorldLoadingScreenController.Instance : UnityEngine.Object.FindFirstObjectByType<WorldLoadingScreenController>())?.SetCheckpoint(progress);
		}

		private static void NotifyLoadingPlayerTeleported(bool completeLoading)
		{
			((WorldLoadingScreenController.Instance != null) ? WorldLoadingScreenController.Instance : UnityEngine.Object.FindFirstObjectByType<WorldLoadingScreenController>())?.NotifyLocalPlayerTeleported(completeLoading);
		}

		private static void CompleteLoadingScreen()
		{
			((WorldLoadingScreenController.Instance != null) ? WorldLoadingScreenController.Instance : UnityEngine.Object.FindFirstObjectByType<WorldLoadingScreenController>())?.CompleteLoading();
		}

		private void StartWorldPermissionRefreshIfNeeded()
		{
			if (worldPermissionRefreshCoroutine == null && enableWorldPersistence && !string.IsNullOrEmpty(cachedBaseWorldName) && !string.IsNullOrEmpty(cachedPlayerId))
			{
				worldPermissionRefreshCoroutine = StartCoroutine(WorldPermissionRefreshLoop());
			}
		}

		private IEnumerator WorldPermissionRefreshLoop()
		{
			while (PhotonNetwork.InRoom && enableWorldPersistence && !string.IsNullOrEmpty(cachedBaseWorldName))
			{
				yield return new WaitForSecondsRealtime(Mathf.Clamp(permissionRefreshIntervalSeconds, 2f, 30f));
				if (groupManager == null)
				{
					continue;
				}
				EnsureWorldBackendClient();
				WorldBackendClient.ResolveWorldResponse resolve = null;
				yield return worldBackendClient.ResolveWorld(cachedBaseWorldName, cachedPlayerId, delegate(WorldBackendClient.ResolveWorldResponse r)
				{
					resolve = r;
				});
				if (resolve != null && resolve.ok)
				{
					bool isCreator = resolve.isCreator;
					if (isCreator != isCreatorForCurrentWorld)
					{
						isCreatorForCurrentWorld = isCreator;
						bool flag = string.Equals(cachedBaseWorldName, "Lobby", StringComparison.OrdinalIgnoreCase);
						groupManager.SetEditingLocked(!isCreatorForCurrentWorld && !flag);
					}
				}
			}
			worldPermissionRefreshCoroutine = null;
		}

		private void StartWorldAutoSaveIfNeeded()
		{
			if (worldAutoSaveCoroutine == null && PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient && enableWorldPersistence && currentWorldExists && !string.IsNullOrEmpty(currentWorldId))
			{
				worldAutoSaveCoroutine = StartCoroutine(WorldAutoSaveLoop());
			}
		}

		private IEnumerator WorldAutoSaveLoop()
		{
			while (PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient && enableWorldPersistence && currentWorldExists && !string.IsNullOrEmpty(currentWorldId))
			{
				yield return new WaitForSecondsRealtime(Mathf.Clamp(autoSaveIntervalSeconds, 5f, 300f));
				if (worldDirty && !suppressWorldDirty && isCreatorForCurrentWorld && !(groupManager == null))
				{
					EnsureWorldBackendClient();
					List<VoxelGroup> persistableWorldGroups = GetPersistableWorldGroups();
					byte[] gzipBytes = WorldGroupsCodec.EncodeGzip(persistableWorldGroups, (nodeGraphManager != null) ? nodeGraphManager.BuildWorldNodeRecords() : null, (nodeGraphManager != null) ? nodeGraphManager.BuildWorldWireRecords(null, BuildGroupSaveIndexMap(persistableWorldGroups)) : null);
					WorldBackendClient.UploadGroupsResponse upload = null;
					yield return worldBackendClient.UploadGroups(currentWorldId, gzipBytes, cachedPlayerId, delegate(WorldBackendClient.UploadGroupsResponse r)
					{
						upload = r;
					});
					if (upload != null && upload.ok && upload.saved)
					{
						worldDirty = false;
					}
				}
			}
			worldAutoSaveCoroutine = null;
		}

		public IEnumerator ForceSaveNow()
		{
			if (!enableWorldPersistence || !currentWorldExists || string.IsNullOrEmpty(currentWorldId) || !PhotonNetwork.InRoom || !isCreatorForCurrentWorld || groupManager == null)
			{
				yield break;
			}
			EnsureWorldBackendClient();
			List<VoxelGroup> persistableWorldGroups = GetPersistableWorldGroups();
			byte[] gzipBytes = WorldGroupsCodec.EncodeGzip(persistableWorldGroups, (nodeGraphManager != null) ? nodeGraphManager.BuildWorldNodeRecords() : null, (nodeGraphManager != null) ? nodeGraphManager.BuildWorldWireRecords(null, BuildGroupSaveIndexMap(persistableWorldGroups)) : null);
			WorldBackendClient.UploadGroupsResponse upload = null;
			yield return worldBackendClient.UploadGroups(currentWorldId, gzipBytes, cachedPlayerId, delegate(WorldBackendClient.UploadGroupsResponse r)
			{
				upload = r;
			});
			if (upload != null && upload.ok && upload.saved)
			{
				worldDirty = false;
				WorldBackendClient.BroadcastReloadResponse broadcast = null;
				yield return worldBackendClient.BroadcastReload(cachedPlayerId, cachedBaseWorldName, delegate(WorldBackendClient.BroadcastReloadResponse r)
				{
					broadcast = r;
				});
			}
		}

		private bool CanSendRpc()
		{
			if (!PhotonNetwork.InRoom || cachedPhotonView == null)
			{
				return false;
			}
			if (cachedPhotonView.ViewID == 0)
			{
				Debug.LogWarning("VoxelGroupPhotonSync requires a valid PhotonView ViewID to send RPCs.", this);
				return false;
			}
			return true;
		}

		private bool CanSendStrokePreviewRpc(byte voxelValue, float radius)
		{
			if (CanSendRpc() && PhotonNetwork.LocalPlayer != null && radius > 0f)
			{
				return !PackedVoxel.IsAir(voxelValue);
			}
			return false;
		}

		private bool ShouldIgnoreStrokePreview(int actorNumber, int voxelValue, float radius)
		{
			if (!(groupManager == null) && actorNumber > 0 && (PhotonNetwork.LocalPlayer == null || actorNumber != PhotonNetwork.LocalPlayer.ActorNumber) && voxelValue >= 0 && voxelValue <= 255 && !(radius <= 0f))
			{
				return PackedVoxel.IsAir((byte)voxelValue);
			}
			return true;
		}

		private bool ShouldIgnoreErasePreview(int actorNumber, float radius)
		{
			if (!(groupManager == null) && actorNumber > 0 && (PhotonNetwork.LocalPlayer == null || actorNumber != PhotonNetwork.LocalPlayer.ActorNumber))
			{
				return radius <= 0f;
			}
			return true;
		}

		private Vector3 ResolveRightHandStrokePoint(int actorNumber, Vector3 fallbackPoint, float forwardOffset)
		{
			if (TryFindRightHand(actorNumber, out var rightHand))
			{
				return rightHand.position + rightHand.rotation * Vector3.forward * forwardOffset;
			}
			return fallbackPoint;
		}

		private bool TryFindRightHand(int actorNumber, out Transform rightHand)
		{
			if (rightHandCache.TryGetValue(actorNumber, out rightHand) && rightHand != null)
			{
				return true;
			}
			PhotonVRPlayer[] array = UnityEngine.Object.FindObjectsByType<PhotonVRPlayer>(FindObjectsInactive.Include);
			foreach (PhotonVRPlayer photonVRPlayer in array)
			{
				if (photonVRPlayer == null)
				{
					continue;
				}
				PhotonView component = photonVRPlayer.GetComponent<PhotonView>();
				if (!(component == null) && component.OwnerActorNr == actorNumber)
				{
					rightHand = ((photonVRPlayer.RightHand != null) ? photonVRPlayer.RightHand : photonVRPlayer.transform.Find("RightHand"));
					if (!(rightHand != null))
					{
						break;
					}
					rightHandCache[actorNumber] = rightHand;
					return true;
				}
			}
			rightHandCache.Remove(actorNumber);
			rightHand = null;
			return false;
		}

		private void EndStrokePreview(int actorNumber)
		{
			if (actorNumber > 0 && strokePreviews.TryGetValue(actorNumber, out var value))
			{
				strokePreviews.Remove(actorNumber);
				if (groupManager != null && value.group != null)
				{
					groupManager.DiscardTransientStrokeGroup(value.group);
				}
			}
		}

		private void ApplyErasePreviewSegment(ErasePreviewState state, Vector3 start, Vector3 end)
		{
			if (!(groupManager == null) && state != null)
			{
				float num = Mathf.Max(groupManager.VoxelSize * 0.5f, state.radius * 0.5f);
				float num2 = Vector3.Distance(start, end);
				int num3 = Mathf.Max(1, Mathf.CeilToInt(num2 / num));
				HashSet<VoxelGroup> editedGroups = new HashSet<VoxelGroup>();
				for (int i = 0; i <= num3; i++)
				{
					float t = ((num3 == 0) ? 0f : ((float)i / (float)num3));
					Vector3 vector = Vector3.Lerp(start, end, t);
					SnapshotErasePreviewGroups(state, vector, state.radius);
					groupManager.EraseSpherePreview(vector, state.radius, editedGroups);
				}
			}
		}

		private void SnapshotErasePreviewGroups(ErasePreviewState state, Vector3 point, float radius)
		{
			List<VoxelGroup> groupsInRadius = groupManager.GetGroupsInRadius(point, radius);
			for (int i = 0; i < groupsInRadius.Count; i++)
			{
				VoxelGroup voxelGroup = groupsInRadius[i];
				if (!(voxelGroup == null) && !state.beforeByGroupId.ContainsKey(voxelGroup.id) && groupManager.TryCaptureGroupData(voxelGroup, out var data))
				{
					state.beforeByGroupId[voxelGroup.id] = data;
				}
			}
		}

		private void EndErasePreview(int actorNumber)
		{
			if (actorNumber <= 0 || !erasePreviews.TryGetValue(actorNumber, out var value))
			{
				return;
			}
			erasePreviews.Remove(actorNumber);
			foreach (KeyValuePair<ushort, VoxelGroupManager.SavedGroupData> item in value.beforeByGroupId)
			{
				groupManager?.TryRestoreTransientGroup(item.Key, item.Value);
			}
		}

		private void UpdateMovePreviews()
		{
			if (movePreviews.Count == 0 || groupManager == null)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			float t = 1f - Mathf.Exp(-18f * Time.deltaTime);
			movePreviewCleanup.Clear();
			foreach (KeyValuePair<ushort, MovePreviewState> movePreview in movePreviews)
			{
				MovePreviewState value = movePreview.Value;
				if (value == null || value.group == null)
				{
					movePreviewCleanup.Add(movePreview.Key);
					continue;
				}
				float num = Mathf.Clamp(realtimeSinceStartup - value.lastPacketTime, 0f, 0.15f);
				Vector3 b = value.targetPosition + value.velocity * num;
				Quaternion rotation = value.group.transform.rotation;
				value.group.transform.SetPositionAndRotation(Vector3.Lerp(value.group.transform.position, b, t), Quaternion.Slerp(rotation, value.targetRotation, t));
				if (realtimeSinceStartup - value.lastPacketTime > 2f)
				{
					movePreviewCleanup.Add(movePreview.Key);
				}
			}
			for (int i = 0; i < movePreviewCleanup.Count; i++)
			{
				EndMovePreview(movePreviewCleanup[i], restoreCollider: true);
			}
			movePreviewCleanup.Clear();
		}

		private void EndMovePreview(ushort groupId, bool restoreCollider)
		{
			if (movePreviews.Remove(groupId) && restoreCollider && groupManager != null && groupManager.TryGetGroup(groupId, out var group))
			{
				groupManager.SetGroupColliderEnabled(group, enabled: true);
			}
		}

		private void ClearMovePreviews(bool restoreColliders)
		{
			if (movePreviews.Count != 0)
			{
				movePreviewCleanup.Clear();
				movePreviewCleanup.AddRange(movePreviews.Keys);
				for (int i = 0; i < movePreviewCleanup.Count; i++)
				{
					EndMovePreview(movePreviewCleanup[i], restoreColliders);
				}
				movePreviewCleanup.Clear();
			}
		}

		private void ClearStrokePreviews()
		{
			if (strokePreviews.Count != 0 || erasePreviews.Count != 0)
			{
				List<int> list = new List<int>(strokePreviews.Keys);
				for (int i = 0; i < list.Count; i++)
				{
					EndStrokePreview(list[i]);
				}
				list.Clear();
				list.AddRange(erasePreviews.Keys);
				for (int j = 0; j < list.Count; j++)
				{
					EndErasePreview(list[j]);
				}
			}
		}

		private bool IsStrokePreviewGroup(VoxelGroup group)
		{
			if (group == null)
			{
				return false;
			}
			foreach (StrokePreviewState value in strokePreviews.Values)
			{
				if (value.group == group)
				{
					return true;
				}
			}
			return false;
		}

		private static int GetActorNumberFromGroupId(int groupId)
		{
			return (groupId >> 8) & 0xFF;
		}
	}
}