class="kw">package com.hypixel.hytale.server.core.modules.entitystats;

class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.codec.codecs.map.MapCodec;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.asset.EntityStatType;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.modifier.Modifier;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.modifier.StaticModifier;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import java.util.Arrays;
class="kw">import java.util.HashMap;
class="kw">import java.util.Map;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class EntityStatValue {
   class="kw">public class="kw">static class="kw">final EntityStatValue[] EMPTY_ARRAY = new EntityStatValue[0];
   class="kw">public class="kw">static class="kw">final BuilderCodec<EntityStatValue> CODEC = BuilderCodec.<EntityStatValue>builder(EntityStatValue.class, EntityStatValue::new)
      .addField(new KeyedCodec<>("Id", Codec.STRING), (var0, var1) -> var0.id = var1, var0 -> var0.id)
      .addField(new KeyedCodec<>("Value", Codec.FLOAT), (var0, var1) -> var0.value = var1, var0 -> var0.value)
      .addField(
         new KeyedCodec<>("Modifiers", new MapCodec<>(Modifier.CODEC, HashMap::new, false)),
         (var0, var1) -> var0.modifiers = var1,
         var0 -> var0.modifiers != null && !var0.modifiers.isEmpty() ? var0.modifiers : null
      )
      .build();
   class="kw">private String id;
   class="kw">private int index = Integer.MIN_VALUE;
   class="kw">private float value;
   class="kw">private float min;
   class="kw">private float max;
   class="kw">private boolean ignoreInvulnerability;
   @Nullable
   class="kw">private RegeneratingValue[] regeneratingValues;
   @Nullable
   class="kw">private Map<String, Modifier> modifiers;

   class="kw">protected EntityStatValue() {
   }

   class="kw">public EntityStatValue(int var1, @Nonnull EntityStatType var2) {
      this.id = var2.getId();
      this.index = var1;
      this.value = var2.getInitialValue();
      this.synchronizeAsset(var1, var2);
   }

   class="kw">public String getId() {
      class="kw">return this.id;
   }

   class="kw">public int getIndex() {
      class="kw">return this.index;
   }

   class="kw">public float get() {
      class="kw">return this.value;
   }

   class="kw">public float asPercentage() {
      class="kw">return this.min == this.max ? 0.0F : (this.value - this.min) / (this.max - this.min);
   }

   class="kw">public float getMin() {
      class="kw">return this.min;
   }

   class="kw">public float getMax() {
      class="kw">return this.max;
   }

   class="kw">protected float set(float var1) {
      class="kw">return this.value = MathUtil.clamp(var1, this.min, this.max);
   }

   @Nullable
   class="kw">public RegeneratingValue[] getRegeneratingValues() {
      class="kw">return this.regeneratingValues;
   }

   @Nullable
   class="kw">public Modifier getModifier(String var1) {
      class="kw">return this.modifiers == null ? null : this.modifiers.get(var1);
   }

   class="kw">public boolean getIgnoreInvulnerability() {
      class="kw">return this.ignoreInvulnerability;
   }

   @Nullable
   class="kw">public Map<String, Modifier> getModifiers() {
      class="kw">return this.modifiers;
   }

   @Nullable
   class="kw">protected Modifier putModifier(String var1, Modifier var2) {
      if (this.modifiers == null) {
         this.modifiers = new Object2ObjectOpenHashMap();
      }

      Modifier var3 = this.modifiers.put(var1, var2);
      this.computeModifiers(EntityStatType.getAssetMap().getAsset(this.index));
      class="kw">return var3;
   }

   @Nullable
   class="kw">protected Modifier removeModifier(String var1) {
      if (this.modifiers == null) {
         class="kw">return null;
      }

      Modifier var2 = this.modifiers.remove(var1);
      if (var2 != null) {
         this.computeModifiers(EntityStatType.getAssetMap().getAsset(this.index));
      }

      class="kw">return var2;
   }

   class="kw">public boolean synchronizeAsset(int var1, @Nonnull EntityStatType var2) {
      this.id = var2.getId();
      this.index = var1;
      this.initializeRegenerating(var2);
      boolean var3 = this.min != var2.getMin() || this.max != var2.getMax();
      this.ignoreInvulnerability = var2.getIgnoreInvulnerability();
      float var4 = this.value;
      this.computeModifiers(var2);
      class="kw">return var3 || this.value != var4;
   }

   class="kw">private void initializeRegenerating(@Nonnull EntityStatType var1) {
      EntityStatType.Regenerating[] var2 = var1.getRegenerating();
      if (var2 != null) {
         this.regeneratingValues = new RegeneratingValue[var2.length];

         for (int var3 = 0; var3 < var2.length; var3++) {
            this.regeneratingValues[var3] = new RegeneratingValue(var2[var3]);
         }
      }
   }

   class="kw">protected void computeModifiers(@Nonnull EntityStatType var1) {
      this.min = var1.getMin();
      this.max = var1.getMax();
      if (this.modifiers != null) {
         for (Modifier.ModifierTarget var5 : Modifier.ModifierTarget.VALUES) {
            boolean var6 = false;
            float var7 = 0.0F;
            boolean var8 = false;
            float var9 = 0.0F;

            for (Modifier var11 : this.modifiers.values()) {
               if (var11 class="kw">instanceof StaticModifier var12 && var12.getTarget() == var5) {
                  class="kw">switch (var12.getCalculationType()) {
                     case ADDITIVE:
                        var6 = true;
                        var7 += var12.getAmount();
                        break;
                     case MULTIPLICATIVE:
                        var8 = true;
                        var9 += var12.getAmount();
                  }
               }
            }

            class="kw">switch (var5) {
               case MIN:
                  if (var6) {
                     this.min = StaticModifier.CalculationType.ADDITIVE.compute(this.min, var7);
                  }

                  if (var8) {
                     this.min = StaticModifier.CalculationType.MULTIPLICATIVE.compute(this.min, var9);
                  }
                  break;
               case MAX:
                  if (var6) {
                     this.max = StaticModifier.CalculationType.ADDITIVE.compute(this.max, var7);
                  }

                  if (var8) {
                     this.max = StaticModifier.CalculationType.MULTIPLICATIVE.compute(this.max, var9);
                  }
            }
         }

         for (Modifier var14 : this.modifiers.values()) {
            if (!(var14 class="kw">instanceof StaticModifier)) {
               this.applyModifier(var14);
            }
         }
      }

      this.value = MathUtil.clamp(this.value, this.min, this.max);
   }

   class="kw">private void applyModifier(@Nonnull Modifier var1) {
      class="kw">switch (var1.getTarget()) {
         case MIN:
            this.min = var1.apply(this.min);
            break;
         case MAX:
            this.max = var1.apply(this.max);
      }
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "EntityStatValue{id='"
         + this.id
         + "', index="
         + this.index
         + ", value="
         + this.value
         + ", min="
         + this.min
         + ", max="
         + this.max
         + ", regeneratingValues="
         + Arrays.toString(this.regeneratingValues)
         + ", modifiers="
         + this.modifiers
         + "}";
   }
}