class="kw">package com.hypixel.hytale.builtin.buildertools.prefabeditor;

class="kw">import com.hypixel.hytale.builtin.buildertools.prefabeditor.enums.PrefabAlignment;
class="kw">import com.hypixel.hytale.builtin.buildertools.prefabeditor.enums.PrefabRowSplitMode;
class="kw">import com.hypixel.hytale.builtin.buildertools.prefabeditor.enums.PrefabStackingAxis;
class="kw">import com.hypixel.hytale.builtin.buildertools.prefabeditor.enums.WorldGenType;
class="kw">import com.hypixel.hytale.common.map.IWeightedMap;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.event.EventRegistry;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.util.FastRandom;
class="kw">import com.hypixel.hytale.math.vector.Transform;
class="kw">import com.hypixel.hytale.protocol.Color;
class="kw">import com.hypixel.hytale.protocol.GameMode;
class="kw">import com.hypixel.hytale.protocol.MovementStates;
class="kw">import com.hypixel.hytale.protocol.SavedMovementStates;
class="kw">import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
class="kw">import com.hypixel.hytale.server.core.Constants;
class="kw">import com.hypixel.hytale.server.core.Message;
class="kw">import com.hypixel.hytale.server.core.asset.type.environment.config.Environment;
class="kw">import com.hypixel.hytale.server.core.asset.type.environment.config.WeatherForecast;
class="kw">import com.hypixel.hytale.server.core.asset.util.ColorParseUtil;
class="kw">import com.hypixel.hytale.server.core.command.system.CommandSender;
class="kw">import com.hypixel.hytale.server.core.entity.UUIDComponent;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
class="kw">import com.hypixel.hytale.server.core.entity.movement.MovementStatesComponent;
class="kw">import com.hypixel.hytale.server.core.event.events.player.AddPlayerToWorldEvent;
class="kw">import com.hypixel.hytale.server.core.event.events.player.PlayerReadyEvent;
class="kw">import com.hypixel.hytale.server.core.inventory.InventoryComponent;
class="kw">import com.hypixel.hytale.server.core.inventory.ItemStack;
class="kw">import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.teleport.Teleport;
class="kw">import com.hypixel.hytale.server.core.modules.time.WorldTimeResource;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPlugin;
class="kw">import com.hypixel.hytale.server.core.prefab.PrefabRotation;
class="kw">import com.hypixel.hytale.server.core.prefab.PrefabStore;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.buffer.PrefabBufferUtil;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.buffer.impl.IPrefabBuffer;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.buffer.impl.PrefabBuffer;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.Universe;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.WorldConfig;
class="kw">import com.hypixel.hytale.server.core.universe.world.spawn.GlobalSpawnProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.provider.FlatWorldGenProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.provider.VoidWorldGenProvider;
class="kw">import com.hypixel.hytale.server.core.util.PrefabUtil;
class="kw">import it.unimi.dsi.fastutil.ints.IntArrayList;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.io.File;
class="kw">import java.io.IOException;
class="kw">import java.nio.file.Files;
class="kw">import java.nio.file.Path;
class="kw">import java.util.HashSet;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.UUID;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.function.Consumer;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3i;

class="kw">public class PrefabEditSessionManager {
   @Nonnull
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   @Nonnull
   class="kw">private class="kw">static class="kw">final Message MESSAGE_COMMANDS_PREFAB_EDIT_SESSION_MANAGER_EXISTING_EDIT_SESSION = Message.translation(
      "server.commands.prefabeditsessionmanager.existingEditSession"
   );
   @Nonnull
   class="kw">private class="kw">static class="kw">final Message MESSAGE_COMMANDS_EDIT_PREFAB_SOMETHING_WENT_WRONG = Message.translation("server.commands.editprefab.somethingWentWrong");
   class="kw">public class="kw">static class="kw">final float NOON_TIME = 0.5F;
   class="kw">public class="kw">static class="kw">final String DEFAULT_NEW_WORLD_ZERO_COORDINATE_BLOCK_NAME = "Rock_Stone";
   class="kw">public class="kw">static class="kw">final String DEFAULT_ENVIRONMENT = "Zone1_Sunny";
   class="kw">private class="kw">static class="kw">final String PREFAB_SELECTOR_TOOL_ID = "EditorTool_PrefabEditing_SelectPrefab";
   class="kw">public class="kw">static class="kw">final String DEFAULT_CHUNK_ENVIRONMENT = "Env_Zone1_Plains";
   class="kw">public class="kw">static class="kw">final String PREFAB_EDITING_WORLD_NAME_PREFIX = "prefabEditor-";
   @Nonnull
   class="kw">public class="kw">static class="kw">final Color DEFAULT_TINT = new Color((byte)91, (byte)-98, (byte)40);
   class="kw">private class="kw">static class="kw">final long PROGRESS_UPDATE_INTERVAL_NANOS = 100000000L;
   class="kw">public class="kw">static class="kw">final String DEFAULT_GRASS_TINT_HEX = "#5B9E28";
   @Nonnull
   class="kw">private class="kw">static class="kw">final PrefabRotation PASTE_ROTATION = PrefabRotation.ROTATION_0;
   @Nonnull
   class="kw">private class="kw">final Map<UUID, PrefabEditSession> activeEditSessions = new Object2ObjectOpenHashMap();
   @Nonnull
   class="kw">private class="kw">final HashSet<Path> prefabsBeingEdited = new HashSet<>();
   @Nonnull
   class="kw">private class="kw">final Map<UUID, UUID> inProgressTeleportations = new Object2ObjectOpenHashMap();
   @Nonnull
   class="kw">private class="kw">final HashSet<UUID> inProgressLoading = new HashSet<>();
   @Nonnull
   class="kw">private class="kw">final HashSet<UUID> cancelledLoading = new HashSet<>();

