class="kw">package com.hypixel.hytale.builtin.hytalegenerator.plugin.editor;

class="kw">import com.hypixel.hytale.assetstore.AssetMap;
class="kw">import com.hypixel.hytale.assetstore.AssetPack;
class="kw">import com.hypixel.hytale.assetstore.AssetRegistry;
class="kw">import com.hypixel.hytale.assetstore.AssetStore;
class="kw">import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
class="kw">import com.hypixel.hytale.builtin.asseteditor.util.BsonTransformationUtil;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.Viewport;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.assets.AssetManager;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.assets.biomes.BiomeAsset;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.assets.worldstructures.WorldStructureAsset;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.assets.worldstructures.basic.BasicWorldStructureAsset;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.bounds.Bounds3i;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.plugin.HandleProvider;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.plugin.HytaleGenerator;
class="kw">import com.hypixel.hytale.builtin.instances.InstancesPlugin;
class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.ExtraInfo;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.codec.util.RawJsonReader;
class="kw">import com.hypixel.hytale.common.plugin.PluginIdentifier;
class="kw">import com.hypixel.hytale.common.util.ArrayUtil;
class="kw">import com.hypixel.hytale.common.util.PathUtil;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.vector.Rotation3f;
class="kw">import com.hypixel.hytale.math.vector.Transform;
class="kw">import com.hypixel.hytale.math.vector.Vector3iUtil;
class="kw">import com.hypixel.hytale.server.core.HytaleServer;
class="kw">import com.hypixel.hytale.server.core.HytaleServerConfig;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
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.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.provider.IWorldGenProvider;
class="kw">import com.hypixel.hytale.sneakythrow.SneakyThrow;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
class="kw">import java.io.IOException;
class="kw">import java.nio.file.Path;
class="kw">import java.util.Arrays;
class="kw">import java.util.Set;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.function.BiConsumer;
class="kw">import java.util.function.Function;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.bson.BsonArray;
class="kw">import org.bson.BsonDocument;
class="kw">import org.bson.BsonString;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3i;

class="kw">public class="kw">interface BiomeEditor {
   HytaleLogger LOGGER = HytaleLogger.get("BiomeEditor");
   String[] BIOME_NAME_PATH = new String[]{"Name"};
   String[] BIOMES_PATH = new String[]{"Biomes"};
   String[] DEFAULT_BIOME_PATH = new String[]{"DefaultBiome"};

   class="kw">static CompletableFuture<BiomeEditor.Context> setupAssets(@Nonnull BiomeEditor.Config var0) {
      class="kw">return !PathUtil.isValidName(var0.name)
         ? CompletableFuture.failedFuture(new IllegalArgumentException("Invalid name: " + var0.name))
         : AssetPackUtil.getOrCreatePack(var0.group, var0.pack)
            .thenApply(var1 -> {
               BiomeEditor.Context var2 = new BiomeEditor.Context();
               var2.config = var0;
               var2.pack = var1;
               class="kw">return var2;
            })
            .thenComposeAsync(var0x -> {
               AssetPack var1 = var0x.pack;
               PluginIdentifier var2 = new PluginIdentifier(var1.getManifest());
               HytaleServerConfig var3 = HytaleServer.get().getConfig();
               HytaleServerConfig.setBoot(var3, var2, true);
               var3.markChanged();
               class="kw">return var3.consumeHasChanged() ? HytaleServerConfig.save(var3).thenApply(var0x) : CompletableFuture.completedFuture(var0x);
            })
            .thenApplyAsync(
               SneakyThrow.sneakyFunction(
                  var0x -> {
                     ((HytaleLogger.Api)LOGGER.atInfo()).log("Creating Biome %s with Template %s", var0x.config.name, var0x.config.biomeTemplate);
                     createAssetFromTemplate(
                        var0x,
                        var0x.config.biomeTemplate,
                        BiomeAsset.class,
                        BiomeAsset.CODEC,
                        (var0xx, var1) -> BsonTransformationUtil.setProperty(var0xx, BIOME_NAME_PATH, new BsonString(var1.name))
                     );
                     class="kw">return var0x;
                  }
               )
            )
            .thenApplyAsync(SneakyThrow.sneakyFunction(var1 -> {
               ((HytaleLogger.Api)LOGGER.atInfo()).log("Creating WorldStructure %s with Template %s", var0.name, var0.worldStructureTemplate);
               createAssetFromTemplate(var1, var1.config.worldStructureTemplate, WorldStructureAsset.class, BasicWorldStructureAsset.CODEC, (var0x, var1x) -> {
                  BsonTransformationUtil.setProperty(var0x, BIOMES_PATH, new BsonArray());
                  BsonTransformationUtil.setProperty(var0x, DEFAULT_BIOME_PATH, new BsonString(var1x.name));
               });
               class="kw">return var1;
            }))
            .thenComposeAsync(var1 -> {
               ((HytaleLogger.Api)LOGGER.atInfo()).log("Creating Instance %s", var0.name);
               HandleProvider var2 = createWorldGenProvider();
               var2.setWorldStructureName(var0.name);
               WorldConfig var3 = new WorldConfig();
               var3.setWorldGenProvider(var2);
               var3.setSavingConfig(var0.enablePersistence);
               var3.setSaveNewChunks(var0.enablePersistence);
               var3.setCanSaveChunks(var0.enablePersistence);
               var3.setSavingPlayers(var0.enablePersistence);
               var3.setDeleteOnRemove(!var0.enablePersistence);
               Path var4 = var1.pack.getRoot().resolve("Server", new String[]{"Instances", var0.name, "instance.bson"});
               class="kw">return WorldConfig.save(var4, var3).thenApply(var1);
            })
            .whenComplete((var0x, var1) -> {
               if (var1 != null) {
                  ((HytaleLogger.Api)((HytaleLogger.Api)LOGGER.atWarning()).withCause(var1)).log("Error occurred whilst setting up assets");
               }
            });
   }

