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.assetstore.map.IndexedLookupTableAssetMap;
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.core.prefab.selection.mask.BlockPattern;
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 javax.annotation.Nonnull;

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

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

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

         BlockTypeAssetMap var2 = BlockType.getAssetMap();
         IndexedLookupTableAssetMap var3 = Fluid.getAssetMap();
         BlockFluidEntry[] var4 = new BlockFluidEntry[var1.size()];

         for (int var5 = 0; var5 < var4.length; var5++) {
            JsonElement var6 = var1.get(var5);
            if (var6.isJsonObject()) {
               JsonObject var7 = var6.getAsJsonObject();
               int var8 = 0;
               int var9 = 0;
               int var10 = 0;
               if (var7.has("Block")) {
                  BlockPattern.BlockEntry var11 = BlockPattern.BlockEntry.decode(var7.get("Block").getAsString());
                  int var12 = BlockType.getBlockIdOrUnknown(var11.blockTypeKey(), "Failed to find block '%s' in resolved block array!", var11.blockTypeKey());
                  if (var12 == Integer.MIN_VALUE) {
                     throw new IllegalArgumentException("Unknown key! " + var11);
                  }

                  var8 = var12;
                  var9 = var11.rotation();
               }

               if (var7.has("Fluid")) {
                  String var17 = var7.get("Fluid").getAsString();
                  int var18 = Fluid.getFluidIdOrUnknown(var17, "Failed to find fluid '%s' in resolved block array!", var17);
                  if (var18 == Integer.MIN_VALUE) {
                     throw new IllegalArgumentException("Unknown key! " + var17);
                  }

                  var10 = var18;
               }

               var4[var5] = new BlockFluidEntry(var8, var9, var10);
            } else {
               String var14 = var6.getAsString();

               try {
                  BlockPattern.BlockEntry var15 = BlockPattern.BlockEntry.decode(var14);
                  int var16 = BlockType.getBlockIdOrUnknown(var15.blockTypeKey(), "Failed to find block '%s' in resolved block array!", var15.blockTypeKey());
                  if (var16 == Integer.MIN_VALUE) {
                     throw new IllegalArgumentException("Unknown key! " + var15);
                  }

                  var4[var5] = new BlockFluidEntry(var16, var15.rotation(), 0);
               } catch (IllegalArgumentException var13) {
                  throw new IllegalArgumentException("BlockLayer " + var14 + " does not exist in BlockTypes", var13);
               }
            }
         }

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

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

      try {
         BlockPattern.BlockEntry var3 = BlockPattern.BlockEntry.decode(var1);
         int var4 = var2.getIndex(var3.blockTypeKey());
         if (var4 == Integer.MIN_VALUE) {
            throw new IllegalArgumentException("Unknown key! " + var3);
         }

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

         ResolvedBlockArray var9 = new ResolvedBlockArray(new BlockFluidEntry[]{new BlockFluidEntry(var4, var3.rotation(), 0)});
         if (var3.rotation() == 0) {
            ResolvedBlockArray.RESOLVED_BLOCKS.put(var5, var9);
         }

         class="kw">return var9;
      } 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();
      IndexedLookupTableAssetMap var2 = Fluid.getAssetMap();

      try {
         int var3 = 0;
         int var4 = 0;
         int var5 = 0;
         if (var0.has("Block")) {
            BlockPattern.BlockEntry var6 = BlockPattern.BlockEntry.decode(var0.get("Block").getAsString());
            int var7 = var1.getIndex(var6.blockTypeKey());
            if (var7 == Integer.MIN_VALUE) {
               throw new IllegalArgumentException("Unknown key! " + var6);
            }

            var3 = var7;
            var4 = var6.rotation();
         }

         if (var0.has("Fluid")) {
            String var10 = var0.get("Fluid").getAsString();
            int var12 = var2.getIndex(var10);
            if (var12 == Integer.MIN_VALUE) {
               throw new IllegalArgumentException("Unknown key! " + var10);
            }

            var5 = var12;
         }

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

         ResolvedBlockArray var13 = new ResolvedBlockArray(new BlockFluidEntry[]{new BlockFluidEntry(var3, var4, var5)});
         if (var4 == 0) {
            ResolvedBlockArray.RESOLVED_BLOCKS.put(var11, var13);
         }

         class="kw">return var13;
      } catch (IllegalArgumentException var9) {
         throw new IllegalArgumentException("BlockLayer does not exist in BlockTypes", var9);
      }
   }
}