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

class="kw">import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
class="kw">import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
class="kw">import com.hypixel.hytale.common.util.CompletableFutureUtil;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.RemoveReason;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.function.consumer.TriIntConsumer;
class="kw">import com.hypixel.hytale.function.predicate.TriIntPredicate;
class="kw">import com.hypixel.hytale.math.block.BlockUtil;
class="kw">import com.hypixel.hytale.math.shape.Box;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.blockhitbox.BlockBoundingBoxes;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.blocktype.component.BlockPhysics;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.BlockChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.BlockOperations;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockComponentSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class FillerBlockUtil {
   class="kw">public class="kw">static class="kw">final float THRESHOLD = 0.0F;
   class="kw">public class="kw">static class="kw">final int NO_FILLER = 0;
   class="kw">private class="kw">static class="kw">final int BITS_PER_AXIS = 5;
   class="kw">private class="kw">static class="kw">final int MASK = 31;
   class="kw">private class="kw">static class="kw">final int INVERT = -32;

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

   class="kw">public class="kw">static void forEachFillerBlock(@Nonnull BlockBoundingBoxes.RotatedVariantBoxes var0, @Nonnull TriIntConsumer var1) {
      forEachFillerBlock(0.0F, var0, var1);
   }

   class="kw">public class="kw">static void forEachFillerBlock(float var0, @Nonnull BlockBoundingBoxes.RotatedVariantBoxes var1, @Nonnull TriIntConsumer var2) {
      forEachFillerBlock(var0, 0, var1, var2);
   }

   class="kw">public class="kw">static void forEachFillerBlock(float var0, int var1, @Nonnull BlockBoundingBoxes.RotatedVariantBoxes var2, @Nonnull TriIntConsumer var3) {
      forEachFillerBlock(var0, var1, var1, var1, var2, var3);
   }

   class="kw">public class="kw">static void forEachFillerBlock(
      float var0, int var1, int var2, int var3, @Nonnull BlockBoundingBoxes.RotatedVariantBoxes var4, @Nonnull TriIntConsumer var5
   ) {
      if (!(var0 < 0.0F) && !(var0 >= 1.0F)) {
         Box var6 = var4.getBoundingBox();
         int var7 = (int)var6.min.x;
         int var8 = (int)var6.min.y;
         int var9 = (int)var6.min.z;
         if (var7 - var6.min.x > var0) {
            var7--;
         }

         if (var8 - var6.min.y > var0) {
            var8--;
         }

         if (var9 - var6.min.z > var0) {
            var9--;
         }

         int var10 = (int)var6.max.x;
         int var11 = (int)var6.max.y;
         int var12 = (int)var6.max.z;
         var7 -= var1;
         var8 -= var2;
         var9 -= var3;
         var10 += var1;
         var11 += var2;
         var12 += var3;
         if (var6.max.x - var10 > var0) {
            var10++;
         }

         if (var6.max.y - var11 > var0) {
            var11++;
         }

         if (var6.max.z - var12 > var0) {
            var12++;
         }

         int var13 = Math.max(var10 - var7, 1);
         int var14 = Math.max(var11 - var8, 1);
         int var15 = Math.max(var12 - var9, 1);

         for (int var16 = 0; var16 < var13; var16++) {
            for (int var17 = 0; var17 < var14; var17++) {
               for (int var18 = 0; var18 < var15; var18++) {
                  var5.accept(var7 + var16, var8 + var17, var9 + var18);
               }
            }
         }
      } else {
         throw new IllegalArgumentException("Threshold must be between 0 and 1");
      }
   }

   class="kw">public class="kw">static boolean testFillerBlocks(@Nonnull BlockBoundingBoxes.RotatedVariantBoxes var0, @Nonnull TriIntPredicate var1) {
      class="kw">return testFillerBlocks(0.0F, var0, var1);
   }

