class="kw">package com.hypixel.hytale.server.core.command.commands.world.chunk;

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.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.util.MathUtil;
class="kw">import com.hypixel.hytale.protocol.packets.interface_.CustomPageLifetime;
class="kw">import com.hypixel.hytale.protocol.packets.interface_.CustomUIEventBindingType;
class="kw">import com.hypixel.hytale.server.core.Message;
class="kw">import com.hypixel.hytale.server.core.command.system.CommandContext;
class="kw">import com.hypixel.hytale.server.core.command.system.CommandManager;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.system.DefaultArg;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.system.FlagArg;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.system.RequiredArg;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.types.ArgTypes;
class="kw">import com.hypixel.hytale.server.core.command.system.basecommands.AbstractPlayerCommand;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.pages.InteractiveCustomUIPage;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.ui.builder.EventData;
class="kw">import com.hypixel.hytale.server.core.ui.builder.UICommandBuilder;
class="kw">import com.hypixel.hytale.server.core.ui.builder.UIEventBuilder;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.AbstractCachedAccessor;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.BlockChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.CachedAccessor;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import it.unimi.dsi.fastutil.longs.Long2IntOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
class="kw">import it.unimi.dsi.fastutil.longs.Long2IntMap.Entry;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.joml.Vector3d;

class="kw">public class ChunkTintCommand class="kw">extends AbstractPlayerCommand {
   class="kw">private class="kw">static class="kw">final int BLUR_RADIUS = 5;
   class="kw">private class="kw">static class="kw">final double BLUR_SIGMA = 1.5;
   class="kw">private class="kw">static class="kw">final AbstractCachedAccessor.Registry REGISTRY = new AbstractCachedAccessor.Registry();
   class="kw">private class="kw">static class="kw">final AbstractCachedAccessor.Key<BlockChunk> BLOCK_CHUNK = REGISTRY.forColumn(BlockChunk::getComponentType);
   class="kw">private class="kw">static class="kw">final AbstractCachedAccessor.InitFunction ACCESSOR = REGISTRY.oneShot();
   @Nonnull
   class="kw">private class="kw">final RequiredArg<Integer> colorArg = this.withRequiredArg("color", "server.commands.chunk.tint.color.desc", ArgTypes.COLOR);
   @Nonnull
   class="kw">private class="kw">final DefaultArg<Integer> radiusArg = this.withDefaultArg(
         "radius", "server.commands.chunk.tint.radius.desc", ArgTypes.INTEGER, 5, "server.commands.chunk.tint.radius.class="kw">default"
      )
      .addValidator(Validators.greaterThan(0));
   @Nonnull
   class="kw">private class="kw">final DefaultArg<Double> sigmaArg = this.withDefaultArg(
         "sigma", "server.commands.chunk.tint.sigma.desc", ArgTypes.DOUBLE, 1.5, "server.commands.chunk.tint.sigma.class="kw">default"
      )
      .addValidator(Validators.greaterThan(0.0));
   @Nonnull
   class="kw">private class="kw">final FlagArg blurArg = this.withFlagArg("blur", "server.commands.chunk.tint.blur.desc");

   class="kw">public ChunkTintCommand() {
      super("tint", "server.commands.chunk.tint.desc");
      this.setPermissionGroups("hytale:WorldEditor");
      this.addUsageVariant(new ChunkTintCommand.TintChunkPageCommand());
   }

