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

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.array.ArrayCodec;
class="kw">import com.hypixel.hytale.codec.codecs.simple.BooleanCodec;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.math.Axis;
class="kw">import com.hypixel.hytale.math.util.HashUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockFlipType;
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.asset.type.buildertool.config.BlockTypeListAsset;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.mask.BlockPattern;
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.Pair;
class="kw">import java.util.HashSet;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Optional;
class="kw">import java.util.Random;
class="kw">import java.util.Set;
class="kw">import java.util.Map.Entry;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.joml.Vector3i;
class="kw">import org.joml.Vector3ic;

class="kw">public class CustomConnectedBlockPattern class="kw">extends CustomTemplateConnectedBlockPattern {
   @Nonnull
   class="kw">public class="kw">static class="kw">final BuilderCodec<CustomConnectedBlockPattern> CODEC = BuilderCodec.builder(
         CustomConnectedBlockPattern.class, CustomConnectedBlockPattern::new
      )
      .append(
         new KeyedCodec<>("TransformRulesToOrientation", Codec.BOOLEAN, false),
         (var0, var1) -> var0.transformRulesToOrientation = var1,
         var0 -> var0.transformRulesToOrientation
      )
      .documentation("If the rules should be transformed to the current orientation of the block.")
      .add()
      .<Rotation>append(
         new KeyedCodec<>("YawToApplyAddReplacedBlockType", Rotation.CODEC, false),
         (var0, var1) -> var0.yawToApplyAddReplacedBlockType = var1,
         var0 -> var0.yawToApplyAddReplacedBlockType
      )
      .documentation(
         "Apply an additional Yaw to the resulting BlockType represented by this shape. This allows your replacement to be offset from your original placement"
      )
      .add()
      .<Boolean>append(
         new KeyedCodec<>("RequireFaceTagsMatchingRoll", Codec.BOOLEAN, false),
         (var0, var1) -> var0.requireFaceTagsMatchingRoll = var1,
         var0 -> var0.requireFaceTagsMatchingRoll
      )
      .documentation("Adds Roll comparison to face tag matching in patterns below")
      .add()
      .<PatternRotationDefinition>append(
         new KeyedCodec<>("AllowedPatternTransformations", PatternRotationDefinition.CODEC, false),
         (var0, var1) -> var0.patternRotationDefinition = var1,
         var0 -> var0.patternRotationDefinition
      )
      .documentation(
         "Will create additional generated patterns that are variants of this pattern, but rotated/mirrored/flipped to achieve different results. A common example of this is the Fence, which should its resulting shape based on the rotation of its pattern (fence corner rotates depending on which two sides have the corner fence shape)"
      )
      .add()
      .<ConnectedBlockPatternRule[]>append(
         new KeyedCodec<>("RulesToMatch", new ArrayCodec<>(ConnectedBlockPatternRule.CODEC, ConnectedBlockPatternRule[]::new), true),
         (var0, var1) -> var0.rulesToMatch = var1,
         var0 -> var0.rulesToMatch
      )
      .documentation("All rules must match in order for the pattern to match")
      .add()
      .<Boolean>append(
         new KeyedCodec<>("OnlyOnPlacement", new BooleanCodec(), false), (var0, var1) -> var0.onlyOnPlacement = var1, var0 -> var0.onlyOnPlacement
      )
      .documentation("If true, this pattern will only be checked when the block is first placed.")
      .add()
      .<Boolean>append(new KeyedCodec<>("OnlyOnUpdate", new BooleanCodec(), false), (var0, var1) -> var0.onlyOnUpdate = var1, var0 -> var0.onlyOnUpdate)
      .documentation("If true, this pattern will only be checked when the block is updated by neighboring block changes.")
      .add()
      .build();
   @Nonnull
   class="kw">private class="kw">static class="kw">final Random random = new Random();
   class="kw">private boolean transformRulesToOrientation = true;
   class="kw">private PatternRotationDefinition patternRotationDefinition = PatternRotationDefinition.DEFAULT;
   class="kw">private ConnectedBlockPatternRule[] rulesToMatch;
   class="kw">private Rotation yawToApplyAddReplacedBlockType;
   class="kw">private boolean requireFaceTagsMatchingRoll;
   class="kw">private boolean onlyOnUpdate;
   class="kw">private boolean onlyOnPlacement;

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

