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.EmptyExtraInfo;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.config.ItemStackContainerConfig;
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.container.filter.TagFilter;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.ClearTransaction;
class="kw">import java.util.Map;
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">import org.bson.BsonDocument;

class="kw">public class ItemStackItemContainer class="kw">extends ItemContainer {
   @Nonnull
   class="kw">public class="kw">static class="kw">final KeyedCodec<BsonDocument> CONTAINER_CODEC = new KeyedCodec<>("Container", Codec.BSON_DOCUMENT);
   @Nonnull
   class="kw">public class="kw">static class="kw">final KeyedCodec<Short> CAPACITY_CODEC = new KeyedCodec<>("Capacity", Codec.SHORT);
   @Nonnull
   class="kw">public class="kw">static class="kw">final KeyedCodec<ItemStack[]> ITEMS_CODEC = new KeyedCodec<>("Items", new ArrayCodec<>(ItemStack.CODEC, ItemStack[]::new));
   class="kw">protected class="kw">final ReadWriteLock lock = new ReentrantReadWriteLock();
   class="kw">protected class="kw">final ItemContainer parentContainer;
   class="kw">protected class="kw">final short itemStackSlot;
   class="kw">protected class="kw">final ItemStack originalItemStack;
   class="kw">protected class="kw">final short capacity;
   class="kw">protected ItemStack[] items;
   class="kw">private class="kw">final Map<FilterActionType, Int2ObjectConcurrentHashMap<SlotFilter>> slotFilters = new ConcurrentHashMap<>();
   @Nonnull
   class="kw">private FilterType globalFilter = FilterType.ALLOW_ALL;

   class="kw">private ItemStackItemContainer(ItemContainer var1, short var2, ItemStack var3, short var4, ItemStack[] var5) {
      this.parentContainer = var1;
      this.itemStackSlot = var2;
      this.originalItemStack = var3;
      this.capacity = var4;
      this.items = var5;
   }

   class="kw">public ItemContainer getParentContainer() {
      class="kw">return this.parentContainer;
   }

   class="kw">public short getItemStackSlot() {
      class="kw">return this.itemStackSlot;
   }

   class="kw">public ItemStack getOriginalItemStack() {
      class="kw">return this.originalItemStack;
   }

   class="kw">public boolean isItemStackValid() {
      ItemStack var1 = this.parentContainer.getItemStack(this.itemStackSlot);
      class="kw">return ItemStack.isEmpty(var1) ? false : ItemStack.isSameItemType(var1, this.originalItemStack);
   }

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

