class="kw">package com.hypixel.hytale.builtin.blockphysics;

class="kw">import com.hypixel.hytale.builtin.fallingblocks.FallingBlock;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.math.shape.Box;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.protocol.BlockMaterial;
class="kw">import com.hypixel.hytale.server.core.asset.type.blockhitbox.BlockBoundingBoxes;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockFace;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockFaceSupport;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.RequiredBlockFaceSupport;
class="kw">import com.hypixel.hytale.server.core.asset.type.fluid.Fluid;
class="kw">import com.hypixel.hytale.server.core.blocktype.component.BlockPhysics;
class="kw">import com.hypixel.hytale.server.core.modules.blockset.BlockSetModule;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.BlockHarvestUtils;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.FluidSection;
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.FillerBlockUtil;
class="kw">import java.util.Map;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3i;
class="kw">import org.joml.Vector3ic;

class="kw">public class BlockPhysicsUtil {
   class="kw">public class="kw">static class="kw">final int DOESNT_SATISFY = 0;
   class="kw">public class="kw">static class="kw">final int IGNORE = -1;
   class="kw">public class="kw">static class="kw">final int SATISFIES_SUPPORT = -2;
   class="kw">public class="kw">static class="kw">final int WAITING_CHUNK = -3;

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

   @Nonnull
   class="kw">public class="kw">static BlockPhysicsUtil.Result applyBlockPhysics(
      @Nonnull ComponentAccessor<EntityStore> var0,
      @Nonnull BlockPhysicsSystems.CachedAccessor var1,
      @Nonnull Ref<ChunkStore> var2,
      BlockSection var3,
      @Nonnull BlockPhysics var4,
      @Nonnull FluidSection var5,
      int var6,
      int var7,
      int var8,
      @Nonnull BlockType var9,
      int var10,
      int var11
   ) {
      if (var11 != 0) {
         class="kw">return BlockPhysicsUtil.Result.VALID;
      }

      int var12 = testBlockPhysics(var1, var3, var4, var5, var6, var7, var8, var9, var10, var11);
      if (var12 == 0) {
         World var15 = var0.getExternalData().getWorld();
         Store var14 = var15.getChunkStore().getStore();
         class="kw">switch (var9.getSupportDropType()) {
            case BREAK:
               BlockHarvestUtils.naturallyRemoveBlockByPhysics(new Vector3i(var6, var7, var8), var9, var11, 256, var2, var0, var14);
               break;
            case DESTROY:
               BlockHarvestUtils.naturallyRemoveBlockByPhysics(new Vector3i(var6, var7, var8), var9, var11, 2304, var2, var0, var14);
               break;
            case FALL:
               FallingBlock.fallBlock(var15, var0.getExternalData().getStore(), var6, var7, var8);
         }

         class="kw">return BlockPhysicsUtil.Result.INVALID;
      } else {
         if (var12 == -1) {
            class="kw">return BlockPhysicsUtil.Result.VALID;
         }

         if (var12 == -3) {
            class="kw">return BlockPhysicsUtil.Result.WAITING_CHUNK;
         }

         int var13 = var4.get(var6, var7, var8);
         if (var12 == -2) {
            if (var13 != 0) {
               var4.set(var6, var7, var8, 0);
               var1.performBlockUpdate(var6, var7, var8);
            }

            class="kw">return BlockPhysicsUtil.Result.VALID;
         } else {
            if (var13 == var12) {
               var1.performBlockUpdate(var6, var7, var8, var12 - 1);
            } else {
               var4.set(var6, var7, var8, var12);
               var1.performBlockUpdate(var6, var7, var8);
            }

            class="kw">return BlockPhysicsUtil.Result.VALID;
         }
      }
   }