   class="kw">static CompletableFuture<Void> setupViewport(@Nonnull BiomeEditor.Config var0, @Nonnull Ref<EntityStore> var1) {
      class="kw">return setupViewport(setupAssets(var0), var1);
   }

   class="kw">static CompletableFuture<Void> setupViewport(@Nonnull CompletableFuture<BiomeEditor.Context> var0, @Nonnull Ref<EntityStore> var1) {
      World var2 = var1.getStore().getExternalData().getWorld();
      class="kw">return var0.<Viewport>thenComposeAsync(
            var1x -> {
               if (!var1.isValid()) {
                  throw new IllegalStateException("Ref no longer valid");
               }

               Store var2 = var1.getStore();
               World var3 = var2.getExternalData().getWorld();
               TransformComponent var4 = var2.getComponent(var1, TransformComponent.getComponentType());
               if (var4 == null) {
                  throw new IllegalStateException("Entity ref does not have TransformComponent");
               }

               ((HytaleLogger.Api)LOGGER.atInfo()).log("Creating world Instance %s", var1x.config.name);
               CompletableFuture var5 = InstancesPlugin.get()
                  .spawnInstance(var1x.config.name, var3, new Transform(new Vector3d(var4.getPosition()), new Rotation3f(var4.getRotation())));
               ((HytaleLogger.Api)LOGGER.atInfo()).log("Teleporting player to Instance %s", var1x.config.name);
               InstancesPlugin.teleportPlayerToLoadingInstance(var1, var2, var5, null);
               class="kw">return var5.thenApply(var1x::createViewport);
            },
            var2
         )
         .thenAcceptAsync(var0x -> {
            AssetManager var1 = HytaleGenerator.get().getAssetManager();
            if (var1 == null) {
               throw new IllegalStateException("AssetManager is not available. Unable to configure viewport");
            }

            var1.registerReloadListener(var0x::submitRefresh);
         }, var2);
   }

