class="kw">package com.hypixel.hytale.server.core.asset.type.item.config;

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.EnumCodec;
class="kw">import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
class="kw">import com.hypixel.hytale.codec.codecs.map.EnumMapCodec;
class="kw">import com.hypixel.hytale.codec.codecs.map.MapCodec;
class="kw">import com.hypixel.hytale.codec.validation.Validators;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.protocol.Cosmetic;
class="kw">import com.hypixel.hytale.protocol.ItemArmorSlot;
class="kw">import com.hypixel.hytale.protocol.Modifier;
class="kw">import com.hypixel.hytale.protocol.ResistanceModifier;
class="kw">import com.hypixel.hytale.server.core.io.NetworkSerializable;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.EntityStatMap;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.EntityStatsModule;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.RegeneratingValue;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.asset.EntityStatType;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.modifier.StaticModifier;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.server.combat.DamageClass;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import java.util.ArrayList;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collections;
class="kw">import java.util.HashMap;
class="kw">import java.util.List;
class="kw">import java.util.Locale;
class="kw">import java.util.Map;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class ItemArmor class="kw">implements NetworkSerializable<com.hypixel.hytale.protocol.ItemArmor> {
   class="kw">public class="kw">static class="kw">final BuilderCodec<ItemArmor> CODEC = BuilderCodec.builder(ItemArmor.class, ItemArmor::new)
      .append(new KeyedCodec<>("ArmorSlot", new EnumCodec<>(ItemArmorSlot.class)), (var0, var1) -> var0.armorSlot = var1, var0 -> var0.armorSlot)
      .addValidator(Validators.nonNull())
      .add()
      .<Map>append(
         new KeyedCodec<>(
            "DamageResistance",
            new MapCodec<>(
               new ArrayCodec<>(
                  com.hypixel.hytale.server.core.modules.entity.damage.ResistanceModifier.CODEC,
                  com.hypixel.hytale.server.core.modules.entity.damage.ResistanceModifier[]::new
               ),
               HashMap::new
            )
         ),
         (var0, var1) -> var0.damageResistanceValuesRaw = var1,
         var0 -> var0.damageResistanceValuesRaw
      )
      .addValidator(DamageCause.VALIDATOR_CACHE.getMapKeyValidator())
      .add()
      .<Map>append(
         new KeyedCodec<>("DamageEnhancement", new MapCodec<>(new ArrayCodec<>(StaticModifier.CODEC, StaticModifier[]::new), HashMap::new)),
         (var0, var1) -> var0.damageEnhancementValuesRaw = var1,
         var0 -> var0.damageEnhancementValuesRaw
      )
      .addValidator(DamageCause.VALIDATOR_CACHE.getMapKeyValidator())
      .add()
      .<Map<DamageClass, StaticModifier[]>>appendInherited(
         new KeyedCodec<>("DamageClassEnhancement", new EnumMapCodec<>(DamageClass.class, new ArrayCodec<>(StaticModifier.CODEC, StaticModifier[]::new))),
         (var0, var1) -> var0.damageClassEnhancement = var1,
         var0 -> var0.damageClassEnhancement,
         (var0, var1) -> var0.damageClassEnhancement = var1.damageClassEnhancement
      )
      .addValidator(Validators.nonNull())
      .add()
      .<Map>append(
         new KeyedCodec<>("KnockbackResistances", new MapCodec<>(Codec.FLOAT, HashMap::new)),
         (var0, var1) -> var0.knockbackResistancesRaw = var1,
         var0 -> var0.knockbackResistancesRaw
      )
      .addValidator(DamageCause.VALIDATOR_CACHE.getMapKeyValidator())
      .add()
      .<Map>append(
         new KeyedCodec<>("KnockbackEnhancements", new MapCodec<>(Codec.FLOAT, HashMap::new)),
         (var0, var1) -> var0.knockbackEnhancementsRaw = var1,
         var0 -> var0.knockbackEnhancementsRaw
      )
      .addValidator(DamageCause.VALIDATOR_CACHE.getMapKeyValidator())
      .add()
      .<Map>append(
         new KeyedCodec<>("Regenerating", new MapCodec<>(new ArrayCodec<>(EntityStatType.Regenerating.CODEC, EntityStatType.Regenerating[]::new), HashMap::new)),
         (var0, var1) -> var0.regenerating = var1,
         var0 -> var0.regenerating
      )
      .addValidator(EntityStatType.VALIDATOR_CACHE.getMapKeyValidator())
      .add()
      .append(new KeyedCodec<>("BaseDamageResistance", Codec.DOUBLE), (var0, var1) -> var0.baseDamageResistance = var1, var0 -> var0.baseDamageResistance)
      .add()
      .append(
         new KeyedCodec<>("StatModifiers", new MapCodec<>(new ArrayCodec<>(StaticModifier.CODEC, StaticModifier[]::new), HashMap::new)),
         (var0, var1) -> var0.rawStatModifiers = var1,
         var0 -> var0.rawStatModifiers
      )
      .add()
      .append(
         new KeyedCodec<>("InteractionModifiers", new MapCodec<>(new MapCodec<>(StaticModifier.CODEC, HashMap::new), HashMap::new)),
         (var0, var1) -> var0.interactionModifiersRaw = var1,
         var0 -> var0.interactionModifiersRaw
      )
      .add()
      .append(
         new KeyedCodec<>("CosmeticsToHide", new ArrayCodec<>(new EnumCodec<>(Cosmetic.class), Cosmetic[]::new)),
         (var0, var1) -> var0.cosmeticsToHide = var1,
         var0 -> var0.cosmeticsToHide
      )
      .add()
      .append(new KeyedCodec<>("MovementSettings", ItemMovementSettings.CODEC), (var0, var1) -> var0.movementSettings = var1, var0 -> var0.movementSettings)
      .add()
      .afterDecode(var0 -> processConfig(var0))
      .build();
   @Nonnull
   class="kw">protected ItemArmorSlot armorSlot = ItemArmorSlot.Head;
   @Nullable
   class="kw">protected Map<String, com.hypixel.hytale.server.core.modules.entity.damage.ResistanceModifier[]> damageResistanceValuesRaw;
   @Nullable
   class="kw">protected Map<DamageCause, com.hypixel.hytale.server.core.modules.entity.damage.ResistanceModifier[]> damageResistanceValues;
   @Nullable
   class="kw">protected Map<String, StaticModifier[]> damageEnhancementValuesRaw;
   @Nullable
   class="kw">protected Map<DamageCause, StaticModifier[]> damageEnhancementValues;
   class="kw">protected double baseDamageResistance;
   @Nullable
   class="kw">protected Map<String, StaticModifier[]> rawStatModifiers;
   @Nullable
   class="kw">protected Int2ObjectMap<StaticModifier[]> statModifiers;
   class="kw">protected Cosmetic[] cosmeticsToHide;
   @Nullable
   class="kw">protected Map<String, EntityStatType.Regenerating[]> regenerating;
   @Nullable
   class="kw">protected Int2ObjectMap<List<RegeneratingValue>> regeneratingValues;
   @Nullable
   class="kw">protected Map<String, Float> knockbackResistancesRaw;
   @Nullable
   class="kw">protected Map<DamageCause, Float> knockbackResistances;
   @Nullable
   class="kw">protected Map<String, Float> knockbackEnhancementsRaw;
   @Nullable
   class="kw">protected Map<DamageCause, Float> knockbackEnhancements;
   @Nullable
   class="kw">protected Map<String, Map<String, StaticModifier>> interactionModifiersRaw;
   @Nullable
   class="kw">protected Map<String, Int2ObjectMap<StaticModifier>> interactionModifiers;
   @Nonnull
   class="kw">protected Map<DamageClass, StaticModifier[]> damageClassEnhancement = Collections.emptyMap();
   @Nullable
   class="kw">protected ItemMovementSettings movementSettings;

