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

class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.math.shape.Box2D;
class="kw">import com.hypixel.hytale.protocol.GameMode;
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.arguments.types.ArgumentType;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.types.EnumArgumentType;
class="kw">import com.hypixel.hytale.server.core.command.system.basecommands.AbstractCommandCollection;
class="kw">import com.hypixel.hytale.server.core.command.system.basecommands.AbstractWorldCommand;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.WorldConfig;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.provider.IChunkStorageProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.provider.IWorldGenProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldmap.provider.IWorldMapProvider;
class="kw">import java.util.HashSet;
class="kw">import java.util.Objects;
class="kw">import java.util.Set;
class="kw">import java.util.function.BiConsumer;
class="kw">import java.util.function.Function;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.joml.Vector2d;

class="kw">public class WorldSettingsCommand class="kw">extends AbstractCommandCollection {
   @Nonnull
   class="kw">private class="kw">final WorldConfig defaultWorldConfig = new WorldConfig();

   class="kw">public WorldSettingsCommand() {
      super("settings", "server.commands.world.settings.desc");
      this.addAliases("ws");
      this.generateSubCommand(
         "worldgentype",
         "server.commands.world.settings.worldgentype.desc",
         "type",
         ArgTypes.WORLD_GEN_PROVIDER_KEY,
         "server.commands.world.settings.worldgentype.name",
         var0 -> IWorldGenProvider.CODEC.getIdFor((Class<? class="kw">extends IWorldGenProvider>)var0.getWorldGenProvider().getClass()),
         (var0, var1) -> var0.setWorldGenProvider(IWorldGenProvider.CODEC.getCodecFor(var1).getDefaultValue())
      );
      this.generateSubCommand(
         "worldmaptype",
         "server.commands.world.settings.worldmaptype.desc",
         "type",
         ArgTypes.WORLD_MAP_PROVIDER_KEY,
         "server.commands.world.settings.worldmaptype.name",
         var0 -> IWorldMapProvider.CODEC.getIdFor((Class<? class="kw">extends IWorldMapProvider>)var0.getWorldMapProvider().getClass()),
         (var0, var1) -> var0.setWorldMapProvider(IWorldMapProvider.CODEC.getCodecFor(var1).getDefaultValue())
      );
      this.generateSubCommand(
         "chunkstoragetype",
         "server.commands.world.settings.chunkstoragetype.desc",
         "type",
         ArgTypes.CHUNK_STORAGE_PROVIDER_KEY,
         "server.commands.world.settings.chunkstoragetype.name",
         var0 -> IChunkStorageProvider.CODEC.getIdFor((Class<? class="kw">extends IChunkStorageProvider<?>>)var0.getChunkStorageProvider().getClass()),
         (var0, var1) -> var0.setChunkStorageProvider((IChunkStorageProvider<?>)IChunkStorageProvider.CODEC.getCodecFor(var1).getDefaultValue())
      );
      this.generateSubCommand(
         "ticking",
         "server.commands.world.settings.ticking.desc",
         "ticking",
         ArgTypes.BOOLEAN,
         "server.commands.world.settings.ticking.name",
         WorldConfig::isTicking,
         WorldConfig::setTicking
      );
      this.generateSubCommand(
         "blockticking",
         "server.commands.world.settings.blockticking.desc",
         "blockticking",
         ArgTypes.BOOLEAN,
         "server.commands.world.settings.blockticking.name",
         WorldConfig::isBlockTicking,
         WorldConfig::setBlockTicking
      );
      this.generateSubCommand(
         "pvp",
         "server.commands.world.settings.pvp.desc",
         "pvp",
         ArgTypes.BOOLEAN,
         "server.commands.world.settings.pvp.name",
         WorldConfig::isPvpEnabled,
         WorldConfig::setPvpEnabled
      );
      this.generateSubCommand(
         "timepaused",
         "server.commands.world.settings.timepaused.desc",
         "timepaused",
         ArgTypes.BOOLEAN,
         "server.commands.world.settings.timepaused.name",
         WorldConfig::isGameTimePaused,
         WorldConfig::setGameTimePaused
      );
      this.generateSubCommand(
         "spawningnpc",
         "server.commands.world.settings.spawningnpc.desc",
         "spawning",
         ArgTypes.BOOLEAN,
         "server.commands.world.settings.spawningnpc.name",
         WorldConfig::isSpawningNPC,
         WorldConfig::setSpawningNPC
      );
      this.generateSubCommand(
         "spawnmarkers",
         "server.commands.world.settings.spawnmarkers.desc",
         "enabled",
         ArgTypes.BOOLEAN,
         "server.commands.world.settings.spawnmarkers.name",
         WorldConfig::isSpawnMarkersEnabled,
         WorldConfig::setIsSpawnMarkersEnabled
      );
      this.generateSubCommand(
         "freezeallnpcs",
         "server.commands.world.settings.freezeallnpcs.desc",
         "enabled",
         ArgTypes.BOOLEAN,
         "server.commands.world.settings.freezeallnpcs.name",
         WorldConfig::isAllNPCFrozen,
         WorldConfig::setIsAllNPCFrozen
      );
      this.generateSubCommand(
         "compassupdating",
         "server.commands.world.settings.compassupdating.desc",
         "updating",
         ArgTypes.BOOLEAN,
         "server.commands.world.settings.compassupdating.name",
         World::isCompassUpdating,
         WorldConfig::isCompassUpdating,
         World::setCompassUpdating
      );
      this.generateSubCommand(
         "playersaving",
         "server.commands.world.settings.playersaving.desc",
         "enabled",
         ArgTypes.BOOLEAN,
         "server.commands.world.settings.playersaving.name",
         WorldConfig::isSavingPlayers,
         WorldConfig::setSavingPlayers
      );
      this.generateSubCommand(
         "chunksaving",
         "server.commands.world.settings.chunkSaving.desc",
         "enabled",
         ArgTypes.BOOLEAN,
         "server.commands.world.settings.chunksaving.name",
         WorldConfig::canSaveChunks,
         WorldConfig::setCanSaveChunks
      );
      this.generateSubCommand(
         "chunkunloading",
         "server.commands.world.settings.chunkUnload.desc",
         "enabled",
         ArgTypes.BOOLEAN,
         "server.commands.world.settings.chunkunloading.name",
         WorldConfig::canUnloadChunks,
         WorldConfig::setCanUnloadChunks
      );
      this.generateSubCommand(
         "gamemode",
         "server.commands.world.settings.gamemode.desc",
         "gamemode",
         new EnumArgumentType<>("server.commands.parsing.argtype.gamemode.name", GameMode.class),
         "server.commands.world.settings.gamemode.name",
         WorldConfig::getGameMode,
         WorldConfig::setGameMode
      );
      this.generateSubCommand(
         "gameplayconfig",
         "server.commands.world.settings.gameplayconfig.desc",
         "id",
         ArgTypes.STRING,
         "server.commands.world.settings.gameplayconfig.name",
         WorldConfig::getGameplayConfig,
         WorldConfig::setGameplayConfig
      );
      this.addSubCommand(
         new WorldSettingsCommand.WorldSettingsBox2DCommand(
            "pregenerate",
            "server.commands.world.settings.pregenerate.desc",
            "server.commands.world.settings.pregenerate.name",
            var0 -> var0.getWorldConfig().getChunkConfig().getPregenerateRegion(),
            var0 -> var0.getChunkConfig().getPregenerateRegion(),
            (var0, var1) -> {
               WorldConfig var2 = var0.getWorldConfig();
               var2.getChunkConfig().setPregenerateRegion(var1);
               var2.markChanged();
            }
         )
      );
      this.addSubCommand(
         new WorldSettingsCommand.WorldSettingsBox2DCommand(
            "keeploaded",
            "server.commands.world.settings.keeploaded.desc",
            "server.commands.world.settings.keeploaded.name",
            var0 -> var0.getWorldConfig().getChunkConfig().getKeepLoadedRegion(),
            var0 -> var0.getChunkConfig().getKeepLoadedRegion(),
            (var0, var1) -> {
               WorldConfig var2 = var0.getWorldConfig();
               var2.getChunkConfig().setKeepLoadedRegion(var1);
               var2.markChanged();
            }
         )
      );
      this.addSubCommand(
         new WorldSettingsCommand.WorldSettingsSetCommand<>(
            "disabledfluidtickers",
            "server.commands.world.settings.disabledfluidtickers.desc",
            "server.commands.world.settings.disabledfluidtickers.name",
            var0 -> var0.getWorldConfig().getDisabledFluidTickers(),
            (var0, var1) -> {
               var0.getWorldConfig().setDisabledFluidTickers(var1);
               var0.getWorldConfig().markChanged();
            }
         )
      );
   }

