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

class="kw">import com.google.gson.JsonArray;
class="kw">import com.google.gson.JsonElement;
class="kw">import com.google.gson.JsonObject;
class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.ExtraInfo;
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.ArraySchema;
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 com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.logger.sentry.SkipSentryException;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.RootInteraction;
class="kw">import com.hypixel.hytale.server.core.util.BsonUtil;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.expression.BuilderExpression;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.StringHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.StateStringValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.StringNotEmptyValidator;
class="kw">import com.hypixel.hytale.server.npc.config.balancing.BalanceAsset;
class="kw">import com.hypixel.hytale.server.npc.util.expression.ExecutionContext;
class="kw">import com.hypixel.hytale.server.npc.util.expression.ForwardedModifier;
class="kw">import com.hypixel.hytale.server.npc.util.expression.Scope;
class="kw">import com.hypixel.hytale.server.npc.util.expression.StdScope;
class="kw">import com.hypixel.hytale.server.npc.util.expression.ValueType;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectMaps;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectMap.Entry;
class="kw">import java.util.LinkedHashMap;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.function.Consumer;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class BuilderModifier class="kw">implements ForwardedModifier {
   class="kw">public class="kw">static class="kw">final String KEY_MODIFY = "Modify";
   class="kw">public class="kw">static class="kw">final String KEY_EXPORT_STATES = "_ExportStates";
   class="kw">public class="kw">static class="kw">final String KEY_INTERFACE_PARAMETERS = "_InterfaceParameters";
   class="kw">public class="kw">static class="kw">final String KEY_COMBAT_CONFIG = "_CombatConfig";
   class="kw">public class="kw">static class="kw">final String KEY_INTERACTION_VARS = "_InteractionVars";
   class="kw">public class="kw">static class="kw">final String KEY_FORWARDED_MODIFIERS = "_ForwardedModifiers";
   @Nonnull
   class="kw">public class="kw">static class="kw">final BuilderModifier CLEARED = new BuilderModifier(new Object2ObjectOpenHashMap(), new StatePair[0], null, null, null, null);
   class="kw">private class="kw">final Object2ObjectMap<String, BuilderModifier.ExpressionHolder> builderExpressionMap;
   class="kw">private class="kw">final StatePair[] exportedStateIndexes;
   class="kw">private class="kw">final StateMappingHelper stateHelper;
   class="kw">private class="kw">final String combatConfig;
   class="kw">private class="kw">final Map<String, String> interactionVars;
   @Nullable
   class="kw">private class="kw">final Map<String, BuilderModifier> forwardedModifiers;

   class="kw">protected BuilderModifier(
      Object2ObjectMap<String, BuilderModifier.ExpressionHolder> var1,
      StatePair[] var2,
      StateMappingHelper var3,
      String var4,
      Map<String, String> var5,
      @Nullable Map<String, BuilderModifier> var6
   ) {
      this.builderExpressionMap = var1;
      this.exportedStateIndexes = var2;
      this.stateHelper = var3;
      this.combatConfig = var4;
      this.interactionVars = var5;
      this.forwardedModifiers = var6;
   }

   class="kw">public String getCombatConfig() {
      class="kw">return this.combatConfig;
   }

   class="kw">public Map<String, String> getInteractionVars() {
      class="kw">return this.interactionVars;
   }

   @Nullable
   class="kw">public Map<String, BuilderModifier> getForwardedModifiers() {
      class="kw">return this.forwardedModifiers;
   }

   class="kw">public boolean isEmpty() {
      class="kw">return this.builderExpressionMap.isEmpty();
   }

   class="kw">public int exportedStateCount() {
      class="kw">return this.exportedStateIndexes.length;
   }

   class="kw">public void applyComponentStateMap(@Nonnull BuilderSupport var1) {
      var1.setModifiedStateMap(this.stateHelper, this.exportedStateIndexes);
   }

   class="kw">public void popComponentStateMap(@Nonnull BuilderSupport var1) {
      var1.popModifiedStateMap();
   }

   @Nonnull
   class="kw">public Scope createScope(@Nonnull BuilderSupport var1, @Nonnull BuilderParameters var2, Scope var3) {
      ExecutionContext var4 = var1.getExecutionContext();
      class="kw">return this.createScope(var4, var2, var3);
   }

   @Nonnull
   class="kw">public Scope createScope(ExecutionContext var1, @Nonnull BuilderParameters var2, @Nullable Scope var3) {
      StdScope var4 = var2.createScope();
      if (var3 != null) {
         StdScope var5 = new StdScope(var3);
         var5.merge(var4);
         var4 = var5;
      }