   class="kw">public ItemArmor(ItemArmorSlot var1, double var2, @Nullable Int2ObjectMap<StaticModifier[]> var4, Cosmetic[] var5) {
      this.armorSlot = var1;
      this.baseDamageResistance = var2;
      this.statModifiers = var4;
      this.cosmeticsToHide = var5;
   }

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

   @Nonnull
   class="kw">public com.hypixel.hytale.protocol.ItemArmor toPacket() {
      com.hypixel.hytale.protocol.ItemArmor var1 = new com.hypixel.hytale.protocol.ItemArmor();
      var1.armorSlot = this.armorSlot;
      var1.cosmeticsToHide = this.cosmeticsToHide;
      var1.statModifiers = EntityStatMap.toPacket(this.statModifiers);
      var1.baseDamageResistance = this.baseDamageResistance;
      if (this.damageResistanceValues != null && !this.damageResistanceValues.isEmpty()) {
         Map var2 = new Object2ObjectOpenHashMap();

         for (Entry var4 : this.damageResistanceValues.entrySet()) {
            if (var4.getKey() != null && var4.getValue() != null) {
               ResistanceModifier[] var5 = new ResistanceModifier[((com.hypixel.hytale.server.core.modules.entity.damage.ResistanceModifier[])var4.getValue()).length];

               for (int var6 = 0; var6 < ((com.hypixel.hytale.server.core.modules.entity.damage.ResistanceModifier[])var4.getValue()).length; var6++) {
                  var5[var6] = var4.getValue()[var6].toPacket();
               }

               var2.put(var4.getKey().getId(), var5);
            }
         }

         var1.damageResistance = var2.isEmpty() ? null : var2;
      }

