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

class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.server.core.asset.type.entityeffect.config.EntityEffect;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.BrokenPenalties;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.config.Item;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.config.ItemArmor;
class="kw">import com.hypixel.hytale.server.core.entity.effect.EffectControllerComponent;
class="kw">import com.hypixel.hytale.server.core.inventory.InventoryComponent;
class="kw">import com.hypixel.hytale.server.core.inventory.ItemStack;
class="kw">import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.EntityStatMap;
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 com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
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.ints.IntIterator;
class="kw">import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
class="kw">import it.unimi.dsi.fastutil.ints.IntSet;
class="kw">import it.unimi.dsi.fastutil.objects.Object2FloatMap;
class="kw">import it.unimi.dsi.fastutil.objects.Object2FloatOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import it.unimi.dsi.fastutil.objects.Object2FloatMap.Entry;
class="kw">import java.util.Iterator;
class="kw">import java.util.function.Function;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class StatModifiersManager {
   class="kw">private boolean recalculate = true;
   @Nonnull
   class="kw">private class="kw">final IntSet statsToClear = new IntOpenHashSet();

   class="kw">public StatModifiersManager() {
   }

   class="kw">public void scheduleRecalculate() {
      this.recalculate = true;
   }

   class="kw">public void queueEntityStatsToClear(@Nonnull int[] var1) {
      for (int var2 = 0; var2 < var1.length; var2++) {
         this.statsToClear.add(var1[var2]);
      }
   }

   class="kw">public void recalculateEntityStatModifiers(@Nonnull Ref<EntityStore> var1, @Nonnull EntityStatMap var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      if (this.recalculate) {
         this.recalculate = false;
         if (!this.statsToClear.isEmpty()) {
            IntIterator var4 = this.statsToClear.iterator();

            while (var4.hasNext()) {
               var2.minimizeStatValue(EntityStatMap.Predictable.SELF, var4.nextInt());
            }

            this.statsToClear.clear();
         }

         World var11 = var3.getExternalData().getWorld();
         Int2ObjectOpenHashMap var5 = calculateEffectStatModifiers(var1, var3);
         applyEffectModifiers(var2, var5);
         BrokenPenalties var6 = var11.getGameplayConfig().getItemDurabilityConfig().getBrokenPenalties();
         InventoryComponent.Armor var7 = var3.getComponent(var1, InventoryComponent.Armor.getComponentType());
         if (var7 != null) {
            Int2ObjectMap var8 = computeStatModifiers(var6, var7.getInventory());
            applyStatModifiers(var2, var8);
         }

         ItemStack var12 = InventoryComponent.getItemInHand(var3, var1);
         addItemStatModifiers(var12, var2, "*Weapon_", var0 -> var0.getWeapon() != null ? var0.getWeapon().getStatModifiers() : null);
         if (var12 == null || var12.getItem().getUtility().isCompatible()) {
            InventoryComponent.Utility var9 = var3.getComponent(var1, InventoryComponent.Utility.getComponentType());
            ItemStack var10 = var9 != null ? var9.getActiveItem() : null;
            addItemStatModifiers(var10, var2, "*Utility_", var0 -> var0.getUtility().getStatModifiers());
         }
      }
   }

   @Nonnull
   class="kw">private class="kw">static Int2ObjectOpenHashMap<Object2FloatMap<StaticModifier.CalculationType>> calculateEffectStatModifiers(
      @Nonnull Ref<EntityStore> var0, @Nonnull ComponentAccessor<EntityStore> var1
   ) {
      Int2ObjectOpenHashMap var2 = new Int2ObjectOpenHashMap();
      EffectControllerComponent var3 = var1.getComponent(var0, EffectControllerComponent.getComponentType());
      if (var3 == null) {
         class="kw">return var2;
      }

      var3.getActiveEffects()
         .forEach(
            (var1x, var2x) -> {
               if (var2x.isInfinite() || !(var2x.getRemainingDuration() <= 0.0F)) {
                  int var3 = var2x.getEntityEffectIndex();
                  EntityEffect var4 = EntityEffect.getAssetMap().getAsset(var3);
                  if (var4 != null && var4.getStatModifiers() != null) {
                     Iterator var5 = var4.getStatModifiers().int2ObjectEntrySet().iterator();

                     while (var5.hasNext()) {
                        it.unimi.dsi.fastutil.ints.Int2ObjectMap.Entry var6 = (it.unimi.dsi.fastutil.ints.Int2ObjectMap.Entry<StaticModifier[]>)var5.next();
                        int var7 = var6.getIntKey();

                        for (StaticModifier var11 : (StaticModifier[])var6.getValue()) {
                           float var12 = var11.getAmount();
                           Object2FloatMap var13 = (Object2FloatMap<StaticModifier.CalculationType>)var2.computeIfAbsent(
                              var7, var0x -> new Object2FloatOpenHashMap()
                           );
                           var13.mergeFloat(var11.getCalculationType(), var12, Float::sum);
                        }
                     }
                  }
               }
            }
         );
      class="kw">return var2;
   }

