class="kw">package com.hypixel.hytale.builtin.model.commands;

class="kw">import com.hypixel.hytale.builtin.model.pages.ChangeModelPage;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.server.core.Message;
class="kw">import com.hypixel.hytale.server.core.asset.type.model.config.Model;
class="kw">import com.hypixel.hytale.server.core.asset.type.model.config.ModelAsset;
class="kw">import com.hypixel.hytale.server.core.command.system.CommandContext;
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.OptionalArg;
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.command.system.basecommands.CommandBase;
class="kw">import com.hypixel.hytale.server.core.cosmetics.CosmeticsModule;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.ModelComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerSkinComponent;
class="kw">import com.hypixel.hytale.server.core.permissions.HytalePermissions;
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 javax.annotation.Nonnull;

class="kw">public class ModelCommand class="kw">extends AbstractPlayerCommand {
   class="kw">public ModelCommand() {
      super("model", "server.commands.model.desc");
      this.setPermissionGroups("hytale:Builder");
      this.addUsageVariant(new ModelCommand.ModelOtherCommand());
      this.addSubCommand(new ModelCommand.ModelSetCommand());
      this.addSubCommand(new ModelCommand.ModelResetCommand());
   }

   @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 ChangeModelPage(var4));
   }

   class="kw">private class="kw">static class ModelOtherCommand class="kw">extends CommandBase {
      @Nonnull
      class="kw">private class="kw">final RequiredArg<PlayerRef> playerArg = this.withRequiredArg("player", "server.commands.argtype.player.desc", ArgTypes.PLAYER_REF);

      ModelOtherCommand() {
         super("server.commands.model.other.desc");
         this.requirePermission(HytalePermissions.fromCommand("model.other"));
      }

      @Override
      class="kw">protected void executeSync(@Nonnull CommandContext var1) {
         PlayerRef var2 = this.playerArg.get(var1);
         Ref var3 = var2.getReference();
         if (var3 != null && var3.isValid()) {
            Store var4 = var3.getStore();
            World var5 = var4.getExternalData().getWorld();
            var5.execute(() -> {
               Player var4 = var4.getComponent(var3, Player.getComponentType());
               if (var4 == null) {
                  var1.sendMessage(Message.translation("server.commands.errors.playerNotInWorld"));
               } else {
                  var4.getPageManager().openCustomPage(var3, var4, new ChangeModelPage(var2));
               }
            });
         } else {
            var1.sendMessage(Message.translation("server.commands.errors.playerNotInWorld"));
         }
      }
   }

   class="kw">static class ModelResetCommand class="kw">extends AbstractPlayerCommand {
      @Nonnull
      class="kw">private class="kw">final OptionalArg<Float> scaleArg = this.withOptionalArg("scale", "server.commands.model.reset.scale.desc", ArgTypes.FLOAT);

      ModelResetCommand() {
         super("reset", "server.commands.model.reset.desc");
         this.addAliases("clear");
         this.addUsageVariant(new ModelCommand.ModelResetCommand.ModelResetOtherCommand());
      }

      @Override
      class="kw">protected void execute(
         @Nonnull CommandContext var1, @Nonnull Store<EntityStore> var2, @Nonnull Ref<EntityStore> var3, @Nonnull PlayerRef var4, @Nonnull World var5
      ) {
         PlayerSkinComponent var6 = var2.getComponent(var3, PlayerSkinComponent.getComponentType());
         if (var6 == null) {
            var1.sendMessage(Message.translation("server.commands.model.noAuthSkinForPlayer").param("model", "Player"));
         } else {
            PlayerSkinComponent var7 = var2.getComponent(var3, PlayerSkinComponent.getComponentType());
            assert var7 != null;
            CosmeticsModule var8 = CosmeticsModule.get();
            if (this.scaleArg.provided(var1)) {
               Float var9 = this.scaleArg.get(var1);
               Model var10 = var8.createModel(var7.getPlayerSkin(), var9);
               var2.putComponent(var3, ModelComponent.getComponentType(), new ModelComponent(var10));
            } else {
               Model var11 = var8.createModel(var7.getPlayerSkin());
               var2.putComponent(var3, ModelComponent.getComponentType(), new ModelComponent(var11));
            }

            var7.setNetworkOutdated();
            var1.sendMessage(Message.translation("server.commands.model.modelResetForPlayer"));
         }
      }

      class="kw">private class="kw">static class ModelResetOtherCommand class="kw">extends CommandBase {
         @Nonnull
         class="kw">private class="kw">final RequiredArg<PlayerRef> playerArg = this.withRequiredArg("player", "server.commands.argtype.player.desc", ArgTypes.PLAYER_REF);
         @Nonnull
         class="kw">private class="kw">final OptionalArg<Float> scaleArg = this.withOptionalArg("scale", "server.commands.model.reset.scale.desc", ArgTypes.FLOAT);

         ModelResetOtherCommand() {
            super("server.commands.model.reset.other.desc");
            this.requirePermission(HytalePermissions.fromCommand("model.reset.other"));
         }

         @Override
         class="kw">protected void executeSync(@Nonnull CommandContext var1) {
            PlayerRef var2 = this.playerArg.get(var1);
            Ref var3 = var2.getReference();
            if (var3 != null && var3.isValid()) {
               Store var4 = var3.getStore();
               World var5 = var4.getExternalData().getWorld();
               var5.execute(() -> {
                  Player var5 = var4.getComponent(var3, Player.getComponentType());
                  if (var5 == null) {
                     var1.sendMessage(Message.translation("server.commands.errors.playerNotInWorld"));
                  } else {
                     PlayerSkinComponent var6 = var4.getComponent(var3, PlayerSkinComponent.getComponentType());
                     if (var6 == null) {
                        var1.sendMessage(Message.translation("server.commands.model.noAuthSkin").param("name", var2.getUsername()).param("model", "Player"));
                     } else {
                        PlayerSkinComponent var7 = var4.getComponent(var3, PlayerSkinComponent.getComponentType());
                        assert var7 != null;
                        CosmeticsModule var8 = CosmeticsModule.get();
                        if (this.scaleArg.provided(var1)) {
                           Float var9 = this.scaleArg.get(var1);
                           Model var10 = var8.createModel(var7.getPlayerSkin(), var9);
                           var4.putComponent(var3, ModelComponent.getComponentType(), new ModelComponent(var10));
                        } else {
                           Model var11 = var8.createModel(var7.getPlayerSkin());
                           var4.putComponent(var3, ModelComponent.getComponentType(), new ModelComponent(var11));
                        }

                        var7.setNetworkOutdated();
                        var1.sendMessage(Message.translation("server.commands.model.modelReset").param("name", var2.getUsername()));
                     }
                  }
               });
            } else {
               var1.sendMessage(Message.translation("server.commands.errors.playerNotInWorld"));
            }
         }
      }
   }

   class="kw">static class ModelSetCommand class="kw">extends AbstractPlayerCommand {
      @Nonnull
      class="kw">private class="kw">final RequiredArg<ModelAsset> modelAssetArg = this.withRequiredArg("model", "server.commands.model.set.model.desc", ArgTypes.MODEL_ASSET);
      @Nonnull
      class="kw">private class="kw">final OptionalArg<Float> scaleArg = this.withOptionalArg("scale", "server.commands.model.set.scale.desc", ArgTypes.FLOAT);
      @Nonnull
      class="kw">private class="kw">final FlagArg bypassScaleLimitsFlag = this.withFlagArg("bypassScaleLimits", "server.commands.model.set.bypassScaleLimits.desc");

      ModelSetCommand() {
         super("set", "server.commands.model.set.desc");
         this.addUsageVariant(new ModelCommand.ModelSetCommand.ModelSetOtherCommand());
      }

      @Override
      class="kw">protected void execute(
         @Nonnull CommandContext var1, @Nonnull Store<EntityStore> var2, @Nonnull Ref<EntityStore> var3, @Nonnull PlayerRef var4, @Nonnull World var5
      ) {
         ModelAsset var6 = this.modelAssetArg.get(var1);
         float var7 = this.scaleArg.provided(var1) ? this.scaleArg.get(var1) : var6.generateRandomScale();
         if (!this.bypassScaleLimitsFlag.provided(var1)) {
            var7 = MathUtil.clamp(var7, var6.getMinScale(), var6.getMaxScale());
         }

         Model var8 = Model.createScaledModel(var6, var7);
         var2.putComponent(var3, ModelComponent.getComponentType(), new ModelComponent(var8));
         var1.sendMessage(Message.translation("server.commands.model.modelSetForPlayer").param("modelName", var6.getId()));
      }

      class="kw">private class="kw">static class ModelSetOtherCommand class="kw">extends CommandBase {
         @Nonnull
         class="kw">private class="kw">final RequiredArg<ModelAsset> modelAssetArg = this.withRequiredArg("model", "server.commands.model.set.model.desc", ArgTypes.MODEL_ASSET);
         @Nonnull
         class="kw">private class="kw">final RequiredArg<PlayerRef> playerArg = this.withRequiredArg("player", "server.commands.argtype.player.desc", ArgTypes.PLAYER_REF);
         @Nonnull
         class="kw">private class="kw">final OptionalArg<Float> scaleArg = this.withOptionalArg("scale", "server.commands.model.set.scale.desc", ArgTypes.FLOAT);
         @Nonnull
         class="kw">private class="kw">final FlagArg bypassScaleLimitsFlag = this.withFlagArg("bypassScaleLimits", "server.commands.model.set.bypassScaleLimits.desc");

         ModelSetOtherCommand() {
            super("server.commands.model.set.other.desc");
            this.requirePermission(HytalePermissions.fromCommand("model.set.other"));
         }

         @Override
         class="kw">protected void executeSync(@Nonnull CommandContext var1) {
            PlayerRef var2 = this.playerArg.get(var1);
            Ref var3 = var2.getReference();
            if (var3 != null && var3.isValid()) {
               Store var4 = var3.getStore();
               World var5 = var4.getExternalData().getWorld();
               var5.execute(
                  () -> {
                     Player var5 = var4.getComponent(var3, Player.getComponentType());
                     if (var5 == null) {
                        var1.sendMessage(Message.translation("server.commands.errors.playerNotInWorld"));
                     } else {
                        ModelAsset var6 = this.modelAssetArg.get(var1);
                        float var7 = this.scaleArg.provided(var1) ? this.scaleArg.get(var1) : var6.generateRandomScale();
                        if (!this.bypassScaleLimitsFlag.provided(var1)) {
                           var7 = MathUtil.clamp(var7, var6.getMinScale(), var6.getMaxScale());
                        }

                        Model var8 = Model.createScaledModel(var6, var7);
                        var4.putComponent(var3, ModelComponent.getComponentType(), new ModelComponent(var8));
                        var1.sendMessage(
                           Message.translation("server.commands.model.modelSet").param("playerName", var2.getUsername()).param("modelName", var6.getId())
                        );
                     }
                  }
               );
            } else {
               var1.sendMessage(Message.translation("server.commands.errors.playerNotInWorld"));
            }
         }
      }
   }
}