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.logger.sentry.SkipSentryException;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.StringHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.providerevaluators.ReferenceProviderEvaluator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.StringArrayNotEmptyValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.StringNotEmptyValidator;
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 com.hypixel.hytale.server.npc.validators.NPCLoadTimeValidationHelper;
class="kw">import java.util.Arrays;
class="kw">import java.util.HashMap;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Objects;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class BuilderObjectReferenceHelper<T> class="kw">extends BuilderObjectHelper<T> {
   class="kw">public class="kw">static class="kw">final String KEY_REFERENCE = "Reference";
   class="kw">public class="kw">static class="kw">final String KEY_LOCAL = "Local";
   class="kw">public class="kw">static class="kw">final String KEY_INTERFACE_LIST = "Interfaces";
   class="kw">public class="kw">static class="kw">final String KEY_NULLABLE = "Nullable";
   class="kw">public class="kw">static class="kw">final String NULL_COMPONENT = "$Null";
   class="kw">public class="kw">static class="kw">final String KEY_LABEL = "$Label";
   class="kw">public class="kw">static class="kw">final String KEY_ACCEPTS_FORWARD = "AcceptsForward";
   @Nullable
   class="kw">protected Builder<T> builder;
   class="kw">protected class="kw">final StringHolder fileReference = new StringHolder();
   class="kw">protected String[] componentInterfaces;
   class="kw">protected int referenceIndex;
   class="kw">protected boolean isReference;
   class="kw">protected boolean isNullable;
   @Nullable
   class="kw">protected String forwardModifierSlot;
   @Nullable
   class="kw">protected BuilderModifier modifier;
   class="kw">protected FeatureEvaluatorHelper evaluatorHelper;
   class="kw">protected InternalReferenceResolver internalReferenceResolver;
   class="kw">protected boolean isInternalReference;
   class="kw">protected String label;

   class="kw">public BuilderObjectReferenceHelper(Class<?> var1, BuilderContext var2) {
      super(var1, var2);
      this.builder = null;
      this.referenceIndex = Integer.MIN_VALUE;
      this.modifier = null;
   }

   class="kw">public boolean excludeFromRegularBuild() {
      class="kw">return this.builder == null ? false : this.builder.excludeFromRegularBuilding();
   }

   @Nullable
   @Override
   class="kw">public T build(@Nonnull BuilderSupport var1) {
      if (!this.isPresent()) {
         class="kw">return null;
      }

      Builder var2 = this.getBuilder(var1.getBuilderManager(), var1, this.isNullable);
      if (var2 == null) {
         class="kw">return null;
      }

      StateMappingHelper var3 = var2.getStateMappingHelper();
      boolean var4 = this.builder == null && var3 != null && var3.hasComponentStates();
      if (var4) {
         var3.initialiseComponentState(var1);
      }

      ExecutionContext var5 = var1.getExecutionContext();
      BuilderModifier var6 = null;
      if (this.forwardModifierSlot != null) {
         BuilderModifier var7 = var1.getForwardedModifier(this.forwardModifierSlot);
         if (var7 != null && var7 != BuilderModifier.CLEARED) {
            var6 = var7;
         }
      }

      Map var14 = mergeForwardedModifiers(
         this.modifier != null ? this.modifier.getForwardedModifiers() : null, var6 != null ? var6.getForwardedModifiers() : null
      );
      if (this.modifier == null && var6 == null) {
         Map var15 = this.isReference ? var1.setForwardedModifiers(var14) : null;
         this.validateRequiredFeatures(var2, var1.getBuilderManager(), var5);
         Object var16 = var2.isEnabled(var5) ? var2.build(var1) : null;
         if (this.isReference) {
            var1.setForwardedModifiers(var15);
         }

         if (var4) {
            var3.popComponentState(var1);
         }

         class="kw">return var16;
      } else {
         Scope var8 = null;
         if (this.isInternalReference) {
            var8 = var1.getGlobalScope();
            Objects.requireNonNull(var8, "Global scope should not be null when applying to an internal component");
         }

         if (this.modifier != null && this.modifier.exportedStateCount() != var2.getStateMappingHelper().importedStateCount()) {
            throw new SkipSentryException(
               new IllegalStateException(
                  String.format("Number of exported states does not match imported states in component %s", this.fileReference.get(var5))
               )
            );
         }

         StdScope var9;
         if (this.modifier != null) {
            var9 = (StdScope)this.modifier.createScope(var1, var2.getBuilderParameters(), var8);
         } else {
            StdScope var10 = var2.getBuilderParameters().createScope();
            if (var8 != null) {
               StdScope var11 = new StdScope(var8);
               var11.merge(var10);
               var9 = var11;
            } else {
               var9 = var10;
            }
         }

         if (var6 != null) {
            var6.applyTo(var9, var2.getBuilderParameters(), var5);
         }

         Scope var17 = var5.setScope(var9);
         boolean var18 = this.modifier != null && this.modifier.exportedStateCount() > 0;
         if (var18) {
            this.modifier.applyComponentStateMap(var1);
         }

         Map var12 = var1.setForwardedModifiers(var14);
         this.validateRequiredFeatures(var2, var1.getBuilderManager(), var5);
         this.validateInstructionContext(var2, var1);
         Object var13 = var2.isEnabled(var5) ? var2.build(var1) : null;
         var1.setForwardedModifiers(var12);
         if (var18) {
            this.modifier.popComponentStateMap(var1);
         }

         if (var4) {
            var3.popComponentState(var1);
         }

         var5.setScope(var17);
         class="kw">return var13;
      }
   }