   class="kw">public class="kw">static int testBlockPhysics(
      @Nonnull BlockPhysicsSystems.CachedAccessor var0,
      BlockSection var1,
      @Nullable BlockPhysics var2,
      @Nonnull FluidSection var3,
      int var4,
      int var5,
      int var6,
      @Nonnull BlockType var7,
      int var8,
      int var9
   ) {
      class="kw">return testBlockPhysics(new BlockPhysicsUtil.WorldSupportReader(var0, var1, var2, var3, var4, var5, var6), var4, var5, var6, var7, var8, var9);
   }

   class="kw">public class="kw">static int testBlockPhysics(@Nonnull BlockPhysicsUtil.SupportReader var0, int var1, int var2, int var3, @Nonnull BlockType var4, int var5, int var6) {
      int var7 = -1;
      if (var4.getHitboxTypeIndex() != 0) {
         BlockBoundingBoxes var8 = BlockBoundingBoxes.getAssetMap().getAsset(var4.getHitboxTypeIndex());
         if (var8 != null && var8.protrudesUnitBox()) {
            BlockBoundingBoxes.RotatedVariantBoxes var9 = var8.get(var5);
            Box var10 = var9.getBoundingBox();
            int var11 = (int)var10.min.x;
            int var12 = (int)var10.min.y;
            int var13 = (int)var10.min.z;
            if (var11 - var10.min.x > 0.0) {
               var11--;
            }

            if (var12 - var10.min.y > 0.0) {
               var12--;
            }

            if (var13 - var10.min.z > 0.0) {
               var13--;
            }

            int var14 = (int)var10.max.x;
            int var15 = (int)var10.max.y;
            int var16 = (int)var10.max.z;
            if (var10.max.x - var14 > 0.0) {
               var14++;
            }

            if (var10.max.y - var15 > 0.0) {
               var15++;
            }

            if (var10.max.z - var16 > 0.0) {
               var16++;
            }

            int var17 = Math.max(var14 - var11, 1);
            int var18 = Math.max(var15 - var12, 1);
            int var19 = Math.max(var16 - var13, 1);

            for (int var20 = 0; var20 < var17; var20++) {
               for (int var21 = 0; var21 < var18; var21++) {
                  for (int var22 = 0; var22 < var19; var22++) {
                     int var23 = var1 + var11 + var20;
                     int var24 = var2 + var12 + var21;
                     int var25 = var3 + var13 + var22;
                     int var26 = FillerBlockUtil.pack(var11 + var20, var12 + var21, var13 + var22);
                     if (!var0.isPositionAvailable(var23, var24, var25)) {
                        class="kw">return -3;
                     }

                     int var27 = var0.getProtrudingFillerRotation(var23, var24, var25, var5);
                     int var28 = testBlockPhysicsAtPosition(var0, var23, var24, var25, var4, var27, var26);
                     if (var28 != -1) {
                        class="kw">switch (var4.getBlockSupportsRequiredFor()) {
                           case Any:
                              if (var28 == -2) {
                                 byte var30 = -2;
                                 class="kw">return var30;
                              }

                              if (var28 == 0) {
                                 var7 = 0;
                              } else if (var7 < var28) {
                                 var7 = var28;
                              }
                              break;
                           case All:
                              if (var28 == 0) {
                                 byte var29 = 0;
                                 class="kw">return var29;
                              }

                              if (var28 == -2) {
                                 var7 = -2;
                              } else if (var7 == -1 && var7 < var28) {
                                 var7 = var28;
                              }
                        }
                     }
                  }
               }
            }
         } else {
            var7 = testBlockPhysicsAtPosition(var0, var1, var2, var3, var4, var5, var6);
         }
      } else {
         var7 = testBlockPhysicsAtPosition(var0, var1, var2, var3, var4, var5, var6);
      }

      class="kw">return var7;
   }

