class="kw">package com.hypixel.hytale.server.npc.asset.builder;

class="kw">import com.google.gson.JsonElement;
class="kw">import com.google.gson.JsonObject;
class="kw">import com.hypixel.hytale.codec.schema.NamedSchema;
class="kw">import com.hypixel.hytale.codec.schema.SchemaContext;
class="kw">import com.hypixel.hytale.codec.schema.SchemaConvertable;
class="kw">import com.hypixel.hytale.codec.schema.config.ObjectSchema;
class="kw">import com.hypixel.hytale.codec.schema.config.Schema;
class="kw">import com.hypixel.hytale.codec.schema.config.StringSchema;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.util.HashMap;
class="kw">import java.util.LinkedHashMap;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.function.Supplier;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class BuilderFactory<T> class="kw">implements SchemaConvertable<Void>, NamedSchema {
   class="kw">public class="kw">static class="kw">final String DEFAULT_TYPE = "Type";
   class="kw">public class="kw">static class="kw">final String COMPONENT_TYPE = "Component";
   class="kw">private class="kw">final String typeTag;
   class="kw">private class="kw">final Supplier<Builder<T>> defaultBuilder;
   class="kw">private class="kw">final Class<T> category;
   class="kw">private class="kw">final Map<String, Supplier<Builder<T>>> buildersSuppliers = new HashMap<>();

   class="kw">public BuilderFactory(Class<T> var1, String var2) {
      this(var1, var2, null);
   }

   class="kw">public BuilderFactory(Class<T> var1, String var2, Supplier<Builder<T>> var3) {
      this.category = var1;
      this.typeTag = var2;
      this.defaultBuilder = var3;
      this.add("Component", () -> new BuilderComponent<>(var1));
   }

   @Nonnull
   class="kw">public BuilderFactory<T> add(String var1, Supplier<Builder<T>> var2) {
      if (this.buildersSuppliers.containsKey(var1)) {
         throw new IllegalArgumentException(String.format("Builder with name %s already exists", var1));
      }

      if (this.typeTag.isEmpty()) {
         throw new IllegalArgumentException("Can't add named builder to array builder factory");
      }

      this.buildersSuppliers.put(var1, var2);
      class="kw">return this;
   }

   class="kw">public Class<T> getCategory() {
      class="kw">return this.category;
   }

   class="kw">public Builder<T> createBuilder(@Nonnull JsonElement var1) {
      if (!var1.isJsonObject()) {
         if (this.defaultBuilder == null) {
            throw new IllegalArgumentException(String.format("Array builder must have class="kw">default builder defined: %s", var1));
         } else {
            class="kw">return this.defaultBuilder.get();
         }
      } else {
         class="kw">return this.createBuilder(var1.getAsJsonObject(), this.typeTag);
      }
   }

   class="kw">public String getKeyName(@Nonnull JsonElement var1) {
      if (!var1.isJsonObject()) {
         class="kw">return "-";
      }

      JsonElement var2 = var1.getAsJsonObject().get(this.typeTag);
      class="kw">return var2 != null ? var2.getAsString() : "???";
   }

   @Nonnull
   class="kw">public Builder<T> createBuilder(String var1) {
      if (!this.buildersSuppliers.containsKey(var1)) {
         throw new IllegalArgumentException(String.format("Builder %s does not exist", var1));
      }

      Builder var2 = this.buildersSuppliers.get(var1).get();
      if (var2.category() != this.getCategory()) {
         throw new IllegalArgumentException(
            String.format("Builder %s has category %s which does not match %s", var1, var2.category().getName(), this.getCategory().getName())
         );
      }

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

   @Nullable
   class="kw">public Builder<T> tryCreateDefaultBuilder() {
      class="kw">return this.defaultBuilder != null ? this.defaultBuilder.get() : null;
   }

   @Nonnull
   class="kw">public List<String> getBuilderNames() {
      class="kw">return new ObjectArrayList(this.buildersSuppliers.keySet());
   }

   class="kw">private Builder<T> createBuilder(@Nonnull JsonObject var1, @Nonnull String var2) {
      if (var1 == null) {
         throw new IllegalArgumentException("JSON config cannot be null when creating builder");
      }

      if (var2 != null && !var2.trim().isEmpty()) {
         JsonElement var3 = var1.get(var2);
         if (var3 == null && this.defaultBuilder != null) {
            class="kw">return this.defaultBuilder.get();
         } else if (var3 == null) {
            throw new IllegalArgumentException(String.format("Builder tag of type %s must be supplied if no class="kw">default is defined in %s", var2, var1));
         } else {
            class="kw">return this.createBuilder(var3.getAsString());
         }
      } else {
         throw new IllegalArgumentException(String.format("Tag cannot be null or empty when creating builder with content %s", var1));
      }
   }

   @Nonnull
   @Override
   class="kw">public String getSchemaName() {
      class="kw">return "NPCType:" + this.getCategory().getSimpleName();
   }

   @Nonnull
   @Override
   class="kw">public Schema toSchema(@Nonnull SchemaContext var1) {
      class="kw">return this.toSchema(var1, false);
   }

   @Nonnull
   class="kw">public Schema toSchema(@Nonnull SchemaContext var1, boolean var2) {
      int var3 = 0;
      Schema[] var4 = new Schema[this.getBuilderNames().size()];
      ObjectSchema var5 = new ObjectSchema();
      var5.setRequired(this.typeTag);
      StringSchema var6 = new StringSchema();
      var6.setEnum(this.getBuilderNames().toArray(String[]::new));
      var5.setProperties(Map.of(this.typeTag, var6));
      Schema var7 = new Schema();
      if (this.defaultBuilder == null && this.getBuilderNames().isEmpty()) {
         var7.setAnyOf(var4);
      } else {
         var7.setIf(var5);
         var7.setThen(Schema.anyOf(var4));
      }

      for (String var9 : this.getBuilderNames()) {
         Builder var10 = this.createBuilder(var9);
         Schema var11 = var1.refDefinition(var10);
         ObjectSchema var12 = (ObjectSchema)var1.getRawDefinition(var10);
         LinkedHashMap var13 = new LinkedHashMap<>();
         Schema var14 = StringSchema.constant(var9);
         if (var10 class="kw">instanceof BuilderBase) {
            var14.setDescription(((BuilderBase)var10).getLongDescription());
         }

         var13.put(this.typeTag, var14);
         if (var2) {
            var13.put("TestType", new StringSchema());
            var13.put("FailReason", new StringSchema());
            var13.put("Parameters", BuilderParameters.toSchema(var1));
         }

         var13.putAll(var12.getProperties());
         var12.setProperties(var13);
         Schema var15 = new Schema();
         ObjectSchema var16 = new ObjectSchema();
         var16.setProperties(Map.of(this.typeTag, StringSchema.constant(var9)));
         var16.setRequired(this.typeTag);
         var15.setIf(var16);
         var15.setThen(var11);
         var15.setElse(false);
         var4[var3++] = var15;
      }

      if (this.defaultBuilder != null) {
         Builder var17 = this.defaultBuilder.get();
         Schema var18 = var1.refDefinition(var17);
         var7.setElse(var18);
      } else {
         var7.setElse(false);
      }

      var7.setHytaleSchemaTypeField(new Schema.SchemaTypeField(this.typeTag, null, this.getBuilderNames().toArray(String[]::new)));
      var7.setTitle(this.getCategory().getSimpleName());
      class="kw">return var7;
   }
}