   @Nullable
   class="kw">private class="kw">static Map<String, BuilderModifier> mergeForwardedModifiers(@Nullable Map<String, BuilderModifier> var0, @Nullable Map<String, BuilderModifier> var1) {
      if (var0 == null || var0.isEmpty()) {
         class="kw">return var1;
      } else if (var1 != null && !var1.isEmpty()) {
         HashMap var2 = new HashMap<>(var0);
         var2.putAll(var1);
         class="kw">return var2;
      } else {
         class="kw">return var0;
      }
   }

   @Override
   class="kw">public boolean validate(
      String var1, NPCLoadTimeValidationHelper var2, @Nonnull BuilderManager var3, @Nonnull ExecutionContext var4, Scope var5, @Nonnull List<String> var6
   ) {
      if (!this.isPresent()) {
         class="kw">return true;
      }

      Builder var7;
      try {
         var7 = this.getBuilder(var3, var4, null);
      } catch (Exception var18) {
         var6.add(String.format("%s: %s", var1, var18.getMessage()));
         class="kw">return false;
      }

      if (var7 == null) {
         if (this.isNullable) {
            class="kw">return true;
         }

         var6.add(String.format("%s: %s is not a nullable component reference but a null component was passed", var1, this.fileReference.getExpressionString()));
         class="kw">return false;
      } else {
         BuilderModifier var8 = this.forwardModifierSlot == null ? null : forwardedModifierFor(var4, this.forwardModifierSlot);
         Map var9 = mergeForwardedModifiers(
            this.modifier != null ? this.modifier.getForwardedModifiers() : null, var8 != null ? var8.getForwardedModifiers() : null
         );
         if (this.modifier != null || var8 != null) {
            boolean var21 = true;
            if (this.modifier != null && this.modifier.exportedStateCount() != var7.getStateMappingHelper().importedStateCount()) {
               var6.add(String.format("%s: Number of exported states does not match imported states in component %s", var1, this.fileReference.get(var4)));
               var21 = false;
            }

            Scope var22 = this.isInternalReference ? var5 : null;

            StdScope var12;
            try {
               if (this.modifier != null) {
                  var12 = (StdScope)this.modifier.createScope(var4, var7.getBuilderParameters(), var22);
               } else {
                  StdScope var13 = var7.getBuilderParameters().createScope();
                  if (var22 != null) {
                     StdScope var14 = new StdScope(var22);
                     var14.merge(var13);
                     var12 = var14;
                  } else {
                     var12 = var13;
                  }
               }

               if (var8 != null) {
                  var8.applyTo(var12, var7.getBuilderParameters(), var4);
               }
            } catch (Exception var19) {
               var6.add(String.format("%s: %s", var1, var19.getMessage()));
               class="kw">return false;
            }

            Scope var23 = var4.setScope(var12);
            Map var24 = var4.setForwardedModifiers(var9);
            if (var7.isEnabled(var4)) {
               try {
                  this.validateRequiredFeatures(var7, var3, var4);
               } catch (Exception var17) {
                  var6.add(String.format("%s: %s", var1, var17.getMessage()));
                  var21 = false;
               }

               var21 &= var7.validate(var1, var2, var4, var5, var6);
            }

            var4.setForwardedModifiers(var24);
            var4.setScope(var23);
            class="kw">return var21;
         } else {
            if (!var7.isEnabled(var4)) {
               class="kw">return true;
            }

            boolean var10 = true;
            Map var11 = this.isReference ? var4.setForwardedModifiers(var9) : null;

            try {
               this.validateRequiredFeatures(var7, var3, var4);
            } catch (Exception var16) {
               var6.add(String.format("%s: %s", var1, var16.getMessage()));
               var10 = false;
            }

            var10 &= var7.validate(var1, var2, var4, var5, var6);
            if (this.isReference) {
               var4.setForwardedModifiers(var11);
            }

            class="kw">return var10;
         }
      }
   }

