class="kw">package com.hypixel.hytale.server.worldgen.loader.container;

class="kw">import com.google.gson.JsonArray;
class="kw">import com.google.gson.JsonElement;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.event.ModifyEvent;
class="kw">import com.hypixel.hytale.builtin.worldgen.modifier.event.ModifyEvents;
class="kw">import com.hypixel.hytale.procedurallib.condition.ICoordinateCondition;
class="kw">import com.hypixel.hytale.procedurallib.json.DoubleRangeJsonLoader;
class="kw">import com.hypixel.hytale.procedurallib.json.JsonLoader;
class="kw">import com.hypixel.hytale.procedurallib.json.NoiseMaskConditionJsonLoader;
class="kw">import com.hypixel.hytale.procedurallib.json.NoisePropertyJsonLoader;
class="kw">import com.hypixel.hytale.procedurallib.json.SeedString;
class="kw">import com.hypixel.hytale.procedurallib.property.NoiseProperty;
class="kw">import com.hypixel.hytale.procedurallib.supplier.DoubleRange;
class="kw">import com.hypixel.hytale.procedurallib.supplier.DoubleRangeNoiseSupplier;
class="kw">import com.hypixel.hytale.procedurallib.supplier.IDoubleCoordinateSupplier;
class="kw">import com.hypixel.hytale.procedurallib.supplier.IDoubleRange;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.environment.config.Environment;
class="kw">import com.hypixel.hytale.server.worldgen.SeedStringResource;
class="kw">import com.hypixel.hytale.server.worldgen.container.LayerContainer;
class="kw">import com.hypixel.hytale.server.worldgen.loader.context.BiomeFileContext;
class="kw">import com.hypixel.hytale.server.worldgen.loader.util.NoiseBlockArrayJsonLoader;
class="kw">import com.hypixel.hytale.server.worldgen.util.ConstantNoiseProperty;
class="kw">import com.hypixel.hytale.server.worldgen.util.ListPool;
class="kw">import com.hypixel.hytale.server.worldgen.util.NoiseBlockArray;
class="kw">import java.nio.file.Path;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class LayerContainerJsonLoader class="kw">extends JsonLoader<SeedStringResource, LayerContainer> {
   @Nonnull
   class="kw">protected class="kw">final BiomeFileContext biomeContext;

   class="kw">public LayerContainerJsonLoader(@Nonnull SeedString<SeedStringResource> var1, Path var2, JsonElement var3, @Nonnull BiomeFileContext var4) {
      super(var1.append(".LayerContainer"), var2, var3);
      this.biomeContext = var4;
   }

   @Nonnull
   class="kw">public LayerContainer load() {
      class="kw">return new LayerContainer(this.loadDefault(), this.loadDefaultEnvironment(), this.loadStaticLayers(), this.loadDynamicLayers());
   }

   class="kw">protected int loadDefault() {
      if (!this.has("Default")) {
         throw new IllegalArgumentException("Could not find class="kw">default material. Keyword: Default");
      } else {
         String var1 = this.get("Default").getAsString();
         int var2 = BlockType.getAssetMap().getIndex(var1);
         if (var2 == Integer.MIN_VALUE) {
            throw new Error(String.format("Default block for LayerContainer could not be found! BlockType: %s", var1));
         } else {
            class="kw">return var2;
         }
      }
   }

   class="kw">protected int loadDefaultEnvironment() {
      int var1 = Integer.MIN_VALUE;
      if (this.has("Environment")) {
         String var2 = this.get("Environment").getAsString();
         var1 = Environment.getAssetMap().getIndex(var2);
         if (var1 == Integer.MIN_VALUE) {
            throw new Error(String.format("Error while looking up environment \"%s\"!", var2));
         }
      }

      class="kw">return var1;
   }

   @Nonnull
   class="kw">protected LayerContainer.StaticLayer[] loadStaticLayers() {
      JsonArray var1 = this.mustGetArray("Static", EMPTY_ARRAY);

      try (ListPool.Resource var2 = LayerContainer.STATIC_POOL.acquire(var1.size())) {
         for (int var3 = 0; var3 < var1.size(); var3++) {
            try {
               var2.add(new LayerContainerJsonLoader.StaticLayerJsonLoader(this.seed.append("-" + var3), this.dataFolder, var1.get(var3)).load());
            } catch (Throwable var6) {
               throw new Error(String.format("Error while loading StaticLayer #%s", var3), var6);
            }
         }

         ModifyEvent.SeedGenerator var8 = new ModifyEvent.SeedGenerator<>(this.seed);
         ModifyEvent.dispatch(
            ModifyEvents.BiomeStaticLayers.class,
            new ModifyEvents.BiomeStaticLayers(
               this.seed,
               this.biomeContext,
               var2,
               var2x -> new LayerContainerJsonLoader.StaticLayerJsonLoader(var8.next(), this.dataFolder, this.loadFile(var2x)).load()
            )
         );
         class="kw">return var2.toArray();
      }
   }

