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

class="kw">import com.hypixel.fastutil.ints.Int2ObjectConcurrentHashMap;
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.Short2ObjectMapCodec;
class="kw">import com.hypixel.hytale.codec.validation.Validators;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.server.core.entity.ItemUtils;
class="kw">import com.hypixel.hytale.server.core.inventory.ItemStack;
class="kw">import com.hypixel.hytale.server.core.inventory.container.filter.FilterActionType;
class="kw">import com.hypixel.hytale.server.core.inventory.container.filter.FilterType;
class="kw">import com.hypixel.hytale.server.core.inventory.container.filter.SlotFilter;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.ClearTransaction;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.ItemStackSlotTransaction;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.ItemStackTransaction;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.ListTransaction;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import it.unimi.dsi.fastutil.shorts.Short2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.shorts.Short2ObjectMap.Entry;
class="kw">import java.util.Iterator;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Objects;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.concurrent.locks.ReadWriteLock;
class="kw">import java.util.concurrent.locks.ReentrantReadWriteLock;
class="kw">import java.util.function.Function;
class="kw">import java.util.function.Supplier;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class SimpleItemContainer class="kw">extends ItemContainer {
   class="kw">public class="kw">static class="kw">final BuilderCodec<SimpleItemContainer> CODEC = BuilderCodec.builder(SimpleItemContainer.class, SimpleItemContainer::new)
      .append(new KeyedCodec<>("Capacity", Codec.SHORT), (var0, var1) -> var0.capacity = var1, var0 -> var0.capacity)
      .addValidator(Validators.greaterThanOrEqual((short)0))
      .add()
      .append(new KeyedCodec<>("Items", new Short2ObjectMapCodec<>(ItemStack.CODEC, Short2ObjectOpenHashMap::new, false)), (var0, var1) -> {
         var0.items = new ItemStack[var0.capacity];
         int var2 = 0;
         Iterator var3 = var1.short2ObjectEntrySet().iterator();

         while (var3.hasNext()) {
            Entry var4 = (Entry<ItemStack>)var3.next();
            short var5 = var4.getShortKey();
            ItemStack var6 = (ItemStack)var4.getValue();
            if (var5 >= 0 && var5 < var0.capacity && !ItemStack.isEmpty(var6)) {
               var0.items[var5] = var6;
               var2++;
            }
         }

         var0.itemsCount = var2;
      }, var0 -> {
         Short2ObjectOpenHashMap var1 = new Short2ObjectOpenHashMap();

         for (short var2 = 0; var2 < var0.capacity; var2++) {
            ItemStack var3 = var0.items[var2];
            if (var3 != null && !ItemStack.isEmpty(var3)) {
               var1.put(var2, var3);
            }
         }

         class="kw">return var1;
      })
      .add()
      .afterDecode(var0 -> {
         if (var0.items == null) {
            var0.items = new ItemStack[var0.capacity];
            var0.itemsCount = 0;
         }
      })
      .build();
   class="kw">protected short capacity;
   class="kw">protected class="kw">final ReadWriteLock lock = new ReentrantReadWriteLock();
   class="kw">protected ItemStack[] items;
   class="kw">protected int itemsCount;
   class="kw">private class="kw">final Map<FilterActionType, Int2ObjectConcurrentHashMap<SlotFilter>> slotFilters = new ConcurrentHashMap<>();
   class="kw">private FilterType globalFilter = FilterType.ALLOW_ALL;

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

   class="kw">public SimpleItemContainer(short var1) {
      if (var1 <= 0) {
         throw new IllegalArgumentException("Capacity is less than or equal zero! " + var1 + " <= 0");
      }

      this.capacity = var1;
      this.items = new ItemStack[var1];
   }

   class="kw">public SimpleItemContainer(@Nonnull SimpleItemContainer var1) {
      this.capacity = var1.capacity;
      var1.lock.readLock().lock();

      try {
         this.items = new ItemStack[var1.capacity];
         System.arraycopy(var1.items, 0, this.items, 0, var1.capacity);
         this.itemsCount = var1.itemsCount;
      } class="kw">finally {
         var1.lock.readLock().unlock();
      }

      this.slotFilters.putAll(var1.slotFilters);
      this.globalFilter = var1.globalFilter;
   }

   @Override
   class="kw">protected <V> V readAction(@Nonnull Supplier<V> var1) {
      this.lock.readLock().lock();

      try {
         class="kw">return var1.get();
      } class="kw">finally {
         this.lock.readLock().unlock();
      }
   }

