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

class="kw">import com.google.gson.JsonArray;
class="kw">import com.google.gson.JsonElement;
class="kw">import com.google.gson.JsonObject;
class="kw">import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.procedurallib.json.JsonLoader;
class="kw">import com.hypixel.hytale.procedurallib.json.SeedString;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.fluid.Fluid;
class="kw">import com.hypixel.hytale.server.worldgen.SeedStringResource;
class="kw">import com.hypixel.hytale.server.worldgen.util.BlockFluidEntry;
class="kw">import com.hypixel.hytale.server.worldgen.util.ResolvedBlockArray;
class="kw">import java.nio.file.Path;
class="kw">import java.util.ArrayList;
class="kw">import java.util.List;
class="kw">import javax.annotation.Nonnull;

class="kw">public class ResolvedVariantsBlockArrayLoader class="kw">extends JsonLoader<SeedStringResource, ResolvedBlockArray> {
   class="kw">public ResolvedVariantsBlockArrayLoader(SeedString<SeedStringResource> var1, Path var2, JsonElement var3) {
      super(var1, var2, var3);
   }

   @Nonnull
   class="kw">public ResolvedBlockArray load() {
      if (this.json != null && !this.json.isJsonNull()) {
         if (!this.json.isJsonArray()) {
            class="kw">return loadSingleBlock(this.json.getAsString());
         }

         JsonArray var1 = this.json.getAsJsonArray();
         if (var1.size() == 1) {
            class="kw">return loadSingleBlock(var1.get(0).getAsString());
         }

         BlockTypeAssetMap var2 = BlockType.getAssetMap();
         List var3 = new ArrayList<>();
         int var4 = 0;

         for (int var5 = 0; var5 < var1.size(); var5++) {
            String var6 = var1.get(var5).getAsString();

            try {
               if (var2.getAsset(var6) == null) {
                  throw new IllegalArgumentException(String.valueOf(var6));
               }

               int var7 = var2.getIndex(var6);
               if (var7 == Integer.MIN_VALUE) {
                  throw new IllegalArgumentException("Unknown key! " + var6);
               }

               ResolvedBlockArray var8 = (ResolvedBlockArray)ResolvedBlockArray.RESOLVED_BLOCKS_WITH_VARIANTS.get(var7);
               BlockFluidEntry[] var9;
               if (var8 != null) {
                  var9 = var8.getEntries();
               } else {
                  var9 = resolveBlockArrayWithVariants(var6, var2, 0);
               }

               var3.add(var9);
               var4 += var9.length;
            } catch (IllegalArgumentException var12) {
               throw new IllegalArgumentException("BlockLayer does not exist in BlockTypes", var12);
            }
         }

         BlockFluidEntry[] var13 = new BlockFluidEntry[var4];

         for (BlockFluidEntry[] var15 : var3) {
            for (BlockFluidEntry var11 : var15) {
               var13[--var4] = var11;
            }
         }

         class="kw">return new ResolvedBlockArray(var13);
      } else {
         class="kw">return ResolvedBlockArray.EMPTY;
      }
   }

   @Nonnull
   class="kw">public class="kw">static ResolvedBlockArray loadSingleBlock(@Nonnull String var0) {
      BlockTypeAssetMap var1 = BlockType.getAssetMap();

      try {
         if (var1.getAsset(var0) == null) {
            throw new IllegalArgumentException(String.valueOf(var0));
         }

         int var2 = var1.getIndex(var0);
         if (var2 == Integer.MIN_VALUE) {
            throw new IllegalArgumentException("Unknown block! " + var0);
         }

         long var3 = MathUtil.packLong(var2, 0);
         ResolvedBlockArray var5 = (ResolvedBlockArray)ResolvedBlockArray.RESOLVED_BLOCKS_WITH_VARIANTS.get(var3);
         if (var5 != null) {
            class="kw">return var5;
         }

         BlockFluidEntry[] var6 = resolveBlockArrayWithVariants(var0, var1, 0);
         ResolvedBlockArray var7 = new ResolvedBlockArray(var6);
         ResolvedBlockArray.RESOLVED_BLOCKS_WITH_VARIANTS.put(var3, var7);
         class="kw">return var7;
      } catch (IllegalArgumentException var8) {
         throw new IllegalArgumentException("BlockLayer does not exist in BlockTypes", var8);
      }
   }

   @Nonnull
   class="kw">public class="kw">static ResolvedBlockArray loadSingleBlock(@Nonnull JsonObject var0) {
      BlockTypeAssetMap var1 = BlockType.getAssetMap();

      try {
         if (var0.has("Block")) {
            String var2 = var0.get("Block").getAsString();
            if (var1.getAsset(var2) == null) {
               throw new IllegalArgumentException(String.valueOf(var2));
            }

            int var3 = var1.getIndex(var2);
            if (var3 == Integer.MIN_VALUE) {
               throw new IllegalArgumentException("Unknown block! " + var2);
            }

            int var4 = 0;
            if (var0.has("Fluid")) {
               String var5 = var0.get("Fluid").getAsString();
               var4 = Fluid.getAssetMap().getIndex(var5);
               if (var4 == Integer.MIN_VALUE) {
                  throw new IllegalArgumentException("Unknown fluid! " + var5);
               }
            }

            long var11 = MathUtil.packLong(var3, var4);
            ResolvedBlockArray var7 = (ResolvedBlockArray)ResolvedBlockArray.RESOLVED_BLOCKS_WITH_VARIANTS.get(var11);
            if (var7 != null) {
               class="kw">return var7;
            }

            BlockFluidEntry[] var8 = resolveBlockArrayWithVariants(var2, var1, var4);
            ResolvedBlockArray var9 = new ResolvedBlockArray(var8);
            ResolvedBlockArray.RESOLVED_BLOCKS_WITH_VARIANTS.put(var11, var9);
            class="kw">return var9;
         } else if (var0.has("Fluid")) {
            class="kw">return ResolvedBlockArrayJsonLoader.loadSingleBlock(var0);
         } else {
            throw new IllegalArgumentException("Required either Block or Fluid key");
         }
      } catch (IllegalArgumentException var10) {
         throw new IllegalArgumentException("BlockLayer does not exist in BlockTypes", var10);
      }
   }

   @Nonnull
   class="kw">public class="kw">static BlockFluidEntry[] resolveBlockArrayWithVariants(String var0, @Nonnull BlockTypeAssetMap<String, BlockType> var1, int var2) {
      List var3 = new ArrayList<>(var1.getSubKeys(var0));
      BlockFluidEntry[] var4 = new BlockFluidEntry[var3.size()];

      for (int var5 = 0; var5 < var3.size(); var5++) {
         String var6 = var3.get(var5);
         int var7 = var1.getIndex(var6);
         if (var7 == Integer.MIN_VALUE) {
            throw new IllegalArgumentException("Unknown key! " + var6);
         }

         var4[var5] = new BlockFluidEntry(var7, 0, var2);
      }

      class="kw">return var4;
   }
}