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

class="kw">import com.hypixel.hytale.builtin.buildertools.tooloperations.transform.Transform;
class="kw">import com.hypixel.hytale.builtin.buildertools.utils.FluidPatternHelper;
class="kw">import com.hypixel.hytale.builtin.buildertools.utils.Material;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.protocol.InteractionType;
class="kw">import com.hypixel.hytale.protocol.packets.buildertools.BrushShape;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.mask.BlockMask;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.mask.BlockPattern;
class="kw">import java.util.Random;
class="kw">import java.util.function.BiConsumer;
class="kw">import java.util.function.Function;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3i;

class="kw">public class BrushConfig {
   class="kw">private class="kw">static class="kw">final Random random = new Random();
   @Nullable
   class="kw">private InteractionType interactionType;
   class="kw">private boolean isHoldDownInteraction;
   class="kw">private Vector3i origin;
   class="kw">private boolean isCurrentlyExecuting;
   class="kw">private boolean hasExecutionContextEncounteredError;
   @Nullable
   class="kw">private String executionErrorMessage;
   class="kw">private Vector3i originOffset = new Vector3i(0, 0, 0);
   @Nullable
   class="kw">private Vector3i originAfterOffset;
   class="kw">private Vector3i transformOrigin;
   class="kw">private Transform transform = Transform.NONE;
   class="kw">private BrushShape shape;
   class="kw">private int shapeWidth;
   class="kw">private int shapeHeight;
   class="kw">private int shapeThickness;
   class="kw">private boolean capped;
   class="kw">private BlockPattern pattern;
   class="kw">private int density;
   class="kw">private boolean enableBrushMask;
   class="kw">private BlockMask brushMask;
   class="kw">private boolean enableOperationMask;
   class="kw">private BlockMask operationMask;
   class="kw">private BlockMask combinedMasks;
   class="kw">private BrushConfig.HistoryMask historyMask;

   class="kw">public BrushConfig() {
      this.resetToDefaultValues();
   }

   class="kw">public BrushConfig(@Nonnull BrushConfig var1) {
      this.interactionType = var1.interactionType;
      this.origin = var1.origin;
      this.isCurrentlyExecuting = var1.isCurrentlyExecuting;
      this.hasExecutionContextEncounteredError = var1.hasExecutionContextEncounteredError;
      this.executionErrorMessage = var1.executionErrorMessage;
      this.originOffset = new Vector3i(var1.originOffset);
      this.originAfterOffset = new Vector3i(var1.originAfterOffset);
      this.shape = var1.shape;
      this.shapeWidth = var1.shapeWidth;
      this.shapeHeight = var1.shapeHeight;
      this.shapeThickness = var1.shapeThickness;
      this.transformOrigin = new Vector3i(var1.transformOrigin);
      this.transform = var1.transform;
      this.capped = var1.capped;
      this.pattern = var1.pattern;
      this.density = var1.density;
      this.enableBrushMask = var1.enableBrushMask;
      this.brushMask = var1.brushMask;
      this.enableOperationMask = var1.enableOperationMask;
      this.operationMask = var1.operationMask;
      this.combinedMasks = var1.combinedMasks;
      this.historyMask = var1.historyMask;
      this.isHoldDownInteraction = var1.isHoldDownInteraction;
   }

   class="kw">public void beginExecution(Vector3i var1, boolean var2, InteractionType var3) {
      this.isCurrentlyExecuting = true;
      this.origin = var1;
      this.isHoldDownInteraction = var2;
      this.interactionType = var3;
      this.updateOriginWithOffsets();
   }

   class="kw">public void endExecution() {
      this.resetToDefaultValues();
   }