   class="kw">public class="kw">static boolean testFillerBlocks(float var0, @Nonnull BlockBoundingBoxes.RotatedVariantBoxes var1, @Nonnull TriIntPredicate var2) {
      if (!(var0 < 0.0F) && !(var0 >= 1.0F)) {
         Box var3 = var1.getBoundingBox();
         int var4 = (int)var3.min.x;
         int var5 = (int)var3.min.y;
         int var6 = (int)var3.min.z;
         if (var4 - var3.min.x > var0) {
            var4--;
         }

         if (var5 - var3.min.y > var0) {
            var5--;
         }

         if (var6 - var3.min.z > var0) {
            var6--;
         }

         int var7 = (int)var3.max.x;
         int var8 = (int)var3.max.y;
         int var9 = (int)var3.max.z;
         if (var3.max.x - var7 > var0) {
            var7++;
         }

         if (var3.max.y - var8 > var0) {
            var8++;
         }

         if (var3.max.z - var9 > var0) {
            var9++;
         }

         int var10 = Math.max(var7 - var4, 1);
         int var11 = Math.max(var8 - var5, 1);
         int var12 = Math.max(var9 - var6, 1);

         for (int var13 = 0; var13 < var10; var13++) {
            for (int var14 = 0; var14 < var11; var14++) {
               for (int var15 = 0; var15 < var12; var15++) {
                  if (!var2.test(var4 + var13, var5 + var14, var6 + var15)) {
                     class="kw">return false;
                  }
               }
            }
         }

         class="kw">return true;
      } else {
         throw new IllegalArgumentException("Threshold must be between 0 and 1");
      }
   }

   @Nullable
   class="kw">public class="kw">static BlockBoundingBoxes.RotatedVariantBoxes multiCellFootprint(int var0, int var1) {
      BlockType var2 = BlockType.getAssetMap().getAsset(var0);
      if (var2 == null) {
         class="kw">return null;
      }

      BlockBoundingBoxes var3 = BlockBoundingBoxes.getAssetMap().getAsset(var2.getHitboxTypeIndex());
      class="kw">return var3 != null && var3.protrudesUnitBox() ? var3.get(var1) : null;
   }

   class="kw">public class="kw">static boolean isFootprintFree(@Nonnull LongOpenHashSet var0, int var1, int var2, int var3, @Nonnull BlockBoundingBoxes.RotatedVariantBoxes var4) {
      class="kw">return testFillerBlocks(var4, (var4x, var5, var6) -> !var0.contains(BlockUtil.pack(var1 + var4x, var2 + var5, var3 + var6)));
   }

   class="kw">public class="kw">static void markFootprint(@Nonnull LongOpenHashSet var0, int var1, int var2, int var3, @Nonnull BlockBoundingBoxes.RotatedVariantBoxes var4) {
      forEachFillerBlock(var4, (var4x, var5, var6) -> var0.add(BlockUtil.pack(var1 + var4x, var2 + var5, var3 + var6)));
   }

   class="kw">public class="kw">static <A, B> FillerBlockUtil.ValidationResult validateBlock(
      int var0, int var1, int var2, int var3, int var4, int var5, A var6, B var7, @Nonnull FillerBlockUtil.FillerFetcher<A, B> var8
   ) {
      if (var3 == 0) {
         class="kw">return FillerBlockUtil.ValidationResult.OK;
      }

      BlockTypeAssetMap var9 = BlockType.getAssetMap();
      BlockType var10 = var9.getAsset(var3);
      if (var10 == null) {
         class="kw">return FillerBlockUtil.ValidationResult.OK;
      }

      String var11 = var10.getId();
      IndexedLookupTableAssetMap var12 = BlockBoundingBoxes.getAssetMap();
      if (var5 != 0) {
         int var22 = unpackX(var5);
         int var23 = unpackY(var5);
         int var15 = unpackZ(var5);
         int var16 = var8.getBlock(var6, var7, var0 - var22, var1 - var23, var2 - var15);
         BlockType var17 = var9.getAsset(var16);
         if (var17 == null) {
            class="kw">return FillerBlockUtil.ValidationResult.INVALID_BLOCK;
         }

         String var18 = var17.getId();
         BlockBoundingBoxes var19 = var12.getAsset(var17.getHitboxTypeIndex());
         if (var19 == null) {
            class="kw">return FillerBlockUtil.ValidationResult.OK;
         }

         int var20 = var8.getFiller(var6, var7, var0 - var22, var1 - var23, var2 - var15);
         int var21 = var8.getRotationIndex(var6, var7, var0 - var22, var1 - var23, var2 - var15);
         class="kw">return var20 == 0 && var21 == var4 && var11.equals(var18) && var19.get(var21).getBoundingBox().containsBlock(var22, var23, var15)
            ? FillerBlockUtil.ValidationResult.OK
            : FillerBlockUtil.ValidationResult.INVALID_BLOCK;
      } else {
         BlockBoundingBoxes var13 = var12.getAsset(var10.getHitboxTypeIndex());
         if (var13 != null && var13.protrudesUnitBox()) {
            boolean var14 = testFillerBlocks(var13.get(var4), (var9x, var10x, var11x) -> {
               if (var9x == 0 && var10x == 0 && var11x == 0) {
                  class="kw">return true;
               }

               int var12 = var0 + var9x;
               int var13 = var1 + var10x;
               int var14 = var2 + var11x;
               int var15 = var8.getBlock(var6, var7, var12, var13, var14);
               BlockType var16 = var9.getAsset(var15);
               int var17 = pack(var9x, var10x, var11x);
               if (var8.getFiller(var6, var7, var12, var13, var14) != var17) {
                  class="kw">return false;
               }

               if (var8.getRotationIndex(var6, var7, var12, var13, var14) != var4) {
                  class="kw">return false;
               }

               if (var16 == null) {
                  class="kw">return false;
               }

               String var18 = var16.getId();
               class="kw">return var18.equals(var11);
            });
            class="kw">return var14 ? FillerBlockUtil.ValidationResult.OK : FillerBlockUtil.ValidationResult.INVALID_FILLER;
         } else {
            class="kw">return FillerBlockUtil.ValidationResult.OK;
         }
      }
   }

