class="kw">package com.hypixel.hytale.server.core.prefab.selection.buffer;

class="kw">import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
class="kw">import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockMigration;
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.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.buffer.impl.PrefabBuffer;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.buffer.impl.PrefabBufferBlockEntry;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.nio.file.Path;
class="kw">import java.util.Arrays;
class="kw">import java.util.Comparator;
class="kw">import java.util.List;
class="kw">import java.util.Map;
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.BsonInt32;
class="kw">import org.bson.BsonValue;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3i;

class="kw">public class BsonPrefabBufferDeserializer {
   class="kw">public class="kw">static class="kw">final BsonPrefabBufferDeserializer INSTANCE = new BsonPrefabBufferDeserializer();
   class="kw">public class="kw">static class="kw">final BsonInt32 LEGACY_BLOCK_ID_VERSION = new BsonInt32(8);
   class="kw">private class="kw">static class="kw">final BsonInt32 DEFAULT_SUPPORT_VALUE = new BsonInt32(0);
   class="kw">private class="kw">static class="kw">final BsonInt32 DEFAULT_FILLER_VALUE = new BsonInt32(0);
   class="kw">private class="kw">static class="kw">final BsonInt32 DEFAULT_ROTATION_VALUE = new BsonInt32(0);

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

   @Nonnull
   class="kw">public PrefabBuffer deserialize(Path var1, @Nonnull BsonDocument var2) {
      BsonValue var3 = var2.get("version");
      int var4 = var3 != null ? var3.asInt32().getValue() : -1;
      if (var4 < 8) {
         throw new IllegalArgumentException("Prefab version is too old: " + var4);
      }

      if (var4 > 8) {
         throw new IllegalArgumentException("Prefab version is too new: " + var4 + " by expected 8");
      }

      Vector3i var5 = new Vector3i();
      var5.x = var2.getInt32("anchorX").getValue();
      var5.y = var2.getInt32("anchorY").getValue();
      var5.z = var2.getInt32("anchorZ").getValue();
      int var6 = var2.getInt32("blockIdVersion", LEGACY_BLOCK_ID_VERSION).getValue();
      Function var7 = null;
      Map var8 = BlockMigration.getAssetMap().getAssetMap();
      int var9 = var6;

      for (BlockMigration var10 = var8.get(var9); var10 != null; var10 = var8.get(++var9)) {
         if (var7 == null) {
            var7 = var10::getMigration;
         } else {
            var7 = var7.andThen(var10::getMigration);
         }
      }

      Int2ObjectOpenHashMap var11 = new Int2ObjectOpenHashMap();
      PrefabBuffer.Builder var12 = PrefabBuffer.newBuilder();
      var12.setAnchor(var5);
      BsonValue var13 = var2.get("blocks");
      if (var13 != null) {
         BlockTypeAssetMap var14 = BlockType.getAssetMap();

         for (BsonValue var17 : var13.asArray()) {
            BsonDocument var18 = var17.asDocument();
            int var19 = var18.getInt32("x").getValue();
            int var20 = var18.getInt32("y").getValue();
            int var21 = var18.getInt32("z").getValue();
            int var22 = var19 - var5.x;
            int var23 = var20 - var5.y;
            int var24 = var21 - var5.z;
            if (-32768 > var22 || var22 > 32767) {
               throw new IllegalArgumentException("Violation X: Short.MIN_VALUE < " + var22 + " < Short.MAX_VALUE");
            }

            if (-32768 > var23 || var23 > 32767) {
               throw new IllegalArgumentException("Violation Y: Short.MIN_VALUE < " + var23 + " < Short.MAX_VALUE");
            }

            if (-32768 > var24 || var24 > 32767) {
               throw new IllegalArgumentException("Violation Z: Short.MIN_VALUE < " + var24 + " < Short.MAX_VALUE");
            }

            PrefabBufferBlockEntry var25 = var12.newBlockEntry(var23);

            try {
               deserializeBlockType(var25, var18, var14, var7);
            } catch (Throwable var30) {
               throw new IllegalStateException("Failed to load block type for " + var1 + " at " + var19 + ", " + var20 + ", " + var21, var30);
            }

            deserializeState(var25, var18);
            var25.supportValue = (byte)var18.getInt32("support", DEFAULT_SUPPORT_VALUE).getValue();
            var25.filler = var18.getInt32("filler", DEFAULT_FILLER_VALUE).getValue();
            var25.rotation = var18.getInt32("rotation", DEFAULT_ROTATION_VALUE).getValue();
            int var26 = MathUtil.packInt(var22, var24);
            Int2ObjectMap var27 = (Int2ObjectMap<PrefabBufferBlockEntry>)var11.get(var26);
            if (var27 == null) {
               var11.put(var26, var27 = new Int2ObjectOpenHashMap());
            }

            PrefabBufferBlockEntry var28 = (PrefabBufferBlockEntry)var27.putIfAbsent(var23, var25);
            if (var28 != null) {
               throw new IllegalStateException(
                  "Block is already present in column. Given: "
                     + var19
                     + ", "
                     + var20
                     + ", "
                     + var21
                     + ", "
                     + var25.blockTypeKey
                     + " - Existing: "
                     + var28.y
                     + ", "
                     + var28.blockTypeKey
               );
            }
         }
      }