   @Nonnull
   class="kw">protected LayerContainer.DynamicLayer[] loadDynamicLayers() {
      JsonArray var1 = this.mustGetArray("Dynamic", EMPTY_ARRAY);

      try (ListPool.Resource var2 = LayerContainer.DYNAMIC_POOL.acquire(var1.size())) {
         for (int var3 = 0; var3 < var1.size(); var3++) {
            try {
               var2.add(new LayerContainerJsonLoader.DynamicLayerJsonLoader(this.seed.append("-" + var3), this.dataFolder, var1.get(var3)).load());
            } catch (Throwable var6) {
               throw new Error(String.format("Error while loading DynamicLayer #%s", var3), var6);
            }
         }

         ModifyEvent.SeedGenerator var8 = new ModifyEvent.SeedGenerator<>(this.seed);
         ModifyEvent.dispatch(
            ModifyEvents.BiomeDynamicLayers.class,
            new ModifyEvents.BiomeDynamicLayers(
               this.seed,
               this.biomeContext,
               var2,
               var2x -> new LayerContainerJsonLoader.DynamicLayerJsonLoader(var8.next(), this.dataFolder, this.loadFile(var2x)).load()
            )
         );
         class="kw">return var2.toArray();
      }
   }

   class="kw">public class="kw">interface Constants {
      String KEY_DEFAULT = "Default";
      String KEY_DYNAMIC = "Dynamic";
      String KEY_STATIC = "Static";
      String KEY_ENTRY_ENTRIES = "Entries";
      String KEY_ENTRY_BLOCKS = "Blocks";
      String KEY_ENTRY_NOISE_MASK = "NoiseMask";
      String KEY_ENTRY_DYNAMIC_OFFSET = "Offset";
      String KEY_ENTRY_DYNAMIC_OFFSET_NOISE = "OffsetNoise";
      String KEY_ENTRY_STATIC_MIN = "Min";
      String KEY_ENTRY_STATIC_MIN_NOISE = "MinNoise";
      String KEY_ENTRY_STATIC_MAX = "Max";
      String KEY_ENTRY_STATIC_MAX_NOISE = "MaxNoise";
      String KEY_ENVIRONMENT = "Environment";
      String ERROR_NO_DEFAULT = "Could not find class="kw">default material. Keyword: Default";
      String ERROR_DEFAULT_INVALID = "Default block for LayerContainer could not be found! BlockType: %s";
      String ERROR_FAIL_DYNAMIC_LAYER = "Error while loading DynamicLayer #%s";
      String ERROR_FAIL_STATIC_LAYER = "Error while loading StaticLayer #%s";
      String ERROR_NO_BLOCKS = "Could not find block data for layer entry. Keyword: Blocks";
      String ERROR_UNKOWN_STATIC = "Unknown type for class="kw">static Layer";
      String ERROR_UNKOWN_DYNAMIC = "Unknown type for dynamic Layer";
      String ERROR_FAIL_DYNAMIC_ENTRY = "Error while loading DynamicLayerEntry #%s";
      String ERROR_FAIL_STATIC_ENTRY = "Error while loading StaticLayerEntry #%s";
      String ERROR_STATIC_NO_MIN = "Could not find minimum of class="kw">static layer entry.";
      String ERROR_STATIC_NO_MAX = "Could not find maximum of class="kw">static layer entry.";
   }

   class="kw">protected class="kw">static class DynamicLayerJsonLoader class="kw">extends JsonLoader<SeedStringResource, LayerContainer.DynamicLayer> {
      class="kw">public DynamicLayerJsonLoader(@Nonnull SeedString<SeedStringResource> var1, Path var2, JsonElement var3) {
         super(var1.append(".DynamicLayer"), var2, var3);
      }

      @Nonnull
      class="kw">public LayerContainer.DynamicLayer load() {
         class="kw">return new LayerContainer.DynamicLayer(this.loadEntries(), this.loadMapCondition(), this.loadEnvironment(), this.loadOffset());
      }

      @Nonnull
      class="kw">protected ICoordinateCondition loadMapCondition() {
         class="kw">return new NoiseMaskConditionJsonLoader<>(this.seed, this.dataFolder, this.get("NoiseMask")).load();
      }

