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

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.logger.HytaleLogger;
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.BsonPrefabBufferDeserializer;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.standard.BlockSelection;
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.Arrays;
class="kw">import java.util.ArrayList;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Objects;
class="kw">import java.util.function.Function;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.bson.BsonArray;
class="kw">import org.bson.BsonDocument;
class="kw">import org.bson.BsonInt32;
class="kw">import org.bson.BsonString;
class="kw">import org.bson.BsonValue;

class="kw">public class SelectionPrefabSerializer {
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">public class="kw">static class="kw">final int VERSION = 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">private SelectionPrefabSerializer() {
   }

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

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

      int var3 = var0.getInt32("anchorX").getValue();
      int var4 = var0.getInt32("anchorY").getValue();
      int var5 = var0.getInt32("anchorZ").getValue();
      BlockSelection var6 = new BlockSelection();
      var6.setAnchor(var3, var4, var5);
      int var7 = var0.getInt32("blockIdVersion", BsonPrefabBufferDeserializer.LEGACY_BLOCK_ID_VERSION).getValue();
      Function var8 = null;
      Map var9 = BlockMigration.getAssetMap().getAssetMap();
      int var10 = var7;

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

      BsonValue var12 = var0.get("blocks");
      if (var12 != null) {
         BlockTypeAssetMap var13 = BlockType.getAssetMap();
         BsonArray var14 = var12.asArray();

         for (int var15 = 0; var15 < var14.size(); var15++) {
            BsonDocument var16 = var14.get(var15).asDocument();
            int var17 = var16.getInt32("x").getValue();
            int var18 = var16.getInt32("y").getValue();
            int var19 = var16.getInt32("z").getValue();
            String var20 = var16.getString("name").getValue();
            int var21 = var16.getInt32("support", DEFAULT_SUPPORT_VALUE).getValue();
            int var22 = var16.getInt32("filler", DEFAULT_FILLER_VALUE).getValue();
            int var23 = var16.getInt32("rotation", DEFAULT_ROTATION_VALUE).getValue();
            String var24 = var20;
            if (var8 != null) {
               var24 = var8.apply(var24);
            }

            int var25 = BlockType.getBlockIdOrUnknown(var13, var24, "Failed to find block '%s' in unknown legacy prefab!", var20);
            Holder var26 = null;
            BsonValue var27 = var16.get("components");
            if (var27 != null) {
               var26 = ChunkStore.REGISTRY.deserialize(var27.asDocument());
            }

            var6.addBlockAtLocalPos(var17, var18, var19, var25, var23, var22, var21, var26);
         }
      }

      BsonValue var28 = var0.get("fluids");
      if (var28 != null) {
         IndexedLookupTableAssetMap var29 = Fluid.getAssetMap();
         BsonArray var31 = var28.asArray();

         for (int var33 = 0; var33 < var31.size(); var33++) {
            BsonDocument var35 = var31.get(var33).asDocument();
            int var37 = var35.getInt32("x").getValue();
            int var38 = var35.getInt32("y").getValue();
            int var39 = var35.getInt32("z").getValue();
            String var40 = var35.getString("name").getValue();
            int var41 = Fluid.getFluidIdOrUnknown(var29, var40, "Failed to find fluid '%s' in unknown legacy prefab!", var40);
            byte var42 = (byte)var35.getInt32("level").getValue();
            var6.addFluidAtLocalPos(var37, var38, var39, var41, var42);
         }
      }

      BsonValue var30 = var0.get("entities");
      if (var30 != null) {
         BsonArray var32 = var30.asArray();

         for (int var34 = 0; var34 < var32.size(); var34++) {
            BsonDocument var36 = var32.get(var34).asDocument();
            var6.addEntityHolderRaw(EntityStore.REGISTRY.deserialize(var36));
         }
      }