   class="kw">public PrefabEditSessionManager(@Nonnull JavaPlugin var1) {
      EventRegistry var2 = var1.getEventRegistry();
      var2.registerGlobal(AddPlayerToWorldEvent.class, this::onPlayerAddedToWorld);
      var2.registerGlobal(PlayerReadyEvent.class, this::onPlayerReady);
   }

   class="kw">private void onPlayerReady(@Nonnull PlayerReadyEvent var1) {
      Ref var2 = var1.getPlayerRef();
      if (var2.isValid()) {
         Store var3 = var2.getStore();
         World var4 = var3.getExternalData().getWorld();
         var4.execute(() -> {
            UUIDComponent var3 = var3.getComponent(var2, UUIDComponent.getComponentType());
            assert var3 != null;
            UUID var4 = var3.getUuid();
            if (this.inProgressTeleportations.containsKey(var4)) {
               this.inProgressTeleportations.remove(var4);
               MovementStatesComponent var5 = var3.getComponent(var2, MovementStatesComponent.getComponentType());
               assert var5 != null;
               MovementStates var6 = var5.getMovementStates();
               Player var7 = var3.getComponent(var2, Player.getComponentType());
               assert var7 != null;
               Player.applyMovementStates(var2, new SavedMovementStates(true), var6, var3);
               PlayerRef var8 = var3.getComponent(var2, PlayerRef.getComponentType());
               if (var8 != null) {
                  givePrefabSelectorTool(var2, var7, var8, var3);
               }
            }
         });
      }
   }

   class="kw">private class="kw">static void givePrefabSelectorTool(
      @Nonnull Ref<EntityStore> var0, @Nonnull Player var1, @Nonnull PlayerRef var2, @Nonnull ComponentAccessor<EntityStore> var3
   ) {
      InventoryComponent.Hotbar var4 = var3.getComponent(var0, InventoryComponent.Hotbar.getComponentType());
      if (var4 != null) {
         ItemContainer var5 = var4.getInventory();
         int var6 = var5.getCapacity();

         for (short var7 = 0; var7 < var6; var7++) {
            ItemStack var8 = var5.getItemStack(var7);
            if (var8 != null && !var8.isEmpty() && "EditorTool_PrefabEditing_SelectPrefab".equals(var8.getItemId())) {
               var4.setActiveSlot((byte)var7, var0, var3);
               var2.getPacketHandler().writeNoCache(new SetActiveSlot(-1, (byte)var7));
               class="kw">return;
            }
         }

         short var10 = -1;

         for (short var11 = 0; var11 < var6; var11++) {
            ItemStack var9 = var5.getItemStack(var11);
            if (var9 == null || var9.isEmpty()) {
               var10 = var11;
               break;
            }
         }

         if (var10 == -1) {
            var10 = 0;
         }

         var5.setItemStackForSlot(var10, new ItemStack("EditorTool_PrefabEditing_SelectPrefab"));
         var4.setActiveSlot((byte)var10, var0, var3);
         var2.getPacketHandler().writeNoCache(new SetActiveSlot(-1, (byte)var10));
      }
   }

   class="kw">public void onPlayerAddedToWorld(@Nonnull AddPlayerToWorldEvent var1) {
      World var2 = var1.getWorld();
      Holder var3 = var1.getHolder();
      UUIDComponent var4 = var3.getComponent(UUIDComponent.getComponentType());
      assert var4 != null;
      if (var2.getName().startsWith("prefabEditor-")) {
         var2.execute(() -> this.inProgressTeleportations.put(var4.getUuid(), var2.getWorldConfig().getUuid()));
      } else if (this.isEditingAPrefab(var4.getUuid())) {
         PrefabEditSession var5 = this.getPrefabEditSession(var4.getUuid());
         var5.setWorldArrivedFrom(var2.getWorldConfig().getUuid());
      }
   }

   class="kw">public void updatePathOfLoadedPrefab(@Nonnull Path var1, @Nonnull Path var2) {
      this.prefabsBeingEdited.remove(var1);
      this.prefabsBeingEdited.add(var2);
   }

   class="kw">public boolean isEditingAPrefab(@Nonnull UUID var1) {
      class="kw">return this.activeEditSessions.containsKey(var1);
   }

   class="kw">public PrefabEditSession getPrefabEditSession(@Nonnull UUID var1) {
      class="kw">return this.activeEditSessions.get(var1);
   }

   @Nonnull
   class="kw">public Map<UUID, PrefabEditSession> getActiveEditSessions() {
      class="kw">return this.activeEditSessions;
   }

   void populateActiveEditSession(@Nonnull UUID var1, @Nonnull PrefabEditSession var2) {
      this.activeEditSessions.put(var1, var2);
   }

   void populatePrefabsBeingEdited(@Nonnull Path var1) {
      this.prefabsBeingEdited.add(var1);
   }

   void scheduleAnchorEntityRecreation(@Nonnull PrefabEditSession var1) {
      CompletableFuture.runAsync(() -> {
         World var1 = Universe.get().getWorld(var1.getWorldName());
         if (var1 != null) {
            var1.execute(() -> {
               for (PrefabEditingMetadata var3 : var1.getLoadedPrefabMetadata().values()) {
                  var3.recreateAnchorEntity(var1);
               }
            });
         }
      });
   }

   class="kw">public boolean hasInProgressLoading(@Nonnull UUID var1) {
      class="kw">return this.inProgressLoading.contains(var1);
   }

   class="kw">public void cancelLoading(@Nonnull UUID var1) {
      this.cancelledLoading.add(var1);
   }

   class="kw">public boolean isLoadingCancelled(@Nonnull UUID var1) {
      class="kw">return this.cancelledLoading.contains(var1);
   }

   class="kw">public void clearLoadingState(@Nonnull UUID var1) {
      this.inProgressLoading.remove(var1);
      this.cancelledLoading.remove(var1);
   }