   class="kw">static <T class="kw">extends JsonAssetWithMap<String, M>, M class="kw">extends AssetMap<String, T>> void createAssetFromTemplate(
      @Nonnull BiomeEditor.Context var0,
      @Nullable String var1,
      @Nonnull Class<T> var2,
      @Nonnull BuilderCodec<? class="kw">extends T> var3,
      @Nonnull BiConsumer<BsonDocument, BiomeEditor.Config> var4
   ) class="kw">throws IllegalStateException, IOException {
      AssetPack var5 = var0.pack;
      String var6 = var0.config.name;
      AssetStore var7 = AssetRegistry.getAssetStore(var2);
      AssetMap var8 = var7.getAssetMap();
      JsonAssetWithMap var9 = (T)var8.getAsset(var6);
      if (var9 != null) {
         if (!var5.getName().equals(var8.getAssetPack(var6))) {
            BsonDocument var17 = var7.getCodec().encode(var9, ExtraInfo.THREAD_LOCAL.get()).asDocument();
            var4.accept(var17, var0.config);
            AssetPackUtil.exportAsset(var5, var6, var17, var2);
         }
      } else if (var1 == null) {
         JsonAssetWithMap var16 = (T)var3.getDefaultValue();
         BsonDocument var18 = var7.getCodec().encode(var16, ExtraInfo.THREAD_LOCAL.get()).asDocument();
         var4.accept(var18, var0.config);
         AssetPackUtil.exportAsset(var5, var6, var18, var2);
      } else {
         Path var10 = var8.getPath(var1);
         if (var10 == null) {
            throw new IllegalStateException("Template asset does not exist: " + var1);
         }

         try (RawJsonReader var11 = RawJsonReader.fromPath(var10, RawJsonReader.READ_BUFFER.get())) {
            BsonDocument var12 = RawJsonReader.readBsonDocument(var11);
            var4.accept(var12, var0.config);
            AssetPackUtil.exportAsset(var5, var6, var12, var2);
         }
      }
   }

   class="kw">static HandleProvider createWorldGenProvider() {
      BuilderCodec var0 = IWorldGenProvider.CODEC.getCodecFor("HytaleGenerator");
      if (var0.getDefaultValue() class="kw">instanceof HandleProvider var1) {
         class="kw">return var1;
      } else {
         throw new IllegalStateException("HandleProvider codec returned unexpected class="kw">default value type");
      }
   }

   class Config {
      @Nonnull
      class="kw">public String name = "";
      @Nonnull
      class="kw">public String pack = "Biomes";
      @Nonnull
      class="kw">public String group = "User";
      @Nullable
      class="kw">public String biomeTemplate = "Basic";
      @Nullable
      class="kw">public String worldStructureTemplate = "Basic";
      @Nonnull
      class="kw">public class="kw">transient Bounds3i viewport = BiomeEditor.Defaults.DEFAULT_VIEWPORT_BOUNDS;
      class="kw">public class="kw">transient boolean enablePersistence = false;

      class="kw">public Config() {
      }
   }

   class Context class="kw">implements Function<Object, BiomeEditor.Context> {
      class="kw">protected BiomeEditor.Config config;
      class="kw">protected AssetPack pack;

      class="kw">public Context() {
      }

      @Nonnull
      class="kw">public BiomeEditor.Context apply(@Nullable Object var1) {
         class="kw">return this;
      }

      @Nonnull
      class="kw">public Viewport createViewport(@Nonnull World var1) {
         class="kw">return new Viewport(this.config.viewport, var1);
      }
   }