      this.applyTo(var4, var2, var1);
      class="kw">return var4;
   }

   class="kw">public void applyTo(@Nonnull StdScope var1, @Nonnull BuilderParameters var2, ExecutionContext var3) {
      ObjectIterator var4 = Object2ObjectMaps.fastIterator(this.builderExpressionMap);

      while (var4.hasNext()) {
         Entry var5 = (Entry<String, BuilderModifier.ExpressionHolder>)var4.next();
         String var6 = (String)var5.getKey();
         BuilderModifier.ExpressionHolder var7 = (BuilderModifier.ExpressionHolder)var5.getValue();
         ValueType var8 = var2.getParameterType(var6);
         BuilderExpression var9 = var7.getExpression(var2.getInterfaceCode());
         if (var9 != null) {
            if (var8 == ValueType.VOID) {
               throw new SkipSentryException(new IllegalStateException("Parameter " + var6 + " does not exist or is class="kw">private"));
            }

            if (!ValueType.isAssignableType(var9.getType(), var8)) {
               throw new SkipSentryException(new IllegalStateException("Parameter " + var6 + " has type " + var9.getType() + " but should be " + var8));
            }

            var9.updateScope(var1, var6, var3);
         }
      }
   }

   class="kw">public class="kw">static boolean validateForwardedModifiers(
      @Nonnull BuilderModifier var0,
      @Nonnull BuilderParameters var1,
      @Nonnull BuilderManager var2,
      @Nonnull ExecutionContext var3,
      String var4,
      @Nonnull List<String> var5
   ) {
      Map var6 = var0.getForwardedModifiers();
      if (var6 == null) {
         class="kw">return true;
      }

      boolean var7 = true;

      for (java.util.Map.Entry var9 : var6.entrySet()) {
         String var10 = var9.getKey();
         BuilderModifier var11 = var9.getValue();
         if (var11 != CLEARED) {
            if (!var1.getForwardingSlots().contains(var10)) {
               var5.add(String.format("%s: '%s' is not a forwardable component slot", var4, var10));
               var7 = false;
            } else {
               String var12;
               try {
                  var12 = var3.getScope().getStringSupplier(var10).get();
               } catch (RuntimeException var25) {
                  var5.add(String.format("%s: could not resolve a component for forwarded slot '%s': %s", var4, var10, var25.getMessage()));
                  var7 = false;
                  class="kw">continue;
               }

               if (var12 != null && !var12.isEmpty() && !var12.equals("$Null")) {
                  int var13 = var2.getIndex(var12);
                  BuilderInfo var14 = var13 >= 0 ? var2.tryGetBuilderInfo(var13) : null;
                  if (var14 == null) {
                     var5.add(String.format("%s: forwarded slot '%s' resolves to unknown component '%s'", var4, var10, var12));
                     var7 = false;
                  } else {
                     BuilderParameters var15 = var14.getBuilder().getBuilderParameters();
                     StdScope var16 = var15.createScope();
                     Scope var17 = var3.setScope(var16);

                     try {
                        var11.applyTo(var16, var15, var3);
                        var7 &= validateForwardedModifiers(var11, var15, var2, var3, var4, var5);
                     } catch (RuntimeException var23) {
                        var5.add(String.format("%s: forwarded modifier for slot '%s' (%s): %s", var4, var10, var12, var23.getMessage()));
                        var7 = false;
                     } class="kw">finally {
                        var3.setScope(var17);
                     }
                  }
               }
            }
         }
      }

      class="kw">return var7;
   }

   @Nonnull
   class="kw">public class="kw">static BuilderModifier fromJSON(@Nonnull JsonObject var0, @Nonnull BuilderParameters var1, @Nonnull StateMappingHelper var2, @Nonnull ExtraInfo var3) {
      JsonObject var4 = null;
      JsonElement var5 = var0.get("Modify");
      if (var5 != null) {
         var4 = BuilderBase.expectObject(var5, "Modify");
      }

      class="kw">return var4 != null && !var4.entrySet().isEmpty() ? fromModifyContents(var4, var1, var2, var3, true) : EmptyBuilderModifier.INSTANCE;
   }