      if (this.damageClassEnhancement != null && !this.damageClassEnhancement.isEmpty()) {
         Map var7 = new Object2ObjectOpenHashMap();

         for (Entry var11 : this.damageClassEnhancement.entrySet()) {
            if (var11.getKey() != null && var11.getValue() != null) {
               Modifier[] var13 = new Modifier[((StaticModifier[])var11.getValue()).length];

               for (int var15 = 0; var15 < ((StaticModifier[])var11.getValue()).length; var15++) {
                  var13[var15] = var11.getValue()[var15].toPacket();
               }

               var7.put(var11.getKey().name().toLowerCase(Locale.ROOT), var13);
            }
         }

         var1.damageClassEnhancement = var7.isEmpty() ? null : var7;
      }

      if (this.damageEnhancementValues != null && !this.damageEnhancementValues.isEmpty()) {
         Map var8 = new Object2ObjectOpenHashMap();

         for (Entry var12 : this.damageEnhancementValues.entrySet()) {
            if (var12.getKey() != null && var12.getValue() != null) {
               Modifier[] var14 = new Modifier[((StaticModifier[])var12.getValue()).length];

               for (int var16 = 0; var16 < ((StaticModifier[])var12.getValue()).length; var16++) {
                  var14[var16] = var12.getValue()[var16].toPacket();
               }

               var8.put(var12.getKey().getId(), var14);
            }
         }

         var1.damageEnhancement = var8.isEmpty() ? null : var8;
      }

      if (this.movementSettings != null) {
         var1.movementSettings = this.movementSettings.toPacket();
      }

      class="kw">return var1;
   }

   class="kw">public ItemArmorSlot getArmorSlot() {
      class="kw">return this.armorSlot;
   }

   class="kw">public double getBaseDamageResistance() {
      class="kw">return this.baseDamageResistance;
   }

   @Nullable
   class="kw">public Int2ObjectMap<List<RegeneratingValue>> getRegeneratingValues() {
      class="kw">return this.regeneratingValues;
   }

   @Nullable
   class="kw">public Int2ObjectMap<StaticModifier[]> getStatModifiers() {
      class="kw">return this.statModifiers;
   }

   @Nullable
   class="kw">public Map<DamageCause, com.hypixel.hytale.server.core.modules.entity.damage.ResistanceModifier[]> getDamageResistanceValues() {
      class="kw">return this.damageResistanceValues;
   }

   @Nullable
   class="kw">public Map<DamageCause, StaticModifier[]> getDamageEnhancementValues() {
      class="kw">return this.damageEnhancementValues;
   }

   @Nonnull
   class="kw">public Map<DamageClass, StaticModifier[]> getDamageClassEnhancement() {
      class="kw">return this.damageClassEnhancement;
   }

   @Nullable
   class="kw">public Map<DamageCause, Float> getKnockbackEnhancements() {
      class="kw">return this.knockbackEnhancements;
   }

   @Nullable
   class="kw">public Map<DamageCause, Float> getKnockbackResistances() {
      class="kw">return this.knockbackResistances;
   }

   @Nullable
   class="kw">public Int2ObjectMap<StaticModifier> getInteractionModifier(String var1) {
      class="kw">return this.interactionModifiers == null ? null : this.interactionModifiers.get(var1);
   }