   class="kw">private class="kw">static boolean checkPatternRuleAgainstBlockType(
      @Nonnull CustomTemplateConnectedBlockRuleSet var0,
      @Nonnull CustomConnectedBlockTemplateAsset var1,
      @Nonnull ConnectedBlockPatternRule var2,
      @Nonnull String var3,
      @Nonnull RotationTuple var4,
      int var5
   ) {
      if (!var2.getFaceTags().getDirections().isEmpty()) {
         BlockType var6 = BlockType.getAssetMap().getAsset(var3);
         if (!(var6.getConnectedBlockRuleSet() class="kw">instanceof CustomTemplateConnectedBlockRuleSet var8)) {
            class="kw">return !var2.isInclude();
         }

         int var9 = BlockType.getAssetMap().getIndex(var3);
         Set var10 = var8.getShapesForBlockType(var9);
         CustomConnectedBlockTemplateAsset var11 = var8.getShapeTemplateAsset();
         if (var11 == null) {
            class="kw">return !var2.isInclude();
         }

         for (String var13 : var10) {
            if (var1.connectsToOtherMaterials || var0.getShapeNameToBlockPatternMap().equals(var8.getShapeNameToBlockPatternMap())) {
               ConnectedBlockShape var14 = var11.connectedBlockShapes.get(var13);
               Map var15 = var2.getFaceTags().getBlockFaceTags();

               for (Entry var17 : var15.entrySet()) {
                  Vector3i var18 = Rotation.rotate(new Vector3i(var17.getKey()), Rotation.None.subtract(var4.yaw()), Rotation.None);

                  for (String var20 : var17.getValue()) {
                     boolean var21 = var14.getFaceTags() != null && var14.getFaceTags().contains(var18, var20);
                     if (var21) {
                        class="kw">return var2.isInclude();
                     }
                  }
               }
            }
         }
      }

      if (!var2.getShapeBlockTypeKeys().isEmpty()) {
         BlockType var22 = BlockType.getAssetMap().getAsset(var3);
         if (!(var22.getConnectedBlockRuleSet() class="kw">instanceof CustomTemplateConnectedBlockRuleSet var26)) {
            class="kw">return !var2.isInclude();
         }

         int var28 = BlockType.getAssetMap().getIndex(var3);

         for (String var33 : var26.getShapesForBlockType(var28)) {
            if ((var1.connectsToOtherMaterials || var0.getShapeNameToBlockPatternMap().equals(var26.getShapeNameToBlockPatternMap()))
               && var2.getShapeBlockTypeKeys().contains(new BlockPattern.BlockEntry(var33, var4.index(), var5))) {
               class="kw">return var2.isInclude();
            }
         }
      }

      HashSet var23 = var2.getBlockTypes();
      if (!var23.isEmpty() && var23.contains(var3)) {
         class="kw">return var2.isInclude();
      }

      if (var2.getBlockTypeListAssets() != null) {
         for (BlockTypeListAsset var31 : var2.getBlockTypeListAssets()) {
            if (var31.getBlockTypeKeys().contains(var3)) {
               class="kw">return var2.isInclude();
            }
         }
      }

      class="kw">return !var2.isInclude();
   }

