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.block.BlockUtil;
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.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 com.hypixel.hytale.server.core.util.BsonUtil;
class="kw">import com.hypixel.hytale.sneakythrow.SneakyThrow;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
class="kw">import java.io.DataOutputStream;
class="kw">import java.io.IOException;
class="kw">import java.nio.ByteBuffer;
class="kw">import java.nio.charset.StandardCharsets;
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.BsonDocument;
class="kw">import org.joml.Vector3i;

class="kw">public class BinaryPrefabBufferCodec {
   class="kw">public class="kw">static class="kw">final BinaryPrefabBufferCodec INSTANCE = new BinaryPrefabBufferCodec();
   class="kw">public class="kw">static class="kw">final int VERSION = 21;
   class="kw">private class="kw">static class="kw">final int MASK_CHANCE = 1;
   class="kw">private class="kw">static class="kw">final int MASK_COMPONENTS = 2;
   class="kw">private class="kw">static class="kw">final int MASK_FLUID = 4;
   class="kw">private class="kw">static class="kw">final int MASK_SUPPORT_VALUE = 8;
   class="kw">private class="kw">static class="kw">final int MASK_FILLER = 16;
   class="kw">private class="kw">static class="kw">final int MASK_ROTATION = 32;

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

   class="kw">public class="kw">static void writeUTF(@Nonnull DataOutputStream var0, @Nonnull String var1) class="kw">throws IOException {
      byte[] var2 = var1.getBytes(StandardCharsets.UTF_8);
      if (var2.length >= 65535) {
         throw new IllegalArgumentException("String is too large");
      }

      var0.writeShort(var2.length);
      var0.write(var2);
   }

   @Nonnull
   class="kw">public class="kw">static String readUTF(@Nonnull ByteBuffer var0) {
      int var1 = Short.toUnsignedInt(var0.getShort());
      byte[] var2 = new byte[var1];
      var0.get(var2);
      class="kw">return new String(var2, StandardCharsets.UTF_8);
   }

   @Nonnull
   class="kw">public PrefabBuffer deserialize(@Nonnull ByteBuffer var1) {
      int var2 = Short.toUnsignedInt(var1.getShort());
      if (var2 != 18553 && var2 >= 21) {
         if (21 < var2) {
            throw new IllegalStateException("Prefab version is newer than supported. Given: " + var2);
         }

         BlockTypeAssetMap var3 = BlockType.getAssetMap();
         int var4 = var1.getShort();
         long var5 = var1.getLong();
         Vector3i var7 = new Vector3i(BlockUtil.unpackX(var5), BlockUtil.unpackY(var5), BlockUtil.unpackZ(var5));
         Function var8 = null;
         Map var9 = BlockMigration.getAssetMap().getAssetMap();
         int var10 = var4;

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

         int var12 = var1.getInt();
         Int2ObjectOpenHashMap var13 = new Int2ObjectOpenHashMap(var12);

         for (int var14 = 0; var14 < var12; var14++) {
            try {
               int var15 = var1.getInt();
               BinaryPrefabBufferCodec.BlockIdEntry var16 = this.deserializeBlock(var1, var3, var8);
               var13.put(var15, var16);
            } catch (Exception var44) {
               throw new IllegalStateException("Failed to deserialize block name #" + var14, var44);
            }
         }

         IndexedLookupTableAssetMap var45 = Fluid.getAssetMap();
         int var46 = var1.getInt();
         Int2ObjectOpenHashMap var47 = new Int2ObjectOpenHashMap(var46);

         for (int var17 = 0; var17 < var46; var17++) {
            try {
               int var18 = var1.getInt();
               BinaryPrefabBufferCodec.FluidIdEntry var19 = this.deserializeFluid(var1, var45);
               var47.put(var18, var19);
            } catch (Exception var43) {
               throw new IllegalStateException("Failed to deserialize block name #" + var17, var43);
            }
         }

         PrefabBuffer.Builder var48 = PrefabBuffer.newBuilder();
         var48.setAnchor(var7);
         int var49 = var1.getInt();

         for (int var50 = 0; var50 < var49; var50++) {
            int var20 = var1.getInt();
            int var21 = var1.getInt();
            PrefabBufferBlockEntry[] var22 = new PrefabBufferBlockEntry[var21];

            for (int var23 = 0; var23 < var21; var23++) {
               int var24 = var1.getShort();
               int var25 = var1.getInt();
               BinaryPrefabBufferCodec.BlockIdEntry var26 = (BinaryPrefabBufferCodec.BlockIdEntry)var13.get(var25);
               int var27 = Byte.toUnsignedInt(var1.get());
               boolean var28 = (var27 & 1) == 1;
               boolean var29 = (var27 & 2) == 2;
               boolean var30 = (var27 & 4) == 4;
               boolean var31 = (var27 & 8) == 8;
               boolean var32 = (var27 & 16) == 16;
               boolean var33 = (var27 & 32) == 32;
               float var34 = var28 ? var1.getFloat() : 1.0F;
               Holder var35 = null;
               if (var29) {
                  BsonDocument var36 = BsonUtil.readFromBinaryStream(var1);
                  var35 = ChunkStore.REGISTRY.deserialize(var36);
               }

               byte var58 = 0;
               if (var31) {
                  var58 = (byte)(var1.get() & 15);
               }

               int var37 = 0;
               if (var32) {
                  var37 = Short.toUnsignedInt(var1.getShort());
               }

               int var38 = 0;
               if (var33) {
                  var38 = Byte.toUnsignedInt(var1.get());
               }

               int var39 = 0;
               byte var40 = 0;
               if (var30) {
                  int var41 = var1.getInt();
                  var39 = ((BinaryPrefabBufferCodec.FluidIdEntry)var47.get(var41)).id;
                  var40 = var1.get();
               }

               var22[var23] = new PrefabBufferBlockEntry(var24, var26.id, var26.key, var34, var35, var39, var40, var58, var38, var37);
            }

            int var51 = Short.toUnsignedInt(var1.getShort());
            Holder[] var52 = null;
            if (var51 > 0) {
               var52 = new Holder[var51];

               for (int var53 = 0; var53 < var51; var53++) {
                  try {
                     BsonDocument var55 = BsonUtil.readFromBinaryStream(var1);
                     Holder var57 = EntityStore.REGISTRY.deserialize(var55);
                     var52[var53] = var57;
                  } catch (Exception var42) {
                     throw new IllegalStateException("Failed to deserialize entity wrapper #" + var50, var42);
                  }
               }
            }

            int var54 = MathUtil.unpackLeft(var20);
            int var56 = MathUtil.unpackRight(var20);
            var48.addColumn(var54, var56, var22, var52);
         }

         class="kw">return var48.build();
      } else {
         throw new UpdateBinaryPrefabException("Old prefab format!");
      }
   }