   @Nonnull
   class="kw">private class="kw">static BuilderModifier fromModifyContents(
      @Nonnull JsonObject var0, @Nonnull BuilderParameters var1, @Nonnull StateMappingHelper var2, @Nonnull ExtraInfo var3, boolean var4
   ) {
      Object2ObjectMap var5 = new Object2ObjectOpenHashMap();
      List var6 = new ObjectArrayList();

      for (java.util.Map.Entry var8 : var0.entrySet()) {
         String var9 = var8.getKey();
         if (var5.containsKey(var9)) {
            throw new SkipSentryException(new IllegalStateException("Duplicate entry '" + var9 + "' in 'Modify' block"));
         }

         if (!var9.equals("_InterfaceParameters") && !var9.equals("_CombatConfig") && !var9.equals("_InteractionVars") && !var9.equals("_ForwardedModifiers")) {
            if (var9.equals("_ExportStates")) {
               if (!var4) {
                  throw new SkipSentryException(
                     new IllegalStateException(String.format("%s is not allowed inside a %s block", "_ExportStates", "_ForwardedModifiers"))
                  );
               }

               if (!var8.getValue().isJsonArray()) {
                  throw new SkipSentryException(new IllegalStateException(String.format("%s in modifier block must be a Json Array", "_ExportStates")));
               }

               StateStringValidator var21 = StateStringValidator.requireMainState();
               JsonArray var11 = var8.getValue().getAsJsonArray();

               for (int var12 = 0; var12 < var11.size(); var12++) {
                  String var13 = var11.get(var12).getAsString();
                  if (!var21.test(var13)) {
                     throw new SkipSentryException(new IllegalStateException(var21.errorMessage(var13)));
                  }

                  String var14 = var21.hasSubState() ? var21.getSubState() : var2.getDefaultSubState();
                  var2.getAndPutSetterIndex(var21.getMainState(), var14, (var2x, var3x) -> var6.add(new StatePair(var21.getMainState(), var2x, var3x)));
               }
            } else {
               BuilderExpression var10 = BuilderExpression.fromJSON(var8.getValue(), var1, false);
               var5.put(var9, new BuilderModifier.ExpressionHolder(var10));
            }
         }
      }

      JsonElement var16 = var0.get("_InterfaceParameters");
      if (var16 != null) {
         JsonObject var17 = BuilderBase.expectObject(var16, "_InterfaceParameters");

         for (java.util.Map.Entry var22 : var17.entrySet()) {
            String var24 = var22.getKey();
            JsonObject var26 = BuilderBase.expectObject(var22.getValue());

            for (java.util.Map.Entry var30 : var26.entrySet()) {
               BuilderModifier.ExpressionHolder var15 = (BuilderModifier.ExpressionHolder)var5.computeIfAbsent(
                  var30.getKey(), var0x -> new BuilderModifier.ExpressionHolder()
               );
               if (var15.hasInterfaceMappedExpression(var24)) {
                  throw new SkipSentryException(new IllegalStateException("Duplicate entry '" + var30.getKey() + "' in 'Modify' block for class="kw">interface '" + var24));
               }

               var15.addInterfaceMappedExpression(var24, BuilderExpression.fromJSON(var30.getValue(), var1, false));
            }
         }
      }

      String var18 = null;
      JsonElement var20 = var0.get("_CombatConfig");
      if (var20 != null) {
         var18 = BalanceAsset.CHILD_ASSET_CODEC.decode(BsonUtil.translateJsonToBson(var20), var3);
         var3.getValidationResults()._processValidationResults();
         var3.getValidationResults().logOrThrowValidatorExceptions(HytaleLogger.getLogger());
      }

      Map var23 = null;
      JsonElement var25 = var0.get("_InteractionVars");
      if (var25 != null) {
         var23 = RootInteraction.CHILD_ASSET_CODEC_MAP.decode(BsonUtil.translateJsonToBson(var25), var3);
         var3.getValidationResults()._processValidationResults();
         var3.getValidationResults().logOrThrowValidatorExceptions(HytaleLogger.getLogger());
      }

      Map var27 = null;
      JsonElement var29 = var0.get("_ForwardedModifiers");
      if (var29 != null) {
         var27 = parseForwardedModifiers(var29, var1, var2, var3);
      }

      class="kw">return new BuilderModifier(var5, var6.toArray(StatePair[]::new), var2, var18, var23, var27);
   }

   @Nonnull
   class="kw">private class="kw">static Map<String, BuilderModifier> parseForwardedModifiers(
      @Nonnull JsonElement var0, @Nonnull BuilderParameters var1, @Nonnull StateMappingHelper var2, @Nonnull ExtraInfo var3
   ) {
      JsonObject var4 = BuilderBase.expectObject(var0, "_ForwardedModifiers");
      Map var5 = new Object2ObjectOpenHashMap();

      for (java.util.Map.Entry var7 : var4.entrySet()) {
         String var8 = var7.getKey();
         JsonElement var9 = var7.getValue();
         if (var9.isJsonPrimitive() && var9.getAsJsonPrimitive().isString() && var9.getAsString().equals("$Null")) {
            var5.put(var8, CLEARED);
         } else {
            JsonObject var10 = BuilderBase.expectObject(var9, var8);
            var5.put(var8, fromModifyContents(var10, var1, var2, var3, false));
         }
      }

      class="kw">return var5;
   }