   class="kw">private class="kw">static void applyEffectModifiers(@Nonnull EntityStatMap var0, @Nonnull Int2ObjectMap<Object2FloatMap<StaticModifier.CalculationType>> var1) {
      for (int var2 = 0; var2 < var0.size(); var2++) {
         Object2FloatMap var3 = (Object2FloatMap<StaticModifier.CalculationType>)var1.get(var2);
         if (var3 == null) {
            for (StaticModifier.CalculationType var15 : StaticModifier.CalculationType.values()) {
               var0.removeModifier(var2, var15.createKey("Effect"));
            }
         } else {
            for (StaticModifier.CalculationType var7 : StaticModifier.CalculationType.values()) {
               if (!var3.containsKey(var7)) {
                  var0.removeModifier(var2, var7.createKey("Effect"));
               }
            }

            ObjectIterator var8 = var3.object2FloatEntrySet().iterator();

            while (var8.hasNext()) {
               Entry var10 = (Entry<StaticModifier.CalculationType>)var8.next();
               StaticModifier.CalculationType var12 = (StaticModifier.CalculationType)var10.getKey();
               StaticModifier var14 = new StaticModifier(Modifier.ModifierTarget.MAX, var12, var10.getFloatValue());
               var0.putModifier(var2, var12.createKey("Effect"), var14);
            }
         }
      }
   }

   class="kw">private class="kw">static void computeStatModifiers(
      double var0,
      @Nonnull Int2ObjectMap<Object2FloatMap<StaticModifier.CalculationType>> var2,
      @Nonnull ItemStack var3,
      @Nonnull Int2ObjectMap<StaticModifier[]> var4
   ) {
      boolean var5 = var3.isBroken();
      ObjectIterator var6 = var4.int2ObjectEntrySet().iterator();

      while (var6.hasNext()) {
         it.unimi.dsi.fastutil.ints.Int2ObjectMap.Entry var7 = (it.unimi.dsi.fastutil.ints.Int2ObjectMap.Entry<StaticModifier[]>)var6.next();
         int var8 = var7.getIntKey();

         for (StaticModifier var12 : (StaticModifier[])var7.getValue()) {
            float var13 = var12.getAmount();
            if (var5) {
               var13 *= (float)var0;
            }

            Object2FloatMap var14 = (Object2FloatMap<StaticModifier.CalculationType>)var2.computeIfAbsent(var8, var0x -> new Object2FloatOpenHashMap());
            var14.mergeFloat(var12.getCalculationType(), var13, Float::sum);
         }
      }
   }

   @Nonnull
   class="kw">private class="kw">static Int2ObjectMap<Object2FloatMap<StaticModifier.CalculationType>> computeStatModifiers(
      @Nonnull BrokenPenalties var0, @Nonnull ItemContainer var1
   ) {
      Int2ObjectOpenHashMap var2 = new Int2ObjectOpenHashMap();
      double var3 = var0.getArmor(0.0);

      for (short var5 = 0; var5 < var1.getCapacity(); var5++) {
         ItemStack var6 = var1.getItemStack(var5);
         if (var6 != null) {
            addArmorStatModifiers(var6, var3, var2);
         }
      }

      class="kw">return var2;
   }