   class="kw">public class="kw">static int pack(int var0, int var1, int var2) {
      class="kw">return var0 & 31 | (var2 & 31) << 5 | (var1 & 31) << 10;
   }

   class="kw">public class="kw">static int unpackX(int var0) {
      int var1 = var0 & 31;
      if ((var1 & 16) != 0) {
         var1 |= -32;
      }

      class="kw">return var1;
   }

   class="kw">public class="kw">static int unpackY(int var0) {
      int var1 = var0 >> 10 & 31;
      if ((var1 & 16) != 0) {
         var1 |= -32;
      }

      class="kw">return var1;
   }

   class="kw">public class="kw">static int unpackZ(int var0) {
      int var1 = var0 >> 5 & 31;
      if ((var1 & 16) != 0) {
         var1 |= -32;
      }

      class="kw">return var1;
   }

   class="kw">private class="kw">static void removeBlockEntity(ComponentAccessor<ChunkStore> var0, BlockComponentSection var1, int var2, int var3, int var4) {
      int var5 = ChunkUtil.indexBlock(var2, var3, var4);
      if (!(var0 class="kw">instanceof Store var6 && (!var0.getExternalData().getWorld().isInThread() || var6.isProcessing()))) {
         Ref var7 = var1.getBlockReference(var5);
         if (var7 != null) {
            var0.removeEntity(var7, ChunkStore.REGISTRY.newHolder(), RemoveReason.REMOVE);
         } else {
            var1.removeBlockHolder(var5);
         }
      } else {
         CompletableFutureUtil._catch(CompletableFuture.runAsync(() -> {
            Ref var3 = var1.getBlockReference(var5);
            if (var3 != null) {
               var0.removeEntity(var3, ChunkStore.REGISTRY.newHolder(), RemoveReason.REMOVE);
            } else {
               var1.removeBlockHolder(var5);
            }
         }, var0.getExternalData().getWorld()));
      }
   }

   class="kw">private class="kw">static void removeFiller(
      ComponentAccessor<ChunkStore> var0, BlockSection var1, BlockComponentSection var2, int var3, int var4, int var5, FillerBlockUtil.ChangeReason var6
   ) {
      Ref var7 = var0.getExternalData().getChunkReference(ChunkUtil.indexChunkFromBlock(var3, var5));
      if (var7 != null) {
         BlockChunk var8 = var0.getComponent(var7, BlockChunk.getComponentType());
         if (var8 != null) {
            short var9 = var8.getHeight(var3, var5);
            int var10 = var1.get(var3, var4, var5);
            boolean var11 = var1.set(var3, var4, var5, 0, 0, 0);
            if (var11) {
               short var12 = BlockOperations.updateBlockHeight(var8, 0, BlockType.EMPTY, var3, var4, var5, var9);
               if (var6 != FillerBlockUtil.ChangeReason.NONE) {
                  BlockOperations.spawnBlockParticles(var0.getExternalData(), var10, 0, var3, var4, var5, var6 == FillerBlockUtil.ChangeReason.BY_PHYSICS);
               }

               removeBlockEntity(var0, var2, var3, var4, var5);
               var0.getExternalData()
                  .getWorld()
                  .getChunkLighting()
                  .invalidateLightAtBlock(var0.getExternalData(), var3, var4, var5, BlockType.EMPTY, var9, var12);
            }
         }
      }
   }

