class="kw">package com.hypixel.hytale.server.core.command.commands.utility.net;

class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.protocol.NetworkChannel;
class="kw">import com.hypixel.hytale.protocol.io.ChannelConnection;
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.AbstractTargetPlayerCommand;
class="kw">import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
class="kw">import com.hypixel.hytale.server.core.entity.knockback.KnockbackSystems;
class="kw">import com.hypixel.hytale.server.core.io.PacketHandler;
class="kw">import com.hypixel.hytale.server.core.io.netty.LatencySimulationHandler;
class="kw">import com.hypixel.hytale.server.core.io.netty.NettyUtil;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.KnockbackPredictionSystems;
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 io.netty.channel.Channel;
class="kw">import io.netty.handler.codec.quic.QuicStreamPriority;
class="kw">import java.util.Locale;
class="kw">import java.util.Map;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.concurrent.TimeUnit;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class NetworkCommand class="kw">extends AbstractCommandCollection {
   class="kw">public NetworkCommand() {
      super("network", "server.commands.network.desc");
      this.addAliases("net");
      this.addSubCommand(new NetworkCommand.LatencySimulationCommand());
      this.addSubCommand(new NetworkCommand.StreamPriorityCommand());
      this.addSubCommand(new NetworkCommand.ServerKnockbackCommand());
      this.addSubCommand(new NetworkCommand.DebugKnockbackCommand());
   }

   class="kw">static class DebugKnockbackCommand class="kw">extends CommandBase {
      DebugKnockbackCommand() {
         super("debugknockback", "server.commands.network.debugknockback.desc");
      }

      @Override
      class="kw">protected void executeSync(@Nonnull CommandContext var1) {
         KnockbackPredictionSystems.DEBUG_KNOCKBACK_POSITION = !KnockbackPredictionSystems.DEBUG_KNOCKBACK_POSITION;
         var1.sendMessage(
            Message.translation("server.commands.network.knockbackDebugEnabled").param("enabled", KnockbackPredictionSystems.DEBUG_KNOCKBACK_POSITION)
         );
      }
   }

   class="kw">public class="kw">static class LatencySimulationCommand class="kw">extends AbstractCommandCollection {
      class="kw">public LatencySimulationCommand() {
         super("latencysimulation", "server.commands.latencySimulation.desc");
         this.addAliases("latsim");
         this.addSubCommand(new NetworkCommand.LatencySimulationCommand.Set());
         this.addSubCommand(new NetworkCommand.LatencySimulationCommand.Reset());
      }

      class="kw">static class Reset class="kw">extends AbstractTargetPlayerCommand {
         @Nonnull
         class="kw">private class="kw">static class="kw">final Message MESSAGE_COMMANDS_LATENCY_SIMULATION_RESET_SUCCESS = Message.translation("server.commands.latencySimulation.reset.success");

         Reset() {
            super("reset", "server.commands.latencySimulation.reset.desc");
            this.addAliases("clear");
         }

         @Override
         class="kw">protected void execute(
            @Nonnull CommandContext var1,
            @Nullable Ref<EntityStore> var2,
            @Nonnull Ref<EntityStore> var3,
            @Nonnull PlayerRef var4,
            @Nonnull World var5,
            @Nonnull Store<EntityStore> var6
         ) {
            if (var4.getPacketHandler().getChannel() class="kw">instanceof NettyUtil.NettyChannelConnection(Channel var8)) {
               LatencySimulationHandler.setLatency(var8, 0L, TimeUnit.MILLISECONDS);
               var1.sendMessage(MESSAGE_COMMANDS_LATENCY_SIMULATION_RESET_SUCCESS);
            } else {
               var1.sendMessage(Message.translation("server.commands.latencySimulation.unsupported"));
            }
         }
      }

      class="kw">static class Set class="kw">extends AbstractTargetPlayerCommand {
         @Nonnull
         class="kw">private class="kw">final RequiredArg<Integer> delayArg = this.withRequiredArg("delay", "server.commands.latencySimulation.set.delay.desc", ArgTypes.INTEGER);

         Set() {
            super("set", "server.commands.latencySimulation.set.desc");
         }

