class="kw">package com.hypixel.hytale.server.core.command.commands.debug.component.knockback;

class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.math.vector.Rotation3f;
class="kw">import com.hypixel.hytale.protocol.ChangeVelocityType;
class="kw">import com.hypixel.hytale.protocol.VelocityThresholdStyle;
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.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.AbstractCommandCollection;
class="kw">import com.hypixel.hytale.server.core.command.system.basecommands.AbstractPlayerCommand;
class="kw">import com.hypixel.hytale.server.core.entity.knockback.KnockbackComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.HeadRotation;
class="kw">import com.hypixel.hytale.server.core.modules.splitvelocity.VelocityConfig;
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.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.util.TargetUtil;
class="kw">import java.util.Locale;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;

class="kw">public class KnockbackApplyCommand class="kw">extends AbstractCommandCollection {
   @Nonnull
   class="kw">private class="kw">static class="kw">final Message MESSAGE_COMMANDS_KNOCKBACK_APPLY_SUCCESS = Message.translation("server.commands.knockback.apply.success");
   @Nonnull
   class="kw">private class="kw">static class="kw">final Message MESSAGE_COMMANDS_KNOCKBACK_APPLY_INVALID_DIRECTION = Message.translation("server.commands.knockback.apply.invalidDirection");
   @Nonnull
   class="kw">private class="kw">static class="kw">final Message MESSAGE_COMMANDS_KNOCKBACK_APPLY_INVALID_PRESET = Message.translation("server.commands.knockback.apply.invalidPreset");
   @Nonnull
   class="kw">private class="kw">static class="kw">final Message MESSAGE_GENERAL_NO_ENTITY_IN_VIEW = Message.translation("server.general.noEntityInView");

   class="kw">public KnockbackApplyCommand() {
      super("apply", "server.commands.knockback.apply.desc");
      this.addSubCommand(new KnockbackApplyCommand.KnockbackApplySelfCommand());
      this.addSubCommand(new KnockbackApplyCommand.KnockbackApplyAimedCommand());
   }

   class="kw">private class="kw">static void applyKnockback(
      @Nonnull Ref<EntityStore> var0,
      @Nonnull CommandContext var1,
      @Nonnull Store<EntityStore> var2,
      @Nonnull Ref<EntityStore> var3,
      @Nonnull String var4,
      float var5,
      float var6,
      @Nonnull String var7
   ) {
      KnockbackApplyCommand.HorizontalDirection var8 = parseDirection(var4);
      if (var8 == KnockbackApplyCommand.HorizontalDirection.Invalid) {
         var1.sendMessage(MESSAGE_COMMANDS_KNOCKBACK_APPLY_INVALID_DIRECTION.param("direction", var4).param("values", "left|l, right|r, forward|f, backward|b"));
      } else {
         KnockbackApplyCommand.VelocityConfigPreset var9 = velocityConfigPreset(var7);
         if (var9 == KnockbackApplyCommand.VelocityConfigPreset.Invalid) {
            var1.sendMessage(MESSAGE_COMMANDS_KNOCKBACK_APPLY_INVALID_PRESET.param("preset", var7).param("values", "null, linear, exp, def"));
         } else {
            Vector3d var10 = computeVelocity(var8, var5, var6, var3, var2);
            KnockbackComponent var11 = var2.ensureAndGetComponent(var0, KnockbackComponent.getComponentType());
            var11.setVelocity(var10);
            var11.setVelocityType(ChangeVelocityType.Set);
            var11.setVelocityConfig(toVelocityConfig(var9));
            var11.setDuration(0.0F);
            var11.setTimer(0.0F);
            var1.sendMessage(
               MESSAGE_COMMANDS_KNOCKBACK_APPLY_SUCCESS.param("force", var6)
                  .param("y", var5)
                  .param("direction", var8.name().toLowerCase(Locale.ROOT))
                  .param("preset", var9.name().toLowerCase(Locale.ROOT))
            );
         }
      }
   }

   @Nonnull
   class="kw">private class="kw">static Vector3d computeVelocity(
      @Nonnull KnockbackApplyCommand.HorizontalDirection var0, float var1, float var2, @Nonnull Ref<EntityStore> var3, @Nonnull Store<EntityStore> var4
   ) {
      HeadRotation var5 = var4.getComponent(var3, HeadRotation.getComponentType());
      float var6 = var5 == null ? Rotation3f.IDENTITY.yaw() : var5.getRotation().yaw();
      Vector3d var7 = new Vector3d(0.0, 0.0, -1.0).rotateY(var6);

      Vector3d var8 = class="kw">switch (var0) {
         case Left -> new Vector3d(var7.z, 0.0, -var7.x);
         case Right -> new Vector3d(-var7.z, 0.0, var7.x);
         case Forward, Invalid -> var7;
         case Backward -> var7.negate();
      };
      var8.normalize().mul(var2);
      class="kw">return new Vector3d(var8.x, var1, var8.z);
   }

   @Nonnull
   class="kw">private class="kw">static KnockbackApplyCommand.HorizontalDirection parseDirection(@Nonnull String var0) {
      class="kw">return class="kw">switch (var0.toLowerCase(Locale.ROOT)) {
         case "left", "l" -> KnockbackApplyCommand.HorizontalDirection.Left;
         case "right", "r" -> KnockbackApplyCommand.HorizontalDirection.Right;
         case "forward", "f" -> KnockbackApplyCommand.HorizontalDirection.Forward;
         case "backward", "b" -> KnockbackApplyCommand.HorizontalDirection.Backward;
         class="kw">default -> KnockbackApplyCommand.HorizontalDirection.Invalid;
      };
   }