   class="kw">private class="kw">static int testBlockPhysicsAtPosition(
      @Nonnull BlockPhysicsUtil.SupportReader var0, int var1, int var2, int var3, @Nonnull BlockType var4, int var5, int var6
   ) {
      if (var4.isUnknown()) {
         class="kw">return -1;
      }

      Map var7 = var4.getSupport(var5);
      if (var7 != null && !var7.isEmpty()) {
         Vector3i var8 = new Vector3i(FillerBlockUtil.unpackX(var6), FillerBlockUtil.unpackY(var6), FillerBlockUtil.unpackZ(var6));
         Vector3i var9 = new Vector3i();
         BlockBoundingBoxes var10 = BlockBoundingBoxes.getAssetMap().getAsset(var4.getHitboxTypeIndex());
         if (var10 == null) {
            class="kw">return -1;
         }

         Box var11 = var10.get(var5).getBoundingBox();
         Vector3i var12 = new Vector3i(var1 - FillerBlockUtil.unpackX(var6), var2 - FillerBlockUtil.unpackY(var6), var3 - FillerBlockUtil.unpackZ(var6));
         boolean var13 = false;
         int var14 = var4.getMaxSupportDistance();
         int var15 = Integer.MAX_VALUE;

         for (BlockFace var19 : BlockFace.VALUES) {
            RequiredBlockFaceSupport[] var20 = var7.get(var19);
            if (var20 != null && var20.length != 0) {
               BlockFace[] var21 = var19.getConnectingFaces();
               Vector3ic[] var22 = var19.getConnectingFaceOffsets();

               for (int var23 = 0; var23 < var21.length; var23++) {
                  BlockFace var24 = var21[var23];
                  Vector3ic var25 = var22[var23];
                  int var26 = var1 + var25.x();
                  int var27 = var2 + var25.y();
                  int var28 = var3 + var25.z();
                  if (!var11.containsBlock(var12, var26, var27, var28)) {
                     if (!var0.isPositionAvailable(var26, var27, var28)) {
                        class="kw">return -3;
                     }

                     BlockPhysicsUtil.SupportBlock var29 = var0.getBlock(var26, var27, var28);
                     boolean var30 = var29 == null && var0.doesMissingNeighbourSatisfySupport(var25);
                     int var31 = 0;
                     int var32 = var5;
                     int var33 = 0;
                     int var34 = 0;
                     Fluid var35 = Fluid.getAssetMap().getAsset(0);
                     BlockType var36 = BlockType.getAssetMap().getAsset(0);
                     if (var29 != null) {
                        var31 = var29.blockId();
                        var32 = var29.rotation();
                        var33 = var29.filler();
                        var34 = var29.fluidId();
                        var35 = var29.fluid();
                        var36 = BlockType.getAssetMap().getAsset(var31);
                        if (var36 == null
                           || var35 == null
                           || var33 != 0
                              && var36 == var4
                              && var26 - FillerBlockUtil.unpackX(var33) == var12.x
                              && var27 - FillerBlockUtil.unpackY(var33) == var12.y
                              && var28 - FillerBlockUtil.unpackZ(var33) == var12.z) {
                           class="kw">continue;
                        }
                     }

                     var9.set(FillerBlockUtil.unpackX(var33), FillerBlockUtil.unpackY(var33), FillerBlockUtil.unpackZ(var33));
                     boolean var37 = false;
                     boolean var38 = false;

                     for (RequiredBlockFaceSupport var42 : var20) {
                        if (var42.isAppliedToFiller(var8)) {
                           boolean var43 = var30;
                           if (!var43 && var29 != null) {
                              var43 = doesSatisfyRequirements(var4, var8, var9, var19, var24, var31, var36, var32, var34, var35, var42);
                           }

                           if (var43 && var14 > 0 && var42.allowsSupportPropagation()) {
                              int var44 = var29 != null ? var0.getSupportValue(var26, var27, var28) : var0.getMissingNeighbourSupportValue(var26, var27, var28);
                              if (var44 == 15) {
                                 var15 = 1;
                              } else if (var44 < var15) {
                                 var15 = var44;
                              }
                           }

                           class="kw">switch (var42.getSupport()) {
                              case IGNORED:
                              class="kw">default:
                                 break;
                              case REQUIRED:
                                 if (var43) {
                                    var37 = true;
                                 }

                                 var13 = true;
                                 break;
                              case DISALLOWED:
                                 if (var43) {
                                    var38 = true;
                                 }

                                 var13 = true;
                           }
                        }
                     }

                     if (!var38 && var37) {
                        class="kw">return -2;
                     }
                  }
               }
            }
         }

         if (!var13) {
            class="kw">return -1;
         }

         if (var15 < Integer.MAX_VALUE && var15 >= 0) {
            int var45 = var15 + 1;
            if (var14 >= var45) {
               class="kw">return var45;
            }
         }

         class="kw">return 0;
      } else {
         class="kw">return -1;
      }
   }