   class="kw">public void resetToDefaultValues() {
      this.interactionType = null;
      this.origin = new Vector3i(0, 0, 0);
      this.isCurrentlyExecuting = false;
      this.hasExecutionContextEncounteredError = false;
      this.executionErrorMessage = null;
      this.originOffset = new Vector3i(0, 0, 0);
      this.originAfterOffset = null;
      this.shape = BrushShape.Sphere;
      this.shapeWidth = 5;
      this.shapeHeight = 5;
      this.shapeThickness = 0;
      this.capped = false;
      this.transform = Transform.NONE;
      this.transformOrigin = new Vector3i(0, 0, 0);
      this.pattern = BlockPattern.parse("Rock_Stone");
      this.density = 100;
      this.enableBrushMask = true;
      this.brushMask = BlockMask.EMPTY;
      this.enableOperationMask = true;
      this.operationMask = BlockMask.EMPTY;
      this.combinedMasks = BlockMask.EMPTY;
      this.historyMask = BrushConfig.HistoryMask.None;
   }

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

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

   @Nullable
   class="kw">public InteractionType getInteractionType() {
      class="kw">return this.interactionType;
   }

   @Nullable
   class="kw">public Vector3i getExecutionOrigin() {
      class="kw">return new Vector3i(this.origin);
   }

   @Nullable
   class="kw">public Vector3i getOrigin() {
      class="kw">return this.originAfterOffset;
   }

   @Nonnull
   class="kw">public Vector3i getOriginOffset() {
      class="kw">return new Vector3i(this.originOffset);
   }

   class="kw">public void setOriginOffset(Vector3i var1) {
      this.originOffset = var1;
      this.updateOriginWithOffsets();
   }

   class="kw">public void modifyOriginOffset(@Nonnull Vector3i var1) {
      this.originOffset = this.originOffset.add(var1);
      this.updateOriginWithOffsets();
   }

   class="kw">public void updateOriginWithOffsets() {
      if (this.origin != null) {
         this.originAfterOffset = new Vector3i(this.origin).add(this.originOffset);
      }
   }

   @Nonnull
   class="kw">public Random getRandom() {
      class="kw">return random;
   }

   class="kw">public int getNextBlock() {
      class="kw">return this.pattern.nextBlock(random);
   }

   @Nonnull
   class="kw">public Material getNextMaterial() {
      BlockPattern.BlockEntry var1 = this.pattern.nextBlockTypeKey(random);
      if (var1 != null) {
         FluidPatternHelper.FluidInfo var2 = FluidPatternHelper.getFluidInfo(var1.blockTypeKey());
         if (var2 != null) {
            class="kw">return Material.fluid(var2.fluidId(), var2.fluidLevel());
         }
      }

      class="kw">return Material.block(this.pattern.nextBlock(random));
   }

   class="kw">public BlockMask getBlockMask() {
      class="kw">return this.combinedMasks;
   }

   class="kw">public void setOperationMask(BlockMask var1) {
      this.operationMask = var1;
      this.refreshCombinedMasks();
   }

   class="kw">public void appendOperationMask(BlockMask var1) {
      this.operationMask = BlockMask.combine(var1, this.operationMask);
      this.refreshCombinedMasks();
   }

   class="kw">public void clearOperationMask() {
      this.operationMask = BlockMask.EMPTY;
      this.refreshCombinedMasks();
   }

   class="kw">public void setUseBrushMask(boolean var1) {
      this.enableBrushMask = var1;
      this.refreshCombinedMasks();
   }

   class="kw">public void setUseOperationMask(boolean var1) {
      this.enableOperationMask = var1;
      this.refreshCombinedMasks();
   }

   class="kw">public void setBrushMask(BlockMask var1) {
      this.brushMask = var1;
      this.refreshCombinedMasks();
   }

   class="kw">private void refreshCombinedMasks() {
      if (this.enableBrushMask && this.enableOperationMask) {
         this.combinedMasks = BlockMask.combine(this.brushMask, this.operationMask);
      } else if (this.enableBrushMask) {
         this.combinedMasks = this.brushMask;
      } else if (this.enableOperationMask) {
         this.combinedMasks = this.operationMask;
      }
   }

   class="kw">public int getDensity() {
      class="kw">return this.density;
   }

   class="kw">public void setDensity(int var1) {
      this.density = MathUtil.clamp(var1, 0, 100);
   }