   class="kw">public class="kw">static void removeFillerBlocksAt(
      @Nonnull ComponentAccessor<ChunkStore> var0,
      BlockSection var1,
      BlockComponentSection var2,
      int var3,
      int var4,
      int var5,
      int var6,
      int var7,
      int var8,
      FillerBlockUtil.ChangeReason var9
   ) {
      BlockType var10 = BlockType.getAssetMap().getAsset(var6);
      if (var10 != null) {
         int var11 = unpackX(var7);
         int var12 = unpackY(var7);
         int var13 = unpackZ(var7);
         int var14 = var3 - var11;
         int var15 = var4 - var12;
         int var16 = var5 - var13;
         BlockBoundingBoxes var17 = BlockBoundingBoxes.getAssetMap().getAsset(var10.getHitboxTypeIndex());
         if (var17 == null) {
            var17 = BlockBoundingBoxes.UNIT_BOX;
         }

         forEachFillerBlock(var17.get(var8), (var14x, var15x, var16x) -> {
            if (var14x != var11 || var15x != var12 || var16x != var13) {
               int var17 = var14 + var14x;
               int var18 = var15 + var15x;
               int var19 = var16 + var16x;
               if (ChunkUtil.isSameChunkSection(var3, var4, var5, var17, var18, var19)) {
                  if (var1.get(var17, var18, var19) == var6) {
                     removeFiller(var0, var1, var2, var17, var18, var19, var9);
                  }
               } else {
                  ChunkStore var20 = var0.getExternalData();
                  Ref var21 = var20.getWorld().isInThread() ? var20.getChunkSectionReferenceAtBlock(var17, var18, var19) : null;
                  if (var21 != null) {
                     BlockSection var22 = var0.getComponent(var21, BlockSection.getComponentType());
                     if (var22 == null) {
                        class="kw">return;
                     }

                     BlockComponentSection var23 = var0.getComponent(var21, BlockComponentSection.getComponentType());
                     if (var23 == null) {
                        class="kw">return;
                     }

                     if (var22.get(var17, var18, var19) == var6) {
                        removeFiller(var0, var22, var23, var17, var18, var19, var9);
                     }
                  } else {
                     CompletableFutureUtil._catch(var20.getChunkSectionReferenceAtBlockAsync(var17, var18, var19).thenAcceptAsync(var6x -> {
                        BlockSection var7 = var6x.getStore().getComponent((Ref<ChunkStore>)var6x, BlockSection.getComponentType());
                        if (var7 != null) {
                           BlockComponentSection var8 = var6x.getStore().getComponent((Ref<ChunkStore>)var6x, BlockComponentSection.getComponentType());
                           if (var8 != null) {
                              if (var7.get(var17, var18, var19) == var6) {
                                 removeFiller(var0, var7, var8, var17, var18, var19, var9);
                              }
                           }
                        }
                     }, var20.getWorld()));
                  }
               }
            }
         });
      }
   }

   class="kw">private class="kw">static void setFiller(
      @Nonnull ComponentAccessor<ChunkStore> var0,
      @Nonnull Ref<ChunkStore> var1,
      @Nonnull BlockSection var2,
      @Nonnull BlockComponentSection var3,
      int var4,
      int var5,
      int var6,
      int var7,
      BlockType var8,
      int var9,
      int var10,
      FillerBlockUtil.ChangeReason var11
   ) {
      int var12 = var2.get(var4, var5, var6);
      int var13 = var2.getFiller(var4, var5, var6);
      int var14 = var2.getRotationIndex(var4, var5, var6);
      if (var2.set(var4, var5, var6, var7, var10, var9)) {
         if (var12 != 0) {
            removeFillerBlocksAt(var0, var2, var3, var4, var5, var6, var12, var13, var14, var11);
         }

         Ref var15 = var0.getExternalData().getChunkReference(ChunkUtil.indexChunkFromBlock(var4, var6));
         if (var15 != null) {
            BlockChunk var16 = var0.getComponent(var15, BlockChunk.getComponentType());
            if (var16 != null) {
               short var17 = var16.getHeight(var4, var6);
               short var18 = BlockOperations.updateBlockHeight(var16, var7, var8, var4, var5, var6, var17);
               if (var11 != FillerBlockUtil.ChangeReason.NONE) {
                  BlockOperations.spawnBlockParticles(var0.getExternalData(), var12, var7, var4, var5, var6, var11 == FillerBlockUtil.ChangeReason.BY_PHYSICS);
               }

               var0.getExternalData().getWorld().getChunkLighting().invalidateLightAtBlock(var0.getExternalData(), var4, var5, var6, var8, var17, var18);
               removeBlockEntity(var0, var3, var4, var5, var6);
               World var19 = var0.getExternalData().getWorld();
               if (var19.isInThread()) {
                  if (!var8.hasSupport()) {
                     BlockPhysics.clear(var0, var1, var4, var5, var6);
                  } else {
                     BlockPhysics.reset(var0, var1, var4, var5, var6);
                  }
               } else {
                  var19.execute(() -> {
                     if (!var8.hasSupport()) {
                        BlockPhysics.clear(var0, var1, var4, var5, var6);
                     } else {
                        BlockPhysics.reset(var0, var1, var4, var5, var6);
                     }
                  });
               }
            }
         }
      }
   }

