path: root/src/main/java/ftbsc/bscv/tools/Setting.java

package ftbsc.bscv.tools;

import com.mojang.brigadier.arguments.*;
import ftbsc.bscv.api.IModule;
import net.minecraft.command.Commands;
import net.minecraftforge.common.ForgeConfigSpec;
import net.minecraftforge.server.command.EnumArgument;

import java.util.Optional;
import java.util.function.Consumer;

import static ftbsc.bscv.Boscovicino.log;

public abstract class Setting<T> {

   protected Optional<String> name;
   protected Optional<String> comment;
   protected Optional<T> fallback;
   protected Optional<Consumer<T>> callback;


   Setting() {
      this.name = Optional.empty();
      this.comment = Optional.empty();
      this.fallback = Optional.empty();
      this.callback = Optional.empty();
   }

   public Setting<T> name(String name) {
      this.name = Optional.of(name);
      return this;
   }

   public Setting<T> comment(String comment) {
      this.comment = Optional.of(comment);
      return this;
   }

   public Setting<T> fallback(T fallback) {
      this.fallback = Optional.of(fallback);
      return this;
   }

   public Setting<T> callback(Consumer<T> callback) {
      this.callback = Optional.of(callback);
      return this;
   }

   abstract ForgeConfigSpec.ConfigValue<T> value(ForgeConfigSpec.Builder builder);

   abstract ArgumentType<T> argument();

   abstract Class<T> clazz();

   public ForgeConfigSpec.ConfigValue<T> build(IModule module) {
      ForgeConfigSpec.ConfigValue<T> conf = this.value(module.getConfigBuilder());

      String optName = this.name.get();
      Class<T> clazz = this.clazz();
      ArgumentType<T> arg = this.argument();
      Consumer<T> cb = this.callback.isPresent() ? this.callback.get() : null;

      module.getDispatcher().register(
         Commands.literal(module.getName().toLowerCase())
            .then(
               Commands.literal(optName)
               .then(
                  Commands.argument(optName, arg)
                     .executes( ctx -> {
                        T value = ctx.getArgument(optName, clazz);
                        if (cb != null) {
                           cb.accept(value);
                        }
                        conf.set(value);
                        conf.save();
                        log(String.format("> %s -> %s <", String.join(".", conf.getPath()), conf.get().toString()));
                        return 1;
                     }))
               .executes(ctx -> {
                  log(String.format("> %s: %s <", optName, conf.get().toString()));
                  return 1;
               })
            )
      );

      return conf;

   }

   public static class Bool extends Setting<Boolean> {
      public static Bool builder() { return new Bool(); }

      public Class<Boolean> clazz() { return Boolean.class; }
      public BoolArgumentType argument() { return BoolArgumentType.bool(); }

      public ForgeConfigSpec.BooleanValue value(ForgeConfigSpec.Builder builder) {
         return builder
            .comment(this.comment.get())
            .define(this.name.get(), this.fallback.get() ? true : false);
      }
   }


   public static class Decimal extends Setting<Double> {
      protected Optional<Double> min;
      protected Optional<Double> max;

      public static Decimal builder() { return new Decimal(); }
      public Decimal() {
         super();
         this.min = Optional.of(Double.MIN_VALUE);
         this.max = Optional.of(Double.MAX_VALUE);
      }

      public Decimal min(double min) {
         this.min = Optional.of(min);
         return this;
      }

      public Decimal max(double max) {
         this.max = Optional.of(max);
         return this;
      }

      public Class<Double> clazz() { return Double.class; }
      public DoubleArgumentType argument() { return DoubleArgumentType.doubleArg(this.min.get(), this.max.get()); }

      public ForgeConfigSpec.DoubleValue value(ForgeConfigSpec.Builder builder) {
         return builder
            .comment(this.comment.get())
            .defineInRange(this.name.get(), this.fallback.get(), this.min.get(), this.max.get());
      }
   }


   public static class Number extends Setting<Integer> {
      protected Optional<Integer> min;
      protected Optional<Integer> max;

      public static Number builder() { return new Number(); }
      public Number() {
         super();
         this.min = Optional.of(Integer.MIN_VALUE);
         this.max = Optional.of(Integer.MAX_VALUE);
      }

      public Number min(int min) {
         this.min = Optional.of(min);
         return this;
      }

      public Number max(int max) {
         this.max = Optional.of(max);
         return this;
      }

      public Class<Integer> clazz() { return Integer.class; }
      public IntegerArgumentType argument() { return IntegerArgumentType.integer(this.min.get(), this.max.get()); }

      public ForgeConfigSpec.IntValue value(ForgeConfigSpec.Builder builder) {
         return builder
            .comment(this.comment.get())
            .defineInRange(this.name.get(), this.fallback.get(), this.min.get(), this.max.get());
      }
   }


   public static class Str extends Setting<String> {
      public static Str builder() { return new Str(); }

      protected boolean greedy = false;

      public Str greedy(boolean greedy) {
         this.greedy = greedy;
         return this;
      }

      public Class<String> clazz() { return String.class; }
      public StringArgumentType argument() {
         return this.greedy ?
            StringArgumentType.greedyString()
            : StringArgumentType.string();
      }

      public ForgeConfigSpec.ConfigValue<String> value(ForgeConfigSpec.Builder builder) {
         return builder
            .comment(this.comment.get())
            .define(this.name.get(), this.fallback.get());
      }
   }


   public static class Switch<T extends Enum<T>> extends Setting<T> {
      private final Class<T> enumClazz;

      public static<T extends Enum<T>> Switch<T> builder(Class<T> type) { return new Switch<T>(type); }

      protected Switch(Class<T> type) {
         this.enumClazz = type;
      }

      public Class<T> clazz() {
         return this.enumClazz;
      }

      public EnumArgument<T> argument() {
         return EnumArgument.enumArgument(this.enumClazz);
      }

      public ForgeConfigSpec.EnumValue<T> value(ForgeConfigSpec.Builder builder) {
         return builder
            .comment(this.comment.get())
            .defineEnum(this.name.get(), this.fallback.get());
      }
   }

}