   class Defaults {
      class="kw">public class="kw">static class="kw">final BuilderCodec<BiomeEditor.Defaults> CODEC = BuilderCodec.builder(BiomeEditor.Defaults.class, BiomeEditor.Defaults::new)
         .documentation("Default configuration options for the BiomeEditor")
         .<String>append(new KeyedCodec<>("Group", Codec.STRING), (var0, var1) -> var0.group = var1, var0 -> var0.group)
         .documentation("The asset-pack group to create new biomes under")
         .add()
         .<String>append(new KeyedCodec<>("Pack", Codec.STRING), (var0, var1) -> var0.pack = var1, var0 -> var0.pack)
         .documentation("The asset-pack name to create new biomes under")
         .add()
         .<String>append(new KeyedCodec<>("DefaultBiome", Codec.STRING), (var0, var1) -> var0.biome = var1, var0 -> var0.biome)
         .documentation("The Biome asset template selected as class="kw">default")
         .add()
         .<String>append(new KeyedCodec<>("DefaultWorldStructure", Codec.STRING), (var0, var1) -> var0.worldStructure = var1, var0 -> var0.worldStructure)
         .documentation("The WorldStructure asset template selected as class="kw">default")
         .add()
         .<String[]>append(
            new KeyedCodec<>("AssetTemplateTags", Codec.STRING_ARRAY), (var0, var1) -> var0.assetTemplateTags = var1, var0 -> var0.assetTemplateTags
         )
         .documentation("List of tags to match Biome and WorldStructure assets to use as templates")
         .add()
         .<Vector3i>append(new KeyedCodec<>("ViewportMin", Vector3iUtil.CODEC), (var0, var1) -> var0.viewportMin = var1, var0 -> var0.viewportMin)
         .documentation("The min corner of the Viewport to set up in the biome editor world")
         .add()
         .<Vector3i>append(new KeyedCodec<>("ViewportMax", Vector3iUtil.CODEC), (var0, var1) -> var0.viewportMax = var1, var0 -> var0.viewportMax)
         .documentation("The max corner of the Viewport to set up in the biome editor world")
         .add()
         .<Boolean>append(new KeyedCodec<>("EnablePersistence", Codec.BOOLEAN), (var0, var1) -> var0.enablePersistence = var1, var0 -> var0.enablePersistence)
         .documentation("Whether the BiomdEditor world should be stored on disk after exiting it")
         .add()
         .afterDecode(var0 -> {
            var0.biomeAssets = resolveAssetTags(BiomeAsset.class, var0.assetTemplateTags);
            var0.worldStructureAssets = resolveAssetTags(WorldStructureAsset.class, var0.assetTemplateTags);
            var0.viewportBounds = new Bounds3i(var0.viewportMin, var0.viewportMax);
         })
         .build();
      class="kw">public class="kw">static class="kw">final String DEFAULT_PACK = "Biomes";
      class="kw">public class="kw">static class="kw">final String DEFAULT_GROUP = "User";
      class="kw">public class="kw">static class="kw">final String DEFAULT_BIOME_TEMPLATE = "Basic";
      class="kw">public class="kw">static class="kw">final String DEFAULT_WORLD_STRUCTURE_TEMPLATE = "Basic";
      class="kw">public class="kw">static class="kw">final String[] DEFAULT_ASSET_TEMPLATE_TAGS = new String[]{"Template"};
      class="kw">public class="kw">static class="kw">final Vector3i VIEWPORT_MIN = new Vector3i(-128, 0, -128);
      class="kw">public class="kw">static class="kw">final Vector3i VIEWPORT_MAX = new Vector3i(128, 0, 128);
      class="kw">public class="kw">static class="kw">final Bounds3i DEFAULT_VIEWPORT_BOUNDS = new Bounds3i(VIEWPORT_MIN, VIEWPORT_MAX);
      class="kw">public class="kw">static class="kw">final boolean DEFAULT_ENABLE_PERSISTENCE = false;
      @Nonnull
      class="kw">public String pack = "Biomes";
      @Nonnull
      class="kw">public String group = "User";
      @Nullable
      class="kw">public String biome = "Basic";
      @Nullable
      class="kw">public String worldStructure = "Basic";
      @Nonnull
      class="kw">public String[] assetTemplateTags = DEFAULT_ASSET_TEMPLATE_TAGS;
      @Nonnull
      class="kw">public Vector3i viewportMin = VIEWPORT_MIN;
      @Nonnull
      class="kw">public Vector3i viewportMax = VIEWPORT_MAX;
      class="kw">public boolean enablePersistence = false;
      @Nonnull
      class="kw">public class="kw">transient Bounds3i viewportBounds = new Bounds3i();
      @Nonnull
      class="kw">public class="kw">transient String[] biomeAssets = ArrayUtil.EMPTY_STRING_ARRAY;
      @Nonnull
      class="kw">public class="kw">transient String[] worldStructureAssets = ArrayUtil.EMPTY_STRING_ARRAY;

      class="kw">public Defaults() {
      }

      class="kw">protected class="kw">static <T class="kw">extends JsonAssetWithMap<String, M>, M class="kw">extends AssetMap<String, T>> String[] resolveAssetTags(
         @Nonnull Class<T> var0, @Nonnull String[] var1
      ) {
         AssetStore var2 = AssetRegistry.getAssetStore(var0);
         if (var2 == null) {
            class="kw">return ArrayUtil.EMPTY_STRING_ARRAY;
         }

         AssetMap var3 = var2.getAssetMap();
         Set var4 = (Set<String>)(var1.length == 0 ? var3.getAssetMap().keySet() : new ObjectOpenHashSet());

         for (String var8 : var1) {
            int var9 = AssetRegistry.getTagIndex(var8);
            Set var10 = var3.getKeysForTag(var9);
            var4.addAll(var10);
         }

         String[] var11 = var4.toArray(ArrayUtil.EMPTY_STRING_ARRAY);
         Arrays.sort(var11);
         class="kw">return var11;
      }
   }
}