   @Override
   class="kw">public void setGlobalFilter(@Nonnull FilterType var1) {
      this.globalFilter = 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;
         });
      }
   }

   @Override
   class="kw">public ItemContainer clone() {
      throw new UnsupportedOperationException("Item stack containers don't support clone");
   }

   @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">public boolean isEmpty() {
      this.lock.readLock().lock();

      try {
         if (this.items == null) {
            class="kw">return true;
         }

         for (short var1 = 0; var1 < this.items.length; var1++) {
            if (!ItemStack.isEmpty(this.items[var1])) {
               class="kw">return false;
            }
         }

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

   @Nonnull
   @Override
   class="kw">protected ClearTransaction internal_clear() {
      if (this.items == null) {
         class="kw">return new ClearTransaction(true, (short)0, ItemStack.EMPTY_ARRAY);
      }

      ItemStack[] var1 = this.items;
      this.items = new ItemStack[var1.length];
      writeToItemStack(this.parentContainer, this.itemStackSlot, this.originalItemStack, this.items);
      class="kw">return new ClearTransaction(true, (short)0, var1);
   }

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

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

      if (ItemStack.isEmpty(var2)) {
         class="kw">return this.internal_removeSlot(var1);
      }

      ItemStack var3 = this.items[var1];
      this.items[var1] = var2;
      writeToItemStack(this.parentContainer, this.itemStackSlot, this.originalItemStack, this.items);
      class="kw">return var3;
   }

   @Nullable
   @Override
   class="kw">protected ItemStack internal_removeSlot(short var1) {
      if (this.items == null) {
         class="kw">return null;
      }

      ItemStack var2 = this.items[var1];
      this.items[var1] = null;
      writeToItemStack(this.parentContainer, this.itemStackSlot, this.originalItemStack, this.items);
      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 var1 == this.parentContainer && var2 == this.itemStackSlot;
   }

   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);
   }

   @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();
      }
   }

   class="kw">public class="kw">static void writeToItemStack(@Nonnull ItemContainer var0, short var1, ItemStack var2, ItemStack[] var3) {
      if (ItemStack.isEmpty(var2)) {
         throw new IllegalStateException("Item stack container is empty");
      }

      ItemStack var4 = var0.getItemStack(var1);
      if (!ItemStack.isSameItemType(var4, var2)) {
         throw new IllegalStateException("Item stack in parent container changed!");
      }

      BsonDocument var5 = var4.getMetadata();
      BsonDocument var6 = CONTAINER_CODEC.getOrNull(var5, EmptyExtraInfo.EMPTY);
      if (var6 == null) {
         throw new IllegalStateException("Item stack container is empty!");
      }

      ITEMS_CODEC.put(var6, var3, EmptyExtraInfo.EMPTY);
      var0.setItemStackForSlot(var1, var4.withMetadata(var5));
   }

   @Nullable
   class="kw">public class="kw">static ItemStackItemContainer getContainer(@Nonnull ItemContainer var0, short var1) {
      ItemStack var2 = var0.getItemStack(var1);
      if (ItemStack.isEmpty(var2)) {
         class="kw">return null;
      }

      BsonDocument var3 = var2.getFromMetadataOrNull(CONTAINER_CODEC);
      if (var3 == null) {
         class="kw">return null;
      }

      Short var4 = CAPACITY_CODEC.getOrNull(var3, EmptyExtraInfo.EMPTY);
      if (var4 != null && var4 > 0) {
         ItemStack[] var5 = ITEMS_CODEC.getOrNull(var3, EmptyExtraInfo.EMPTY);
         if (var5 == null) {
            var5 = new ItemStack[var4];
         }

         class="kw">return new ItemStackItemContainer(var0, var1, var2, var4, var5);
      } else {
         class="kw">return null;
      }
   }

   @Nonnull
   class="kw">public class="kw">static ItemStackItemContainer makeContainerWithCapacity(@Nonnull ItemContainer var0, short var1, short var2) {
      if (var2 <= 0) {
         throw new IllegalArgumentException("Capacity must be > 0");
      }

      ItemStack var3 = var0.getItemStack(var1);
      if (ItemStack.isEmpty(var3)) {
         throw new IllegalArgumentException("Item stack is empty!");
      }

      ItemStackItemContainer var4 = getContainer(var0, var1);
      if (var4 != null && var4.getCapacity() != 0) {
         throw new IllegalStateException("Item stack already has a container!");
      }

      BsonDocument var5 = var3.getMetadata();
      if (var5 == null) {
         var5 = new BsonDocument();
      }

      BsonDocument var6 = CONTAINER_CODEC.getOrNull(var5, EmptyExtraInfo.EMPTY);
      if (var6 == null) {
         var6 = new BsonDocument();
         CONTAINER_CODEC.put(var5, var6, EmptyExtraInfo.EMPTY);
      }

      CAPACITY_CODEC.put(var6, var2, EmptyExtraInfo.EMPTY);
      var0.setItemStackForSlot(var1, var3.withMetadata(var5));
      class="kw">return new ItemStackItemContainer(var0, var1, var3, var2, new ItemStack[var2]);
   }

   @Nullable
   class="kw">public class="kw">static ItemStackItemContainer ensureContainer(@Nonnull ItemContainer var0, short var1, short var2) {
      if (var2 <= 0) {
         throw new IllegalArgumentException("Capacity must be > 0");
      }

      ItemStack var3 = var0.getItemStack(var1);
      if (ItemStack.isEmpty(var3)) {
         class="kw">return null;
      }

      ItemStackItemContainer var4 = getContainer(var0, var1);
      if (var4 != null && var4.getCapacity() != 0) {
         class="kw">return var4;
      }

      BsonDocument var5 = var3.getMetadata();
      if (var5 == null) {
         var5 = new BsonDocument();
      }

      BsonDocument var6 = CONTAINER_CODEC.getOrNull(var5, EmptyExtraInfo.EMPTY);
      if (var6 == null) {
         var6 = new BsonDocument();
         CONTAINER_CODEC.put(var5, var6, EmptyExtraInfo.EMPTY);
      }

      CAPACITY_CODEC.put(var6, var2, EmptyExtraInfo.EMPTY);
      var0.setItemStackForSlot(var1, var3.withMetadata(var5));
      class="kw">return new ItemStackItemContainer(var0, var1, var3, var2, new ItemStack[var2]);
   }

   @Nullable
   class="kw">public class="kw">static ItemStackItemContainer ensureConfiguredContainer(@Nonnull ItemContainer var0, short var1, @Nonnull ItemStackContainerConfig var2) {
      ItemStackItemContainer var3 = ensureContainer(var0, var1, var2.getCapacity());
      if (var3 == null) {
         class="kw">return null;
      }

      var3.setGlobalFilter(var2.getGlobalFilter());
      int var4 = var2.getTagIndex();
      if (var4 != Integer.MIN_VALUE) {
         for (short var5 = 0; var5 < var3.getCapacity(); var5++) {
            var3.setSlotFilter(FilterActionType.ADD, var5, new TagFilter(var4));
         }
      }

      class="kw">return var3;
   }
}