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

package ftbsc.bscv.tools;

import com.google.common.collect.Lists;
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.io.Serializable;
import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;

import static ftbsc.bscv.Boscovicino.log;

public abstract class Setting<T, I> {

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

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

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

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

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

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

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

   abstract ArgumentType<I> argument();

   public abstract ForgeConfigSpec.ConfigValue<T> build(IModule module);



   private static abstract class ValueSetting<T> extends Setting<T, T> {
      
      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 ValueSetting<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 ValueSetting<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 ValueSetting<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 ValueSetting<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 ValueSetting<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());
      }
   }

   public static class Many<T, S extends Serializable> extends Setting<List<? extends S>, T> {
      private Predicate<Object> validator;
      private Function<T, S> writer;
      private final ArgumentType<T> argument_type;
      private final Class<T> clazz;

      // TODO can we infer clazz from the argument type without needing the second argument???
      public Many(ArgumentType<T> argument, Class<T> clazz) {
         super();
         this.validator = x -> true;
         this.writer = x -> (S) x; // TODO this works ootb if it's just the same type but crashes at runtime for everything else
         this.argument_type = argument;
         this.clazz = clazz;
      }

      public static<T, S extends Serializable> Many<T, S> builder(ArgumentType<T> argument, Class<T> clazz) { return new Many<T, S>(argument, clazz); }

      public Many<T, S> validator(Predicate<Object> validator) {
         this.validator = validator;
         return this;
      }

      public Many<T, S> writer(Function<T, S> writer) {
         this.writer = writer;
         return this;
      }

      public ArgumentType<T> argument() {
         return this.argument_type;
      }

      public ForgeConfigSpec.ConfigValue<List<? extends S>> value(ForgeConfigSpec.Builder builder) {
         return builder
            .comment(this.comment.get())
            .defineList(
               this.name.get(),
               this.fallback.get(),
               this.validator
            );
      }

      public ForgeConfigSpec.ConfigValue<List<? extends S>> build(IModule module) {
         ForgeConfigSpec.ConfigValue<List<? extends S>> conf = this.value(module.getConfigBuilder());

         String optName = this.name.get();
         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.literal("add")
                     .then(
                        Commands.argument(optName, arg)
                           .executes( ctx -> {
                              T value = ctx.getArgument(optName, this.clazz);
                              if (cb != null) {
                                 cb.accept(value);
                              }
                              List<S> botch = Lists.newArrayList(conf.get());
                              botch.add(this.writer.apply(value));
                              conf.set(botch);
                              conf.save();
                              log(String.format("> %s -++> %s <", String.join(".", conf.getPath()), conf.get().toString()));
                              return 1;
                           })
                     )
                  )
                  .then(
                     Commands.literal("remove")
                        .then(
                           Commands.argument(optName, arg)
                              .executes( ctx -> {
                                 T value = ctx.getArgument(optName, clazz);
                                 if (cb != null) {
                                    cb.accept(value);
                                 }
                                 List<S> botch = Lists.newArrayList(conf.get());
                                 boolean removed = botch.remove(this.writer.apply(value));
                                 conf.set(botch);
                                 conf.save();
                                 log(String.format("> %s -%s> %s <", String.join(".", conf.getPath()), removed ? "//" : "--", conf.get().toString()));
                                 return 1;
                              })
                        )
                  )
                  .executes(ctx -> {
                     log(String.format("> %s: %s <", optName, conf.get().toString()));
                     return 1;
                  })
               )
         );

         return conf;
      }
   }
}