         @Override
         class="kw">protected void execute(
            @Nonnull CommandContext var1,
            @Nullable Ref<EntityStore> var2,
            @Nonnull Ref<EntityStore> var3,
            @Nonnull PlayerRef var4,
            @Nonnull World var5,
            @Nonnull Store<EntityStore> var6
         ) {
            int var7 = this.delayArg.get(var1);
            if (var4.getPacketHandler().getChannel() class="kw">instanceof NettyUtil.NettyChannelConnection(Channel var9)) {
               LatencySimulationHandler.setLatency(var9, var7, TimeUnit.MILLISECONDS);
               var1.sendMessage(Message.translation("server.commands.latencySimulation.set.success").param("millis", var7));
            } else {
               var1.sendMessage(Message.translation("server.commands.latencySimulation.unsupported"));
            }
         }
      }
   }

   class="kw">static class ServerKnockbackCommand class="kw">extends CommandBase {
      ServerKnockbackCommand() {
         super("serverknockback", "server.commands.network.serverknockback.desc");
      }

      @Override
      class="kw">protected void executeSync(@Nonnull CommandContext var1) {
         KnockbackSystems.ApplyPlayerKnockback.DO_SERVER_PREDICTION = !KnockbackSystems.ApplyPlayerKnockback.DO_SERVER_PREDICTION;
         var1.sendMessage(
            Message.translation("server.commands.network.knockbackServerPredictionEnabled")
               .param("enabled", KnockbackSystems.ApplyPlayerKnockback.DO_SERVER_PREDICTION)
         );
      }
   }

   class="kw">public class="kw">static class StreamPriorityCommand class="kw">extends AbstractCommandCollection {
      class="kw">private class="kw">static class="kw">final Map<String, Map<NetworkChannel, QuicStreamPriority>> PRESETS = Map.of(
         "class="kw">default",
         PacketHandler.DEFAULT_STREAM_PRIORITIES,
         "equal",
         priority(0, 0, 0),
         "tiered",
         priority(0, 1, 2),
         "maplow",
         priority(0, 0, 1),
         "datalow",
         priority(0, 1, 1),
         "chunkshi",
         priority(1, 0, 2),
         "maphi",
         priority(1, 2, 0)
      );

      class="kw">public StreamPriorityCommand() {
         super("streampriority", "server.commands.network.streamPriority.desc");
         this.addAliases("sp");
         this.addSubCommand(new NetworkCommand.StreamPriorityCommand.Set());
         this.addSubCommand(new NetworkCommand.StreamPriorityCommand.Preset());
         this.addSubCommand(new NetworkCommand.StreamPriorityCommand.Reset());
      }

      class="kw">private class="kw">static void applyPriorities(@Nonnull PlayerRef var0, @Nonnull Map<NetworkChannel, QuicStreamPriority> var1) {
         PacketHandler var2 = var0.getPacketHandler();

         for (Entry var4 : var1.entrySet()) {
            ChannelConnection var5 = var2.getChannel(var4.getKey());
            QuicStreamPriority var6 = var4.getValue();
            var5.updateStreamPriority(var6.urgency(), var6.isIncremental());
         }
      }

      class="kw">private class="kw">static String formatPriorities(@Nonnull Map<NetworkChannel, QuicStreamPriority> var0) {
         StringBuilder var1 = new StringBuilder();

         for (NetworkChannel var5 : NetworkChannel.VALUES) {
            QuicStreamPriority var6 = var0.get(var5);
            if (var6 != null) {
               if (!var1.isEmpty()) {
                  var1.append(", ");
               }

               var1.append(var5.name()).append('=').append(var6.urgency());
            }
         }

         class="kw">return var1.toString();
      }

      class="kw">private class="kw">static Map<NetworkChannel, QuicStreamPriority> priority(int var0, int var1, int var2) {
         class="kw">return Map.of(
            NetworkChannel.Default,
            new QuicStreamPriority(var0, true),
            NetworkChannel.Chunks,
            new QuicStreamPriority(var1, true),
            NetworkChannel.WorldMap,
            new QuicStreamPriority(var2, true)
         );
      }