   class="kw">public class="kw">static void readModifierObject(
      @Nonnull JsonObject var0,
      @Nonnull BuilderParameters var1,
      @Nonnull StringHolder var2,
      @Nonnull Consumer<StringHolder> var3,
      @Nonnull Consumer<BuilderModifier> var4,
      @Nonnull StateMappingHelper var5,
      @Nonnull ExtraInfo var6
   ) {
      var2.readJSON(BuilderBase.expectKey(var0, "Reference"), StringNotEmptyValidator.get(), "Reference", var1);
      BuilderModifier var7 = fromJSON(var0, var1, var5, var6);
      var3.accept(var2);
      var4.accept(var7);
   }

   @Nonnull
   class="kw">public class="kw">static Schema toSchema(@Nonnull SchemaContext var0) {
      class="kw">return var0.refDefinition(BuilderModifier.SchemaGenerator.INSTANCE);
   }

   class="kw">private class="kw">static class ExpressionHolder {
      class="kw">private class="kw">final BuilderExpression expression;
      class="kw">private Object2ObjectMap<String, BuilderExpression> interfaceMappedExpressions;

      class="kw">public ExpressionHolder() {
         this(null);
      }

      class="kw">public ExpressionHolder(BuilderExpression var1) {
         this.expression = var1;
      }

      class="kw">public boolean hasInterfaceMappedExpression(String var1) {
         class="kw">return this.interfaceMappedExpressions != null && this.interfaceMappedExpressions.containsKey(var1);
      }

      class="kw">public void addInterfaceMappedExpression(String var1, BuilderExpression var2) {
         if (this.interfaceMappedExpressions == null) {
            this.interfaceMappedExpressions = new Object2ObjectOpenHashMap();
         }

         this.interfaceMappedExpressions.put(var1, var2);
      }

      class="kw">public BuilderExpression getExpression(@Nullable String var1) {
         class="kw">return var1 != null && this.interfaceMappedExpressions != null && this.interfaceMappedExpressions.containsKey(var1)
            ? (BuilderExpression)this.interfaceMappedExpressions.get(var1)
            : this.expression;
      }
   }

   class="kw">private class="kw">static class SchemaGenerator class="kw">implements SchemaConvertable<Void>, NamedSchema {
      @Nonnull
      class="kw">public class="kw">static class="kw">final BuilderModifier.SchemaGenerator INSTANCE = new BuilderModifier.SchemaGenerator();

      class="kw">private SchemaGenerator() {
      }

      @Nonnull
      @Override
      class="kw">public String getSchemaName() {
         class="kw">return "NPC:Type:BuilderModifier";
      }

      @Nonnull
      @Override
      class="kw">public Schema toSchema(@Nonnull SchemaContext var1) {
         ObjectSchema var2 = new ObjectSchema();
         var2.setTitle("BuilderModifier");
         LinkedHashMap var3 = new LinkedHashMap<>();
         var2.setProperties(var3);
         var3.put("_ExportStates", new ArraySchema(new StringSchema()));
         var3.put("_InterfaceParameters", new ObjectSchema());
         Schema var4 = var1.refDefinition(Codec.STRING);
         var4.setTitle("Reference to " + BalanceAsset.class.getSimpleName());
         Schema var5 = var1.refDefinition(BalanceAsset.CHILD_ASSET_CODEC);
         Schema var6 = Schema.anyOf(var4, var5);
         var3.put("_CombatConfig", var6);
         ObjectSchema var7 = new ObjectSchema();
         var7.setTitle("Map");
         Schema var8 = var1.refDefinition(RootInteraction.CHILD_ASSET_CODEC);
         var7.setAdditionalProperties(var8);
         var3.put("_InteractionVars", var7);
         ObjectSchema var9 = new ObjectSchema();
         var9.setTitle("ForwardedModifiers");
         var9.setAdditionalProperties(Schema.anyOf(var1.refDefinition(INSTANCE), StringSchema.constant("$Null")));
         var3.put("_ForwardedModifiers", var9);
         var2.setAdditionalProperties(BuilderExpression.toSchema(var1));
         class="kw">return var2;
      }
   }
}