      @Nonnull
      class="kw">protected IDoubleCoordinateSupplier loadOffset() {
         IDoubleRange var1 = DoubleRange.ZERO;
         NoiseProperty var2 = ConstantNoiseProperty.DEFAULT_ZERO;
         if (this.has("Offset")) {
            var1 = new DoubleRangeJsonLoader<>(this.seed, this.dataFolder, this.get("Offset")).load();
            if (this.has("OffsetNoise")) {
               var2 = new NoisePropertyJsonLoader<>(this.seed, this.dataFolder, this.get("OffsetNoise")).load();
            }
         }

         class="kw">return new DoubleRangeNoiseSupplier(var1, var2);
      }

      @Nonnull
      class="kw">protected LayerContainer.DynamicLayerEntry[] loadEntries() {
         if (this.json == null || this.json.isJsonNull()) {
            class="kw">return new LayerContainer.DynamicLayerEntry[0];
         }

         if (!this.json.isJsonObject()) {
            throw new Error("Unknown type for dynamic Layer");
         }

         if (!this.has("Entries")) {
            try {
               class="kw">return new LayerContainer.DynamicLayerEntry[]{
                  new LayerContainerJsonLoader.DynamicLayerJsonLoader.DynamicLayerEntryJsonLoader(this.seed, this.dataFolder, this.json).load()
               };
            } catch (Throwable var6) {
               throw new Error(String.format("Error while loading DynamicLayerEntry #%s", 0), var6);
            }
         } else {
            JsonArray var1 = this.get("Entries").getAsJsonArray();
            LayerContainer.DynamicLayerEntry[] var2 = new LayerContainer.DynamicLayerEntry[var1.size()];

            for (int var3 = 0; var3 < var2.length; var3++) {
               try {
                  var2[var3] = new LayerContainerJsonLoader.DynamicLayerJsonLoader.DynamicLayerEntryJsonLoader(
                        this.seed.append("-" + var3), this.dataFolder, var1.get(var3)
                     )
                     .load();
               } catch (Throwable var5) {
                  throw new Error(String.format("Error while loading DynamicLayerEntry #%s", var3), var5);
               }
            }

            class="kw">return var2;
         }
      }

      class="kw">protected int loadEnvironment() {
         int var1 = Integer.MIN_VALUE;
         if (this.has("Environment")) {
            String var2 = this.get("Environment").getAsString();
            var1 = Environment.getAssetMap().getIndex(var2);
            if (var1 == Integer.MIN_VALUE) {
               throw new Error(String.format("Error while looking up environment \"%s\"!", var2));
            }
         }

         class="kw">return var1;
      }

      class="kw">protected class="kw">static class DynamicLayerEntryJsonLoader class="kw">extends LayerContainerJsonLoader.LayerEntryJsonLoader<LayerContainer.DynamicLayerEntry> {
         class="kw">public DynamicLayerEntryJsonLoader(@Nonnull SeedString<SeedStringResource> var1, Path var2, JsonElement var3) {
            super(var1, var2, var3);
         }

         @Nonnull
         class="kw">public LayerContainer.DynamicLayerEntry load() {
            class="kw">return new LayerContainer.DynamicLayerEntry(this.loadBlocks(), this.loadMapCondition());
         }
      }
   }

   class="kw">protected class="kw">abstract class="kw">static class LayerEntryJsonLoader<T class="kw">extends LayerContainer.LayerEntry> class="kw">extends JsonLoader<SeedStringResource, T> {
      class="kw">public LayerEntryJsonLoader(@Nonnull SeedString<SeedStringResource> var1, Path var2, JsonElement var3) {
         super(var1.append(".LayerEntry"), var2, var3);
      }

      @Nonnull
      class="kw">protected NoiseBlockArray loadBlocks() {
         class="kw">return !this.has("Blocks") ? NoiseBlockArray.EMPTY : new NoiseBlockArrayJsonLoader(this.seed, this.dataFolder, this.get("Blocks")).load();
      }

      @Nonnull
      class="kw">protected ICoordinateCondition loadMapCondition() {
         class="kw">return new NoiseMaskConditionJsonLoader<>(this.seed, this.dataFolder, this.get("NoiseMask")).load();
      }
   }

   class="kw">protected class="kw">static class StaticLayerJsonLoader class="kw">extends JsonLoader<SeedStringResource, LayerContainer.StaticLayer> {
      class="kw">public StaticLayerJsonLoader(@Nonnull SeedString<SeedStringResource> var1, Path var2, JsonElement var3) {
         super(var1.append(".StaticLayer"), var2, var3);
      }

      @Nonnull
      class="kw">public LayerContainer.StaticLayer load() {
         class="kw">return new LayerContainer.StaticLayer(this.loadEntries(), this.loadMapCondition(), this.loadEnvironment());
      }