      BsonValue var31 = var2.get("fluids");
      if (var31 != null) {
         IndexedLookupTableAssetMap var32 = Fluid.getAssetMap();

         for (BsonValue var36 : var31.asArray()) {
            BsonDocument var37 = var36.asDocument();
            int var38 = var37.getInt32("x").getValue();
            int var39 = var37.getInt32("y").getValue();
            int var40 = var37.getInt32("z").getValue();
            int var41 = var38 - var5.x;
            int var42 = var39 - var5.y;
            int var43 = var40 - var5.z;
            if (-32768 > var41 || var41 > 32767) {
               throw new IllegalArgumentException("Violation X: Short.MIN_VALUE < " + var41 + " < Short.MAX_VALUE");
            }

            if (-32768 > var42 || var42 > 32767) {
               throw new IllegalArgumentException("Violation Y: Short.MIN_VALUE < " + var42 + " < Short.MAX_VALUE");
            }

            if (-32768 > var43 || var43 > 32767) {
               throw new IllegalArgumentException("Violation Z: Short.MIN_VALUE < " + var43 + " < Short.MAX_VALUE");
            }

            int var44 = MathUtil.packInt(var41, var43);
            Int2ObjectMap var45 = (Int2ObjectMap<PrefabBufferBlockEntry>)var11.get(var44);
            if (var45 == null) {
               var11.put(var44, var45 = new Int2ObjectOpenHashMap());
            }

            PrefabBufferBlockEntry var46 = (PrefabBufferBlockEntry)var45.computeIfAbsent(var42, var12::newBlockEntry);
            String var29 = var37.getString("name").getValue();
            var46.fluidId = Fluid.getFluidIdOrUnknown(var29, "Unknown fluid '%s'", var29);
            var46.fluidLevel = (byte)var37.getInt32("level").getValue();
         }
      }