   @Nonnull
   class="kw">public CompletableFuture<Void> createEditSessionForNewPrefab(
      @Nonnull Ref<EntityStore> var1, @Nonnull Player var2, @Nonnull PrefabEditorCreationSettings var3, @Nonnull ComponentAccessor<EntityStore> var4
   ) {
      PlayerRef var5 = var4.getComponent(var1, PlayerRef.getComponentType());
      assert var5 != null;
      PrefabEditorCreationContext var6 = var3.finishProcessing(var2, var5, true);
      if (var6 == null) {
         Message var7 = var3.getFailureMessage();
         var5.sendMessage(var7 != null ? var7 : MESSAGE_COMMANDS_EDIT_PREFAB_SOMETHING_WENT_WRONG);
         class="kw">return CompletableFuture.completedFuture(null);
      } else {
         class="kw">return this.createEditSession(var1, var6, true, var4);
      }
   }

   @Nullable
   class="kw">public CompletableFuture<Void> loadPrefabAndCreateEditSession(
      @Nonnull Ref<EntityStore> var1, @Nonnull Player var2, @Nonnull PrefabEditorCreationSettings var3, @Nonnull ComponentAccessor<EntityStore> var4
   ) {
      class="kw">return this.loadPrefabAndCreateEditSession(var1, var2, var3, var4, null);
   }

   @Nullable
   class="kw">public CompletableFuture<Void> loadPrefabAndCreateEditSession(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull Player var2,
      @Nonnull PrefabEditorCreationSettings var3,
      @Nonnull ComponentAccessor<EntityStore> var4,
      @Nullable Consumer<PrefabLoadingState> var5
   ) {
      PlayerRef var6 = var4.getComponent(var1, PlayerRef.getComponentType());
      assert var6 != null;
      UUID var7 = var6.getUuid();
      if (this.inProgressLoading.contains(var7)) {
         PrefabLoadingState var10 = new PrefabLoadingState();
         var10.addError("server.commands.editprefab.error.loadingInProgress");
         this.notifyProgress(var5, var10);
         var6.sendMessage(Message.translation("server.commands.editprefab.error.loadingInProgress"));
         class="kw">return null;
      } else {
         this.inProgressLoading.add(var7);
         this.cancelledLoading.remove(var7);
         PrefabLoadingState var8 = new PrefabLoadingState();
         var8.setPhase(PrefabLoadingState.Phase.INITIALIZING);
         this.notifyProgress(var5, var8);
         PrefabEditorCreationContext var9 = var3.finishProcessing(var2, var6, false);
         if (var9 == null) {
            this.inProgressLoading.remove(var7);
            var8.addError("server.commands.editprefab.error.processingFailed");
            this.notifyProgress(var5, var8);
            class="kw">return null;
         } else if (var9.getPrefabPaths().isEmpty()) {
            this.inProgressLoading.remove(var7);
            var8.addError("server.commands.editprefab.error.noPrefabsFound");
            this.notifyProgress(var5, var8);
            var6.sendMessage(MESSAGE_COMMANDS_EDIT_PREFAB_SOMETHING_WENT_WRONG);
            class="kw">return null;
         } else {
            var8.setTotalPrefabs(var9.getPrefabPaths().size());
            this.notifyProgress(var5, var8);
            class="kw">return this.createEditSession(var1, var9, false, var4, var8, var5);
         }
      }
   }

   class="kw">private void notifyProgress(@Nullable Consumer<PrefabLoadingState> var1, @Nonnull PrefabLoadingState var2) {
      if (var1 != null) {
         PrefabLoadingState.Phase var3 = var2.getCurrentPhase();
         if (var3 != PrefabLoadingState.Phase.LOADING_PREFABS && var3 != PrefabLoadingState.Phase.PASTING_PREFABS) {
            var1.accept(var2);
         } else {
            long var4 = System.nanoTime();
            if (var4 - var2.getLastNotifyTimeNanos() >= 100000000L) {
               var2.setLastNotifyTimeNanos(var4);
               var1.accept(var2);
            }
         }
      }
   }

   @Nonnull
   class="kw">private CompletableFuture<Void> createEditSession(
      @Nonnull Ref<EntityStore> var1, @Nonnull PrefabEditorCreationContext var2, boolean var3, @Nonnull ComponentAccessor<EntityStore> var4
   ) {
      class="kw">return this.createEditSession(var1, var2, var3, var4, null, null);
   }

