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

class="kw">import com.hypixel.hytale.assetstore.AssetPack;
class="kw">import com.hypixel.hytale.builtin.adventure.worldevents.condition.location.EventLocation;
class="kw">import com.hypixel.hytale.builtin.worldgen.integrations.BiomeLocationV1;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.EventHandler;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.WorldGenModifier;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.content.Content;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.content.FileContent;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.content.cave.CaveTypeContent;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.content.cave.CaveTypeGenerator;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.content.cave.ore.OreCluster;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.content.cover.BiomeCoverContent;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.content.cover.CaveCoverContent;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.content.fluid.BiomeFluidContent;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.content.layer.BiomeDynamicLayerContent;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.content.layer.BiomeStaticLayerContent;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.content.prefab.BiomePrefabContent;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.content.prefab.CavePrefabContent;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.content.tint.BiomeTintContent;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.event.ModifyEvents;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.op.AddOp;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.op.LogOp;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.op.Op;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.op.RemoveOp;
class="kw">import com.hypixel.hytale.codec.ExtraInfo;
class="kw">import com.hypixel.hytale.codec.lookup.Priority;
class="kw">import com.hypixel.hytale.codec.util.RawJsonReader;
class="kw">import com.hypixel.hytale.common.plugin.PluginManifest;
class="kw">import com.hypixel.hytale.common.semver.Semver;
class="kw">import com.hypixel.hytale.procedurallib.file.FileIO;
class="kw">import com.hypixel.hytale.server.core.asset.AssetModule;
class="kw">import com.hypixel.hytale.server.core.asset.HytaleAssetStore;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPlugin;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPluginInit;
class="kw">import com.hypixel.hytale.server.core.universe.Universe;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.provider.IWorldGenProvider;
class="kw">import com.hypixel.hytale.server.worldgen.BiomeDataSystem;
class="kw">import com.hypixel.hytale.server.worldgen.HytaleWorldGenProvider;
class="kw">import com.hypixel.hytale.server.worldgen.util.LogUtil;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectLists;
class="kw">import java.io.BufferedReader;
class="kw">import java.io.IOException;
class="kw">import java.nio.charset.StandardCharsets;
class="kw">import java.nio.file.DirectoryStream;
class="kw">import java.nio.file.Files;
class="kw">import java.nio.file.Path;
class="kw">import java.util.Collections;
class="kw">import java.util.Iterator;
class="kw">import java.util.List;
class="kw">import java.util.Objects;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class WorldGenPlugin class="kw">extends JavaPlugin {
   class="kw">private class="kw">static class="kw">final String VERSIONS_DIR_NAME = "$Versions";
   class="kw">private class="kw">static class="kw">final String MANIFEST_FILENAME = "manifest.json";
   class="kw">private class="kw">static WorldGenPlugin instance;

   class="kw">public class="kw">static WorldGenPlugin get() {
      class="kw">return instance;
   }

   class="kw">public WorldGenPlugin(@Nonnull JavaPluginInit var1) {
      super(var1);
   }