   @Override
   class="kw">protected <X, V> V readAction(@Nonnull Function<X, V> var1, X var2) {
      this.lock.readLock().lock();

      try {
         class="kw">return var1.apply(var2);
      } class="kw">finally {
         this.lock.readLock().unlock();
      }
   }

   @Override
   class="kw">protected <V> V writeAction(@Nonnull Supplier<V> var1) {
      this.lock.writeLock().lock();

      try {
         class="kw">return var1.get();
      } class="kw">finally {
         this.lock.writeLock().unlock();
      }
   }

   @Override
   class="kw">protected <X, V> V writeAction(@Nonnull Function<X, V> var1, X var2) {
      this.lock.writeLock().lock();

      try {
         class="kw">return var1.apply(var2);
      } class="kw">finally {
         this.lock.writeLock().unlock();
      }
   }

   @Override
   class="kw">protected void lockForRead() {
      this.lock.readLock().lock();
   }

   @Override
   class="kw">protected void unlockForRead() {
      this.lock.readLock().unlock();
   }

   @Override
   class="kw">protected void lockForWrite() {
      this.lock.writeLock().lock();
   }

   @Override
   class="kw">protected void unlockForWrite() {
      this.lock.writeLock().unlock();
   }

   @Override
   class="kw">protected ItemStack internal_getSlot(short var1) {
      class="kw">return this.items[var1];
   }

   @Override
   class="kw">protected ItemStack internal_setSlot(short var1, ItemStack var2) {
      if (ItemStack.isEmpty(var2)) {
         class="kw">return this.internal_removeSlot(var1);
      }

      ItemStack var3 = this.items[var1];
      this.items[var1] = var2;
      if (var3 == null) {
         this.itemsCount++;
      }

      class="kw">return var3;
   }

   @Override
   class="kw">protected ItemStack internal_removeSlot(short var1) {
      ItemStack var2 = this.items[var1];
      this.items[var1] = null;
      if (var2 != null) {
         this.itemsCount--;
      }

      class="kw">return var2;
   }

   @Override
   class="kw">protected boolean cantAddToSlot(short var1, ItemStack var2, ItemStack var3) {
      class="kw">return !this.globalFilter.allowInput() ? true : this.testFilter(FilterActionType.ADD, var1, var2);
   }

   @Override
   class="kw">protected boolean cantRemoveFromSlot(short var1) {
      class="kw">return !this.globalFilter.allowOutput() ? true : this.testFilter(FilterActionType.REMOVE, var1, null);
   }

   @Override
   class="kw">protected boolean cantDropFromSlot(short var1) {
      class="kw">return this.testFilter(FilterActionType.DROP, var1, null);
   }

   @Override
   class="kw">protected boolean cantMoveToSlot(ItemContainer var1, short var2) {
      class="kw">return false;
   }

   class="kw">private boolean testFilter(FilterActionType var1, short var2, ItemStack var3) {
      Int2ObjectConcurrentHashMap var4 = this.slotFilters.get(var1);
      if (var4 == null) {
         class="kw">return false;
      }

      SlotFilter var5 = var4.get(var2);
      class="kw">return var5 == null ? false : !var5.test(var1, this, var2, var3);
   }

   @Override
   class="kw">public short getCapacity() {
      class="kw">return this.capacity;
   }

   @Nonnull
   @Override
   class="kw">protected ClearTransaction internal_clear() {
      ItemStack[] var1 = new ItemStack[this.getCapacity()];

      for (short var2 = 0; var2 < var1.length; var2++) {
         var1[var2] = this.items[var2];
         this.items[var2] = null;
      }

      this.itemsCount = 0;
      class="kw">return new ClearTransaction(true, (short)0, var1);
   }

   @Nonnull
   class="kw">public SimpleItemContainer clone() {
      class="kw">return new SimpleItemContainer(this);
   }

   @Override
   class="kw">public boolean isEmpty() {
      this.lock.readLock().lock();

      try {
         if (this.itemsCount == 0) {
            class="kw">return true;
         }
      } class="kw">finally {
         this.lock.readLock().unlock();
      }

      class="kw">return super.isEmpty();
   }

   @Override
   class="kw">public void setGlobalFilter(@Nonnull FilterType var1) {
      this.globalFilter = Objects.requireNonNull(var1);
   }

