class="kw">package com.hypixel.hytale.server.core.universe.world.connectedblocks.builtin;

class="kw">import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.codec.codecs.simple.IntegerCodec;
class="kw">import com.hypixel.hytale.codec.validation.Validators;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.math.vector.Vector3iUtil;
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.Rotation;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.RotationTuple;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.connectedblocks.ConnectedBlockRuleSet;
class="kw">import com.hypixel.hytale.server.core.universe.world.connectedblocks.ConnectedBlocksUtil;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.util.FillerBlockUtil;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIntPair;
class="kw">import java.util.Map;
class="kw">import java.util.Optional;
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 RoofConnectedBlockRuleSet class="kw">extends ConnectedBlockRuleSet class="kw">implements StairLikeConnectedBlockRuleSet {
   @Nonnull
   class="kw">public class="kw">static class="kw">final BuilderCodec<RoofConnectedBlockRuleSet> CODEC = BuilderCodec.builder(RoofConnectedBlockRuleSet.class, RoofConnectedBlockRuleSet::new)
      .append(new KeyedCodec<>("Regular", StairConnectedBlockRuleSet.CODEC), (var0, var1) -> var0.regular = var1, var0 -> var0.regular)
      .addValidator(Validators.nonNull())
      .add()
      .append(new KeyedCodec<>("Hollow", StairConnectedBlockRuleSet.CODEC), (var0, var1) -> var0.hollow = var1, var0 -> var0.hollow)
      .add()
      .append(new KeyedCodec<>("Topper", ConnectedBlockOutput.CODEC), (var0, var1) -> var0.topper = var1, var0 -> var0.topper)
      .add()
      .append(new KeyedCodec<>("Width", new IntegerCodec()), (var0, var1) -> var0.width = var1, var0 -> var0.width)
      .add()
      .append(new KeyedCodec<>("MaterialName", Codec.STRING), (var0, var1) -> var0.materialName = var1, var0 -> var0.materialName)
      .add()
      .build();
   class="kw">private StairConnectedBlockRuleSet regular;
   class="kw">private StairConnectedBlockRuleSet hollow;
   class="kw">private ConnectedBlockOutput topper;
   class="kw">private String materialName;
   class="kw">private int width = 1;

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

   @Nonnull
   class="kw">private class="kw">static StairConnectedBlockRuleSet.StairType getConnectedBlockStairType(
      @Nonnull ChunkStore var0, @Nonnull Vector3ic var1, @Nonnull StairLikeConnectedBlockRuleSet var2, int var3, int var4, int var5
   ) {
      RotationTuple var6 = RotationTuple.get(var4);
      Rotation var7 = var6.yaw();
      Rotation var8 = var6.pitch();
      boolean var9 = var8 != Rotation.None;
      if (var9) {
         var7 = var7.flip();
      }

      Vector3i var10 = new Vector3i();
      StairConnectedBlockRuleSet.StairType var11 = StairConnectedBlockRuleSet.StairType.STRAIGHT;
      StairConnectedBlockRuleSet.StairConnection var12 = StairConnectedBlockRuleSet.getInvertedCornerConnection(var0, var2, var1, var10, var7, var9);
      if (var12 != null) {
         boolean var13 = isWidthFulfilled(var0, var1, var10, var12, var7, var3, var4, var5);
         if (var13) {
            var11 = var12.getStairType(true);
         }
      }

      StairConnectedBlockRuleSet.StairConnection var16 = StairConnectedBlockRuleSet.getCornerConnection(var0, var2, var1, var10, var4, var7, var9, var5);
      if (var16 != null) {
         boolean var14 = isWidthFulfilled(var0, var1, var10, var16, var7, var3, var4, var5);
         if (var14) {
            var11 = var16.getStairType(false);
         }
      }

      if (var11 == StairConnectedBlockRuleSet.StairType.STRAIGHT) {
         Vector3i var17 = new Vector3i(var1).add(0, 1, 0);
         StairConnectedBlockRuleSet.StairConnection var15 = getValleyConnection(var0, var1, var17, var2, var6, var10, false, var3, var4, var5);
         if (var15 != null) {
            var11 = var15.getStairType(true);
         }
      }

      if (var11 == StairConnectedBlockRuleSet.StairType.STRAIGHT) {
         Vector3i var18 = new Vector3i(var1).add(0, -1, 0);
         StairConnectedBlockRuleSet.StairConnection var19 = getValleyConnection(var0, var1, var18, var2, var6, var10, true, var3, var4, var5);
         if (var19 != null) {
            var11 = var19.getStairType(false);
         }
      }

      if (var9) {
         var11 = class="kw">switch (var11) {
            case CORNER_LEFT -> StairConnectedBlockRuleSet.StairType.CORNER_RIGHT;
            case CORNER_RIGHT -> StairConnectedBlockRuleSet.StairType.CORNER_LEFT;
            case INVERTED_CORNER_LEFT -> StairConnectedBlockRuleSet.StairType.INVERTED_CORNER_RIGHT;
            case INVERTED_CORNER_RIGHT -> StairConnectedBlockRuleSet.StairType.INVERTED_CORNER_LEFT;
            class="kw">default -> var11;
         };
      }

      class="kw">return var11;
   }

   class="kw">private class="kw">static boolean isWidthFulfilled(
      @Nonnull ChunkStore var0,
      @Nonnull Vector3ic var1,
      @Nonnull Vector3i var2,
      @Nonnull StairConnectedBlockRuleSet.StairConnection var3,
      @Nonnull Rotation var4,
      int var5,
      int var6,
      int var7
   ) {
      Store var8 = var0.getStore();
      boolean var9 = true;

      for (int var10 = 0; var10 < var7 - 1; var10++) {
         var2.set(var3 == StairConnectedBlockRuleSet.StairConnection.CORNER_LEFT ? Vector3iUtil.WEST : Vector3iUtil.EAST).mul(var10 + 1);
         var4.rotateY(var2, var2);
         int var11 = FillerBlockUtil.pack(var2.x, var2.y, var2.z);
         var2.add(var1);
         Ref var12 = var0.getChunkSectionReferenceAtBlock(var2.x, var2.y, var2.z);
         if (var12 != null && var12.isValid()) {
            BlockSection var13 = var8.getComponent(var12, BlockSection.getComponentType());
            if (var13 != null) {
               int var14 = var13.getRotationIndex(var2.x, var2.y, var2.z);
               int var15 = var13.getFiller(var2.x, var2.y, var2.z);
               int var16 = var13.get(var2.x, var2.y, var2.z);
               if ((var15 != 0 || var16 != var5 || var14 != var6) && (var15 != var11 || var16 != var5 || var14 != var6)) {
                  var9 = false;
                  break;
               }
            }
         }
      }

      class="kw">return var9;
   }

   @Nullable
   class="kw">private class="kw">static StairConnectedBlockRuleSet.StairConnection getValleyConnection(
      @Nonnull ChunkStore var0,
      @Nonnull Vector3ic var1,
      @Nonnull Vector3i var2,
      @Nonnull StairLikeConnectedBlockRuleSet var3,
      @Nonnull RotationTuple var4,
      @Nonnull Vector3i var5,
      boolean var6,
      int var7,
      int var8,
      int var9
   ) {
      Rotation var10 = var4.yaw();
      var5.set(var6 ? Vector3iUtil.SOUTH : Vector3iUtil.NORTH).mul(var9);
      var10.rotateY(var5, var5);
      var5.add(var2.x, var2.y, var2.z);
      ObjectIntPair var11 = StairConnectedBlockRuleSet.getStairData(var0, var5, var3.getMaterialName());
      if (var11 == null) {
         class="kw">return null;
      }

      boolean var12 = var6 ? isTopperConnectionCompatible(var4, var11, Rotation.None) : isValleyConnectionCompatible(var4, var11, Rotation.None, false);
      if (!var12) {
         class="kw">return null;
      }

      var5.set(var6 ? Vector3iUtil.EAST : Vector3iUtil.WEST).mul(var9);
      var10.rotateY(var5, var5);
      var5.add(var2.x, var2.y, var2.z);
      ObjectIntPair var13 = StairConnectedBlockRuleSet.getStairData(var0, var5, var3.getMaterialName());
      var5.set(var6 ? Vector3iUtil.WEST : Vector3iUtil.EAST).mul(var9);
      var10.rotateY(var5, var5);
      var5.add(var2.x, var2.y, var2.z);
      ObjectIntPair var14 = StairConnectedBlockRuleSet.getStairData(var0, var5, var3.getMaterialName());
      boolean var15 = var6 ? isTopperConnectionCompatible(var4, var13, Rotation.Ninety) : isValleyConnectionCompatible(var4, var13, Rotation.Ninety, false);
      boolean var16 = var6
         ? isTopperConnectionCompatible(var4, var14, Rotation.TwoSeventy)
         : isValleyConnectionCompatible(var4, var14, Rotation.TwoSeventy, false);
      if (var15 == var16) {
         class="kw">return null;
      }

      StairConnectedBlockRuleSet.StairConnection var17 = var15
         ? StairConnectedBlockRuleSet.StairConnection.CORNER_LEFT
         : StairConnectedBlockRuleSet.StairConnection.CORNER_RIGHT;
      class="kw">return !isWidthFulfilled(var0, var1, var5, var17, var10, var7, var8, var9) ? null : var17;
   }

   class="kw">private class="kw">static boolean isTopperConnectionCompatible(
      @Nonnull RotationTuple var0, @Nullable ObjectIntPair<StairConnectedBlockRuleSet.StairType> var1, @Nonnull Rotation var2
   ) {
      class="kw">return isValleyConnectionCompatible(var0, var1, var2, true);
   }

   class="kw">private class="kw">static boolean canBeTopper(
      @Nonnull ChunkStore var0, @Nonnull Vector3i var1, @Nonnull StairLikeConnectedBlockRuleSet var2, @Nonnull RotationTuple var3, @Nonnull Vector3i var4
   ) {
      Rotation var5 = var3.yaw();
      Vector3ic[] var6 = new Vector3ic[]{Vector3iUtil.NORTH, Vector3iUtil.SOUTH, Vector3iUtil.EAST, Vector3iUtil.WEST};
      Rotation[] var7 = new Rotation[]{Rotation.OneEighty, Rotation.None, Rotation.Ninety, Rotation.TwoSeventy};

      for (int var8 = 0; var8 < var6.length; var8++) {
         var4.set(var6[var8]);
         var5.rotateY(var4, var4);
         var4.add(var1.x, var1.y, var1.z);
         ObjectIntPair var9 = StairConnectedBlockRuleSet.getStairData(var0, var4, var2.getMaterialName());
         if (var9 == null || !isTopperConnectionCompatible(var3, var9, var7[var8])) {
            class="kw">return false;
         }
      }

      class="kw">return true;
   }

   class="kw">private class="kw">static boolean isValleyConnectionCompatible(
      @Nonnull RotationTuple var0, @Nullable ObjectIntPair<StairConnectedBlockRuleSet.StairType> var1, @Nonnull Rotation var2, boolean var3
   ) {
      Rotation var4 = var0.yaw().add(var2);
      if (var1 == null) {
         class="kw">return false;
      } else {
         RotationTuple var5 = RotationTuple.get(var1.rightInt());
         StairConnectedBlockRuleSet.StairType var6 = (StairConnectedBlockRuleSet.StairType)var1.first();
         if (var5.pitch() != var0.pitch()) {
            class="kw">return false;
         } else if (var3 && var6.isCorner()) {
            class="kw">return false;
         } else {
            class="kw">return !var3 && var6.isInvertedCorner()
               ? false
               : var5.yaw() == var4
                  || var6 == StairConnectedBlockRuleSet.StairConnection.CORNER_RIGHT.getStairType(var3) && var5.yaw() == var4.add(Rotation.Ninety)
                  || var6 == StairConnectedBlockRuleSet.StairConnection.CORNER_LEFT.getStairType(var3) && var5.yaw() == var4.add(Rotation.TwoSeventy);
         }
      }
   }

   @Override
   class="kw">public boolean onlyUpdateOnPlacement() {
      class="kw">return false;
   }

   @Nonnull
   @Override
   class="kw">public Optional<ConnectedBlocksUtil.ConnectedBlockResult> getConnectedBlockType(
      @Nonnull ChunkStore var1, @Nonnull Vector3ic var2, @Nonnull BlockType var3, int var4, @Nonnull Vector3ic var5, boolean var6
   ) {
      Store var7 = var1.getStore();
      Ref var8 = var1.getChunkSectionReferenceAtBlock(var2.x(), var2.y(), var2.z());
      if (var8 != null && var8.isValid()) {
         BlockSection var9 = var7.getComponent(var8, BlockSection.getComponentType());
         if (var9 == null) {
            class="kw">return Optional.empty();
         }

         BlockSection var10 = var9;
         int var11 = var2.y() - 1;
         if (!ChunkUtil.isSameChunkSection(var2.x(), var2.y(), var2.z(), var2.x(), var11, var2.z())) {
            Ref var12 = var1.getChunkSectionReferenceAtBlock(var2.x(), var11, var2.z());
            if (var12 != null && var12.isValid()) {
               var10 = var7.getComponent(var12, BlockSection.getComponentType());
            } else {
               var10 = null;
            }
         }

         int var13;
         int var25;
         if (var10 != null) {
            var25 = var10.get(var2.x(), var11, var2.z());
            var13 = var10.getRotationIndex(var2.x(), var11, var2.z());
         } else {
            var25 = 0;
            var13 = 0;
         }

         BlockType var14 = BlockType.getAssetMap().getAsset(var25);
         boolean var15 = true;
         if (var14 != null) {
            Map var16 = var14.getSupporting(var13);
            if (var16 != null) {
               BlockFaceSupport[] var17 = var16.get(BlockFace.UP);
               var15 = var17 == null;
            }
         }

         int var26 = BlockType.getAssetMap().getIndex(var3.getId());
         StairConnectedBlockRuleSet.StairType var27 = getConnectedBlockStairType(var1, var2, this, var26, var4, this.width);
         if (this.topper != null && var27 == StairConnectedBlockRuleSet.StairType.STRAIGHT) {
            Vector3i var18 = new Vector3i(var2).add(0, -1, 0);
            RotationTuple var19 = RotationTuple.get(var4);
            var19 = RotationTuple.of(Rotation.None, var19.pitch(), var19.roll());
            Vector3i var20 = new Vector3i();
            boolean var21 = canBeTopper(var1, var18, this, var19, var20);
            if (var21) {
               BlockType var22 = BlockType.getAssetMap().getAsset(this.topper.blockTypeKey);
               if (var22 != null) {
                  class="kw">return Optional.of(new ConnectedBlocksUtil.ConnectedBlockResult(var22.getId(), var4));
               }
            }
         }

         if (this.hollow != null && var15) {
            BlockType var28 = this.hollow.getStairBlockType(var27);
            if (var28 != null) {
               class="kw">return Optional.of(new ConnectedBlocksUtil.ConnectedBlockResult(var28.getId(), var4));
            }
         }

         BlockType var29 = this.regular.getStairBlockType(var27);
         if (var29 != null) {
            ConnectedBlocksUtil.ConnectedBlockResult var31 = new ConnectedBlocksUtil.ConnectedBlockResult(var29.getId(), var4);
            if (this.regular != null && this.width > 0) {
               StairConnectedBlockRuleSet.StairType var32 = this.regular.getStairType(BlockType.getAssetMap().getIndex(var3.getId()));
               if (var32 != null && var32 != StairConnectedBlockRuleSet.StairType.STRAIGHT) {
                  int var33 = var32.isLeft() ? -(this.width - 1) : (var32.isRight() ? this.width - 1 : 0);
                  int var34 = var27.isLeft() ? -(this.width - 1) : (var27.isRight() ? this.width - 1 : 0);
                  if (var34 != var33) {
                     Vector3i var23 = new Vector3i();
                     Rotation var24 = RotationTuple.get(var4).yaw();
                     var23.set(Vector3iUtil.EAST).mul(var33);
                     var24.rotateY(var23, var23);
                     var31.addAdditionalBlock(var23, var29.getId(), var4);
                  }
               }
            }

            class="kw">return Optional.of(var31);
         } else {
            class="kw">return Optional.empty();
         }
      } else {
         class="kw">return Optional.empty();
      }
   }

   @Override
   class="kw">public void updateCachedBlockTypes(@Nonnull BlockType var1, @Nonnull BlockTypeAssetMap<String, BlockType> var2) {
      if (this.regular != null) {
         this.regular.updateCachedBlockTypes(var1, var2);
      }

      if (this.hollow != null) {
         this.hollow.updateCachedBlockTypes(var1, var2);
      }

      if (this.topper != null) {
         this.topper.resolve(var1, var2);
      }
   }

   @Nullable
   @Override
   class="kw">public StairConnectedBlockRuleSet.StairType getStairType(int var1) {
      StairConnectedBlockRuleSet.StairType var2 = this.regular.getStairType(var1);
      if (var2 != null) {
         class="kw">return var2;
      } else {
         class="kw">return this.hollow != null ? this.hollow.getStairType(var1) : null;
      }
   }

   @Nullable
   @Override
   class="kw">public String getMaterialName() {
      class="kw">return this.materialName;
   }

   @Nullable
   @Override
   class="kw">public com.hypixel.hytale.protocol.ConnectedBlockRuleSet toPacket(@Nonnull BlockTypeAssetMap<String, BlockType> var1) {
      com.hypixel.hytale.protocol.RoofConnectedBlockRuleSet var2 = new com.hypixel.hytale.protocol.RoofConnectedBlockRuleSet();
      if (this.regular != null) {
         var2.regular = this.regular.toProtocol(var1);
      }

      if (this.hollow != null) {
         var2.hollow = this.hollow.toProtocol(var1);
      }

      if (this.topper != null) {
         var2.topperBlockId = var1.getIndex(this.topper.blockTypeKey);
      } else {
         var2.topperBlockId = -1;
      }

      var2.width = this.width;
      var2.materialName = this.materialName;
      class="kw">return var2;
   }
}