   @Nonnull
   class="kw">private CompletableFuture<Void> createEditSession(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull PrefabEditorCreationContext var2,
      boolean var3,
      @Nonnull ComponentAccessor<EntityStore> var4,
      @Nullable PrefabLoadingState var5,
      @Nullable Consumer<PrefabLoadingState> var6
   ) {
      World var7 = var4.getExternalData().getWorld();
      PlayerRef var8 = var4.getComponent(var1, PlayerRef.getComponentType());
      assert var8 != null;
      UUID var9 = var8.getUuid();
      if (this.activeEditSessions.containsKey(var9)) {
         if (var5 != null) {
            var5.addError("server.commands.editprefab.error.existingSession");
            this.notifyProgress(var6, var5);
         }

         var8.sendMessage(MESSAGE_COMMANDS_PREFAB_EDIT_SESSION_MANAGER_EXISTING_EDIT_SESSION);
         class="kw">return CompletableFuture.completedFuture(null);
      } else {
         for (Path var11 : var2.getPrefabPaths()) {
            if (this.prefabsBeingEdited.contains(var11)) {
               if (var5 != null) {
                  var5.addError("server.commands.editprefab.error.alreadyBeingEdited", var11.toString());
                  this.notifyProgress(var6, var5);
               }

               var8.sendMessage(Message.translation("server.commands.prefabeditsessionmanager.alreadyBeingEdited").param("path", var11.toString()));
               class="kw">return CompletableFuture.completedFuture(null);
            }
         }

         if (var5 != null) {
            var5.setPhase(PrefabLoadingState.Phase.CREATING_WORLD);
            this.notifyProgress(var6, var5);
         }

         WorldConfig var18 = new WorldConfig();
         boolean var19 = var2.isWorldTickingEnabled();
         var18.setBlockSpawnersResolved(false);
         var18.setBlockTicking(var19);
         var18.setSpawningNPC(false);
         var18.setIsSpawnMarkersEnabled(false);
         var18.setObjectiveMarkersEnabled(false);
         var18.setGameMode(GameMode.Creative);
         var18.setDeleteOnRemove(false);
         var18.setUuid(UUID.randomUUID());
         var18.setGameTimePaused(true);
         var18.setIsAllNPCFrozen(true);
         var18.setSavingPlayers(true);
         var18.setCanSaveChunks(true);
         var18.setTicking(var19);
         var18.setForcedWeather(this.getWeatherFromEnvironment(var2.getEnvironment()));
         String var12 = this.getWorldName(var2);

         try {
            Files.createDirectories(this.getSavePath(var2));
         } catch (IOException var17) {
            if (var5 != null) {
               var5.addError("server.commands.editprefab.error.createDirectoryFailed", var17.getMessage());
               this.notifyProgress(var6, var5);
            }

            var8.sendMessage(Message.translation("server.commands.instances.createDirectory.failed").param("errormsg", var17.getMessage()));
            class="kw">return CompletableFuture.completedFuture(null);
         }

         TransformComponent var13 = var4.getComponent(var1, TransformComponent.getComponentType());
         assert var13 != null;
         Transform var14 = new Transform(var13.getTransform());
         PrefabEditSession var15 = new PrefabEditSession(var12, var9, var7.getWorldConfig().getUuid(), var14);
         CompletableFuture var16;
         if (var3) {
            var16 = this.getPrefabCreatingCompletableFuture(var2, var15, var18);
         } else {
            var16 = this.getPrefabLoadingCompletableFuture(var2, var15, var18, var5, var6, var9);
         }

         if (var16 == null) {
            if (var5 != null) {
               var5.addError("server.commands.editprefab.error.loadFailed");
               this.notifyProgress(var6, var5);
            }

            class="kw">return CompletableFuture.completedFuture(null);
         } else {
            class="kw">return var16.exceptionally(
                  var5x -> {
                     if (this.isLoadingCancelled(var9)) {
                        class="kw">return null;
                     }

                     ((HytaleLogger.Api)LOGGER.at(Level.SEVERE).withCause(var5x)).log("Error occurred during prefab editor session creation");
                     if (var5 != null) {
                        var5.addError("server.commands.editprefab.error.exception", var5x.getMessage());
                        this.notifyProgress(var6, var5);
                     }

                     var8.sendMessage(
                        Message.translation("server.commands.editprefab.error.exception")
                           .param("details", var5x.getMessage() != null ? var5x.getMessage() : "Unknown error")
                     );
                     class="kw">return null;
                  }
               )
               .thenAcceptAsync(var8x -> {
                  if (!this.isLoadingCancelled(var9)) {
                     if (var8x != null) {
                        if (var5 != null) {
                           var5.setPhase(PrefabLoadingState.Phase.FINALIZING);
                           this.notifyProgress(var6, var5);
                        }

                        Vector3i var9 = var15.getSpawnPoint();
                        var8x.getWorldConfig().setSpawnProvider(new GlobalSpawnProvider(new Transform(var9)));
                        CompletableFuture.runAsync(() -> var8x.getEntityStore().getStore().replaceResource(PrefabEditSession.getResourceType(), var15), var8x);
                        CompletableFuture.runAsync(() -> {
                           Teleport var4 = Teleport.createForPlayer(var8x, new Transform(var9));
                           var4.putComponent(var1, Teleport.getComponentType(), var4);
                        }, var7);
                     }
                  }
               })
               .thenRun(() -> {
                  if (!this.isLoadingCancelled(var9)) {
                     this.prefabsBeingEdited.addAll(var2.getPrefabPaths());
                     this.activeEditSessions.put(var9, var15);
                     if (var5 != null) {
                        var5.markComplete();
                        this.notifyProgress(var6, var5);
                     }

                     var8.sendMessage(Message.translation("server.commands.prefabeditsessionmanager.success." + (var3 ? "new" : "load")));
                  }
               })
               .whenComplete((var2x, var3x) -> this.inProgressLoading.remove(var9));
         }
      }
   }

   @Nonnull
   class="kw">private CompletableFuture<World> getWorldCreatingFuture(@Nonnull PrefabEditorCreationContext var1, @Nonnull WorldConfig var2) {
      class="kw">return Universe.get().makeWorld(this.getWorldName(var1), this.getSavePath(var1), var2, true);
   }

   @Nonnull
   class="kw">private String getWorldName(@Nonnull PrefabEditorCreationContext var1) {
      class="kw">return "prefabEditor-" + var1.getEditorRef().getUsername();
   }

   @Nonnull
   class="kw">private String getWeatherFromEnvironment(@Nullable String var1) {
      if (var1 != null && !var1.isEmpty()) {
         Environment var2 = Environment.getAssetMap().getAsset(var1);
         if (var2 == null) {
            class="kw">return "Zone1_Sunny";
         } else {
            IWeightedMap var3 = var2.getWeatherForecast(12);
            if (var3 != null && var3.size() != 0) {
               String[] var4 = new String[]{null};
               double[] var5 = new double[]{Double.NEGATIVE_INFINITY};
               var3.forEachEntry((var2x, var3x) -> {
                  if (var3x > var5[0]) {
                     var5[0] = var3x;
                     var4[0] = var2x.getWeatherId();
                  }
               });
               class="kw">return var4[0] != null ? var4[0] : "Zone1_Sunny";
            } else {
               class="kw">return "Zone1_Sunny";
            }
         }
      } else {
         class="kw">return "Zone1_Sunny";
      }
   }