      class="kw">static class Preset class="kw">extends AbstractTargetPlayerCommand {
         @Nonnull
         class="kw">private class="kw">final RequiredArg<String> presetArg = this.withRequiredArg(
            "preset", "server.commands.network.streamPriority.preset.name.desc", ArgTypes.STRING
         );

         Preset() {
            super("preset", "server.commands.network.streamPriority.preset.desc");
         }

         @Override
         class="kw">protected void execute(
            @Nonnull CommandContext var1,
            @Nullable Ref<EntityStore> var2,
            @Nonnull Ref<EntityStore> var3,
            @Nonnull PlayerRef var4,
            @Nonnull World var5,
            @Nonnull Store<EntityStore> var6
         ) {
            String var7 = this.presetArg.get(var1).toLowerCase(Locale.ROOT);
            Map var8 = NetworkCommand.StreamPriorityCommand.PRESETS.get(var7);
            if (var8 == null) {
               var1.sendMessage(
                  Message.translation("server.commands.network.streamPriority.preset.unknown")
                     .param("name", var7)
                     .param("presets", String.join(", ", NetworkCommand.StreamPriorityCommand.PRESETS.keySet()))
               );
            } else {
               NetworkCommand.StreamPriorityCommand.applyPriorities(var4, var8);
               var1.sendMessage(
                  Message.translation("server.commands.network.streamPriority.preset.success")
                     .param("name", var7)
                     .param("priorities", NetworkCommand.StreamPriorityCommand.formatPriorities(var8))
               );
            }
         }
      }

      class="kw">static class Reset class="kw">extends AbstractTargetPlayerCommand {
         Reset() {
            super("reset", "server.commands.network.streamPriority.reset.desc");
         }

         @Override
         class="kw">protected void execute(
            @Nonnull CommandContext var1,
            @Nullable Ref<EntityStore> var2,
            @Nonnull Ref<EntityStore> var3,
            @Nonnull PlayerRef var4,
            @Nonnull World var5,
            @Nonnull Store<EntityStore> var6
         ) {
            NetworkCommand.StreamPriorityCommand.applyPriorities(var4, PacketHandler.DEFAULT_STREAM_PRIORITIES);
            var1.sendMessage(
               Message.translation("server.commands.network.streamPriority.reset.success")
                  .param("priorities", NetworkCommand.StreamPriorityCommand.formatPriorities(PacketHandler.DEFAULT_STREAM_PRIORITIES))
            );
         }
      }

      class="kw">static class Set class="kw">extends AbstractTargetPlayerCommand {
         @Nonnull
         class="kw">private class="kw">final RequiredArg<NetworkChannel> channelArg = this.withRequiredArg(
            "channel",
            "server.commands.network.streamPriority.set.channel.desc",
            ArgTypes.forEnum("server.commands.network.streamPriority.channel", NetworkChannel.class)
         );
         @Nonnull
         class="kw">private class="kw">final RequiredArg<Integer> priorityArg = this.withRequiredArg(
            "priority", "server.commands.network.streamPriority.set.priority.desc", ArgTypes.INTEGER
         );

         Set() {
            super("set", "server.commands.network.streamPriority.set.desc");
         }

         @Override
         class="kw">protected void execute(
            @Nonnull CommandContext var1,
            @Nullable Ref<EntityStore> var2,
            @Nonnull Ref<EntityStore> var3,
            @Nonnull PlayerRef var4,
            @Nonnull World var5,
            @Nonnull Store<EntityStore> var6
         ) {
            NetworkChannel var7 = this.channelArg.get(var1);
            int var8 = this.priorityArg.get(var1);
            if (var8 >= 0 && var8 <= 127) {
               ChannelConnection var9 = var4.getPacketHandler().getChannel(var7);
               var9.updateStreamPriority(var8, true);
               var1.sendMessage(Message.translation("server.commands.network.streamPriority.set.success").param("channel", var7.name()).param("priority", var8));
            } else {
               var1.sendMessage(Message.translation("server.commands.network.streamPriority.set.invalidPriority"));
            }
         }
      }
   }
}