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

class="kw">import com.hypixel.hytale.builtin.buildertools.scriptedbrushes.BrushConfig;
class="kw">import com.hypixel.hytale.builtin.buildertools.scriptedbrushes.BrushConfigCommandExecutor;
class="kw">import com.hypixel.hytale.builtin.buildertools.scriptedbrushes.BrushConfigEditStore;
class="kw">import com.hypixel.hytale.builtin.buildertools.scriptedbrushes.operations.system.SequenceBrushOperation;
class="kw">import com.hypixel.hytale.builtin.buildertools.tooloperations.SculptOperation;
class="kw">import com.hypixel.hytale.builtin.buildertools.utils.Material;
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.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.server.core.asset.type.fluid.Fluid;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
class="kw">import java.util.ArrayDeque;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.joml.Vector3i;

class="kw">public class FluidFixOperation class="kw">extends SequenceBrushOperation {
   class="kw">public class="kw">static class="kw">final BuilderCodec<FluidFixOperation> CODEC = BuilderCodec.builder(FluidFixOperation.class, FluidFixOperation::new)
      .append(
         new KeyedCodec<>("FluidAction", new EnumCodec<>(FluidFixOperation.FluidAction.class)),
         (var0, var1) -> var0.fluidAction = var1,
         var0 -> var0.fluidAction
      )
      .documentation("Fill flood-fills fluids into air pockets. Clear removes all fluids in the brush area.")
      .add()
      .documentation("Fixes or clears fluids in the brush area after terrain modifications")
      .build();
   @Nonnull
   class="kw">private FluidFixOperation.FluidAction fluidAction = FluidFixOperation.FluidAction.Fill;
   class="kw">private class="kw">static class="kw">final int BUFFER_MARGIN = 1;
   class="kw">private class="kw">static class="kw">final long MAX_BUFFER_VOLUME = 1000000L;
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">private int originX;
   class="kw">private int originY;
   class="kw">private int originZ;
   class="kw">private int bufferWidth;
   class="kw">private int bufferHeight;
   class="kw">private int halfBufferWidth;
   class="kw">private int halfBufferHeight;

   class="kw">public FluidFixOperation() {
      super("Fluid Fix", "Fixes or clears fluids in the brush area after terrain modifications", true);
   }

   @Override
   class="kw">public void modifyBrushConfig(
      @Nonnull Ref<EntityStore> var1, @Nonnull BrushConfig var2, @Nonnull BrushConfigCommandExecutor var3, @Nonnull ComponentAccessor<EntityStore> var4
   ) {
      Vector3i var5 = var2.getOrigin();
      this.originX = var5.x;
      this.originY = var5.y;
      this.originZ = var5.z;
      this.bufferWidth = var2.getShapeWidth() + 2;
      this.bufferHeight = var2.getShapeHeight() + 2;
      this.halfBufferWidth = this.bufferWidth / 2;
      this.halfBufferHeight = this.bufferHeight / 2;
      if (this.fluidAction == FluidFixOperation.FluidAction.Fill) {
         long var6 = (long)this.bufferWidth * this.bufferHeight * this.bufferWidth;
         if (var6 > 1000000L) {
            LOGGER.at(Level.WARNING)
               .log("Skipping fluid fill for oversized brush buffer %dx%dx%d (%d cells)", this.bufferWidth, this.bufferHeight, this.bufferWidth, var6);
            class="kw">return;
         }

         BrushConfigEditStore var8 = var3.getEdit();
         int[][][] var9 = new int[this.bufferWidth][this.bufferHeight][this.bufferWidth];
         int[][][] var10 = new int[this.bufferWidth][this.bufferHeight][this.bufferWidth];
         this.buildBuffers(var8, var9, var10);
         this.floodFillFluids(var8, var9, var10);
      }
   }

   @Override
   class="kw">public boolean modifyBlocks(
      Ref<EntityStore> var1,
      BrushConfig var2,
      BrushConfigCommandExecutor var3,
      @Nonnull BrushConfigEditStore var4,
      int var5,
      int var6,
      int var7,
      ComponentAccessor<EntityStore> var8
   ) {
      if (this.fluidAction == FluidFixOperation.FluidAction.Clear) {
         int var9 = var4.getFluid(var5, var6, var7);
         if (var9 != 0) {
            var4.setMaterial(var5, var6, var7, Material.fluid(0, (byte)0));
         }
      }

      class="kw">return true;
   }

   class="kw">private void buildBuffers(BrushConfigEditStore var1, int[][][] var2, int[][][] var3) {
      Int2IntOpenHashMap var4 = new Int2IntOpenHashMap();
      var4.defaultReturnValue(Integer.MIN_VALUE);

      for (int var5 = 0; var5 < this.bufferWidth; var5++) {
         int var6 = this.originX - this.halfBufferWidth + var5;

         for (int var7 = 0; var7 < this.bufferWidth; var7++) {
            int var8 = this.originZ - this.halfBufferWidth + var7;

            for (int var9 = 0; var9 < this.bufferHeight; var9++) {
               int var10 = this.originY - this.halfBufferHeight + var9;
               var2[var5][var9][var7] = SculptOperation.filterFullBlockForBuffer(var1.getBlock(var6, var10, var8), var4);
               var3[var5][var9][var7] = var1.getFluid(var6, var10, var8);
            }
         }
      }
   }