   class="kw">public class="kw">static boolean doesSatisfyRequirements(
      @Nonnull BlockType var0,
      Vector3i var1,
      Vector3i var2,
      BlockFace var3,
      BlockFace var4,
      int var5,
      @Nonnull BlockType var6,
      int var7,
      int var8,
      @Nonnull Fluid var9,
      @Nonnull RequiredBlockFaceSupport var10
   ) {
      String var11 = var6.getId();
      boolean var12 = true;
      int var13 = var10.getBlockSetIndex();
      if (var13 >= 0 && !BlockSetModule.getInstance().blockInSet(var13, var5)) {
         var12 = false;
      }

      String var14 = var10.getBlockTypeId();
      if (var12 && var14 != null && !var14.equals(var11)) {
         var12 = false;
      }

      String var15 = var10.getFluidId();
      if (var12 && var15 != null && (var6.getMaterial() != BlockMaterial.Empty || var8 == 0 || !var15.equals(var9.getId()))) {
         var12 = false;
      }

      int var16 = var10.getTagIndex();
      if (var16 >= 0 && !BlockType.getAssetMap().getKeysForTag(var16).contains(var11)) {
         var12 = false;
      }

      if (var12 && var10.getFaceType() != null) {
         var12 = doesMatchFaceType(var2, var10.getFaceType(), var4, var6.getSupporting(var7));
      }

      if (var12 && var10.getSelfFaceType() != null) {
         var12 = doesMatchFaceType(var1, var10.getSelfFaceType(), var3, var0.getSupporting(var7));
      }
      class="kw">return class="kw">switch (var10.getMatchSelf()) {
         case REQUIRED -> {
            if (var12) {
               yield var0.getId().equals(var11);
            }
         }
         case DISALLOWED -> {
            if (var12) {
               yield !var0.getId().equals(var11);
            }
         }
      };
   }

   class="kw">public class="kw">static boolean doesMatchFaceType(Vector3i var0, @Nonnull String var1, BlockFace var2, @Nonnull Map<BlockFace, BlockFaceSupport[]> var3) {
      boolean var4 = false;
      BlockFaceSupport[] var5 = var3.get(var2);
      if (var5 != null) {
         for (BlockFaceSupport var9 : var5) {
            if (var9.providesSupportFromFiller(var0) && var1.equals(var9.getFaceType())) {
               var4 = true;
               break;
            }
         }
      }

      class="kw">return var4;
   }

   class="kw">public enum Result {
      INVALID,
      VALID,
      WAITING_CHUNK;

      Result() {
      }
   }

   class="kw">public record SupportBlock(int blockId, int rotation, int filler, int fluidId, @Nonnull Fluid fluid) {
      class="kw">public SupportBlock {
      }
   }

   class="kw">public class="kw">interface SupportReader {
      boolean isPositionAvailable(int var1, int var2, int var3);

      @Nullable
      BlockPhysicsUtil.SupportBlock getBlock(int var1, int var2, int var3);

      int getSupportValue(int var1, int var2, int var3);

      class="kw">default int getMissingNeighbourSupportValue(int var1, int var2, int var3) {
         class="kw">return 0;
      }

      class="kw">default boolean doesMissingNeighbourSatisfySupport(@Nonnull Vector3ic var1) {
         class="kw">return false;
      }