   @Override
   class="kw">public void setSlotFilter(FilterActionType var1, short var2, @Nullable SlotFilter var3) {
      validateSlotIndex(var2, this.getCapacity());
      if (var3 != null) {
         this.slotFilters.computeIfAbsent(var1, var0 -> new Int2ObjectConcurrentHashMap<>()).put(var2, var3);
      } else {
         this.slotFilters.computeIfPresent(var1, (var1x, var2x) -> {
            var2x.remove(var2);
            class="kw">return var2x.isEmpty() ? null : var2x;
         });
      }
   }

   @Nullable
   @Override
   class="kw">public ItemStack getItemStack(short var1) {
      validateSlotIndex(var1, this.getCapacity());
      this.lock.readLock().lock();

      try {
         class="kw">return this.internal_getSlot(var1);
      } class="kw">finally {
         this.lock.readLock().unlock();
      }
   }

   @Override
   class="kw">public boolean equals(Object var1) {
      if (this == var1) {
         class="kw">return true;
      }

      if (var1 class="kw">instanceof SimpleItemContainer var2) {
         if (this.capacity != var2.capacity) {
            class="kw">return false;
         }

         this.lock.readLock().lock();

         try {
            if (this.itemsCount != var2.itemsCount) {
               class="kw">return false;
            }

            for (int var3 = 0; var3 < this.capacity; var3++) {
               if (!Objects.equals(this.items[var3], var2.items[var3])) {
                  class="kw">return false;
               }
            }

            class="kw">return true;
         } class="kw">finally {
            this.lock.readLock().unlock();
         }
      } else {
         class="kw">return false;
      }
   }

   @Override
   class="kw">public int hashCode() {
      int var1 = this.capacity;
      this.lock.readLock().lock();

      try {
         for (int var2 = 0; var2 < this.capacity; var2++) {
            ItemStack var3 = this.items[var2];
            var1 = 31 * var1 + (var3 != null ? var3.hashCode() : 0);
         }
      } class="kw">finally {
         this.lock.readLock().unlock();
      }

      class="kw">return var1;
   }

   class="kw">public class="kw">static ItemContainer getNewContainer(short var0) {
      class="kw">return ItemContainer.getNewContainer(var0, SimpleItemContainer::new);
   }

   class="kw">public class="kw">static boolean addOrDropItemStack(
      @Nonnull ComponentAccessor<EntityStore> var0, @Nonnull Ref<EntityStore> var1, @Nonnull ItemContainer var2, @Nonnull ItemStack var3
   ) {
      ItemStackTransaction var4 = var2.addItemStack(var3);
      ItemStack var5 = var4.getRemainder();
      if (!ItemStack.isEmpty(var5)) {
         ItemUtils.dropItem(var1, var5, var0);
         class="kw">return true;
      } else {
         class="kw">return false;
      }
   }

   class="kw">public class="kw">static boolean addOrDropItemStack(
      @Nonnull ComponentAccessor<EntityStore> var0, @Nonnull Ref<EntityStore> var1, @Nonnull ItemContainer var2, short var3, @Nonnull ItemStack var4
   ) {
      ItemStackSlotTransaction var5 = var2.addItemStackToSlot(var3, var4);
      ItemStack var6 = var5.getRemainder();
      class="kw">return !ItemStack.isEmpty(var6) ? addOrDropItemStack(var0, var1, var2, var4) : false;
   }

   class="kw">public class="kw">static boolean addOrDropItemStacks(
      @Nonnull ComponentAccessor<EntityStore> var0, @Nonnull Ref<EntityStore> var1, @Nonnull ItemContainer var2, List<ItemStack> var3
   ) {
      ListTransaction var4 = var2.addItemStacks(var3);
      boolean var5 = false;

      for (ItemStackTransaction var7 : var4.getList()) {
         ItemStack var8 = var7.getRemainder();
         if (!ItemStack.isEmpty(var8)) {
            ItemUtils.dropItem(var1, var8, var0);
            var5 = true;
         }
      }

      class="kw">return var5;
   }

   class="kw">public class="kw">static boolean tryAddOrderedOrDropItemStacks(
      @Nonnull ComponentAccessor<EntityStore> var0, @Nonnull Ref<EntityStore> var1, @Nonnull ItemContainer var2, List<ItemStack> var3
   ) {
      ListTransaction var4 = var2.addItemStacksOrdered(var3);
      List var5 = null;

      for (ItemStackSlotTransaction var7 : var4.getList()) {
         ItemStack var8 = var7.getRemainder();
         if (!ItemStack.isEmpty(var8)) {
            if (var5 == null) {
               var5 = new ObjectArrayList();
            }

            var5.add(var8);
         }
      }

      class="kw">return addOrDropItemStacks(var0, var1, var2, var5);
   }
}