   @Override
   class="kw">protected void setup() {
      instance = this;
      this.getEntityStoreRegistry().registerSystem(new BiomeDataSystem());
      IWorldGenProvider.CODEC.register(Priority.DEFAULT.before(1), "Hytale", HytaleWorldGenProvider.class, HytaleWorldGenProvider.CODEC);
      this.getEventRegistry().register(ModifyEvents.BiomeCovers.class, Content.Type.BIOME_COVER, EventHandler::handle);
      this.getEventRegistry().register(ModifyEvents.BiomeEnvironments.class, Content.Type.BIOME_ENVIRONMENT, EventHandler::handle);
      this.getEventRegistry().register(ModifyEvents.BiomeFluids.class, Content.Type.BIOME_FLUID, EventHandler::handle);
      this.getEventRegistry().register(ModifyEvents.BiomeDynamicLayers.class, Content.Type.BIOME_DYNAMIC_LAYER, EventHandler::handle);
      this.getEventRegistry().register(ModifyEvents.BiomeStaticLayers.class, Content.Type.BIOME_STATIC_LAYER, EventHandler::handle);
      this.getEventRegistry().register(ModifyEvents.BiomePrefabs.class, Content.Type.BIOME_PREFAB, EventHandler::handle);
      this.getEventRegistry().register(ModifyEvents.BiomeTints.class, Content.Type.BIOME_TINT, EventHandler::handle);
      this.getEventRegistry().register(ModifyEvents.CaveTypes.class, Content.Type.CAVE_TYPE, EventHandler::handle);
      this.getEventRegistry().register(ModifyEvents.CaveCovers.class, Content.Type.CAVE_COVER, EventHandler::handle);
      this.getEventRegistry().register(ModifyEvents.CavePrefabs.class, Content.Type.CAVE_PREFAB, EventHandler::handle);
      this.getCodecRegistry(CaveTypeGenerator.TYPE_CODEC).register("OreCluster", OreCluster.class, OreCluster.CODEC);
      this.getCodecRegistry(Content.TYPE_CODEC)
         .register("File", FileContent.class, FileContent.CODEC)
         .register("BiomeCover", BiomeCoverContent.class, BiomeCoverContent.CODEC)
         .register("BiomeFluid", BiomeFluidContent.class, BiomeFluidContent.CODEC)
         .register("BiomeDynamicLayer", BiomeDynamicLayerContent.class, BiomeDynamicLayerContent.CODEC)
         .register("BiomeStaticLayer", BiomeStaticLayerContent.class, BiomeStaticLayerContent.CODEC)
         .register("BiomePrefab", BiomePrefabContent.class, BiomePrefabContent.CODEC)
         .register("BiomeTint", BiomeTintContent.class, BiomeTintContent.CODEC)
         .register("CaveCover", CaveCoverContent.class, CaveCoverContent.CODEC)
         .register("CavePrefab", CavePrefabContent.class, CavePrefabContent.CODEC)
         .register("CaveType", CaveTypeContent.class, CaveTypeContent.CODEC);
      this.getCodecRegistry(Op.TYPE_CODEC)
         .register("Add", AddOp.class, AddOp.CODEC)
         .register("Remove", RemoveOp.class, RemoveOp.CODEC)
         .register("Log", LogOp.class, LogOp.CODEC);
      this.getAssetRegistry()
         .register(
            ((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(
                                 WorldGenModifier.class, WorldGenModifier.ASSET_MAP
                              )
                              .setCodec(WorldGenModifier.ASSET_CODEC))
                           .setPath("WorldGen/Modifier"))
                        .setIdProvider(WorldGenModifier.class))
                     .setKeyFunction(WorldGenModifier::getId))
                  .setReplaceOnRemove(WorldGenModifier::new))
               .build()
         );
      this.getCodecRegistry(EventLocation.Config.TYPE_CODEC).register("BiomeLocationV1", BiomeLocationV1.Config.class, BiomeLocationV1.Config.CODEC);
      AssetModule var1 = AssetModule.get();
      if (var1.getAssetPacks().isEmpty()) {
         this.getLogger().at(Level.SEVERE).log("No asset packs loaded");
      } else {
         FileIO.setDefaultRoot(var1.getBaseAssetPack().getRoot());
         List var2 = loadVersionPacks(var1);
         Object2ObjectOpenHashMap var3 = new Object2ObjectOpenHashMap();

         for (WorldGenPlugin.Version var5 : var2) {
            validateVersion(var5, var2);
            if (!var1.registerPack(var5.getPackName(), var5.path, var5.manifest, AssetPack.PackSource.CLASSPATH)) {
               this.getLogger().at(Level.SEVERE).log("Failed to register world gen asset pack: %s", var5.getPackName());
            } else {
               Semver var6 = (Semver)var3.get(var5.name);
               if (var6 == null || var5.manifest.getVersion().compareTo(var6) > 0) {
                  var3.put(var5.name, var5.manifest.getVersion());
               }
            }
         }

         HytaleWorldGenProvider.CODEC.setVersions(var3);
      }
   }

   class="kw">private class="kw">static List<WorldGenPlugin.Version> loadVersionPacks(@Nonnull AssetModule var0) {
      Path var1 = getVersionsPath();
      if (!Files.exists(var1)) {
         class="kw">return ObjectLists.emptyList();
      }

      Path var2 = var0.getBaseAssetPack().getRoot();
      Path var3 = var2.relativize(Universe.getWorldGenPath());

      try (DirectoryStream var4 = Files.newDirectoryStream(var1)) {
         ObjectArrayList var5 = new ObjectArrayList();

         for (Path var7 : var4) {
            if (Files.isDirectory(var7)) {
               String var8 = getWorldConfigName(var7, var3);
               if (var8 != null) {
                  Path var9 = var7.resolve("manifest.json");
                  if (Files.exists(var9)) {
                     PluginManifest var10 = loadManifest(var9);
                     if (var10 != null) {
                        var5.add(new WorldGenPlugin.Version(var8, var7, var10));
                     }
                  }
               }
            }
         }

         Collections.sort(var5);
         class="kw">return var5;
      } catch (IOException var13) {
         throw new RuntimeException(var13);
      }
   }

   class="kw">private class="kw">static void validateVersion(@Nonnull WorldGenPlugin.Version var0, @Nonnull List<WorldGenPlugin.Version> var1) {
      if (var0.manifest.getVersion().compareTo(HytaleWorldGenProvider.MIN_VERSION) <= 0) {
         throw new IllegalArgumentException(
            String.format(
               "Invalid $Version AssetPack: %s. Pack version number: %s must be greater than: %s",
               var0.path(),
               var0.manifest.getVersion(),
               HytaleWorldGenProvider.MIN_VERSION
            )
         );
      }

      for (WorldGenPlugin.Version var3 : var1) {
         if (var3 != var0 && var0.name().equals(var3.name()) && var0.manifest.getVersion().equals(var3.manifest.getVersion())) {
            throw new IllegalArgumentException(
               String.format(
                  "$Version AssetPack: %s conflicts with pack: %s. Pack version numbers must be different. Found: %s in both",
                  var0.path(),
                  var3.path(),
                  var0.manifest.getVersion()
               )
            );
         }
      }
   }

   @Nullable
   class="kw">private class="kw">static String getWorldConfigName(@Nonnull Path var0, @Nonnull Path var1) {
      Path var2 = var0.resolve(var1);
      if (Files.exists(var2) && Files.isDirectory(var2)) {
         try (DirectoryStream var3 = Files.newDirectoryStream(var2)) {
            Iterator var4 = var3.iterator();
            if (!var4.hasNext()) {
               LogUtil.getLogger().at(Level.WARNING).log("WorldGen version pack: %s is empty", var0);
               class="kw">return null;
            } else {
               Path var5 = var4.next();
               if (var4.hasNext()) {
                  LogUtil.getLogger().at(Level.WARNING).log("WorldGen version pack: %s contains multiple world configs", var0);
                  class="kw">return null;
               } else if (!Files.isDirectory(var5)) {
                  LogUtil.getLogger().at(Level.WARNING).log("WorldGen version pack: %s does not contain a world config directory", var0);
                  class="kw">return null;
               } else {
                  class="kw">return var5.getFileName().toString();
               }
            }
         } catch (IOException var9) {
            throw new RuntimeException(var9);
         }
      } else {
         LogUtil.getLogger().at(Level.WARNING).log("WorldGen version pack: %s does not contain dir: %s", var0, var1);
         class="kw">return null;
      }
   }

   @Nullable
   class="kw">private class="kw">static PluginManifest loadManifest(@Nonnull Path var0) class="kw">throws IOException {
      if (!Files.exists(var0)) {
         class="kw">return null;
      }

      try (BufferedReader var1 = Files.newBufferedReader(var0, StandardCharsets.UTF_8)) {
         char[] var2 = RawJsonReader.READ_BUFFER.get();
         RawJsonReader var3 = new RawJsonReader(var1, var2);
         ExtraInfo var4 = ExtraInfo.THREAD_LOCAL.get();
         PluginManifest var5 = PluginManifest.CODEC.decodeJson(var3, var4);
         var4.getValidationResults().logOrThrowValidatorExceptions(LogUtil.getLogger());
         class="kw">return var5;
      }
   }

   class="kw">public class="kw">static Path getVersionsPath() {
      class="kw">return Universe.getWorldGenPath().resolve("$Versions");
   }

   class="kw">public record Version(@Nonnull String name, @Nonnull Path path, @Nonnull PluginManifest manifest) class="kw">implements Comparable<WorldGenPlugin.Version> {
      class="kw">public Version {
      }

      class="kw">public int compareTo(WorldGenPlugin.Version var1) {
         class="kw">return this.manifest.getVersion().compareTo(var1.manifest.getVersion());
      }

      @Nonnull
      class="kw">public String getPackName() {
         String var1 = Objects.requireNonNullElse(this.manifest.getGroup(), "Unknown");
         String var2 = Objects.requireNonNullElse(this.manifest.getName(), "Unknown");
         class="kw">return var1 + ":" + var2;
      }
   }
}