   @Nonnull
   class="kw">private class="kw">static KnockbackApplyCommand.VelocityConfigPreset velocityConfigPreset(@Nonnull String var0) {
      class="kw">return class="kw">switch (var0.toLowerCase(Locale.ROOT)) {
         case "null" -> KnockbackApplyCommand.VelocityConfigPreset.Null;
         case "linear" -> KnockbackApplyCommand.VelocityConfigPreset.Linear;
         case "exp" -> KnockbackApplyCommand.VelocityConfigPreset.Exp;
         case "def" -> KnockbackApplyCommand.VelocityConfigPreset.Def;
         class="kw">default -> KnockbackApplyCommand.VelocityConfigPreset.Invalid;
      };
   }

   @Nullable
   class="kw">private class="kw">static VelocityConfig toVelocityConfig(@Nonnull KnockbackApplyCommand.VelocityConfigPreset var0) {
      class="kw">return class="kw">switch (var0) {
         case Null -> null;
         case Linear -> createVelocityConfig(0.99F, 0.98F, 0.94F, 0.3F, 3.0F, VelocityThresholdStyle.Linear);
         case Exp -> createVelocityConfig(0.97F, 0.96F, 0.94F, 0.3F, 3.0F, VelocityThresholdStyle.Exp);
         case Def -> createVelocityConfig(0.96F, 0.0F, 0.82F, 0.0F, 1.0F, VelocityThresholdStyle.Linear);
         case Invalid -> null;
      };
   }

   @Nonnull
   class="kw">private class="kw">static VelocityConfig createVelocityConfig(float var0, float var1, float var2, float var3, float var4, @Nonnull VelocityThresholdStyle var5) {
      VelocityConfig var6 = new VelocityConfig();
      var6.setAirResistance(var0);
      var6.setAirResistanceMax(var1);
      var6.setGroundResistance(var2);
      var6.setGroundResistanceMax(var3);
      var6.setThreshold(var4);
      var6.setStyle(var5);
      class="kw">return var6;
   }

   class="kw">private enum HorizontalDirection {
      Left,
      Right,
      Forward,
      Backward,
      Invalid;

      HorizontalDirection() {
      }
   }

   class="kw">public class="kw">static class KnockbackApplyAimedCommand class="kw">extends AbstractPlayerCommand {
      @Nonnull
      class="kw">private class="kw">final RequiredArg<String> directionArg = this.withRequiredArg("direction", "server.commands.knockback.apply.direction.desc", ArgTypes.STRING);
      @Nonnull
      class="kw">private class="kw">final RequiredArg<Float> yArg = this.withRequiredArg("y", "server.commands.knockback.apply.y.desc", ArgTypes.FLOAT);
      @Nonnull
      class="kw">private class="kw">final RequiredArg<Float> forceArg = this.withRequiredArg("force", "server.commands.knockback.apply.force.desc", ArgTypes.FLOAT);
      @Nonnull
      class="kw">private class="kw">final RequiredArg<String> presetArg = this.withRequiredArg("preset", "server.commands.knockback.apply.preset.desc", ArgTypes.STRING);

      class="kw">public KnockbackApplyAimedCommand() {
         super("aimed", "server.commands.knockback.apply.aimed.desc");
      }

      @Override
      class="kw">protected void execute(
         @Nonnull CommandContext var1, @Nonnull Store<EntityStore> var2, @Nonnull Ref<EntityStore> var3, @Nonnull PlayerRef var4, @Nonnull World var5
      ) {
         Ref var6 = TargetUtil.getTargetEntity(var3, var2);
         if (var6 != null && var6.isValid()) {
            KnockbackApplyCommand.applyKnockback(
               var6, var1, var2, var3, this.directionArg.get(var1), this.yArg.get(var1), this.forceArg.get(var1), this.presetArg.get(var1)
            );
         } else {
            var1.sendMessage(KnockbackApplyCommand.MESSAGE_GENERAL_NO_ENTITY_IN_VIEW);
         }
      }
   }

   class="kw">public class="kw">static class KnockbackApplySelfCommand class="kw">extends AbstractPlayerCommand {
      @Nonnull
      class="kw">private class="kw">final RequiredArg<String> directionArg = this.withRequiredArg("direction", "server.commands.knockback.apply.direction.desc", ArgTypes.STRING);
      @Nonnull
      class="kw">private class="kw">final RequiredArg<Float> yArg = this.withRequiredArg("y", "server.commands.knockback.apply.y.desc", ArgTypes.FLOAT);
      @Nonnull
      class="kw">private class="kw">final RequiredArg<Float> forceArg = this.withRequiredArg("force", "server.commands.knockback.apply.force.desc", ArgTypes.FLOAT);
      @Nonnull
      class="kw">private class="kw">final RequiredArg<String> presetArg = this.withRequiredArg("preset", "server.commands.knockback.apply.preset.desc", ArgTypes.STRING);

      class="kw">public KnockbackApplySelfCommand() {
         super("self", "server.commands.knockback.apply.self.desc");
      }

      @Override
      class="kw">protected void execute(
         @Nonnull CommandContext var1, @Nonnull Store<EntityStore> var2, @Nonnull Ref<EntityStore> var3, @Nonnull PlayerRef var4, @Nonnull World var5
      ) {
         KnockbackApplyCommand.applyKnockback(
            var3, var1, var2, var3, this.directionArg.get(var1), this.yArg.get(var1), this.forceArg.get(var1), this.presetArg.get(var1)
         );
      }
   }

   class="kw">private enum VelocityConfigPreset {
      Null,
      Linear,
      Exp,
      Def,
      Invalid;

      VelocityConfigPreset() {
      }
   }
}