   class="kw">public BrushConfig.HistoryMask getHistoryMask() {
      class="kw">return this.historyMask;
   }

   class="kw">public void setHistoryMask(BrushConfig.HistoryMask var1) {
      this.historyMask = var1;
   }

   class="kw">public int getShapeWidth() {
      class="kw">return this.shapeWidth;
   }

   class="kw">public void setShapeWidth(int var1) {
      if (var1 <= 0) {
         this.setErrorFlag("You cannot set shape width to be less than or equal to zero. Width: " + var1);
      } else {
         this.shapeWidth = var1;
      }
   }

   class="kw">public int getShapeHeight() {
      class="kw">return this.shapeHeight;
   }

   class="kw">public void setShapeHeight(int var1) {
      if (var1 <= 0) {
         this.setErrorFlag("You cannot set shape height to be less than or equal to zero. Height: " + var1);
      } else {
         this.shapeHeight = var1;
      }
   }

   class="kw">public int getShapeThickness() {
      class="kw">return this.shapeThickness;
   }

   class="kw">public void setShapeThickness(int var1) {
      this.shapeThickness = var1;
   }

   class="kw">public Vector3i getTransformOrigin() {
      class="kw">return this.transformOrigin;
   }

   class="kw">public void setTransformOrigin(Vector3i var1) {
      this.transformOrigin = var1;
   }

   class="kw">public Transform getTransform() {
      class="kw">return this.transform;
   }

   class="kw">public void setTransform(Transform var1) {
      this.transform = var1.then(this.transform);
   }

   class="kw">public void resetTransform() {
      this.transform = Transform.NONE;
   }

   class="kw">public boolean isCapped() {
      class="kw">return this.capped;
   }

   class="kw">public void setCapped(boolean var1) {
      this.capped = var1;
   }

   class="kw">public BrushShape getShape() {
      class="kw">return this.shape;
   }

   class="kw">public void setShape(BrushShape var1) {
      this.shape = var1;
   }

   class="kw">public BlockPattern getPattern() {
      class="kw">return this.pattern;
   }

   class="kw">public void setPattern(BlockPattern var1) {
      this.pattern = var1;
   }

   class="kw">public void setErrorFlag(String var1) {
      this.hasExecutionContextEncounteredError = true;
      this.executionErrorMessage = var1;
   }

   class="kw">public void clearError() {
      this.hasExecutionContextEncounteredError = false;
      this.executionErrorMessage = null;
   }

   class="kw">public boolean isHasExecutionContextEncounteredError() {
      class="kw">return this.hasExecutionContextEncounteredError;
   }

   @Nullable
   class="kw">public String getExecutionErrorMessage() {
      class="kw">return this.executionErrorMessage;
   }

   @Nullable
   class="kw">public Vector3i getOriginAfterOffset() {
      class="kw">return this.originAfterOffset;
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "BrushConfig{interactionType="
         + this.interactionType
         + ", origin="
         + this.origin
         + ", originOffset="
         + this.originOffset
         + ", originAfterOffset="
         + this.originAfterOffset
         + ", shapeWidth="
         + this.shapeWidth
         + ", shapeHeight="
         + this.shapeHeight
         + ", shapeThickness="
         + this.shapeThickness
         + ", capped="
         + this.capped
         + ", density="
         + this.density
         + ", shape="
         + this.shape
         + ", pattern="
         + this.pattern
         + ", historyMask="
         + this.historyMask
         + ", brushMask="
         + this.brushMask
         + ", operationMask="
         + this.operationMask
         + ", combinedMasks="
         + this.combinedMasks
         + ", enableOperationMask="
         + this.enableOperationMask
         + ", enableBrushMask="
         + this.enableBrushMask
         + ", random="
         + random
         + ", isCurrentlyExecuting="
         + this.isCurrentlyExecuting
         + "}";
   }