   @Nonnull
   class="kw">private Path getSavePath(@Nonnull PrefabEditorCreationContext var1) {
      class="kw">return Constants.UNIVERSE_PATH.resolve("worlds").resolve(this.getWorldName(var1));
   }

   class="kw">private void applyWorldGenWorldConfig(@Nonnull PrefabEditorCreationContext var1, int var2, @Nonnull WorldConfig var3) {
      String var4 = var1.getEnvironment() != null ? var1.getEnvironment() : "Env_Zone1_Plains";
      Color var5 = DEFAULT_TINT;
      if (var1.getGrassTint() != null && !var1.getGrassTint().isEmpty()) {
         Color var6 = ColorParseUtil.parseColor(var1.getGrassTint());
         if (var6 != null) {
            var5 = var6;
         }
      }

      if (var1.getWorldGenType().equals(WorldGenType.FLAT)) {
         int var10 = Math.max(1, var2 - var1.getBlocksAboveSurface());
         FlatWorldGenProvider.Layer var7 = new FlatWorldGenProvider.Layer();
         var7.blockType = "Soil_Grass";
         var7.to = var10;
         var7.from = var10 - 1;
         var7.environment = var4;
         FlatWorldGenProvider.Layer var8 = new FlatWorldGenProvider.Layer();
         var8.blockType = "Empty";
         var8.to = 320;
         var8.from = var10;
         var8.environment = var4;
         if (var10 - 2 >= 0) {
            FlatWorldGenProvider.Layer var9 = new FlatWorldGenProvider.Layer();
            var9.blockType = "Soil_Clay";
            var9.to = var10 - 1;
            var9.from = 0;
            var9.environment = var4;
            var3.setWorldGenProvider(new FlatWorldGenProvider(var5, new FlatWorldGenProvider.Layer[]{var8, var7, var9}));
         } else {
            var3.setWorldGenProvider(new FlatWorldGenProvider(var5, new FlatWorldGenProvider.Layer[]{var8, var7}));
         }
      } else {
         var3.setWorldGenProvider(new VoidWorldGenProvider(var5, var4));
      }
   }

   @Nonnull
   class="kw">private CompletableFuture<World> getPrefabCreatingCompletableFuture(
      @Nonnull PrefabEditorCreationContext var1, @Nonnull PrefabEditSession var2, @Nonnull WorldConfig var3
   ) {
      this.applyWorldGenWorldConfig(var1, var1.getPasteLevelGoal() - 1, var3);
      class="kw">return this.getWorldCreatingFuture(var1, var3)
         .thenCompose(
            var2x -> CompletableFuture.supplyAsync(
               () -> {
                  Vector3i var3 = new Vector3i(0, var1.getPasteLevelGoal(), 0);
                  Vector3i var4 = new Vector3i(var3);
                  var2.addPrefab(
                     var1.getPrefabPaths().getFirst(),
                     new Vector3i(-1, var1.getPasteLevelGoal() - 1, -1),
                     new Vector3i(1, var1.getPasteLevelGoal() + 1, 1),
                     var4,
                     var3
                  );
                  Store var5 = var2x.getEntityStore().getStore();
                  WorldTimeResource var6 = var5.getResource(WorldTimeResource.getResourceType());
                  var6.setDayTime(0.5, var2x, var5);
                  var2x.setBlock(0, var1.getPasteLevelGoal(), 0, "Rock_Stone");
                  class="kw">return var2x;
               },
               var2x
            )
         );
   }