   @Nullable
   class="kw">private class="kw">static BuilderModifier forwardedModifierFor(@Nonnull ExecutionContext var0, @Nonnull String var1) {
      Map var2 = var0.getForwardedModifiers();
      if (var2 == null) {
         class="kw">return null;
      }

      ForwardedModifier var3 = var2.get(var1);
      class="kw">return var3 == BuilderModifier.CLEARED ? null : (BuilderModifier)var3;
   }

   @Nullable
   class="kw">public Builder<T> getBuilder(@Nonnull BuilderManager var1, @Nonnull BuilderSupport var2, boolean var3) {
      Builder var4 = this.getBuilder(var1, var2.getExecutionContext(), var2.getRootBuilder());
      if (!var3 && var4 == null) {
         throw new NullPointerException(String.format("ReferenceHelper failed to get builder: %s", this.getClassType().getSimpleName()));
      } else {
         class="kw">return var4;
      }
   }

   @Nullable
   class="kw">public Builder<T> getBuilder(@Nonnull BuilderManager var1, ExecutionContext var2, @Nullable Builder<?> var3) {
      if (this.builder != null) {
         class="kw">return this.builder;
      }

      if (this.isInternalReference) {
         class="kw">return this.internalReferenceResolver.getBuilder(this.referenceIndex, this.classType);
      }

      if (this.referenceIndex >= 0) {
         Builder var8 = var1.tryGetCachedValidBuilder(this.referenceIndex, this.classType);
         if (var8 == null) {
            throw new SkipSentryException(new IllegalStateException(String.format("Builder %s exists but is not valid!", var1.lookupName(this.referenceIndex))));
         } else {
            class="kw">return var8;
         }
      } else {
         String var4 = this.fileReference.get(var2);
         if (var4.equals("$Null")) {
            class="kw">return null;
         }

         int var5 = var1.getIndex(var4);
         if (var5 >= 0) {
            if (var3 != null) {
               var3.addDynamicDependency(var5);
            }

            Builder var6 = var1.getCachedBuilder(var5, this.classType);
            String var7 = var6.getBuilderParameters().getInterfaceCode();
            this.validateComponentInterfaceMatch(var7);
            class="kw">return var6;
         } else if (!var4.isEmpty()) {
            throw new SkipSentryException(new IllegalStateException("Failed to find builder for: " + var4));
         } else {
            class="kw">return null;
         }
      }
   }

   @Override
   class="kw">public void readConfig(@Nonnull JsonElement var1, @Nonnull BuilderManager var2, @Nonnull BuilderParameters var3, @Nonnull BuilderValidationHelper var4) {
      this.readConfig(var1, var2.getFactory(this.classType), var2, var3, var4);
   }

   class="kw">public void readConfig(
      @Nonnull JsonElement var1,
      @Nonnull BuilderFactory<T> var2,
      @Nonnull BuilderManager var3,
      @Nonnull BuilderParameters var4,
      @Nonnull BuilderValidationHelper var5
   ) {
      super.readConfig(var1, var3, var4, var5);
      if (var1.isJsonNull()) {
         this.builder = null;
      } else if (var1.isJsonPrimitive() && var1.getAsJsonPrimitive().isString()) {
         var5.getReadErrors()
            .add(var5.getName() + ": String reference '" + var1.getAsString() + "' to a component is deprecated. Use the 'Reference' parameter instead.");
      } else {
         JsonObject var6 = var1.isJsonObject() ? var1.getAsJsonObject() : null;
         JsonElement var7 = var6 != null ? var6.get("Reference") : null;
         if (var7 != null) {
            try {
               if (BuilderBase.readBoolean(var6, "Local", false)) {
                  BuilderModifier.readModifierObject(
                     var1.getAsJsonObject(),
                     var4,
                     this.fileReference,
                     var2x -> this.setInternalReference(var2x, var5.getInternalReferenceResolver()),
                     var1x -> this.modifier = var1x,
                     var5.getStateMappingHelper(),
                     var5.getExtraInfo()
                  );
               } else {
                  JsonObject var8 = var1.getAsJsonObject();
                  BuilderModifier.readModifierObject(
                     var8,
                     var4,
                     this.fileReference,
                     var3x -> this.setFileReference(var3x, var8, var3),
                     var1x -> this.modifier = var1x,
                     var5.getStateMappingHelper(),
                     var5.getExtraInfo()
                  );
               }

               FeatureEvaluatorHelper var10 = var5.getFeatureEvaluatorHelper();
               if (var10 != null) {
                  if (var10.canAddProvider()) {
                     var10.add(new ReferenceProviderEvaluator(this.referenceIndex, this.classType));
                     var10.setContainsReference();
                     class="kw">return;
                  }

                  this.evaluatorHelper = var10;
               }
            } catch (IllegalArgumentException | IllegalStateException var9) {
               var5.getReadErrors().add(var5.getName() + ": " + var9.getMessage() + " at " + this.getBreadCrumbs());
            }
         } else {
            this.builder = var2.createBuilder(var1);
            if (this.builder.isDeprecated()) {
               var3.checkIfDeprecated(this.builder, var2, var1, var4.getFileName(), this.getBreadCrumbs());
            }

            if (var1.isJsonObject() && var1.getAsJsonObject().has("$Label") && var1.getAsJsonObject().get("$Label").isJsonPrimitive()) {
               this.builder.setLabel(var1.getAsJsonObject().get("$Label").getAsString());
            } else {
               this.builder.setLabel(var2.getKeyName(var1));
            }

            this.builder.readConfig(this, var1, var3, var4, var5);
         }
      }
   }