      @Nonnull
      class="kw">protected ICoordinateCondition loadMapCondition() {
         class="kw">return new NoiseMaskConditionJsonLoader<>(this.seed, this.dataFolder, this.get("NoiseMask")).load();
      }

      @Nonnull
      class="kw">protected LayerContainer.StaticLayerEntry[] loadEntries() {
         if (this.json == null || this.json.isJsonNull()) {
            class="kw">return new LayerContainer.StaticLayerEntry[0];
         }

         if (!this.json.isJsonObject()) {
            throw new Error("Unknown type for class="kw">static Layer");
         }

         if (!this.has("Entries")) {
            try {
               class="kw">return new LayerContainer.StaticLayerEntry[]{
                  new LayerContainerJsonLoader.StaticLayerJsonLoader.StaticLayerEntryJsonLoader(this.seed, this.dataFolder, this.json).load()
               };
            } catch (Throwable var6) {
               throw new Error(String.format("Error while loading StaticLayerEntry #%s", 0), var6);
            }
         } else {
            JsonArray var1 = this.get("Entries").getAsJsonArray();
            LayerContainer.StaticLayerEntry[] var2 = new LayerContainer.StaticLayerEntry[var1.size()];

            for (int var3 = 0; var3 < var2.length; var3++) {
               try {
                  var2[var3] = new LayerContainerJsonLoader.StaticLayerJsonLoader.StaticLayerEntryJsonLoader(
                        this.seed.append("-" + var3), this.dataFolder, var1.get(var3)
                     )
                     .load();
               } catch (Throwable var5) {
                  throw new Error(String.format("Error while loading StaticLayerEntry #%s", var3), var5);
               }
            }

            class="kw">return var2;
         }
      }

      class="kw">protected int loadEnvironment() {
         int var1 = Integer.MIN_VALUE;
         if (this.has("Environment")) {
            String var2 = this.get("Environment").getAsString();
            var1 = Environment.getAssetMap().getIndex(var2);
            if (var1 == Integer.MIN_VALUE) {
               throw new Error(String.format("Error while looking up environment \"%s\"!", var2));
            }
         }

         class="kw">return var1;
      }

      class="kw">protected class="kw">static class StaticLayerEntryJsonLoader class="kw">extends LayerContainerJsonLoader.LayerEntryJsonLoader<LayerContainer.StaticLayerEntry> {
         class="kw">public StaticLayerEntryJsonLoader(@Nonnull SeedString<SeedStringResource> var1, Path var2, JsonElement var3) {
            super(var1.append(".StaticLayerEntry"), var2, var3);
         }

         @Nonnull
         class="kw">public LayerContainer.StaticLayerEntry load() {
            class="kw">return new LayerContainer.StaticLayerEntry(this.loadBlocks(), this.loadMapCondition(), this.loadMin(), this.loadMax());
         }

         @Nonnull
         class="kw">protected IDoubleCoordinateSupplier loadMin() {
            if (!this.has("Min")) {
               throw new IllegalArgumentException("Could not find minimum of class="kw">static layer entry.");
            }

            IDoubleRange var1 = new DoubleRangeJsonLoader<>(this.seed, this.dataFolder, this.get("Min"), 0.0).load();
            NoiseProperty var2 = this.loadMinNoise();
            class="kw">return new DoubleRangeNoiseSupplier(var1, var2);
         }

         @Nonnull
         class="kw">protected IDoubleCoordinateSupplier loadMax() {
            if (!this.has("Max")) {
               throw new IllegalArgumentException("Could not find maximum of class="kw">static layer entry.");
            }

            IDoubleRange var1 = new DoubleRangeJsonLoader<>(this.seed, this.dataFolder, this.get("Max"), 0.0).load();
            NoiseProperty var2 = this.loadMaxNoise();
            class="kw">return new DoubleRangeNoiseSupplier(var1, var2);
         }

         @Nullable
         class="kw">protected NoiseProperty loadMinNoise() {
            NoiseProperty var1 = ConstantNoiseProperty.DEFAULT_ZERO;
            if (this.has("MinNoise")) {
               var1 = new NoisePropertyJsonLoader<>(this.seed, this.dataFolder, this.get("MinNoise")).load();
            }

            class="kw">return var1;
         }

         @Nullable
         class="kw">protected NoiseProperty loadMaxNoise() {
            NoiseProperty var1 = ConstantNoiseProperty.DEFAULT_ZERO;
            if (this.has("MaxNoise")) {
               var1 = new NoisePropertyJsonLoader<>(this.seed, this.dataFolder, this.get("MaxNoise")).load();
            }

            class="kw">return var1;
         }
      }
   }
}