   @Nullable
   class="kw">private CompletableFuture<World> getPrefabLoadingCompletableFuture(
      @Nonnull PrefabEditorCreationContext var1,
      @Nonnull PrefabEditSession var2,
      @Nonnull WorldConfig var3,
      @Nullable PrefabLoadingState var4,
      @Nullable Consumer<PrefabLoadingState> var5,
      @Nonnull UUID var6
   ) {
      CompletableFuture[] var7 = new CompletableFuture[var1.getPrefabPaths().size()];
      if (var4 != null) {
         var4.setPhase(PrefabLoadingState.Phase.LOADING_PREFABS);
         this.notifyProgress(var5, var4);
      }

      for (int var8 = 0; var8 < var1.getPrefabPaths().size(); var8++) {
         Path var9 = var1.getPrefabPaths().get(var8);
         CompletableFuture var10 = this.getPrefabBuffer(var1.getEditorRef(), var9);
         if (var10 == null) {
            if (var4 != null) {
               var4.addError("server.commands.editprefab.error.prefabLoadFailed", var9.toString());
               this.notifyProgress(var5, var4);
            }

            class="kw">return null;
         }

         Path var11 = var9;
         var7[var8] = var10.thenApply(var4x -> {
            if (var4 != null) {
               var4.onPrefabLoaded(var11);
               this.notifyProgress(var5, var4);
            }

            class="kw">return (IPrefabBuffer)var4x;
         });
      }

      class="kw">return CompletableFuture.allOf(var7).thenApply(var7x -> {
         if (this.isLoadingCancelled(var6)) {
            class="kw">return null;
         }

         List var8 = new ObjectArrayList(var7.length);
         int var9 = 0;

         for (CompletableFuture var13 : var7) {
            IPrefabBuffer var14 = (IPrefabBuffer)var13.join();
            var8.add(var14);
            if (var1.loadChildPrefabs()) {
               for (PrefabBuffer.ChildPrefab var18 : var14.getChildPrefabs()) {
                  ;
               }
            }

            int var21 = Math.abs(var14.getMaxY() - var14.getMinY());
            if (var21 > var9) {
               var9 = var21;
            }
         }

         int var19 = this.getAmountOfBlocksBelowPrefab(var9, var1.getPasteLevelGoal());
         this.applyWorldGenWorldConfig(var1, var19, var3);
         if (var4 != null) {
            var4.setPhase(PrefabLoadingState.Phase.PASTING_PREFABS);
            this.notifyProgress(var5, var4);
         }

         if (this.isLoadingCancelled(var6)) {
            class="kw">return null;
         } else {
            String var20 = this.getWorldName(var1);
            if (Universe.get().getWorld(var20) != null) {
               LOGGER.at(Level.WARNING).log("Aborting prefab editor creation for %s: world '%s' already exists", var6, var20);
               class="kw">return null;
            } else {
               class="kw">return new Tri<>(var8, var19, this.getWorldCreatingFuture(var1, var3).join());
            }
         }
      }).thenCompose(var6x -> {
         if (var6x == null) {
            class="kw">return CompletableFuture.completedFuture(null);
         }

         World var7 = var6x.getRight();
         class="kw">return CompletableFuture.<List<PrefabEditSessionManager.PendingPaste>>supplyAsync(() -> {
            if (this.isLoadingCancelled(var6)) {
               class="kw">return null;
            }

            int var5 = (Integer)var6x.getMiddle();
            List var6 = (List<IPrefabBuffer>)var6x.getLeft();
            if (var7 != null && var7.isAlive()) {
               int[] var7 = this.calculateRowGroups(var1, var6.size());
               IntArrayList var8 = new IntArrayList();
               int var9 = -1;
               int var10 = -1;

               for (int var11 = 0; var11 < var6.size(); var11++) {
                  IPrefabBuffer var12 = var6.get(var11);
                  int var13 = var7[var11];
                  if (var13 != var9) {
                     var9 = var13;
                     var10++;
                     var8.add(0);
                  }

                  int var14;
                  if (var1.getStackingAxis().equals(PrefabStackingAxis.X)) {
                     var14 = var12.getMaxZ() - var12.getMinZ();
                  } else {
                     var14 = var12.getMaxX() - var12.getMinX();
                  }

                  var8.set(var10, Math.max(var8.getInt(var10), var14));
               }

               int[] var28 = new int[var8.size()];
               int var29 = 0;

               for (int var30 = 0; var30 < var8.size(); var30++) {
                  var28[var30] = var29;
                  var29 += var8.getInt(var30) + var1.getBlocksBetweenEachPrefab() + 1;
               }

               List var31 = new ObjectArrayList(var6.size());
               var9 = -1;
               var10 = -1;
               int var32 = 0;

               for (int var15 = 0; var15 < var6.size(); var15++) {
                  if (this.isLoadingCancelled(var6) || !var7.isAlive()) {
                     class="kw">return null;
                  }

                  IPrefabBuffer var16 = var6.get(var15);
                  Path var17 = var1.getPrefabPaths().get(var15);
                  int var18 = var7[var15];
                  if (var18 != var9) {
                     var9 = var18;
                     var10++;
                     var32 = 0;
                  }

                  int var19 = var28[var10];
                  int var20 = var16.getMaxX() - var16.getMinX();
                  int var21 = var16.getMaxZ() - var16.getMinZ();
                  Vector3i var22;
                  if (var1.getAlignment().equals(PrefabAlignment.ZERO)) {
                     var22 = new Vector3i(0, var5, 0);
                     var22.sub(Math.min(var16.getMinX(), 0), var16.getMinY(), Math.min(var16.getMinZ(), 0));
                     if (var1.getStackingAxis().equals(PrefabStackingAxis.X)) {
                        var22.add(var32, 0, var19);
                        var32 += var20 + var1.getBlocksBetweenEachPrefab() + 1;
                     } else {
                        var22.add(var19, 0, var32);
                        var32 += var21 + var1.getBlocksBetweenEachPrefab() + 1;
                     }
                  } else {
                     var22 = new Vector3i(0, var5 - Math.min(var16.getMinY(), 0), 0);
                     if (var1.getStackingAxis().equals(PrefabStackingAxis.X)) {
                        int var23 = var32 + Math.abs(Math.min(var16.getMinX(), 0));
                        int var24 = var19 + Math.abs(Math.min(var16.getMinZ(), 0));
                        var22.add(var23, 0, var24);
                        var32 += var20 + var1.getBlocksBetweenEachPrefab() + 1;
                     } else {
                        int var33 = var19 + Math.abs(Math.min(var16.getMinX(), 0));
                        int var35 = var32 + Math.abs(Math.min(var16.getMinZ(), 0));
                        var22.add(var33, 0, var35);
                        var32 += var21 + var1.getBlocksBetweenEachPrefab() + 1;
                     }
                  }

                  Vector3i var34 = new Vector3i(var22.x + var16.getMinX(), var22.y + var16.getMinY(), var22.z + var16.getMinZ());
                  Vector3i var36 = new Vector3i(var22.x + var16.getMaxX(), var22.y + var16.getMaxY(), var22.z + var16.getMaxZ());
                  Vector3i var25 = new Vector3i(var22.x + var16.getAnchorX(), var22.y + var16.getAnchorY(), var22.z + var16.getAnchorZ());
                  var31.add(new PrefabEditSessionManager.PendingPaste(var16, var17, var22, var34, var36, var25));
               }

               class="kw">return var31;
            } else {
               class="kw">return null;
            }
         }, var7).thenCompose(var7x -> {
            if (var7x == null) {
               class="kw">return CompletableFuture.completedFuture(null);
            }

            int var8 = 3;
            if (!var1.shouldLoadEntities()) {
               var8 |= 8;
            }

            class="kw">return this.pastePrefabs((List<PrefabEditSessionManager.PendingPaste>)var7x, var7, var2, var8, var4, var5, var6);
         });
      });
   }