      Int2ObjectOpenHashMap var33 = deserializeEntityHolders(var2, var5);
      var11.int2ObjectEntrySet().fastForEach(var2x -> {
         int var3 = var2x.getIntKey();
         int var4 = MathUtil.unpackLeft(var3);
         int var5 = MathUtil.unpackRight(var3);
         Int2ObjectMap var6 = (Int2ObjectMap<PrefabBufferBlockEntry>)var2x.getValue();
         PrefabBufferBlockEntry[] var7 = (PrefabBufferBlockEntry[])var6.values().toArray(PrefabBufferBlockEntry[]::new);
         Arrays.sort(var7, Comparator.comparingInt(var0x -> var0x.y));
         List var8 = (List<Holder<EntityStore>>)var33.remove(var3);
         Holder[] var9 = var8 != null && !var8.isEmpty() ? var8.toArray(Holder[]::new) : null;
         var12.addColumn(var4, var5, var7, var9);
      });
      var33.int2ObjectEntrySet().fastForEach(var1x -> {
         int var2 = var1x.getIntKey();
         int var3 = MathUtil.unpackLeft(var2);
         int var4 = MathUtil.unpackRight(var2);
         List var5 = (List<Holder<EntityStore>>)var1x.getValue();
         Holder[] var6 = !var5.isEmpty() ? var5.toArray(Holder[]::new) : null;
         if (var6 != null) {
            var12.addColumn(var3, var4, PrefabBufferBlockEntry.EMPTY_ARRAY, var6);
         }
      });
      class="kw">return var12.build();
   }

   class="kw">private class="kw">static void deserializeBlockType(
      @Nonnull PrefabBufferBlockEntry var0,
      @Nonnull BsonDocument var1,
      @Nonnull BlockTypeAssetMap<String, BlockType> var2,
      @Nullable Function<String, String> var3
   ) {
      String var4 = var1.getString("name").getValue();
      int var5 = var4.indexOf(37);
      String var6;
      if (var5 != -1) {
         var6 = var4.substring(var5 + 1);
      } else {
         var6 = var4;
      }

      var0.blockTypeKey = var6;
      if (var3 != null) {
         var0.blockTypeKey = var3.apply(var0.blockTypeKey);
      }

      var0.blockId = BlockType.getBlockIdOrUnknown(var2, var0.blockTypeKey, "Failed to find block. Given %s", var6);
      if (var5 != -1) {
         String var7 = var4.substring(0, var5);
         float var8 = Float.parseFloat(var7);
         if (var8 < 0.0F) {
            throw new IllegalArgumentException("Chance is smaller than 0%. Given: " + var8);
         }

         if (var8 > 100.0F) {
            throw new IllegalArgumentException("Chance is larger than 100%. Given: " + var8);
         }

         var0.chance = var8 / 100.0F;
      }
   }

   class="kw">private class="kw">static void deserializeState(@Nonnull PrefabBufferBlockEntry var0, @Nonnull BsonDocument var1) {
      BsonValue var2 = var1.get("components");
      if (var2 != null) {
         var0.state = ChunkStore.REGISTRY.deserialize(var2.asDocument());
      }
   }

   @Nonnull
   class="kw">private class="kw">static Int2ObjectOpenHashMap<List<Holder<EntityStore>>> deserializeEntityHolders(@Nonnull BsonDocument var0, @Nonnull Vector3i var1) {
      BsonValue var2 = var0.get("entities");
      Int2ObjectOpenHashMap var3 = new Int2ObjectOpenHashMap();
      if (var2 == null) {
         class="kw">return var3;
      }

      BsonArray var4 = var2.asArray();
      int var5 = 0;

      for (int var6 = var4.size(); var5 < var6; var5++) {
         BsonDocument var7 = var4.get(var5).asDocument();

         try {
            Holder var8 = EntityStore.REGISTRY.deserialize(var7);
            TransformComponent var9 = var8.getComponent(TransformComponent.getComponentType());
            assert var9 != null;
            Vector3d var10 = var9.getPosition();
            var10.add(-var1.x, -var1.y, -var1.z);
            int var11 = MathUtil.floor(var10.x()) & 65535;
            int var12 = MathUtil.floor(var10.z()) & 65535;
            int var13 = MathUtil.packInt(var11, var12);
            List var14 = (List<Holder<EntityStore>>)var3.get(var13);
            if (var14 == null) {
               var3.put(var13, var14 = new ObjectArrayList());
            }

            var14.add(var8);
         } catch (Exception var15) {
            throw new IllegalStateException("Failed to load entity wrapper #" + var5 + ": " + var7, var15);
         }
      }

      class="kw">return var3;
   }
}