   class="kw">private class="kw">static void addArmorStatModifiers(
      @Nonnull ItemStack var0, double var1, @Nonnull Int2ObjectOpenHashMap<Object2FloatMap<StaticModifier.CalculationType>> var3
   ) {
      if (!ItemStack.isEmpty(var0)) {
         ItemArmor var4 = var0.getItem().getArmor();
         if (var4 != null) {
            Int2ObjectMap var5 = var4.getStatModifiers();
            if (var5 != null) {
               computeStatModifiers(var1, var3, var0, var5);
            }
         }
      }
   }

   class="kw">private class="kw">static void addItemStatModifiers(
      @Nullable ItemStack var0, @Nonnull EntityStatMap var1, @Nonnull String var2, @Nonnull Function<Item, Int2ObjectMap<StaticModifier[]>> var3
   ) {
      if (ItemStack.isEmpty(var0)) {
         clearAllStatModifiers(EntityStatMap.Predictable.SELF, var1, var2, null);
      } else {
         Int2ObjectMap var4 = var3.apply(var0.getItem());
         if (var4 == null) {
            clearAllStatModifiers(EntityStatMap.Predictable.SELF, var1, var2, null);
         } else {
            ObjectIterator var5 = var4.int2ObjectEntrySet().iterator();

            while (var5.hasNext()) {
               it.unimi.dsi.fastutil.ints.Int2ObjectMap.Entry var6 = (it.unimi.dsi.fastutil.ints.Int2ObjectMap.Entry<StaticModifier[]>)var5.next();
               int var7 = 0;
               int var8 = var6.getIntKey();

               for (StaticModifier var12 : (StaticModifier[])var6.getValue()) {
                  String var13 = var2 + var7;
                  var7++;
                  if (!(var1.getModifier(var8, var13) class="kw">instanceof StaticModifier var15 && var15.equals(var12))) {
                     var1.putModifier(EntityStatMap.Predictable.SELF, var8, var13, var12);
                  }
               }

               clearStatModifiers(EntityStatMap.Predictable.SELF, var1, var8, var2, var7);
            }

            clearAllStatModifiers(EntityStatMap.Predictable.SELF, var1, var2, var4);
         }
      }
   }

   class="kw">private class="kw">static void clearAllStatModifiers(
      @Nonnull EntityStatMap.Predictable var0, @Nonnull EntityStatMap var1, @Nonnull String var2, @Nullable Int2ObjectMap<StaticModifier[]> var3
   ) {
      for (int var4 = 0; var4 < var1.size(); var4++) {
         if (var3 == null || !var3.containsKey(var4)) {
            clearStatModifiers(var0, var1, var4, var2, 0);
         }
      }
   }

   class="kw">private class="kw">static void clearStatModifiers(@Nonnull EntityStatMap.Predictable var0, @Nonnull EntityStatMap var1, int var2, @Nonnull String var3, int var4) {
      String var5;
      do {
         var5 = var3 + var4;
         var4++;
      } while (var1.removeModifier(var0, var2, var5) != null);
   }

   class="kw">private class="kw">static void applyStatModifiers(@Nonnull EntityStatMap var0, @Nonnull Int2ObjectMap<Object2FloatMap<StaticModifier.CalculationType>> var1) {
      for (int var2 = 0; var2 < var0.size(); var2++) {
         Object2FloatMap var3 = (Object2FloatMap<StaticModifier.CalculationType>)var1.get(var2);
         if (var3 == null) {
            for (StaticModifier.CalculationType var15 : StaticModifier.CalculationType.values()) {
               var0.removeModifier(var2, var15.createKey("Armor"));
            }
         } else {
            for (StaticModifier.CalculationType var7 : StaticModifier.CalculationType.values()) {
               if (!var3.containsKey(var7)) {
                  var0.removeModifier(var2, var7.createKey("Armor"));
               }
            }

            ObjectIterator var8 = var3.object2FloatEntrySet().iterator();

            while (var8.hasNext()) {
               Entry var10 = (Entry<StaticModifier.CalculationType>)var8.next();
               StaticModifier.CalculationType var12 = (StaticModifier.CalculationType)var10.getKey();
               StaticModifier var14 = new StaticModifier(Modifier.ModifierTarget.MAX, var12, var10.getFloatValue());
               var0.putModifier(var2, var12.createKey("Armor"), var14);
            }
         }
      }
   }
}