   @Nonnull
   class="kw">private CompletableFuture<World> pastePrefabs(
      @Nonnull List<PrefabEditSessionManager.PendingPaste> var1,
      @Nonnull World var2,
      @Nonnull PrefabEditSession var3,
      int var4,
      @Nullable PrefabLoadingState var5,
      @Nullable Consumer<PrefabLoadingState> var6,
      @Nonnull UUID var7
   ) {
      CompletableFuture var8 = CompletableFuture.completedFuture(var2);

      for (PrefabEditSessionManager.PendingPaste var10 : var1) {
         var8 = var8.thenCompose(
            var7x -> var7x != null && !this.isLoadingCancelled(var7) && var7x.isAlive()
               ? PrefabUtil.loadPasteRegionAsync(var10.buffer(), var7x, var10.position(), PASTE_ROTATION, 0)
                  .thenApplyAsync(var8x -> this.pastePrefab(var10, var8x, var7x, var3, var4, var5, var6, var7), var7x)
               : CompletableFuture.completedFuture(null)
         );
      }

      class="kw">return var8.thenApplyAsync(var0 -> {
         if (var0 == null) {
            class="kw">return null;
         }

         Store var1 = var0.getEntityStore().getStore();
         WorldTimeResource var2 = var1.getResource(WorldTimeResource.getResourceType());
         var2.setDayTime(0.5, var0, var1);
         class="kw">return (World)var0;
      }, var2);
   }

   @Nullable
   class="kw">private World pastePrefab(
      @Nonnull PrefabEditSessionManager.PendingPaste var1,
      @Nonnull PrefabUtil.PasteRegion var2,
      @Nonnull World var3,
      @Nonnull PrefabEditSession var4,
      int var5,
      @Nullable PrefabLoadingState var6,
      @Nullable Consumer<PrefabLoadingState> var7,
      @Nonnull UUID var8
   ) {
      if (!var2.isFullyLoaded()) {
         LOGGER.at(Level.WARNING).log("Paste region for prefab %s is not fully loaded, parts of it will be missing", var1.path());
      }

      try {
         PrefabUtil.paste(
            var1.buffer(),
            var3,
            var1.position(),
            PASTE_ROTATION.getRotation(),
            new FastRandom(),
            var5,
            0,
            var2,
            PrefabUtil.NOOP_BLOCK_ENTITY_CONSUMER,
            PrefabUtil.NOOP_ENTITY_CONSUMER,
            var3.getEntityStore().getStore()
         );
         var4.addPrefab(var1.path(), var1.minPoint(), var1.maxPoint(), var1.anchorPosition(), new Vector3i(var1.position()));
         if (var6 != null) {
            var6.onPrefabPasted(var1.path());
            this.notifyProgress(var7, var6);
         }

         class="kw">return var3;
      } catch (Exception var10) {
         if (!this.isLoadingCancelled(var8) && var3.isAlive()) {
            ((HytaleLogger.Api)LOGGER.at(Level.SEVERE).withCause(var10)).log("Error pasting prefab: %s", var1.path());
            if (var6 != null) {
               var6.addError("server.commands.editprefab.error.pasteFailed", var1.path().getFileName().toString() + ": " + var10.getMessage());
               this.notifyProgress(var7, var6);
            }

            throw var10;
         } else {
            class="kw">return null;
         }
      }
   }

   @Nonnull
   class="kw">private int[] calculateRowGroups(@Nonnull PrefabEditorCreationContext var1, int var2) {
      int[] var3 = new int[var2];
      PrefabRowSplitMode var4 = var1.getRowSplitMode();
      List var5 = var1.getPrefabPaths();
      if (var4 != PrefabRowSplitMode.NONE && var2 != 0) {
         if (var4 == PrefabRowSplitMode.BY_SPECIFIED_FOLDER) {
            List var6 = var1.getUnprocessedPrefabPaths();
            Path var7 = var1.getPrefabRootDirectory().getPrefabPath();
            int var8 = 0;
            int var9 = 0;

            for (String var11 : var6) {
               Path var12 = var7.resolve(var11.replace('/', File.separatorChar).replace('\\', File.separatorChar));

               while (var9 < var2) {
                  Path var13 = var5.get(var9);
                  if (!var13.startsWith(var12) && (!var11.endsWith("/") && !var11.endsWith("\\") ? !var13.equals(var12) : !var13.startsWith(var12))) {
                     break;
                  }

                  var3[var9] = var8;
                  var9++;
               }

               var8++;
            }
         } else if (var4 == PrefabRowSplitMode.BY_ALL_SUBFOLDERS) {
            Object2ObjectOpenHashMap var14 = new Object2ObjectOpenHashMap();
            int var15 = 0;

            for (int var16 = 0; var16 < var2; var16++) {
               Path var17 = var5.get(var16);
               Path var18 = var17.getParent();
               if (var18 != null) {
                  Integer var19 = (Integer)var14.get(var18);
                  if (var19 == null) {
                     var14.put(var18, var15);
                     var3[var16] = var15++;
                  } else {
                     var3[var16] = var19;
                  }
               } else {
                  var3[var16] = 0;
               }
            }
         }

         class="kw">return var3;
      } else {
         class="kw">return var3;
      }
   }

   class="kw">private int getAmountOfBlocksBelowPrefab(int var1, int var2) {
      if (var2 < 0) {
         throw new IllegalArgumentException("Cannot have a negative y level for pasting prefabs");
      } else if (var2 >= 320) {
         throw new IllegalArgumentException("Cannot paste above or at the world height");
      } else {
         class="kw">return Math.min(var2, 320 - var1);
      }
   }