   class="kw">public class="kw">static void setFillerBlocksAt(
      @Nonnull ComponentAccessor<ChunkStore> var0,
      @Nonnull Ref<ChunkStore> var1,
      BlockSection var2,
      BlockComponentSection var3,
      int var4,
      int var5,
      int var6,
      int var7,
      int var8,
      int var9,
      FillerBlockUtil.ChangeReason var10
   ) {
      BlockType var11 = BlockType.getAssetMap().getAsset(var7);
      if (var11 != null) {
         int var12 = unpackX(var8);
         int var13 = unpackY(var8);
         int var14 = unpackZ(var8);
         int var15 = var4 - var12;
         int var16 = var5 - var13;
         int var17 = var6 - var14;
         BlockBoundingBoxes var18 = BlockBoundingBoxes.getAssetMap().getAsset(var11.getHitboxTypeIndex());
         if (var18 == null) {
            var18 = BlockBoundingBoxes.UNIT_BOX;
         }

         forEachFillerBlock(
            var18.get(var9),
            (var17x, var18x, var19) -> {
               if (var17x != var12 || var18x != var13 || var19 != var14) {
                  int var20 = var15 + var17x;
                  int var21 = var16 + var18x;
                  int var22 = var17 + var19;
                  if (ChunkUtil.isSameChunkSection(var4, var5, var6, var20, var21, var22)) {
                     setFiller(var0, var1, var2, var3, var20, var21, var22, var7, var11, pack(var17x, var18x, var19), var9, var10);
                  } else {
                     ChunkStore var23 = var0.getExternalData();
                     Ref var24 = var23.getWorld().isInThread() ? var23.getChunkSectionReferenceAtBlock(var20, var21, var22) : null;
                     if (var24 != null) {
                        BlockSection var25 = var0.getComponent(var24, BlockSection.getComponentType());
                        if (var25 == null) {
                           class="kw">return;
                        }

                        BlockComponentSection var26 = var0.getComponent(var24, BlockComponentSection.getComponentType());
                        if (var26 == null) {
                           class="kw">return;
                        }

                        setFiller(var0, var24, var25, var26, var20, var21, var22, var7, var11, pack(var17x, var18x, var19), var9, var10);
                     } else {
                        var23.getChunkSectionReferenceAtBlockAsync(var20, var21, var22)
                           .thenAcceptAsync(
                              var11x -> {
                                 BlockSection var12 = var11x.getStore().getComponent((Ref<ChunkStore>)var11x, BlockSection.getComponentType());
                                 if (var12 != null) {
                                    BlockComponentSection var13 = var11x.getStore()
                                       .getComponent((Ref<ChunkStore>)var11x, BlockComponentSection.getComponentType());
                                    if (var13 != null) {
                                       setFiller(
                                          var0,
                                          (Ref<ChunkStore>)var11x,
                                          var12,
                                          var13,
                                          var20,
                                          var21,
                                          var22,
                                          var7,
                                          var11,
                                          pack(var17x, var18x, var19),
                                          var9,
                                          var10
                                       );
                                    }
                                 }
                              },
                              var0.getExternalData().getWorld()
                           );
                     }
                  }
               }
            }
         );
      }
   }

   class="kw">public enum ChangeReason {
      NONE,
      NORMAL,
      BY_PHYSICS;

      ChangeReason() {
      }
   }

   class="kw">public class="kw">interface FillerFetcher<A, B> {
      int getBlock(A var1, B var2, int var3, int var4, int var5);

      int getFiller(A var1, B var2, int var3, int var4, int var5);

      int getRotationIndex(A var1, B var2, int var3, int var4, int var5);
   }

   class="kw">public enum ValidationResult {
      OK,
      INVALID_BLOCK,
      INVALID_FILLER;

      ValidationResult() {
      }
   }
}