   class="kw">private class="kw">static void processConfig(@Nonnull ItemArmor var0) {
      processStatModifiers(var0);
      processRegenModifiers(var0);
      processInteractionModifiers(var0);
      var0.damageResistanceValues = convertStringKeyToDamageCause(var0.damageResistanceValuesRaw);
      var0.damageEnhancementValues = convertStringKeyToDamageCause(var0.damageEnhancementValuesRaw);
      var0.knockbackResistances = convertStringKeyToDamageCause(var0.knockbackResistancesRaw);
      var0.knockbackEnhancements = convertStringKeyToDamageCause(var0.knockbackEnhancementsRaw);
   }

   class="kw">private class="kw">static void processStatModifiers(@Nonnull ItemArmor var0) {
      var0.statModifiers = EntityStatsModule.resolveEntityStats(var0.rawStatModifiers);
   }

   class="kw">private class="kw">static void processRegenModifiers(@Nonnull ItemArmor var0) {
      if (var0.regenerating != null) {
         Int2ObjectMap var1 = new Int2ObjectOpenHashMap();

         for (Entry var3 : var0.regenerating.entrySet()) {
            int var4 = EntityStatType.getAssetMap().getIndex(var3.getKey());
            if (var4 != Integer.MIN_VALUE) {
               EntityStatType.Regenerating[] var5 = var3.getValue();
               List var6 = (List<RegeneratingValue>)var1.computeIfAbsent(var4, ArrayList::new);

               for (EntityStatType.Regenerating var10 : var5) {
                  var6.add(new RegeneratingValue(var10));
               }
            }
         }

         var0.regeneratingValues = var1;
      }
   }

   class="kw">private class="kw">static void processInteractionModifiers(@Nonnull ItemArmor var0) {
      if (var0.interactionModifiersRaw != null) {
         Map var1 = new Object2ObjectOpenHashMap();

         for (Entry var3 : var0.interactionModifiersRaw.entrySet()) {
            String var4 = var3.getKey();

            for (Entry var6 : var3.getValue().entrySet()) {
               int var7 = EntityStatType.getAssetMap().getIndex(var6.getKey());
               if (var7 != Integer.MIN_VALUE) {
                  StaticModifier var8 = var6.getValue();
                  Int2ObjectMap var9 = var1.computeIfAbsent(var4, var0x -> new Int2ObjectOpenHashMap());
                  if (var9.get(var7) == null) {
                     var9.put(var7, new StaticModifier(var8.getTarget(), var8.getCalculationType(), var8.getAmount()));
                  } else {
                     HytaleLogger var10 = HytaleLogger.forEnclosingClass();
                     var10.at(Level.SEVERE)
                        .log(
                           "ItemArmor::processInteractionModifiers - Interaction Mod %s / %s has multiple entries on the same object %s",
                           var4,
                           var6.getKey(),
                           var0.armorSlot.name()
                        );
                  }
               }
            }
         }

         var0.interactionModifiers = var1;
      }
   }

   @Nullable
   class="kw">public class="kw">static <T> Map<DamageCause, T> convertStringKeyToDamageCause(@Nullable Map<String, T> var0) {
      if (var0 == null) {
         class="kw">return null;
      }

      Map var1 = new Object2ObjectOpenHashMap();

      for (Entry var3 : var0.entrySet()) {
         DamageCause var4 = DamageCause.getAssetMap().getAsset(var3.getKey());
         if (var4 != null) {
            var1.put(var4, var3.getValue());
         }
      }

      class="kw">return var1;
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "ItemArmor{armorSlot="
         + this.armorSlot
         + ", damageResistanceValues="
         + this.damageResistanceValues
         + ", damageEnhancementValues="
         + this.damageEnhancementValues
         + ", baseDamageResistance="
         + this.baseDamageResistance
         + ", rawStatModifiers="
         + this.rawStatModifiers
         + ", statModifiers="
         + this.statModifiers
         + ", cosmeticsToHide="
         + Arrays.toString(this.cosmeticsToHide)
         + ", regenerating="
         + this.regenerating
         + ", regeneratingValues="
         + this.regeneratingValues
         + ", knockbackResistances="
         + this.knockbackResistances
         + ", knockbackEnhancements="
         + this.knockbackEnhancements
         + ", interactionModifiersRaw="
         + this.interactionModifiersRaw
         + ", interactionModifiers="
         + this.interactionModifiers
         + "}";
   }

   class="kw">public enum InteractionModifierId {
      Dodge;

      InteractionModifierId() {
      }
   }
}