   @Nonnull
   @Override
   class="kw">public Optional<ConnectedBlocksUtil.ConnectedBlockResult> getConnectedBlockTypeKey(
      @Nonnull String var1,
      @Nonnull ChunkStore var2,
      @Nonnull Vector3ic var3,
      @Nonnull CustomTemplateConnectedBlockRuleSet var4,
      @Nonnull BlockType var5,
      int var6,
      @Nonnull Vector3ic var7,
      boolean var8
   ) {
      if ((!var8 || !this.onlyOnUpdate) && (var8 || !this.onlyOnPlacement)) {
         CustomConnectedBlockTemplateAsset var9 = var4.getShapeTemplateAsset();
         if (var9 == null) {
            class="kw">return Optional.empty();
         }

         Vector3i var10 = new Vector3i();
         Rotation3D var11 = new Rotation3D(Rotation.None, Rotation.None, Rotation.None);
         Rotation3D var12 = new Rotation3D(Rotation.None, Rotation.None, Rotation.None);
         List var14 = this.patternRotationDefinition.getRotations();
         int var15 = 0;

         label110:
         while (var15 < var14.size()) {
            Pair var16 = var14.get(var15);
            var11.assign((Rotation)var16.first(), Rotation.None, Rotation.None);
            if (this.transformRulesToOrientation) {
               RotationTuple var17 = RotationTuple.get(var6);
               var12.assign(var17.yaw(), var17.pitch(), var17.roll());
               var11.add(var12);
            }

            label107:
            for (ConnectedBlockPatternRule var20 : this.rulesToMatch) {
               var10.set(var20.getRelativePosition());
               class="kw">switch ((PatternRotationDefinition.MirrorAxis)var16.second()) {
                  case X:
                     var10.x = -var10.x();
                     break;
                  case Z:
                     var10.z = -var10.z();
                  case NONE:
               }

               if (var20.getPlacementNormals() != null) {
                  for (ConnectedBlockPatternRule.AdjacentSide var24 : var20.getPlacementNormals()) {
                     if (var24.relativePosition.equals(var7)) {
                        class="kw">continue label107;
                     }
                  }

                  class="kw">return Optional.empty();
               } else {
                  var10 = Rotation.rotate(var10, var11.rotationYaw, var11.rotationPitch, var11.rotationRoll);
                  var10.add(var3);
                  Ref var34 = var2.getChunkSectionReferenceAtBlock(var10.x, var10.y, var10.z);
                  if (var34 == null || !var34.isValid()) {
                     class="kw">return Optional.empty();
                  }

                  Store var38 = var2.getStore();
                  BlockSection var40 = var38.getComponent(var34, BlockSection.getComponentType());
                  if (var40 == null) {
                     class="kw">return Optional.empty();
                  }

                  BlockType var41 = BlockType.getAssetMap().getAsset(var40.get(var10.x, var10.y, var10.z));
                  if (var41 == null) {
                     class="kw">return Optional.empty();
                  }

                  int var25 = var10.y;
                  RotationTuple var13 = var40.getRotation(var10.x, var25, var10.z);
                  int var26 = var40.getFiller(var10.x, var25, var10.z);
                  var12.assign(var13);
                  var12.subtract(var11);
                  var26 = var12.rotationPitch.subtract(var13.pitch()).rotateX(var26);
                  var26 = var12.rotationYaw.subtract(var13.yaw()).rotateY(var26);
                  var26 = var12.rotationRoll.subtract(var13.roll()).rotateZ(var26);
                  var13 = RotationTuple.of(var12.rotationYaw, var12.rotationPitch, var12.rotationRoll);
                  if (var16.second() != PatternRotationDefinition.MirrorAxis.NONE) {
                     Rotation var27 = var41.getFlipType().flipYaw(var13.yaw(), var16.second() == PatternRotationDefinition.MirrorAxis.X ? Axis.X : Axis.Z);
                     var26 = var27.subtract(var13.yaw()).rotateY(var26);
                     var13 = RotationTuple.of(var27, var13.pitch(), var13.roll());
                  }

                  boolean var45 = checkPatternRuleAgainstBlockType(var4, var9, var20, var41.getId(), var13, var26);
                  if (!var45) {
                     var15++;
                     class="kw">continue label110;
                  }
               }
            }

            BlockPattern var30 = var4.getShapeNameToBlockPatternMap().get(var1);
            if (var30 == null) {
               class="kw">return Optional.empty();
            }

            random.setSeed(HashUtil.hash(var3.x(), var3.y(), var3.z()));
            BlockPattern.BlockEntry var31 = var30.nextBlockTypeKey(random);
            if (var31 == null) {
               class="kw">return Optional.empty();
            }

            BlockType var32 = BlockType.getAssetMap().getAsset(var31.blockTypeKey());
            if (var32 == null) {
               class="kw">return Optional.empty();
            }

            BlockFlipType var33 = var32.getFlipType();
            RotationTuple var35 = RotationTuple.get(var31.rotation());
            var35 = RotationTuple.of(var35.yaw().add(this.yawToApplyAddReplacedBlockType), var35.pitch(), var35.roll());
            if (var16.second() != PatternRotationDefinition.MirrorAxis.NONE) {
               Rotation var39 = var33.flipYaw(var35.yaw(), var16.second() == PatternRotationDefinition.MirrorAxis.X ? Axis.X : Axis.Z);
               var35 = RotationTuple.of(var39, var35.pitch(), var35.roll());
            }

            var35 = RotationTuple.of(var35.yaw().add(var11.rotationYaw), var35.pitch().add(var11.rotationPitch), var35.roll().add(var11.rotationRoll));
            if (var35.pitch().equals(Rotation.OneEighty) && var33.equals(BlockFlipType.ORTHOGONAL)) {
               var35 = RotationTuple.of(var35.yaw().subtract(Rotation.Ninety), var35.pitch(), var35.roll());
            }

            class="kw">return Optional.of(new ConnectedBlocksUtil.ConnectedBlockResult(var31.blockTypeKey(), var35.index()));
         }

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