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

class="kw">import com.hypixel.fastutil.ints.Int2ObjectConcurrentHashMap;
class="kw">import com.hypixel.hytale.event.EventRegistration;
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.Transaction;
class="kw">import java.util.Map;
class="kw">import java.util.Objects;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.function.Consumer;
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 DelegateItemContainer<T class="kw">extends ItemContainer> class="kw">extends ItemContainer {
   class="kw">private T delegate;
   class="kw">private class="kw">final Map<FilterActionType, Int2ObjectConcurrentHashMap<SlotFilter>> slotFilters = new ConcurrentHashMap<>();
   @Nonnull
   class="kw">private FilterType globalFilter = FilterType.ALLOW_ALL;

   class="kw">public DelegateItemContainer(T var1) {
      Objects.requireNonNull(var1, "Delegate can't be null!");
      this.delegate = var1;
   }

   class="kw">public T getDelegate() {
      class="kw">return this.delegate;
   }

   @Override
   class="kw">protected <V> V readAction(Supplier<V> var1) {
      class="kw">return this.delegate.readAction(var1);
   }

   @Override
   class="kw">protected <X, V> V readAction(Function<X, V> var1, X var2) {
      class="kw">return this.delegate.readAction(var1, var2);
   }

   @Override
   class="kw">protected <V> V writeAction(Supplier<V> var1) {
      class="kw">return this.delegate.writeAction(var1);
   }

   @Override
   class="kw">protected <X, V> V writeAction(Function<X, V> var1, X var2) {
      class="kw">return this.delegate.writeAction(var1, var2);
   }

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

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

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

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

   @Override
   class="kw">protected ClearTransaction internal_clear() {
      class="kw">return this.delegate.internal_clear();
   }

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

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

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

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

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

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

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

   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.delegate.getCapacity();
   }

   @Override
   class="kw">public ClearTransaction clear() {
      class="kw">return this.delegate.clear();
   }

   @Nonnull
   class="kw">public DelegateItemContainer<T> clone() {
      class="kw">return new DelegateItemContainer<>(this.delegate);
   }

   @Override
   class="kw">public boolean isEmpty() {
      class="kw">return this.delegate.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;
         });
      }
   }

   @Nonnull
   @Override
   class="kw">public EventRegistration<Void, ItemContainer.ItemContainerChangeEvent> registerChangeEvent(
      short var1, @Nonnull Consumer<ItemContainer.ItemContainerChangeEvent> var2
   ) {
      EventRegistration var3 = super.registerChangeEvent(var1, var2);
      EventRegistration[] var4 = new EventRegistration[]{
         this.delegate
            .internalChangeEventRegistry
            .register(
               var1, null, var2x -> var2.accept(new ItemContainer.ItemContainerChangeEvent(this, var2x.transaction().toParent(this, (short)0, this.delegate)))
            )
      };
      class="kw">return EventRegistration.combine(var3, var4);
   }

   @Override
   class="kw">protected void sendUpdate(@Nonnull Transaction var1) {
      if (var1.succeeded()) {
         super.sendUpdate(var1);
         this.delegate.externalChangeEventRegistry.dispatchFor(null).dispatch(new ItemContainer.ItemContainerChangeEvent(this.delegate, var1));
      }
   }

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

      if (var1 != null && this.getClass() == var1.getClass()) {
         DelegateItemContainer var2 = (DelegateItemContainer<?>)var1;
         if (this.delegate != null ? this.delegate.equals(var2.delegate) : var2.delegate == null) {
            class="kw">return (this.slotFilters != null ? this.slotFilters.equals(var2.slotFilters) : var2.slotFilters == null)
               ? this.globalFilter == var2.globalFilter
               : false;
         } else {
            class="kw">return false;
         }
      } else {
         class="kw">return false;
      }
   }

   @Override
   class="kw">public int hashCode() {
      int var1 = this.delegate != null ? this.delegate.hashCode() : 0;
      var1 = 31 * var1 + (this.slotFilters != null ? this.slotFilters.hashCode() : 0);
      class="kw">return 31 * var1 + (this.globalFilter != null ? this.globalFilter.hashCode() : 0);
   }
}