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

class="kw">import com.hypixel.hytale.component.ArchetypeChunk;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.component.SystemGroup;
class="kw">import com.hypixel.hytale.component.dependency.Dependency;
class="kw">import com.hypixel.hytale.component.dependency.Order;
class="kw">import com.hypixel.hytale.component.dependency.SystemDependency;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import com.hypixel.hytale.component.system.EntityEventSystem;
class="kw">import com.hypixel.hytale.component.system.EntityHolderEventSystem;
class="kw">import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
class="kw">import com.hypixel.hytale.protocol.EquipmentUpdate;
class="kw">import com.hypixel.hytale.protocol.GameMode;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.config.ItemUtility;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.config.ItemWeapon;
class="kw">import com.hypixel.hytale.server.core.entity.StatModifiersManager;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.HotbarManager;
class="kw">import com.hypixel.hytale.server.core.event.events.ecs.InventoryChangeEvent;
class="kw">import com.hypixel.hytale.server.core.event.events.ecs.InventorySetActiveSlotEvent;
class="kw">import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.SlotTransaction;
class="kw">import com.hypixel.hytale.server.core.modules.entity.AllLegacyLivingEntityTypesQuery;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerSettings;
class="kw">import com.hypixel.hytale.server.core.modules.entity.tracker.EntityTrackerSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.EntityStatMap;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import java.util.Map;
class="kw">import java.util.Set;
class="kw">import java.util.concurrent.ConcurrentLinkedQueue;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

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

   class="kw">public class="kw">static class ActiveSlotChangedEntityEventSystem class="kw">extends EntityEventSystem<EntityStore, InventorySetActiveSlotEvent> {
      class="kw">public ActiveSlotChangedEntityEventSystem() {
         super(InventorySetActiveSlotEvent.class);
      }

      class="kw">public void handle(
         int var1,
         @Nonnull ArchetypeChunk<EntityStore> var2,
         @Nonnull Store<EntityStore> var3,
         @Nonnull CommandBuffer<EntityStore> var4,
         @Nonnull InventorySetActiveSlotEvent var5
      ) {
         InventoryComponent.Hotbar var6 = var2.getComponent(var1, InventoryComponent.Hotbar.getComponentType());
         if (var6 != null) {
            var6.setOutdatedEquipment(true);
         }

         InventoryComponent.Utility var7 = var2.getComponent(var1, InventoryComponent.Utility.getComponentType());
         if (var7 != null) {
            var7.setOutdatedEquipment(true);
         }

         EntityStatMap var8 = var2.getComponent(var1, EntityStatMap.getComponentType());
         if (var8 != null) {
            StatModifiersManager var9 = var8.getStatModifiersManager();
            var9.scheduleRecalculate();

            int[] var10 = class="kw">switch (var5.getInventorySectionId()) {
               case -5 -> {
                  if (var7 == null) {
                     yield null;
                  } else {
                     ItemStack var13 = var7.getActiveItem();
                     yield var13 == null ? null : var13.getItem().getUtility().getEntityStatsToClear();
                  }
               }
               case -1 -> {
                  ItemStack var11 = InventoryComponent.getItemInHand(var3, var2.getReferenceTo(var1));
                  if (var11 == null) {
                     yield null;
                  } else {
                     ItemWeapon var12 = var11.getItem().getWeapon();
                     yield var12 == null ? null : var12.getEntityStatsToClear();
                  }
               }
               class="kw">default -> null;
            };
            if (var10 != null) {
               var9.queueEntityStatsToClear(var10);
            }
         }
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return InventoryComponent.Hotbar.getComponentType();
      }
   }

   class="kw">public class="kw">static class ActiveSlotChangedEntityHolderEventSystem class="kw">extends EntityHolderEventSystem<EntityStore, InventorySetActiveSlotEvent> {
      class="kw">public ActiveSlotChangedEntityHolderEventSystem() {
         super(InventorySetActiveSlotEvent.class);
      }

      class="kw">public void handle(
         @Nonnull Holder<EntityStore> var1,
         @Nonnull Store<EntityStore> var2,
         @Nonnull CommandBuffer<EntityStore> var3,
         @Nonnull InventorySetActiveSlotEvent var4
      ) {
         InventoryComponent.Hotbar var5 = var1.getComponent(InventoryComponent.Hotbar.getComponentType());
         if (var5 != null) {
            var5.setOutdatedEquipment(true);
         }

         InventoryComponent.Utility var6 = var1.getComponent(InventoryComponent.Utility.getComponentType());
         if (var6 != null) {
            var6.setOutdatedEquipment(true);
         }

         EntityStatMap var7 = var1.getComponent(EntityStatMap.getComponentType());
         if (var7 != null) {
            StatModifiersManager var8 = var7.getStatModifiersManager();
            var8.scheduleRecalculate();

            int[] var9 = class="kw">switch (var4.getInventorySectionId()) {
               case -5 -> {
                  if (var6 == null) {
                     yield null;
                  } else {
                     ItemStack var12 = var6.getActiveItem();
                     yield var12 == null ? null : var12.getItem().getUtility().getEntityStatsToClear();
                  }
               }
               case -1 -> {
                  ItemStack var10 = InventoryComponent.getItemInHand(var1);
                  if (var10 == null) {
                     yield null;
                  } else {
                     ItemWeapon var11 = var10.getItem().getWeapon();
                     yield var11 == null ? null : var11.getEntityStatsToClear();
                  }
               }
               class="kw">default -> null;
            };
            if (var9 != null) {
               var8.queueEntityStatsToClear(var9);
            }
         }
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return InventoryComponent.Hotbar.getComponentType();
      }
   }

   class="kw">public class="kw">static class ActiveSlotChangedToolsEventSystem class="kw">extends EntityEventSystem<EntityStore, InventorySetActiveSlotEvent> {
      class="kw">public ActiveSlotChangedToolsEventSystem() {
         super(InventorySetActiveSlotEvent.class);
      }

      class="kw">public void handle(
         int var1,
         @Nonnull ArchetypeChunk<EntityStore> var2,
         @Nonnull Store<EntityStore> var3,
         @Nonnull CommandBuffer<EntityStore> var4,
         @Nonnull InventorySetActiveSlotEvent var5
      ) {
         InventoryComponent.Tool var6 = var2.getComponent(var1, InventoryComponent.Tool.getComponentType());
         assert var6 != null;
         class="kw">switch (var5.getInventorySectionId()) {
            case -8:
               var6.setUsingToolsItem(true);
               break;
            case -1:
               var6.setUsingToolsItem(false);
         }
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return InventoryComponent.Tool.getComponentType();
      }
   }

   class="kw">public class="kw">static class ActiveSlotChangedToolsHolderEventSystem class="kw">extends EntityHolderEventSystem<EntityStore, InventorySetActiveSlotEvent> {
      class="kw">public ActiveSlotChangedToolsHolderEventSystem() {
         super(InventorySetActiveSlotEvent.class);
      }

      class="kw">public void handle(
         @Nonnull Holder<EntityStore> var1,
         @Nonnull Store<EntityStore> var2,
         @Nonnull CommandBuffer<EntityStore> var3,
         @Nonnull InventorySetActiveSlotEvent var4
      ) {
         InventoryComponent.Tool var5 = var1.getComponent(InventoryComponent.Tool.getComponentType());
         if (var5 != null) {
            class="kw">switch (var4.getInventorySectionId()) {
               case -8:
                  var5.setUsingToolsItem(true);
                  break;
               case -1:
                  var5.setUsingToolsItem(false);
            }
         }
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return InventoryComponent.Tool.getComponentType();
      }
   }

   class="kw">public class="kw">static class ArmorChangeEventSystem class="kw">extends InventorySystems.InventoryChangeEventSystem<InventoryComponent.Armor> {
      class="kw">public ArmorChangeEventSystem() {
         super(InventoryComponent.Armor.getComponentType());
      }
   }

   class="kw">public class="kw">static class BackpackChangeEventSystem class="kw">extends InventorySystems.InventoryChangeEventSystem<InventoryComponent.Backpack> {
      class="kw">public BackpackChangeEventSystem() {
         super(InventoryComponent.Backpack.getComponentType());
      }
   }

   class="kw">public class="kw">static class HotbarChangeEventSystem class="kw">extends InventorySystems.InventoryChangeEventSystem<InventoryComponent.Hotbar> {
      class="kw">public HotbarChangeEventSystem() {
         super(InventoryComponent.Hotbar.getComponentType());
      }
   }

   class="kw">public class="kw">abstract class="kw">static class InventoryChangeEventSystem<Inv class="kw">extends InventoryComponent> class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">protected class="kw">final ComponentType<EntityStore, Inv> componentType;

      class="kw">protected InventoryChangeEventSystem(ComponentType<EntityStore, Inv> var1) {
         this.componentType = var1;
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         InventoryComponent var6 = var3.getComponent(var2, this.componentType);
         assert var6 != null;
         ConcurrentLinkedQueue var7 = var6.getChangeEvents();
         Ref var9 = var3.getReferenceTo(var2);

         ItemContainer.ItemContainerChangeEvent var8;
         while ((var8 = var7.poll()) != null) {
            InventoryChangeEvent var10 = new InventoryChangeEvent(this.componentType, var6, var8.container(), var8.transaction());
            var5.invoke(var9, var10);
         }
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.componentType;
      }
   }

   @Deprecated(forRemoval = true)
   class="kw">public class="kw">static class LegacyArmorChangeStatSystem class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">private class="kw">final Query<EntityStore> query = Query.and(InventoryComponent.Armor.getComponentType(), AllLegacyLivingEntityTypesQuery.INSTANCE);
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(new SystemDependency<>(Order.BEFORE, InventorySystems.ArmorChangeEventSystem.class));

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

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         InventoryComponent.Armor var6 = var3.getComponent(var2, InventoryComponent.Armor.getComponentType());
         assert var6 != null;
         ConcurrentLinkedQueue var7 = var6.getChangeEvents();
         if (!var7.isEmpty()) {
            var6.setOutdatedEquipment(true);
            EntityStatMap var8 = var3.getComponent(var2, EntityStatMap.getComponentType());
            if (var8 != null) {
               var8.getStatModifiersManager().scheduleRecalculate();
            }
         }
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.query;
      }

      @Nonnull
      @Override
      class="kw">public Set<Dependency<EntityStore>> getDependencies() {
         class="kw">return this.dependencies;
      }
   }

   @Deprecated(forRemoval = true)
   class="kw">public class="kw">static class LegacyHotbarChangeStatSystem class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">private class="kw">final Query<EntityStore> query = Query.and(InventoryComponent.Hotbar.getComponentType(), AllLegacyLivingEntityTypesQuery.INSTANCE);
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(new SystemDependency<>(Order.BEFORE, InventorySystems.HotbarChangeEventSystem.class));

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

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         InventoryComponent.Hotbar var6 = var3.getComponent(var2, InventoryComponent.Hotbar.getComponentType());
         assert var6 != null;
         ConcurrentLinkedQueue var7 = var6.getChangeEvents();
         if (!var7.isEmpty()) {
            boolean var8 = false;
            byte var9 = var6.getActiveSlot();

            for (ItemContainer.ItemContainerChangeEvent var11 : var7) {
               if (var9 != -1
                  && var11.transaction().wasSlotModified(var9)
                  && !(
                     var11.transaction() class="kw">instanceof SlotTransaction var12
                        && var12.getSlotAfter() != null
                        && ItemStack.isEquivalentType(var12.getSlotBefore(), var12.getSlotAfter())
                  )) {
                  var8 = true;
               }
            }

            if (var8) {
               var6.setOutdatedEquipment(true);
               EntityStatMap var15 = var3.getComponent(var2, EntityStatMap.getComponentType());
               if (var15 != null) {
                  StatModifiersManager var16 = var15.getStatModifiersManager();
                  var16.scheduleRecalculate();
                  ItemStack var17 = var6.getActiveItem();
                  if (var17 != null) {
                     ItemWeapon var18 = var17.getItem().getWeapon();
                     if (var18 != null) {
                        int[] var14 = var18.getEntityStatsToClear();
                        if (var14 != null) {
                           var16.queueEntityStatsToClear(var14);
                        }
                     }
                  }
               }
            }
         }
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.query;
      }

      @Nonnull
      @Override
      class="kw">public Set<Dependency<EntityStore>> getDependencies() {
         class="kw">return this.dependencies;
      }
   }

   @Deprecated(forRemoval = true)
   class="kw">public class="kw">static class LegacyUtilityChangeStatSystem class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">private class="kw">final Query<EntityStore> query = Query.and(InventoryComponent.Utility.getComponentType(), AllLegacyLivingEntityTypesQuery.INSTANCE);
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(new SystemDependency<>(Order.BEFORE, InventorySystems.UtilityChangeEventSystem.class));

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

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         InventoryComponent.Utility var6 = var3.getComponent(var2, InventoryComponent.Utility.getComponentType());
         assert var6 != null;
         ConcurrentLinkedQueue var7 = var6.getChangeEvents();
         if (!var7.isEmpty()) {
            boolean var8 = false;
            byte var9 = var6.getActiveSlot();

            for (ItemContainer.ItemContainerChangeEvent var11 : var7) {
               if (var9 != -1
                  && var11.transaction().wasSlotModified(var9)
                  && !(
                     var11.transaction() class="kw">instanceof SlotTransaction var12
                        && var12.getSlotAfter() != null
                        && ItemStack.isEquivalentType(var12.getSlotBefore(), var12.getSlotAfter())
                  )) {
                  var8 = true;
               }
            }

            if (var8) {
               var6.setOutdatedEquipment(true);
               EntityStatMap var15 = var3.getComponent(var2, EntityStatMap.getComponentType());
               if (var15 != null) {
                  StatModifiersManager var16 = var15.getStatModifiersManager();
                  var16.scheduleRecalculate();
                  ItemStack var17 = var6.getActiveItem();
                  if (var17 == null) {
                     class="kw">return;
                  }

                  ItemUtility var18 = var17.getItem().getUtility();
                  if (var18 == null) {
                     class="kw">return;
                  }

                  int[] var14 = var18.getEntityStatsToClear();
                  if (var14 == null) {
                     class="kw">return;
                  }

                  var16.queueEntityStatsToClear(var14);
               }
            }
         }
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.query;
      }

      @Nonnull
      @Override
      class="kw">public Set<Dependency<EntityStore>> getDependencies() {
         class="kw">return this.dependencies;
      }
   }

   class="kw">public class="kw">static class PlayerInventoryChangeEventSystem class="kw">extends EntityEventSystem<EntityStore, InventoryChangeEvent> {
      class="kw">public PlayerInventoryChangeEventSystem() {
         super(InventoryChangeEvent.class);
      }

      class="kw">public void handle(
         int var1,
         @Nonnull ArchetypeChunk<EntityStore> var2,
         @Nonnull Store<EntityStore> var3,
         @Nonnull CommandBuffer<EntityStore> var4,
         @Nonnull InventoryChangeEvent var5
      ) {
         Player var6 = var2.getComponent(var1, Player.getComponentType());
         assert var6 != null;
         HotbarManager var7 = var6.getHotbarManager();
         if (!var7.getIsCurrentlyLoadingHotbar()) {
            if (var6.getGameMode().equals(GameMode.Creative)) {
               InventoryComponent.Hotbar var8 = var2.getComponent(var1, InventoryComponent.Hotbar.getComponentType());
               assert var8 != null;
               ItemContainer var9 = var8.getInventory();
               if (var5.getItemContainer().equals(var9)) {
                  Ref var10 = var2.getReferenceTo(var1);
                  var7.saveHotbar(var10, (short)var7.getCurrentHotbarIndex(), var3);
               }
            }
         }
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return Query.and(Player.getComponentType(), InventoryComponent.Hotbar.getComponentType());
      }
   }

   class="kw">public class="kw">static class StorageChangeEventSystem class="kw">extends InventorySystems.InventoryChangeEventSystem<InventoryComponent.Storage> {
      class="kw">public StorageChangeEventSystem() {
         super(InventoryComponent.Storage.getComponentType());
      }
   }

   class="kw">public class="kw">static class SyncEquipmentSystem class="kw">extends EntityTickingSystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.Visible> visibleComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, InventoryComponent.Armor> armorComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, InventoryComponent.Hotbar> hotbarComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, InventoryComponent.Utility> utilityComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;

      class="kw">public SyncEquipmentSystem(@Nonnull ComponentType<EntityStore, EntityTrackerSystems.Visible> var1) {
         this.visibleComponentType = var1;
         this.armorComponentType = InventoryComponent.Armor.getComponentType();
         this.hotbarComponentType = InventoryComponent.Hotbar.getComponentType();
         this.utilityComponentType = InventoryComponent.Utility.getComponentType();
         this.query = Query.and(var1, Query.or(this.armorComponentType, this.hotbarComponentType, this.utilityComponentType));
      }

      @Nullable
      @Override
      class="kw">public SystemGroup<EntityStore> getGroup() {
         class="kw">return EntityTrackerSystems.QUEUE_UPDATE_GROUP;
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.query;
      }

      @Override
      class="kw">public boolean isParallel(int var1, int var2) {
         class="kw">return EntityTickingSystem.maybeUseParallel(var1, var2);
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         EntityTrackerSystems.Visible var6 = var3.getComponent(var2, this.visibleComponentType);
         assert var6 != null;
         Ref var7 = var3.getReferenceTo(var2);
         boolean var8 = false;
         InventoryComponent.Armor var9 = var3.getComponent(var2, this.armorComponentType);
         if (var9 != null && var9.consumeOutdatedEquipment()) {
            var8 = true;
         }

         InventoryComponent.Hotbar var10 = var3.getComponent(var2, this.hotbarComponentType);
         if (var10 != null && var10.consumeOutdatedEquipment()) {
            var8 = true;
         }

         InventoryComponent.Utility var11 = var3.getComponent(var2, this.utilityComponentType);
         if (var11 != null && var11.consumeOutdatedEquipment()) {
            var8 = true;
         }

         if (var8) {
            queueUpdatesFor(var7, var5, var6.visibleTo, var9, var11);
         } else if (!var6.newlyVisibleTo.isEmpty()) {
            queueUpdatesFor(var7, var5, var6.newlyVisibleTo, var9, var11);
         }
      }

      class="kw">private class="kw">static void queueUpdatesFor(
         @Nonnull Ref<EntityStore> var0,
         @Nonnull CommandBuffer<EntityStore> var1,
         @Nonnull Map<Ref<EntityStore>, EntityTrackerSystems.EntityViewer> var2,
         @Nullable InventoryComponent.Armor var3,
         @Nullable InventoryComponent.Utility var4
      ) {
         PlayerSettings var5 = var1.getComponent(var0, PlayerSettings.getComponentType());
         EquipmentUpdate var6 = InventoryUtils.createEquipmentUpdate(var0, var1, var5, var3, var4);

         for (EntityTrackerSystems.EntityViewer var8 : var2.values()) {
            var8.queueUpdate(var0, var6);
         }
      }
   }

   class="kw">public class="kw">static class ToolChangeEventSystem class="kw">extends InventorySystems.InventoryChangeEventSystem<InventoryComponent.Tool> {
      class="kw">public ToolChangeEventSystem() {
         super(InventoryComponent.Tool.getComponentType());
      }
   }

   class="kw">public class="kw">static class UtilityChangeEventSystem class="kw">extends InventorySystems.InventoryChangeEventSystem<InventoryComponent.Utility> {
      class="kw">public UtilityChangeEventSystem() {
         super(InventoryComponent.Utility.getComponentType());
      }
   }
}