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

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.EnumCodec;
class="kw">import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
class="kw">import com.hypixel.hytale.protocol.ConnectedBlockPattern;
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.connectedblocks.config.rule.ConnectedBlockRule;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectListIterator;
class="kw">import java.util.Collection;
class="kw">import java.util.LinkedHashSet;
class="kw">import java.util.List;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class ConnectedBlockPatternConfig {
   class="kw">private class="kw">static class="kw">final ArrayCodec<ConnectedBlockPatternConfig.RotationGroup> ROTATION_GROUP_ARRAY = ArrayCodec.ofBuilderCodec(
      ConnectedBlockPatternConfig.RotationGroup.CODEC, ConnectedBlockPatternConfig.RotationGroup[]::new
   );
   class="kw">public class="kw">static class="kw">final BuilderCodec<ConnectedBlockPatternConfig> CODEC = BuilderCodec.builder(
         ConnectedBlockPatternConfig.class, ConnectedBlockPatternConfig::new
      )
      .append(new KeyedCodec<>("Rule", ConnectedBlockRule.CODEC, true), (var0, var1) -> var0.rule = var1, var0 -> var0.rule)
      .add()
      .append(new KeyedCodec<>("Output", ConnectedBlockPatternOutput.CODEC, false), (var0, var1) -> var0.output = var1, var0 -> var0.output)
      .add()
      .append(
         new KeyedCodec<>("TransformRulesWithOrientation", Codec.BOOLEAN),
         (var0, var1) -> var0.transformRulesWithOrientation = var1,
         var0 -> var0.transformRulesWithOrientation
      )
      .add()
      .append(new KeyedCodec<>("RotationTransforms", ROTATION_GROUP_ARRAY, false), (var0, var1) -> var0.rotationGroups = var1, var0 -> var0.rotationGroups)
      .add()
      .afterDecode(var0 -> {
         if (var0.rotationGroups != null) {
            LinkedHashSet var1 = new LinkedHashSet<>();

            for (ConnectedBlockPatternConfig.RotationGroup var5 : var0.rotationGroups) {
               var5.addRotationTuples(var1);
            }

            var0.allowedTransformRotations = List.copyOf(var1);
            var0.rotationGroups = null;
         }
      })
      .build();
   class="kw">private ConnectedBlockRule rule;
   class="kw">private ConnectedBlockPatternOutput output;
   @Nullable
   class="kw">private ConnectedBlockPatternConfig.RotationGroup[] rotationGroups;
   class="kw">private List<RotationTuple> allowedTransformRotations = List.of(RotationTuple.NONE);
   class="kw">private boolean transformRulesWithOrientation;

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

   @Nullable
   class="kw">public ConnectedBlockRule getRule() {
      class="kw">return this.rule;
   }

   class="kw">public ConnectedBlockPatternOutput getOutput() {
      class="kw">return this.output;
   }

   @Nonnull
   class="kw">public List<RotationTuple> getAllowedTransformRotations() {
      class="kw">return this.allowedTransformRotations;
   }

   class="kw">public boolean isTransformRulesWithOrientation() {
      class="kw">return this.transformRulesWithOrientation;
   }

   @Nonnull
   class="kw">public ConnectedBlockPattern toPacket() {
      ConnectedBlockPattern var1 = new ConnectedBlockPattern();
      var1.rule = this.rule == null ? null : this.rule.toPacket();
      var1.transformRulesWithOrientation = this.transformRulesWithOrientation;
      var1.outputShapeId = this.output == null ? "" : this.output.getShapeId();
      var1.rotations = new int[this.allowedTransformRotations.size()];

      for (int var2 = 0; var2 < this.allowedTransformRotations.size(); var2++) {
         var1.rotations[var2] = this.allowedTransformRotations.get(var2).index();
      }

      class="kw">return var1;
   }

   class="kw">public enum AllowedRotation {
      None,
      Ninety,
      OneEighty,
      TwoSeventy,
      All;

      class="kw">public class="kw">static class="kw">final EnumCodec<ConnectedBlockPatternConfig.AllowedRotation> CODEC = new EnumCodec<>(ConnectedBlockPatternConfig.AllowedRotation.class);

      AllowedRotation() {
      }

      class="kw">public void addRotations(Collection<Rotation> var1) {
         class="kw">switch (this) {
            case None:
               var1.add(Rotation.None);
               break;
            case Ninety:
               var1.add(Rotation.Ninety);
               break;
            case OneEighty:
               var1.add(Rotation.OneEighty);
               break;
            case TwoSeventy:
               var1.add(Rotation.TwoSeventy);
               break;
            case All:
               var1.add(Rotation.None);
               var1.add(Rotation.Ninety);
               var1.add(Rotation.OneEighty);
               var1.add(Rotation.TwoSeventy);
         }
      }
   }

   class="kw">public class="kw">static class RotationGroup {
      class="kw">public class="kw">static class="kw">final BuilderCodec<ConnectedBlockPatternConfig.RotationGroup> CODEC = BuilderCodec.builder(
            ConnectedBlockPatternConfig.RotationGroup.class, ConnectedBlockPatternConfig.RotationGroup::new
         )
         .append(new KeyedCodec<>("Yaw", ConnectedBlockPatternConfig.AllowedRotation.CODEC, false), (var0, var1) -> var0.yaw = var1, var0 -> var0.yaw)
         .add()
         .append(new KeyedCodec<>("Pitch", ConnectedBlockPatternConfig.AllowedRotation.CODEC, false), (var0, var1) -> var0.pitch = var1, var0 -> var0.pitch)
         .add()
         .append(new KeyedCodec<>("Roll", ConnectedBlockPatternConfig.AllowedRotation.CODEC, false), (var0, var1) -> var0.roll = var1, var0 -> var0.roll)
         .add()
         .build();
      class="kw">private ConnectedBlockPatternConfig.AllowedRotation yaw = ConnectedBlockPatternConfig.AllowedRotation.None;
      class="kw">private ConnectedBlockPatternConfig.AllowedRotation pitch = ConnectedBlockPatternConfig.AllowedRotation.None;
      class="kw">private ConnectedBlockPatternConfig.AllowedRotation roll = ConnectedBlockPatternConfig.AllowedRotation.None;

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

      class="kw">public void addRotationTuples(LinkedHashSet<RotationTuple> var1) {
         ObjectArrayList var2 = new ObjectArrayList();
         ObjectArrayList var3 = new ObjectArrayList();
         ObjectArrayList var4 = new ObjectArrayList();
         this.yaw.addRotations(var2);
         this.pitch.addRotations(var3);
         this.roll.addRotations(var4);
         ObjectListIterator var5 = var2.iterator();

         while (var5.hasNext()) {
            Rotation var6 = (Rotation)var5.next();
            ObjectListIterator var7 = var3.iterator();

            while (var7.hasNext()) {
               Rotation var8 = (Rotation)var7.next();
               ObjectListIterator var9 = var4.iterator();

               while (var9.hasNext()) {
                  Rotation var10 = (Rotation)var9.next();
                  var1.add(RotationTuple.of(var6, var8, var10));
               }
            }
         }
      }
   }
}