   class="kw">private void floodFillFluids(BrushConfigEditStore var1, int[][][] var2, int[][][] var3) {
      boolean[][] var4 = new boolean[this.bufferWidth][this.bufferWidth];
      int[][] var5 = new int[this.bufferWidth][this.bufferWidth];
      boolean[][] var6 = new boolean[this.bufferWidth][this.bufferWidth];
      ArrayDeque var7 = new ArrayDeque<>(this.bufferWidth * this.bufferWidth);

      for (int var8 = this.bufferHeight - 1; var8 >= 0; var8--) {
         int var9 = this.originY - this.halfBufferHeight + var8;

         for (int var10 = 0; var10 < this.bufferWidth; var10++) {
            for (int var11 = 0; var11 < this.bufferWidth; var11++) {
               var6[var10][var11] = false;
               int var12 = var3[var10][var8][var11];
               boolean var13 = var4[var10][var11];
               var4[var10][var11] = false;
               int var14 = var12 != 0 ? var12 : var5[var10][var11];
               var5[var10][var11] = 0;
               if (var14 != 0 || var13) {
                  if (var2[var10][var8][var11] <= 0) {
                     var7.add(new FluidFixOperation.FluidFillEntry(var10, var11, var14));
                     var6[var10][var11] = true;
                  } else {
                     var4[var10][var11] = true;
                     if (var14 != 0) {
                        var5[var10][var11] = var14;
                     }
                  }
               }
            }
         }

         while (!var7.isEmpty()) {
            FluidFixOperation.FluidFillEntry var19 = var7.poll();
            int var20 = var19.bx();
            int var21 = var19.bz();
            int var22 = var19.fluidId();
            var4[var20][var21] = true;
            int var23 = var3[var20][var8][var21];
            if (var23 != 0) {
               var22 = var23;
            } else if (var22 == 0) {
               var22 = this.findNearbyFluid(var3, var20, var8, var21);
            }

            if (var22 != 0) {
               int var15 = this.originX - this.halfBufferWidth + var20;
               int var16 = this.originZ - this.halfBufferWidth + var21;
               Fluid var17 = Fluid.getAssetMap().getAsset(var22);
               byte var18 = (byte)(var17 != null ? var17.getMaxFluidLevel() : 8);
               var1.setMaterial(var15, var9, var16, Material.fluid(var22, var18));
               var3[var20][var8][var21] = var22;
               var5[var20][var21] = var22;
            }

            if (var20 > 0 && !var6[var20 - 1][var21] && var2[var20 - 1][var8][var21] <= 0) {
               var6[var20 - 1][var21] = true;
               var7.add(new FluidFixOperation.FluidFillEntry(var20 - 1, var21, var22));
            }

            if (var20 < this.bufferWidth - 1 && !var6[var20 + 1][var21] && var2[var20 + 1][var8][var21] <= 0) {
               var6[var20 + 1][var21] = true;
               var7.add(new FluidFixOperation.FluidFillEntry(var20 + 1, var21, var22));
            }

            if (var21 > 0 && !var6[var20][var21 - 1] && var2[var20][var8][var21 - 1] <= 0) {
               var6[var20][var21 - 1] = true;
               var7.add(new FluidFixOperation.FluidFillEntry(var20, var21 - 1, var22));
            }

            if (var21 < this.bufferWidth - 1 && !var6[var20][var21 + 1] && var2[var20][var8][var21 + 1] <= 0) {
               var6[var20][var21 + 1] = true;
               var7.add(new FluidFixOperation.FluidFillEntry(var20, var21 + 1, var22));
            }
         }
      }
   }

   class="kw">private int findNearbyFluid(int[][][] var1, int var2, int var3, int var4) {
      if (var3 + 1 < this.bufferHeight) {
         int var5 = var1[var2][var3 + 1][var4];
         if (var5 != 0) {
            class="kw">return var5;
         }
      }

      if (var2 > 0) {
         int var6 = var1[var2 - 1][var3][var4];
         if (var6 != 0) {
            class="kw">return var6;
         }
      }

      if (var2 < this.bufferWidth - 1) {
         int var7 = var1[var2 + 1][var3][var4];
         if (var7 != 0) {
            class="kw">return var7;
         }
      }

      if (var4 > 0) {
         int var8 = var1[var2][var3][var4 - 1];
         if (var8 != 0) {
            class="kw">return var8;
         }
      }

      if (var4 < this.bufferWidth - 1) {
         int var9 = var1[var2][var3][var4 + 1];
         if (var9 != 0) {
            class="kw">return var9;
         }
      }

      if (var3 > 0) {
         int var10 = var1[var2][var3 - 1][var4];
         if (var10 != 0) {
            class="kw">return var10;
         }
      }

      class="kw">return 0;
   }

   class="kw">public enum FluidAction {
      Fill,
      Clear;

      FluidAction() {
      }
   }

   class="kw">private record FluidFillEntry(int bx, int bz, int fluidId) {
      class="kw">private FluidFillEntry {
      }
   }
}