   class="kw">protected void setInternalReference(@Nonnull StringHolder var1, InternalReferenceResolver var2) {
      this.isInternalReference = true;
      this.isReference = true;
      if (var1.isStatic()) {
         this.internalReferenceResolver = var2;
         this.referenceIndex = this.internalReferenceResolver.getOrCreateIndex(var1.get(null));
      }
   }

   class="kw">protected void setFileReference(@Nonnull StringHolder var1, @Nonnull JsonObject var2, @Nonnull BuilderManager var3) {
      this.isInternalReference = false;
      this.isReference = true;
      this.componentInterfaces = BuilderBase.readStringArray(var2, "Interfaces", StringNotEmptyValidator.get(), null);
      this.isNullable = BuilderBase.readBoolean(var2, "Nullable", false);
      if (BuilderBase.readBoolean(var2, "AcceptsForward", false)) {
         if (var1.isStatic()) {
            throw new SkipSentryException(
               new IllegalStateException("'AcceptsForward' requires a computable parameter reference, e.g. \"Reference\": { \"Compute\": \"<parameter>\" }.")
            );
         }

         String var4 = var1.getExpressionString();
         if (this.builderParameters.getParameterType(var4) == ValueType.VOID) {
            throw new SkipSentryException(
               new IllegalStateException("'AcceptsForward' requires the 'Reference' to be a single parameter; '" + var4 + "' is not a parameter.")
            );
         }

         this.forwardModifierSlot = var4;
         this.builderParameters.registerForwardingSlot(var4);
      }

      if (var1.isStatic()) {
         this.referenceIndex = var3.getOrCreateIndex(var1.get(null));
         this.builderParameters.addDependency(this.referenceIndex);
      } else if (!StringArrayNotEmptyValidator.get().test(this.componentInterfaces)) {
         throw new SkipSentryException(
            new IllegalStateException("Computable references must define a list of 'Interfaces' to control which components can be attached.")
         );
      }
   }

   class="kw">private void validateRequiredFeatures(@Nonnull Builder<T> var1, BuilderManager var2, ExecutionContext var3) {
      var1.validateReferencedProvidedFeatures(var2, var3);
      if (this.evaluatorHelper != null) {
         this.evaluatorHelper.validateProviderReferences(var2, var3);
         var1.getEvaluatorHelper().validateComponentRequirements(this.evaluatorHelper, var3);
      }
   }

   class="kw">private void validateInstructionContext(@Nonnull Builder<T> var1, @Nonnull BuilderSupport var2) {
      InstructionContextHelper var3 = var1.getInstructionContextHelper();
      if (var3 != null && !this.isInternalReference) {
         var3.validateComponentContext(var2.getCurrentInstructionContext(), var2.getCurrentComponentContext());
      }
   }

   class="kw">private void validateComponentInterfaceMatch(String var1) {
      for (String var5 : this.componentInterfaces) {
         if (var5.equals(var1)) {
            class="kw">return;
         }
      }

      throw new SkipSentryException(
         new IllegalStateException(String.format("Component code %s does not match any of slot codes: %s.", var1, Arrays.toString(this.componentInterfaces)))
      );
   }

   @Override
   class="kw">public boolean isPresent() {
      class="kw">return this.isFinal() || this.isReference;
   }

   class="kw">public boolean isFinal() {
      class="kw">return this.builder != null;
   }

   @Override
   class="kw">public String getLabel() {
      class="kw">return this.label;
   }

   class="kw">public void setLabel(String var1) {
      this.label = var1;
   }
}