      class="kw">default int getProtrudingFillerRotation(int var1, int var2, int var3, int var4) {
         class="kw">return var4;
      }
   }

   class="kw">private class="kw">static class="kw">final class WorldSupportReader class="kw">implements BlockPhysicsUtil.SupportReader {
      @Nonnull
      class="kw">private class="kw">final BlockPhysicsSystems.CachedAccessor chunkAccessor;
      class="kw">private class="kw">final BlockSection blockSection;
      @Nullable
      class="kw">private class="kw">final BlockPhysics blockPhysics;
      @Nonnull
      class="kw">private class="kw">final FluidSection fluidSection;
      class="kw">private class="kw">final int originX;
      class="kw">private class="kw">final int originY;
      class="kw">private class="kw">final int originZ;

      class="kw">private WorldSupportReader(
         @Nonnull BlockPhysicsSystems.CachedAccessor var1,
         BlockSection var2,
         @Nullable BlockPhysics var3,
         @Nonnull FluidSection var4,
         int var5,
         int var6,
         int var7
      ) {
         this.chunkAccessor = var1;
         this.blockSection = var2;
         this.blockPhysics = var3;
         this.fluidSection = var4;
         this.originX = var5;
         this.originY = var6;
         this.originZ = var7;
      }

      @Override
      class="kw">public boolean isPositionAvailable(int var1, int var2, int var3) {
         class="kw">return this.getBlockSection(var1, var2, var3) != null && this.getFluidSection(var1, var2, var3) != null;
      }

      @Nullable
      @Override
      class="kw">public BlockPhysicsUtil.SupportBlock getBlock(int var1, int var2, int var3) {
         BlockSection var4 = this.getBlockSection(var1, var2, var3);
         FluidSection var5 = this.getFluidSection(var1, var2, var3);
         if (var4 != null && var5 != null) {
            int var6 = var5.getFluidId(var1, var2, var3);
            Fluid var7 = Fluid.getAssetMap().getAsset(var6);
            class="kw">return var7 == null
               ? null
               : new BlockPhysicsUtil.SupportBlock(
                  var4.get(var1, var2, var3), var4.getRotationIndex(var1, var2, var3), var4.getFiller(var1, var2, var3), var6, var7
               );
         } else {
            class="kw">return null;
         }
      }

      @Override
      class="kw">public int getSupportValue(int var1, int var2, int var3) {
         BlockPhysics var4 = this.getBlockPhysics(var1, var2, var3);
         class="kw">return var4 != null ? var4.get(var1, var2, var3) : 0;
      }

      @Override
      class="kw">public int getProtrudingFillerRotation(int var1, int var2, int var3, int var4) {
         BlockSection var5 = this.getBlockSection(var1, var2, var3);
         class="kw">return var5 != null ? var5.getRotationIndex(var1, var2, var3) : var4;
      }

      @Nullable
      class="kw">private BlockSection getBlockSection(int var1, int var2, int var3) {
         class="kw">return ChunkUtil.isSameChunkSection(this.originX, this.originY, this.originZ, var1, var2, var3)
            ? this.blockSection
            : this.chunkAccessor.getBlockSectionAtBlock(var1, var2, var3);
      }

      @Nullable
      class="kw">private FluidSection getFluidSection(int var1, int var2, int var3) {
         class="kw">return ChunkUtil.isSameChunkSection(this.originX, this.originY, this.originZ, var1, var2, var3)
            ? this.fluidSection
            : this.chunkAccessor.getFluidSectionAtBlock(var1, var2, var3);
      }

      @Nullable
      class="kw">private BlockPhysics getBlockPhysics(int var1, int var2, int var3) {
         class="kw">return ChunkUtil.isSameChunkSection(this.originX, this.originY, this.originZ, var1, var2, var3)
            ? this.blockPhysics
            : this.chunkAccessor.getBlockPhysicsAtBlock(var1, var2, var3);
      }
   }
}