   class="kw">public boolean isInEditWorld(@Nonnull PlayerRef var1, @Nonnull Store<EntityStore> var2) {
      String var3 = var2.getExternalData().getWorld().getName();
      String var4 = this.getPrefabEditSession(var1.getUuid()).getWorldName();
      class="kw">return var3.equals(var4);
   }

   @Nullable
   class="kw">public CompletableFuture<Void> sendToEditWorld(@Nonnull Ref<EntityStore> var1, @Nonnull World var2, @Nonnull PlayerRef var3) {
      PrefabEditSession var4 = this.getPrefabEditSession(var3.getUuid());
      if (var4 == null) {
         class="kw">return CompletableFuture.completedFuture(null);
      }

      String var5 = var4.getWorldName();
      World var6 = Universe.get().getWorld(var5);
      Teleport var7 = Teleport.createForPlayer(
         var6, var1.getStore().getComponent(var1, Player.getComponentType()).getPlayerConfigData().getPerWorldData(var5).getLastPosition()
      );
      class="kw">return CompletableFuture.runAsync(() -> var1.getStore().putComponent(var1, Teleport.getComponentType(), var7), var2);
   }

   @Nullable
   class="kw">public CompletableFuture<Void> exitEditSession(
      @Nonnull Ref<EntityStore> var1, @Nonnull World var2, @Nonnull PlayerRef var3, @Nonnull ComponentAccessor<EntityStore> var4
   ) {
      PrefabEditSession var5 = this.activeEditSessions.get(var3.getUuid());
      if (var5 == null) {
         class="kw">return null;
      }

      var5.hidePrefabAnchors(var3.getPacketHandler());
      Runnable var6 = () -> {
         World var3 = Universe.get().getWorld(var5.getWorldName());
         if (var3 != null) {
            var3.getWorldConfig().setDeleteOnRemove(true);
            Universe.get().removeWorld(var5.getWorldName());
         }

         for (PrefabEditingMetadata var6 : var5.getLoadedPrefabMetadata().values()) {
            this.prefabsBeingEdited.remove(var6.getPrefabPath());
         }

         this.activeEditSessions.remove(var3.getUuid());
         var3.sendMessage(Message.translation("server.commands.editprefab.closedEditSession"));
      };
      if (!this.isInEditWorld(var3, var1.getStore())) {
         class="kw">return CompletableFuture.runAsync(var6);
      }

      World var7 = Universe.get().getWorld(var5.getWorldArrivedFrom());
      Transform var8 = var5.getTransformArrivedFrom();
      if (var7 == null || var8 == null) {
         LOGGER.at(Level.WARNING)
            .log(
               "Prefab editor exit fallback triggered for player %s: returnWorld=%s (worldArrivedFrom=%s), returnLocation=%s. Using class="kw">default world spawn.",
               var3.getUuid(),
               var7 != null ? var7.getName() : "null",
               var5.getWorldArrivedFrom(),
               var8
            );
         var7 = Universe.get().getDefaultWorld();
         var8 = var7.getWorldConfig().getSpawnProvider().getSpawnPoint(var1, var4);
      }

      World var9 = var7;
      Transform var10 = var8;
      Teleport var11 = Teleport.createForPlayer(var9, var10);
      class="kw">return CompletableFuture.runAsync(() -> var4.putComponent(var1, Teleport.getComponentType(), var11), var2).thenRunAsync(var6);
   }

   @Nonnull
   class="kw">public CompletableFuture<Void> cleanupCancelledSession(@Nonnull UUID var1, @Nonnull String var2, @Nullable Consumer<PrefabLoadingState> var3) {
      this.cancelLoading(var1);
      PrefabLoadingState var4 = new PrefabLoadingState();
      var4.setPhase(PrefabLoadingState.Phase.CANCELLING);
      this.notifyProgress(var3, var4);
      class="kw">return CompletableFuture.runAsync(() -> {
         World var5 = Universe.get().getWorld(var2);
         if (var5 != null) {
            var4.setPhase(PrefabLoadingState.Phase.SHUTTING_DOWN_WORLD);
            this.notifyProgress(var3, var4);
            var5.getWorldConfig().setDeleteOnRemove(true);
            var4.setPhase(PrefabLoadingState.Phase.DELETING_WORLD);
            this.notifyProgress(var3, var4);
            Universe.get().removeWorld(var2);
         }

         PrefabEditSession var6 = this.activeEditSessions.remove(var1);
         if (var6 != null) {
            for (PrefabEditingMetadata var9 : var6.getLoadedPrefabMetadata().values()) {
               this.prefabsBeingEdited.remove(var9.getPrefabPath());
            }
         }

         this.inProgressLoading.remove(var1);
         var4.setPhase(PrefabLoadingState.Phase.SHUTDOWN_COMPLETE);
         this.notifyProgress(var3, var4);
      });
   }

   @Nonnull
   class="kw">public CompletableFuture<Void> cleanupCancelledSession(@Nonnull UUID var1, @Nonnull String var2) {
      class="kw">return this.cleanupCancelledSession(var1, var2, null);
   }

   @Nullable
   class="kw">private CompletableFuture<IPrefabBuffer> getPrefabBuffer(@Nonnull CommandSender var1, @Nonnull Path var2) {
      if (!PrefabStore.get().prefabExists(var2)) {
         var1.sendMessage(Message.translation("server.commands.editprefab.prefabNotFound").param("name", var2.toString()));
         class="kw">return null;
      } else {
         class="kw">return CompletableFuture.supplyAsync(() -> PrefabBufferUtil.getCached(var2));
      }
   }

   class="kw">private record PendingPaste(
      @Nonnull IPrefabBuffer buffer,
      @Nonnull Path path,
      @Nonnull Vector3i position,
      @Nonnull Vector3i minPoint,
      @Nonnull Vector3i maxPoint,
      @Nonnull Vector3i anchorPosition
   ) {
      class="kw">private PendingPaste {
      }
   }
}