   @Nonnull
   class="kw">public String getInfo() {
      StringBuilder var1 = new StringBuilder("Brush Config Information:");
      var1.append("\nOrigin with Offset: {");
      if (this.originAfterOffset == null) {
         var1.append("Not currently executing, so no origin");
      } else {
         var1.append(this.originAfterOffset.x).append(", ").append(this.originAfterOffset.y).append(", ").append(this.originAfterOffset.z);
      }

      var1.append("}");
      var1.append("\nOffset: {").append(this.originOffset.x).append(", ").append(this.originOffset.y).append(", ").append(this.originOffset.z).append("}");
      var1.append("\nDimensions: {Width: ").append(this.shapeWidth).append(", Height: ").append(this.shapeHeight).append("}");
      var1.append("\nShape Properties: {Shape: ")
         .append(this.shape.name())
         .append(", Thickness: ")
         .append(this.shapeThickness)
         .append(", Capped: ")
         .append(this.capped)
         .append("}");
      var1.append("\nPattern: ").append(this.pattern.toString());
      var1.append("\nMasks: {HistoryMask: ")
         .append(this.historyMask.name())
         .append(", EnableOperationMask: ")
         .append(this.enableOperationMask)
         .append(", EnableBrushMask: ")
         .append(this.enableBrushMask)
         .append(", CombinedMasks: ")
         .append(this.combinedMasks.informativeToString())
         .append("}");
      var1.append("\nIs Currently Executing: ").append(this.isCurrentlyExecuting);
      class="kw">return var1.toString();
   }

   class="kw">public enum BCExecutionStatus {
      Continue,
      Error,
      Complete;

      BCExecutionStatus() {
      }
   }

   class="kw">public enum DataGettingFlags {
      OffsetX(var0 -> var0.getOriginOffset().x),
      OffsetY(var0 -> var0.getOriginOffset().y),
      OffsetZ(var0 -> var0.getOriginOffset().z),
      Height(var0 -> var0.getShapeHeight()),
      Width(var0 -> var0.getShapeWidth()),
      Density(var0 -> var0.getDensity());

      class="kw">private class="kw">final Function<BrushConfig, Integer> valueGetter;

      DataGettingFlags(Function<BrushConfig, Integer> nullxx) {
         this.valueGetter = nullxx;
      }

      class="kw">public int getValue(BrushConfig var1) {
         class="kw">return this.valueGetter.apply(var1);
      }
   }

   class="kw">public enum DataSettingFlags {
      Offset((var0, var1) -> var0.setOriginOffset(var1.getOriginOffset())),
      Shape((var0, var1) -> var0.setShape(var1.getShape())),
      Dimensions((var0, var1) -> {
         var0.setShapeWidth(var1.getShapeWidth());
         var0.setShapeHeight(var1.getShapeHeight());
      }),
      Thickness((var0, var1) -> var0.setShapeThickness(var1.getShapeThickness())),
      Capped((var0, var1) -> var0.setCapped(var1.isCapped())),
      Transform((var0, var1) -> var0.setTransform(var1.getTransform())),
      Pattern((var0, var1) -> var0.setPattern(var1.getPattern())),
      Density((var0, var1) -> var0.setDensity(var1.getDensity())),
      BrushMask((var0, var1) -> {
         var0.setBrushMask(var1.brushMask);
         var0.setUseBrushMask(var1.enableBrushMask);
      }),
      OperationMask((var0, var1) -> {
         var0.setOperationMask(var1.operationMask);
         var0.setUseOperationMask(var1.enableOperationMask);
      }),
      HistoryMask((var0, var1) -> var0.setHistoryMask(var1.getHistoryMask()));

      class="kw">private class="kw">final BiConsumer<BrushConfig, BrushConfig> stateLoader;

      DataSettingFlags(BiConsumer<BrushConfig, BrushConfig> nullxx) {
         this.stateLoader = nullxx;
      }

      class="kw">public void loadData(BrushConfig var1, BrushConfig var2) {
         this.stateLoader.accept(var1, var2);
      }
   }

   class="kw">public enum HistoryMask {
      None,
      Only,
      Not;

      HistoryMask() {
      }
   }
}