   class="kw">private <T> void generateSubCommand(
      @Nonnull String var1,
      @Nonnull String var2,
      @Nonnull String var3,
      @Nonnull ArgumentType<T> var4,
      @Nonnull String var5,
      @Nonnull Function<WorldConfig, T> var6,
      @Nonnull BiConsumer<WorldConfig, T> var7
   ) {
      this.generateSubCommand(
         var1, var2, var3, var4, var5, var1x -> var6.apply(var1x.getWorldConfig()), var6, (var1x, var2x) -> var7.accept(var1x.getWorldConfig(), var2x)
      );
   }

   class="kw">private <T> void generateSubCommand(
      @Nonnull String var1,
      @Nonnull String var2,
      @Nonnull String var3,
      ArgumentType<T> var4,
      @Nonnull String var5,
      @Nonnull Function<World, T> var6,
      Function<WorldConfig, T> var7,
      @Nonnull BiConsumer<World, T> var8
   ) {
      this.addSubCommand(new WorldSettingsCommand.WorldSettingsSubCommand<>(var1, var2, var3, var4, var5, var6, var7, var8, this.defaultWorldConfig));
   }

   class="kw">private class="kw">static class WorldSettingsBox2DCommand class="kw">extends AbstractWorldCommand {
      @Nonnull
      class="kw">private class="kw">final String display;
      @Nonnull
      class="kw">private class="kw">final Function<World, Box2D> getter;
      @Nonnull
      class="kw">private class="kw">final Function<WorldConfig, Box2D> defaultGetter;
      @Nonnull
      class="kw">private class="kw">final BiConsumer<World, Box2D> setter;
      @Nonnull
      class="kw">private class="kw">final WorldConfig defaultWorldConfig;