   @Override
   class="kw">protected void execute(
      @Nonnull CommandContext var1, @Nonnull Store<EntityStore> var2, @Nonnull Ref<EntityStore> var3, @Nonnull PlayerRef var4, @Nonnull World var5
   ) {
      int var6 = this.colorArg.get(var1);
      TransformComponent var7 = var2.getComponent(var3, TransformComponent.getComponentType());
      assert var7 != null;
      Vector3d var8 = var7.getPosition();
      int var9 = MathUtil.floor(var8.x()) >> 5;
      int var10 = MathUtil.floor(var8.z()) >> 5;
      ChunkStore var11 = var5.getChunkStore();
      Store var12 = var11.getStore();
      LongOpenHashSet var13 = new LongOpenHashSet();
      int var14 = 0;
      double var15 = 0.0;
      long var17 = ChunkUtil.indexChunk(var9, var10);
      Ref var19 = var11.getChunkReference(var17);
      if (var19 != null && var19.isValid()) {
         BlockChunk var20 = var12.getComponent(var19, BlockChunk.getComponentType());
         if (var20 != null) {
            for (int var21 = 0; var21 < 32; var21++) {
               for (int var22 = 0; var22 < 32; var22++) {
                  var20.setTint(var21, var22, var6);
               }
            }

            var13.add(var17);
         }

         if (this.blurArg.provided(var1)) {
            var14 = this.radiusArg.get(var1);
            var15 = this.sigmaArg.get(var1);
            double[] var32 = gaussianMatrix(var15, var14);
            int var18 = var9 << 5;
            int var33 = var10 << 5;
            Long2IntOpenHashMap var34 = new Long2IntOpenHashMap();
            CachedAccessor var35 = ACCESSOR.get(var12, var9, 0, var10, 32 + var14 * 2, 1, 32 + var14 * 2);

            for (int var36 = -var14; var36 <= 32 + var14; var36++) {
               for (int var23 = -var14; var23 <= 32 + var14; var23++) {
                  int var24 = var18 + var36;
                  int var25 = var33 + var23;
                  int var26 = blur(var35, var14, var32, var24, var25);
                  var34.put(MathUtil.packLong(var24, var25), var26);
               }
            }

            ObjectIterator var37 = var34.long2IntEntrySet().iterator();

            while (var37.hasNext()) {
               Entry var38 = (Entry)var37.next();
               long var39 = var38.getLongKey();
               int var40 = MathUtil.unpackLeft(var39);
               int var27 = MathUtil.unpackRight(var39);
               Ref chunkRefx = var35.getColumnAtBlock(var40, var27);
               if (chunkRefx != null && chunkRefx.isValid()) {
                  BlockChunk blockChunkx = var35.getComponentColumnAtBlock(var40, var27, BLOCK_CHUNK);
                  if (blockChunkx != null) {
                     blockChunkx.setTint(var40, var27, var38.getIntValue());
                     long chunkIndexx = ChunkUtil.indexChunkFromBlock(var40, var27);
                     var13.add(chunkIndexx);
                  }
               }
            }
         }

         var13.forEach(var1x -> var5.getNotificationHandler().updateChunkTints(var1x));
         if (this.blurArg.provided(var1)) {
            var1.sendMessage(
               Message.translation("server.commands.chunk.tint.success.blur")
                  .param("chunkX", var9)
                  .param("chunkZ", var10)
                  .param("chunksAffected", var13.size())
                  .param("radius", var14)
                  .param("sigma", var15)
            );
         } else {
            var1.sendMessage(Message.translation("server.commands.chunk.tint.success").param("chunkX", var9).param("chunkZ", var10));
         }
      } else {
         var1.sendMessage(Message.translation("server.general.chunkNotLoaded").param("chunkX", var9).param("chunkZ", var10));
      }
   }

   class="kw">private class="kw">static int blur(@Nonnull CachedAccessor var0, int var1, double[] var2, int var3, int var4) {
      double var5 = 0.0;
      double var7 = 0.0;
      double var9 = 0.0;

      for (int var11 = -var1; var11 <= var1; var11++) {
         for (int var12 = -var1; var12 <= var1; var12++) {
            double var13 = var2[gaussianIndex(var1, var11, var12)];
            int var15 = var3 + var11;
            int var16 = var4 + var12;
            BlockChunk var17 = var0.getComponentColumnAtBlock(var15, var16, BLOCK_CHUNK);
            if (var17 != null) {
               int var18 = var17.getTint(var15, var16);
               var5 += (var18 >> 16 & 0xFF) * var13;
               var7 += (var18 >> 8 & 0xFF) * var13;
               var9 += (var18 & 0xFF) * var13;
            }
         }
      }