   @Nonnull
   class="kw">private BinaryPrefabBufferCodec.BlockIdEntry deserializeBlock(
      @Nonnull ByteBuffer var1, @Nonnull BlockTypeAssetMap<String, BlockType> var2, @Nullable Function<String, String> var3
   ) {
      String var4 = readUTF(var1);
      String var5 = var4;
      if (var3 != null) {
         var5 = var3.apply(var5);
      }

      int var6 = BlockType.getBlockIdOrUnknown(var2, var5, "Failed to find block '%s'", var4);
      class="kw">return new BinaryPrefabBufferCodec.BlockIdEntry(var6, var5);
   }

   @Nonnull
   class="kw">private BinaryPrefabBufferCodec.FluidIdEntry deserializeFluid(@Nonnull ByteBuffer var1, @Nonnull IndexedLookupTableAssetMap<String, Fluid> var2) {
      String var3 = readUTF(var1);
      int var4 = Fluid.getFluidIdOrUnknown(var2, var3, "Failed to find fluid '%s'", var3);
      class="kw">return new BinaryPrefabBufferCodec.FluidIdEntry(var4, var3);
   }

   class="kw">public void serialize(@Nonnull PrefabBuffer var1, DataOutputStream var2) class="kw">throws IOException {
      PrefabBuffer.PrefabBufferAccessor var3 = var1.newAccess();
      Int2ObjectOpenHashMap var4 = new Int2ObjectOpenHashMap();
      Int2ObjectOpenHashMap var5 = new Int2ObjectOpenHashMap();
      var3.forEachRaw((var0, var1x, var2x, var3x) -> true, (var1x, var2x, var3x, var4x, var5x, var6, var7, var8, var9, var10, var11) -> {
         if (!var4.containsKey(var5x)) {
            BlockTypeAssetMap var12 = BlockType.getAssetMap();
            BlockType var13 = var12.getAsset(var5x);
            if (var13 == null) {
               var13 = BlockType.UNKNOWN;
            }

            var4.put(var5x, var13.getId().toString());
         }
      }, (var1x, var2x, var3x, var4x, var5x, var6) -> {
         if (!var5.containsKey(var4x)) {
            IndexedLookupTableAssetMap var7 = Fluid.getAssetMap();
            Fluid var8 = var7.getAsset(var4x);
            if (var8 == null) {
               var8 = Fluid.UNKNOWN;
            }

            var5.put(var4x, var8.getId());
         }
      }, (var0, var1x, var2x, var3x) -> {}, null);
      var2.writeShort(21);
      var2.writeShort(BlockMigration.getAssetMap().getAssetCount());
      var2.writeLong(BlockUtil.pack(var1.getAnchorX(), var1.getAnchorY(), var1.getAnchorZ()));
      var2.writeInt(var4.size());
      var4.int2ObjectEntrySet().fastForEach(SneakyThrow.sneakyConsumer(var1x -> {
         var2.writeInt(var1x.getIntKey());
         writeUTF(var2, (String)var1x.getValue());
      }));
      var2.writeInt(var5.size());
      var5.int2ObjectEntrySet().fastForEach(SneakyThrow.sneakyConsumer(var1x -> {
         var2.writeInt(var1x.getIntKey());
         writeUTF(var2, (String)var1x.getValue());
      }));
      var2.writeInt(var3.getColumnCount());
      var3.forEachRaw((var1x, var2x, var3x, var4x) -> {
         try {
            var2.writeInt(MathUtil.packInt(var1x, var2x));
            var2.writeInt(var3x);
            class="kw">return true;
         } catch (IOException var6) {
            throw SneakyThrow.sneakyThrow(var6);
         }
      }, (var1x, var2x, var3x, var4x, var5x, var6, var7, var8, var9, var10, var11) -> {
         try {
            var2.writeShort((short)var2x);
            var2.writeInt(var5x);
            boolean var12 = var6 < 1.0F;
            boolean var13 = var7 != null;
            int var14 = 0;
            if (var12) {
               var14 |= 1;
            }

            if (var13) {
               var14 |= 2;
            }

            if ((var4x & 192) != 0) {
               var14 |= 4;
            }

            if (var8 != 0) {
               var14 |= 8;
            }

            if (var10 != 0) {
               var14 |= 16;
            }

            if (var9 != 0) {
               var14 |= 32;
            }

            var2.writeByte(var14);
            if (var12) {
               var2.writeFloat(var6);
            }

            if (var13) {
               try {
                  BsonUtil.writeToBinaryStream(var2, ChunkStore.REGISTRY.serialize(var7));
               } catch (Throwable var16) {
                  throw new IllegalStateException(String.format("Exception while writing %d, %d, %d state!", var1x, var2x, var3x), var16);
               }
            }

            if (var8 != 0) {
               var2.writeByte(var8);
            }

            if (var10 != 0) {
               var2.writeShort(var10);
            }

            if (var9 != 0) {
               var2.writeByte(var9);
            }
         } catch (IOException var17) {
            throw SneakyThrow.sneakyThrow(var17);
         }
      }, (var1x, var2x, var3x, var4x, var5x, var6) -> {
         try {
            var2.writeInt(var4x);
            var2.writeByte(var5x);
         } catch (IOException var8) {
            throw SneakyThrow.sneakyThrow(var8);
         }
      }, (var1x, var2x, var3x, var4x) -> {
         try {
            int var5 = var3x != null ? var3x.length : 0;
            var2.writeShort(var5);

            for (int var6 = 0; var6 < var5; var6++) {
               Holder var7 = var3x[var6];

               try {
                  BsonDocument var8 = EntityStore.REGISTRY.serialize(var7);
                  BsonUtil.writeToBinaryStream(var2, var8);
               } catch (Exception var9) {
                  throw new IllegalStateException(String.format("Failed to write EntityWrapper at %d, %d #%d", var1x, var2x, var6), var9);
               }
            }
         } catch (IOException var10) {
            throw SneakyThrow.sneakyThrow(var10);
         }
      }, null);
   }

   class="kw">private class="kw">static class BlockIdEntry {
      class="kw">public int id;
      class="kw">public String key;

      class="kw">public BlockIdEntry(int var1, String var2) {
         this.id = var1;
         this.key = var2;
      }
   }

   class="kw">private class="kw">static class FluidIdEntry {
      class="kw">public int id;
      class="kw">public String key;

      class="kw">public FluidIdEntry(int var1, String var2) {
         this.id = var1;
         this.key = var2;
      }
   }
}