      class="kw">public WorldSettingsBox2DCommand(
         String var1,
         String var2,
         @Nonnull String var3,
         @Nonnull Function<World, Box2D> var4,
         @Nonnull Function<WorldConfig, Box2D> var5,
         @Nonnull BiConsumer<World, Box2D> var6
      ) {
         super(var1, var2);
         this.display = var3;
         this.getter = var4;
         this.defaultGetter = var5;
         this.setter = var6;
         this.defaultWorldConfig = new WorldConfig();
         this.addSubCommand(new WorldSettingsCommand.WorldSettingsBox2DCommand.SetSubCommand());
         this.addSubCommand(new WorldSettingsCommand.WorldSettingsBox2DCommand.ResetSubCommand());
      }

      @Override
      class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
         Box2D var4 = this.getter.apply(var2);
         var1.sendMessage(
            Message.translation("server.commands.world.settings.currentValue")
               .param("display", Message.translation(this.display))
               .param("worldName", var2.getName())
               .param("currentValue", Objects.toString(var4))
         );
      }

      class="kw">private class ResetSubCommand class="kw">extends AbstractWorldCommand {
         class="kw">public ResetSubCommand() {
            super("reset", "server.commands.world.settings.reset.desc");
         }

         @Override
         class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
            Box2D var4 = WorldSettingsBox2DCommand.this.getter.apply(var2);
            Box2D var5 = WorldSettingsBox2DCommand.this.defaultGetter.apply(WorldSettingsBox2DCommand.this.defaultWorldConfig);
            WorldSettingsBox2DCommand.this.setter.accept(var2, var5);
            var2.getWorldConfig().markChanged();
            var1.sendMessage(
               Message.translation("server.commands.world.settings.displaySetDefault")
                  .param("display", Message.translation(WorldSettingsBox2DCommand.this.display))
                  .param("worldName", var2.getName())
                  .param("newValue", Objects.toString(var5))
                  .param("oldValue", Objects.toString(var4))
            );
         }
      }

      class="kw">private class SetSubCommand class="kw">extends AbstractWorldCommand {
         @Nonnull
         class="kw">private class="kw">final RequiredArg<Double> minXArg = this.withRequiredArg("minX", "server.commands.world.settings.box2d.minX.desc", ArgTypes.DOUBLE);
         @Nonnull
         class="kw">private class="kw">final RequiredArg<Double> minZArg = this.withRequiredArg("minZ", "server.commands.world.settings.box2d.minZ.desc", ArgTypes.DOUBLE);
         @Nonnull
         class="kw">private class="kw">final RequiredArg<Double> maxXArg = this.withRequiredArg("maxX", "server.commands.world.settings.box2d.maxX.desc", ArgTypes.DOUBLE);
         @Nonnull
         class="kw">private class="kw">final RequiredArg<Double> maxZArg = this.withRequiredArg("maxZ", "server.commands.world.settings.box2d.maxZ.desc", ArgTypes.DOUBLE);

         class="kw">public SetSubCommand() {
            super("set", "server.commands.world.settings.set.desc");
         }

         @Override
         class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
            Box2D var4 = WorldSettingsBox2DCommand.this.getter.apply(var2);
            Box2D var5 = new Box2D(new Vector2d(var1.get(this.minXArg), var1.get(this.minZArg)), new Vector2d(var1.get(this.maxXArg), var1.get(this.maxZArg)));
            WorldSettingsBox2DCommand.this.setter.accept(var2, var5);
            var2.getWorldConfig().markChanged();
            var1.sendMessage(
               Message.translation("server.commands.world.settings.displaySet")
                  .param("display", Message.translation(WorldSettingsBox2DCommand.this.display))
                  .param("worldName", var2.getName())
                  .param("newValue", Objects.toString(var5))
                  .param("oldValue", Objects.toString(var4))
            );
         }
      }
   }

   class="kw">private class="kw">static class WorldSettingsSetCommand<T> class="kw">extends AbstractWorldCommand {
      @Nonnull
      class="kw">private class="kw">final String display;
      @Nonnull
      class="kw">private class="kw">final Function<World, Set<T>> getter;
      @Nonnull
      class="kw">private class="kw">final BiConsumer<World, Set<T>> setter;

      class="kw">public WorldSettingsSetCommand(
         @Nonnull String var1, @Nonnull String var2, @Nonnull String var3, @Nonnull Function<World, Set<T>> var4, @Nonnull BiConsumer<World, Set<T>> var5
      ) {
         super(var1, var2);
         this.display = var3;
         this.getter = var4;
         this.setter = var5;
         this.addSubCommand(new WorldSettingsCommand.WorldSettingsSetCommand.AddSubCommand());
         this.addSubCommand(new WorldSettingsCommand.WorldSettingsSetCommand.RemoveSubCommand());
         this.addSubCommand(new WorldSettingsCommand.WorldSettingsSetCommand.ClearSubCommand());
      }

      @Override
      class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
         Set var4 = this.getter.apply(var2);
         if (var4.isEmpty()) {
            var1.sendMessage(
               Message.translation("server.commands.world.settings.set.empty")
                  .param("display", Message.translation(this.display))
                  .param("worldName", var2.getName())
            );
         } else {
            var1.sendMessage(
               Message.translation("server.commands.world.settings.set.list")
                  .param("display", Message.translation(this.display))
                  .param("worldName", var2.getName())
                  .param("values", String.join(", ", var4.stream().map(Objects::toString).toList()))
            );
         }
      }

      class="kw">private class AddSubCommand class="kw">extends AbstractWorldCommand {
         @Nonnull
         class="kw">private class="kw">final RequiredArg<String> valueArg = this.withRequiredArg("value", "server.commands.world.settings.set.add.value.desc", ArgTypes.STRING);

         class="kw">public AddSubCommand() {
            super("add", "server.commands.world.settings.set.add.desc");
         }

         @Override
         class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
            Object var4 = var1.get(this.valueArg);
            Set var5 = WorldSettingsSetCommand.this.getter.apply(var2);
            HashSet var6 = new HashSet<>(var5);
            if (!var6.add(var4)) {
               var1.sendMessage(
                  Message.translation("server.commands.world.settings.set.alreadyPresent")
                     .param("display", Message.translation(WorldSettingsSetCommand.this.display))
                     .param("worldName", var2.getName())
                     .param("value", var4.toString())
               );
            } else {
               WorldSettingsSetCommand.this.setter.accept(var2, var6);
               var1.sendMessage(
                  Message.translation("server.commands.world.settings.set.added")
                     .param("display", Message.translation(WorldSettingsSetCommand.this.display))
                     .param("worldName", var2.getName())
                     .param("value", var4.toString())
               );
            }
         }
      }

      class="kw">private class ClearSubCommand class="kw">extends AbstractWorldCommand {
         class="kw">public ClearSubCommand() {
            super("clear", "server.commands.world.settings.set.clear.desc");
         }

         @Override
         class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
            Set var4 = WorldSettingsSetCommand.this.getter.apply(var2);
            if (var4.isEmpty()) {
               var1.sendMessage(
                  Message.translation("server.commands.world.settings.set.empty")
                     .param("display", Message.translation(WorldSettingsSetCommand.this.display))
                     .param("worldName", var2.getName())
               );
            } else {
               WorldSettingsSetCommand.this.setter.accept(var2, Set.of());
               var1.sendMessage(
                  Message.translation("server.commands.world.settings.set.cleared")
                     .param("display", Message.translation(WorldSettingsSetCommand.this.display))
                     .param("worldName", var2.getName())
               );
            }
         }
      }

      class="kw">private class RemoveSubCommand class="kw">extends AbstractWorldCommand {
         @Nonnull
         class="kw">private class="kw">final RequiredArg<String> valueArg = this.withRequiredArg("value", "server.commands.world.settings.set.remove.value.desc", ArgTypes.STRING);

         class="kw">public RemoveSubCommand() {
            super("remove", "server.commands.world.settings.set.remove.desc");
         }

         @Override
         class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
            Object var4 = var1.get(this.valueArg);
            Set var5 = WorldSettingsSetCommand.this.getter.apply(var2);
            HashSet var6 = new HashSet<>(var5);
            if (!var6.remove(var4)) {
               var1.sendMessage(
                  Message.translation("server.commands.world.settings.set.notPresent")
                     .param("display", Message.translation(WorldSettingsSetCommand.this.display))
                     .param("worldName", var2.getName())
                     .param("value", var4.toString())
               );
            } else {
               WorldSettingsSetCommand.this.setter.accept(var2, var6);
               var1.sendMessage(
                  Message.translation("server.commands.world.settings.set.removed")
                     .param("display", Message.translation(WorldSettingsSetCommand.this.display))
                     .param("worldName", var2.getName())
                     .param("value", var4.toString())
               );
            }
         }
      }
   }

   class="kw">private class="kw">static class WorldSettingsSubCommand<T> class="kw">extends AbstractWorldCommand {
      @Nonnull
      class="kw">private class="kw">final ArgumentType<T> argumentType;
      @Nonnull
      class="kw">private class="kw">final String display;
      @Nonnull
      class="kw">private class="kw">final Function<World, T> getter;
      class="kw">private class="kw">final Function<WorldConfig, T> defaultGetter;
      @Nonnull
      class="kw">private class="kw">final BiConsumer<World, T> setter;
      @Nonnull
      class="kw">private class="kw">final WorldConfig defaultWorldConfig;

      class="kw">public WorldSettingsSubCommand(
         @Nonnull String var1,
         @Nonnull String var2,
         @Nonnull String var3,
         @Nonnull ArgumentType<T> var4,
         @Nonnull String var5,
         @Nonnull Function<World, T> var6,
         @Nonnull Function<WorldConfig, T> var7,
         @Nonnull BiConsumer<World, T> var8,
         @Nonnull WorldConfig var9
      ) {
         super(var1, var2);
         this.argumentType = var4;
         this.display = var5;
         this.getter = var6;
         this.defaultGetter = var7;
         this.setter = var8;
         this.defaultWorldConfig = var9;
         this.addSubCommand(new WorldSettingsCommand.WorldSettingsSubCommand.SetSubCommand());
         this.addSubCommand(new WorldSettingsCommand.WorldSettingsSubCommand.ResetSubCommand());
      }

      @Override
      class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
         Object var4 = this.getter.apply(var2);
         var1.sendMessage(
            Message.translation("server.commands.world.settings.currentValue")
               .param("display", Message.translation(this.display))
               .param("worldName", var2.getName())
               .param("currentValue", var4.toString())
         );
      }

      class="kw">private class ResetSubCommand class="kw">extends AbstractWorldCommand {
         class="kw">public ResetSubCommand() {
            super("reset", "server.commands.world.settings.reset.desc");
         }

         @Override
         class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
            Object var4 = WorldSettingsSubCommand.this.getter.apply(var2);
            Object var5 = WorldSettingsSubCommand.this.defaultGetter.apply(WorldSettingsSubCommand.this.defaultWorldConfig);
            WorldSettingsSubCommand.this.setter.accept(var2, var5);
            var2.getWorldConfig().markChanged();
            var1.sendMessage(
               Message.translation("server.commands.world.settings.displaySetDefault")
                  .param("display", Message.translation(WorldSettingsSubCommand.this.display))
                  .param("worldName", var2.getName())
                  .param("newValue", var5.toString())
                  .param("oldValue", var4.toString())
            );
         }
      }

      class="kw">private class SetSubCommand class="kw">extends AbstractWorldCommand {
         @Nonnull
         class="kw">private class="kw">final RequiredArg<T> valueArg = this.withRequiredArg(
            "value", "server.commands.world.settings.value.desc", WorldSettingsSubCommand.this.argumentType
         );

         class="kw">public SetSubCommand() {
            super("set", "server.commands.world.settings.set.desc");
         }

         @Override
         class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
            Object var4 = WorldSettingsSubCommand.this.getter.apply(var2);
            Object var5 = var1.get(this.valueArg);
            WorldSettingsSubCommand.this.setter.accept(var2, var5);
            var2.getWorldConfig().markChanged();
            var1.sendMessage(
               Message.translation("server.commands.world.settings.displaySet")
                  .param("display", Message.translation(WorldSettingsSubCommand.this.display))
                  .param("worldName", var2.getName())
                  .param("newValue", var5.toString())
                  .param("oldValue", var4.toString())
            );
         }
      }
   }
}