      class="kw">return 0xFF000000 | MathUtil.floor(var5) << 16 | MathUtil.floor(var7) << 8 | MathUtil.floor(var9);
   }

   class="kw">private class="kw">static double gaussian2d(double var0, double var2, double var4) {
      class="kw">return 1.0 / ((Math.PI * 2) * var0 * var0) * Math.pow(Math.E, -(var2 * var2 + var4 * var4) / (2.0 * var0 * var0));
   }

   class="kw">private class="kw">static double[] gaussianMatrix(double var0, int var2) {
      int var3 = 2 * var2 + 1;
      double[] var4 = new double[var3 * var3];

      for (int var5 = -var2; var5 <= var2; var5++) {
         for (int var6 = -var2; var6 <= var2; var6++) {
            double var7 = gaussian2d(var0, var5, var6);
            var4[gaussianIndex(var2, var5, var6)] = var7;
         }
      }

      double var12 = 0.0;

      for (double var10 : var4) {
         var12 += var10;
      }

      for (int var14 = 0; var14 < var4.length; var14++) {
         var4[var14] /= var12;
      }

      class="kw">return var4;
   }

   class="kw">private class="kw">static int gaussianIndex(int var0, int var1, int var2) {
      var1 += var0;
      var2 += var0;
      class="kw">return var1 * (2 * var0 + 1) + var2;
   }

   class="kw">public class="kw">static class TintChunkPage class="kw">extends InteractiveCustomUIPage<ChunkTintCommand.TintChunkPage.TintChunkPageEventData> {
      TintChunkPage(@Nonnull PlayerRef var1) {
         super(var1, CustomPageLifetime.CanDismiss, ChunkTintCommand.TintChunkPage.TintChunkPageEventData.CODEC);
      }

      @Override
      class="kw">public void build(@Nonnull Ref<EntityStore> var1, @Nonnull UICommandBuilder var2, @Nonnull UIEventBuilder var3, @Nonnull Store<EntityStore> var4) {
         var2.append("Pages/TintChunkPage.ui");
         var3.addEventBinding(
            CustomUIEventBindingType.ValueChanged,
            "#ColorPicker",
            new EventData().append("@Color", "#ColorPicker.Value").append("Submit", ChunkTintCommand.TintChunkPage.TintChunkPageAction.ColorChanged.name()),
            false
         );
         var3.addEventBinding(
            CustomUIEventBindingType.Activating,
            "#ApplyButton",
            new EventData()
               .append("@Color", "#ColorPicker.Value")
               .append("@Radius", "#Radius.Value")
               .append("@BlurEnabled", "#BlurEnabledContainer #CheckBox.Value")
               .append("@Sigma", "#Sigma.Value")
               .append("@HexColor", "#HexColor.Value")
               .append("Submit", ChunkTintCommand.TintChunkPage.TintChunkPageAction.Submit.name()),
            false
         );
      }

      class="kw">public void handleDataEvent(
         @Nonnull Ref<EntityStore> var1, @Nonnull Store<EntityStore> var2, @Nonnull ChunkTintCommand.TintChunkPage.TintChunkPageEventData var3
      ) {
         class="kw">switch (var3.getAction()) {
            case Submit: {
               String var7 = var3.getColor().substring(0, 7);
               int var8 = var3.getRadius();
               int var6 = var3.getSigma();
               if (!var3.getKeyHexColor().isEmpty()) {
                  var7 = var3.getKeyHexColor();
                  if (!var7.startsWith("#")) {
                     var7 = "#" + var7;
                  }
               }

               if (var3.isBlurEnabled()) {
                  CommandManager.get().handleCommand(this.playerRef, "chunk tint " + var7 + " --blur --radius=" + var8 + " --sigma=" + var6);
               } else {
                  CommandManager.get().handleCommand(this.playerRef, "chunk tint " + var7);
               }
               break;
            }
            case ColorChanged: {
               String var4 = var3.getColor().substring(0, 7);
               UICommandBuilder var5 = new UICommandBuilder();
               var5.set("#HexColor.Value", var4);
               this.sendUpdate(var5);
            }
         }
      }