      class="kw">return var6;
   }

   @Nonnull
   class="kw">public class="kw">static BsonDocument serialize(@Nonnull BlockSelection var0) {
      Objects.requireNonNull(var0, "null prefab");
      BlockTypeAssetMap var1 = BlockType.getAssetMap();
      IndexedLookupTableAssetMap var2 = Fluid.getAssetMap();
      BsonDocument var3 = new BsonDocument();
      var3.put("version", new BsonInt32(8));
      var3.put("blockIdVersion", new BsonInt32(BlockMigration.getAssetMap().getAssetCount()));
      var3.put("anchorX", new BsonInt32(var0.getAnchorX()));
      var3.put("anchorY", new BsonInt32(var0.getAnchorY()));
      var3.put("anchorZ", new BsonInt32(var0.getAnchorZ()));
      int var4 = var0.getBlockCount();
      int[] var5 = new int[var4];
      int[] var6 = new int[var4];
      int[] var7 = new int[var4];
      BsonDocument[] var8 = new BsonDocument[var4];
      int[] var9 = new int[]{0};
      var0.forEachBlock((var6x, var7x, var8x, var9x) -> {
         BsonDocument var10 = new BsonDocument();
         var10.put("x", new BsonInt32(var6x));
         var10.put("y", new BsonInt32(var7x));
         var10.put("z", new BsonInt32(var8x));
         var10.put("name", new BsonString(var1.getAsset(var9x.blockId()).getId().toString()));
         if (var9x.holder() != null) {
            var10.put("components", ChunkStore.REGISTRY.serialize(var9x.holder()));
         }

         if (var9x.supportValue() != 0) {
            var10.put("support", new BsonInt32(var9x.supportValue()));
         }

         if (var9x.filler() != 0) {
            var10.put("filler", new BsonInt32(var9x.filler()));
         }

         if (var9x.rotation() != 0) {
            var10.put("rotation", new BsonInt32(var9x.rotation()));
         }

         int var11 = (int)(var9[0]++);
         var5[var11] = var6x;
         var6[var11] = var7x;
         var7[var11] = var8x;
         var8[var11] = var10;
      });
      sortByPosition(var4, var5, var6, var7, var8);
      BsonArray var10 = new BsonArray();

      for (BsonDocument var14 : var8) {
         var10.add(var14);
      }

      var3.put("blocks", var10);
      int[] var21 = new int[]{0};
      int var22 = var0.getFluidCount();
      int[] var23 = new int[var22];
      int[] var24 = new int[var22];
      int[] var15 = new int[var22];
      BsonDocument[] var16 = new BsonDocument[var22];
      int[] var17 = new int[]{0};
      var0.forEachFluid((var7x, var8x, var9x, var10x, var11) -> {
         Fluid var12 = var2.getAsset(var10x);
         if (var12 == null) {
            if (var10x != 0 && var10x != Integer.MIN_VALUE) {
               var21[0]++;
            }
         } else {
            BsonDocument var13 = new BsonDocument();
            var13.put("x", new BsonInt32(var7x));
            var13.put("y", new BsonInt32(var8x));
            var13.put("z", new BsonInt32(var9x));
            var13.put("name", new BsonString(var12.getId()));
            var13.put("level", new BsonInt32(var11));
            int var14 = (int)(var17[0]++);
            var23[var14] = var7x;
            var24[var14] = var8x;
            var15[var14] = var9x;
            var16[var14] = var13;
         }
      });
      int var18 = var17[0];
      sortByPosition(var18, var23, var24, var15, var16);
      if (var18 != 0) {
         BsonArray var19 = new BsonArray();

         for (int var20 = 0; var20 < var18; var20++) {
            var19.add(var16[var20]);
         }

         var3.put("fluids", var19);
      }

      List var25 = new ArrayList<>(var0.getEntityCount());
      var0.forEachEntity(var1x -> var25.add(EntityStore.REGISTRY.serialize(var1x)));
      if (!var25.isEmpty()) {
         BsonArray var26 = new BsonArray();
         var25.forEach(var26::add);
         var3.put("entities", var26);
      }

      if (var21[0] != 0) {
         LOGGER.at(Level.WARNING).log("Skipped %d fluid(s) with unknown asset ids while saving prefab", var21[0]);
      }

      class="kw">return var3;
   }

   class="kw">private class="kw">static void sortByPosition(int var0, @Nonnull int[] var1, @Nonnull int[] var2, @Nonnull int[] var3, @Nonnull BsonDocument[] var4) {
      Arrays.quickSort(0, var0, (var3x, var4x) -> {
         int var5 = Integer.compare(var1[var3x], var1[var4x]);
         if (var5 == 0) {
            var5 = Integer.compare(var3[var3x], var3[var4x]);
         }

         if (var5 == 0) {
            var5 = Integer.compare(var2[var3x], var2[var4x]);
         }

         class="kw">return var5;
      }, (var4x, var5) -> {
         int var6 = var1[var4x];
         var1[var4x] = var1[var5];
         var1[var5] = var6;
         var6 = var2[var4x];
         var2[var4x] = var2[var5];
         var2[var5] = var6;
         var6 = var3[var4x];
         var3[var4x] = var3[var5];
         var3[var5] = var6;
         BsonDocument var7 = var4[var4x];
         var4[var4x] = var4[var5];
         var4[var5] = var7;
      });
   }
}