      class="kw">public enum TintChunkPageAction {
         Submit,
         ColorChanged;

         TintChunkPageAction() {
         }
      }

      class="kw">public class="kw">static class TintChunkPageEventData {
         class="kw">public class="kw">static class="kw">final String KEY_COLOR = "@Color";
         class="kw">public class="kw">static class="kw">final String KEY_RADIUS = "@Radius";
         class="kw">public class="kw">static class="kw">final String KEY_SIGMA = "@Sigma";
         class="kw">public class="kw">static class="kw">final String KEY_BLUR_ENABLED = "@BlurEnabled";
         class="kw">public class="kw">static class="kw">final String KEY_HEX_COLOR = "@HexColor";
         class="kw">public class="kw">static class="kw">final String KEY_ACTION = "Submit";
         @Nonnull
         class="kw">public class="kw">static class="kw">final BuilderCodec<ChunkTintCommand.TintChunkPage.TintChunkPageEventData> CODEC = BuilderCodec.builder(
               ChunkTintCommand.TintChunkPage.TintChunkPageEventData.class, ChunkTintCommand.TintChunkPage.TintChunkPageEventData::new
            )
            .addField(new KeyedCodec<>("@Color", Codec.STRING), (var0, var1) -> var0.color = var1, var0 -> var0.color)
            .addField(new KeyedCodec<>("@Radius", Codec.INTEGER), (var0, var1) -> var0.radius = var1, var0 -> var0.radius)
            .addField(new KeyedCodec<>("@Sigma", Codec.INTEGER), (var0, var1) -> var0.sigma = var1, var0 -> var0.sigma)
            .addField(new KeyedCodec<>("@BlurEnabled", Codec.BOOLEAN), (var0, var1) -> var0.isBlurEnabled = var1, var0 -> var0.isBlurEnabled)
            .addField(new KeyedCodec<>("@HexColor", Codec.STRING), (var0, var1) -> var0.hexColor = var1, var0 -> var0.hexColor)
            .addField(
               new KeyedCodec<>("Submit", new EnumCodec<>(ChunkTintCommand.TintChunkPage.TintChunkPageAction.class)),
               (var0, var1) -> var0.action = var1,
               var0 -> var0.action
            )
            .build();
         class="kw">private String color;
         class="kw">private int radius;
         class="kw">private int sigma;
         class="kw">private String hexColor;
         class="kw">private boolean isBlurEnabled;
         class="kw">private ChunkTintCommand.TintChunkPage.TintChunkPageAction action;

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

         class="kw">public String getColor() {
            class="kw">return this.color;
         }

         class="kw">public int getRadius() {
            class="kw">return this.radius;
         }

         class="kw">public int getSigma() {
            class="kw">return this.sigma;
         }

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

         class="kw">public String getKeyHexColor() {
            class="kw">return this.hexColor;
         }

         class="kw">public ChunkTintCommand.TintChunkPage.TintChunkPageAction getAction() {
            class="kw">return this.action;
         }
      }
   }

   class="kw">static class TintChunkPageCommand class="kw">extends AbstractPlayerCommand {
      TintChunkPageCommand() {
         super("server.commands.chunk.tint.get");
      }

      @Override
      class="kw">protected void execute(
         @Nonnull CommandContext var1, @Nonnull Store<EntityStore> var2, @Nonnull Ref<EntityStore> var3, @Nonnull PlayerRef var4, @Nonnull World var5
      ) {
         Player var6 = var2.getComponent(var3, Player.getComponentType());
         assert var6 != null;
         var6.getPageManager().openCustomPage(var3, var2, new ChunkTintCommand.TintChunkPage(var4));
      }
   }
}