package com.dairymoose.modernlife.tileentities;

import com.dairymoose.modernlife.blocks.ExtractorBlock;
import com.dairymoose.modernlife.core.CustomBlocks;
import com.mojang.datafixers.types.Type;
import java.util.Iterator;
import java.util.List;
import java.util.Optional;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import javax.annotation.Nullable;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.core.NonNullList;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.network.chat.Component;
import net.minecraft.network.chat.TranslatableComponent;
import net.minecraft.world.Container;
import net.minecraft.world.ContainerHelper;
import net.minecraft.world.WorldlyContainer;
import net.minecraft.world.WorldlyContainerHolder;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.EntitySelector;
import net.minecraft.world.entity.item.ItemEntity;
import net.minecraft.world.entity.player.Inventory;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.inventory.AbstractContainerMenu;
import net.minecraft.world.inventory.HopperMenu;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.ChestBlock;
import net.minecraft.world.level.block.HopperBlock;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.block.entity.BlockEntityType;
import net.minecraft.world.level.block.entity.ChestBlockEntity;
import net.minecraft.world.level.block.entity.RandomizableContainerBlockEntity;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.phys.AABB;
import net.minecraft.world.phys.shapes.BooleanOp;
import net.minecraft.world.phys.shapes.Shapes;
import net.minecraftforge.items.IItemHandler;
import net.minecraftforge.items.ItemHandlerHelper;
import net.minecraftforge.items.VanillaInventoryCodeHooks;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

/* loaded from: outputsrg.jar:com/dairymoose/modernlife/tileentities/ExtractorBlockEntity.class */
public class ExtractorBlockEntity extends RandomizableContainerBlockEntity implements IHorizontalHopper {
    public static final BlockEntityType<ExtractorBlockEntity> EXTRACTOR = BlockEntityType.Builder.of(ExtractorBlockEntity::new, new Block[]{(Block) CustomBlocks.BLOCK_EXTRACTOR.get()}).build((Type) null);
    private static final Logger LOGGER = LogManager.getLogger();
    private NonNullList<ItemStack> items;
    private int cooldownTime;
    private long tickedGameTime;

    public ExtractorBlockEntity(BlockPos pos, BlockState state) {
        super(EXTRACTOR, pos, state);
        this.items = NonNullList.withSize(5, ItemStack.EMPTY);
        this.cooldownTime = -1;
    }

    public void load(CompoundTag p_230337_2_) {
        super.load(p_230337_2_);
        this.items = NonNullList.withSize(getContainerSize(), ItemStack.EMPTY);
        if (!tryLoadLootTable(p_230337_2_)) {
            ContainerHelper.loadAllItems(p_230337_2_, this.items);
        }
        this.cooldownTime = p_230337_2_.getInt("TransferCooldown");
    }

    protected void saveAdditional(CompoundTag p_189515_1_) {
        if (!trySaveLootTable(p_189515_1_)) {
            ContainerHelper.saveAllItems(p_189515_1_, this.items);
        }
        p_189515_1_.putInt("TransferCooldown", this.cooldownTime);
    }

    public int getContainerSize() {
        return this.items.size();
    }

    public ItemStack removeItem(int p_70298_1_, int p_70298_2_) {
        unpackLootTable((Player) null);
        return ContainerHelper.removeItem(getItems(), p_70298_1_, p_70298_2_);
    }

    public void setItem(int p_70299_1_, ItemStack p_70299_2_) {
        unpackLootTable((Player) null);
        getItems().set(p_70299_1_, p_70299_2_);
        if (p_70299_2_.getCount() > getMaxStackSize()) {
            p_70299_2_.setCount(getMaxStackSize());
        }
    }

    protected Component m_6820_() {
        return new TranslatableComponent("container.extractor");
    }

    public static void tick(Level level, BlockPos pos, BlockState state, ExtractorBlockEntity blockEntity) {
        blockEntity.tick();
    }

    public void tick() {
        if (this.level != null && !this.level.isClientSide) {
            this.cooldownTime--;
            this.tickedGameTime = this.level.getGameTime();
            if (!isOnCooldown()) {
                setCooldown(0);
                tryMoveItems(() -> {
                    return Boolean.valueOf(suckInItems(this));
                });
            }
        }
    }

    private boolean tryMoveItems(Supplier<Boolean> p_200109_1_) {
        if (this.level != null && !this.level.isClientSide && !isOnCooldown() && ((Boolean) getBlockState().getValue(HopperBlock.ENABLED)).booleanValue()) {
            boolean flag = false;
            if (!isEmpty()) {
                flag = ejectItems();
            }
            if (!inventoryFull()) {
                flag |= p_200109_1_.get().booleanValue();
            }
            if (flag) {
                setCooldown(8);
                setChanged();
                return true;
            }
            return false;
        }
        return false;
    }

    private boolean inventoryFull() {
        Iterator it = this.items.iterator();
        while (it.hasNext()) {
            ItemStack itemstack = (ItemStack) it.next();
            if (itemstack.isEmpty() || itemstack.getCount() != itemstack.getMaxStackSize()) {
                return false;
            }
        }
        return true;
    }

    @Override // com.dairymoose.modernlife.tileentities.IHorizontalHopper
    public Level getHopperLevel() {
        return this.level;
    }

    private static Optional<Pair<IItemHandler, Object>> getItemHandler(IHorizontalHopper hopper, Direction hopperFacing) {
        double x = hopper.getLevelX() + hopperFacing.getStepX();
        double y = hopper.getLevelY() + hopperFacing.getStepY();
        double z = hopper.getLevelZ() + hopperFacing.getStepZ();
        return VanillaInventoryCodeHooks.getItemHandler(hopper.getHopperLevel(), x, y, z, hopperFacing.getOpposite());
    }

    private static boolean isFull(IItemHandler itemHandler) {
        for (int slot = 0; slot < itemHandler.getSlots(); slot++) {
            ItemStack stackInSlot = itemHandler.getStackInSlot(slot);
            if (stackInSlot.isEmpty() || stackInSlot.getCount() < itemHandler.getSlotLimit(slot)) {
                return false;
            }
        }
        return true;
    }

    private static boolean isEmpty(IItemHandler itemHandler) {
        for (int slot = 0; slot < itemHandler.getSlots(); slot++) {
            ItemStack stackInSlot = itemHandler.getStackInSlot(slot);
            if (stackInSlot.getCount() > 0) {
                return false;
            }
        }
        return true;
    }

    public static boolean insertHook(ExtractorBlockEntity hopper) {
        Direction hopperFacing = hopper.getBlockState().getValue(HopperBlock.FACING).getOpposite();
        return ((Boolean) getItemHandler(hopper, hopperFacing).map(destinationResult -> {
            IItemHandler itemHandler = (IItemHandler) destinationResult.getKey();
            Object destination = destinationResult.getValue();
            if (isFull(itemHandler)) {
                return false;
            }
            for (int i = 0; i < hopper.getContainerSize(); i++) {
                if (!hopper.getItem(i).isEmpty()) {
                    ItemStack originalSlotContents = hopper.getItem(i).copy();
                    ItemStack insertStack = hopper.removeItem(i, 1);
                    ItemStack remainder = putStackInInventoryAllSlots(hopper, destination, itemHandler, insertStack);
                    if (remainder.isEmpty()) {
                        return true;
                    }
                    hopper.setItem(i, originalSlotContents);
                }
            }
            return false;
        }).orElse(false)).booleanValue();
    }

    private static ItemStack putStackInInventoryAllSlots(BlockEntity source, Object destination, IItemHandler destInventory, ItemStack stack) {
        for (int slot = 0; slot < destInventory.getSlots() && !stack.isEmpty(); slot++) {
            stack = insertStack(source, destination, destInventory, stack, slot);
        }
        return stack;
    }

    private static ItemStack insertStack(BlockEntity source, Object destination, IItemHandler destInventory, ItemStack stack, int slot) {
        ItemStack itemstack = destInventory.getStackInSlot(slot);
        if (destInventory.insertItem(slot, stack, true).isEmpty()) {
            boolean insertedItem = false;
            boolean inventoryWasEmpty = isEmpty(destInventory);
            if (itemstack.isEmpty()) {
                destInventory.insertItem(slot, stack, false);
                stack = ItemStack.EMPTY;
                insertedItem = true;
            } else if (ItemHandlerHelper.canItemStacksStack(itemstack, stack)) {
                int originalSize = stack.getCount();
                stack = destInventory.insertItem(slot, stack, false);
                insertedItem = originalSize < stack.getCount();
            }
            if (insertedItem && inventoryWasEmpty && (destination instanceof ExtractorBlockEntity)) {
                ExtractorBlockEntity destinationHopper = (ExtractorBlockEntity) destination;
                if (!destinationHopper.isOnCustomCooldown()) {
                    int k = 0;
                    if ((source instanceof ExtractorBlockEntity) && destinationHopper.getLastUpdateTime() >= ((ExtractorBlockEntity) source).getLastUpdateTime()) {
                        k = 1;
                    }
                    destinationHopper.setCooldown(8 - k);
                }
            }
        }
        return stack;
    }

    private boolean ejectItems() {
        if (insertHook(this)) {
            return true;
        }
        Container iinventory = getAttachedContainer();
        if (iinventory == null) {
            return false;
        }
        Direction direction = (Direction) getBlockState().getValue(HopperBlock.FACING);
        if (isFullContainer(iinventory, direction)) {
            return false;
        }
        for (int i = 0; i < getContainerSize(); i++) {
            if (!getItem(i).isEmpty()) {
                ItemStack itemstack = getItem(i).copy();
                ItemStack itemstack1 = addItem(this, iinventory, removeItem(i, 1), direction);
                if (itemstack1.isEmpty()) {
                    iinventory.setChanged();
                    return true;
                }
                setItem(i, itemstack);
            }
        }
        return false;
    }

    private static IntStream getSlots(Container p_213972_0_, Direction p_213972_1_) {
        return p_213972_0_ instanceof WorldlyContainer ? IntStream.of(((WorldlyContainer) p_213972_0_).getSlotsForFace(p_213972_1_)) : IntStream.range(0, p_213972_0_.getContainerSize());
    }

    private boolean isFullContainer(Container p_174919_1_, Direction p_174919_2_) {
        return getSlots(p_174919_1_, p_174919_2_).allMatch(p_213970_1_ -> {
            ItemStack itemstack = p_174919_1_.getItem(p_213970_1_);
            return itemstack.getCount() >= itemstack.getMaxStackSize();
        });
    }

    private static boolean isEmptyContainer(Container p_174917_0_, Direction p_174917_1_) {
        return getSlots(p_174917_0_, p_174917_1_).allMatch(p_213973_1_ -> {
            return p_174917_0_.getItem(p_213973_1_).isEmpty();
        });
    }

    @Nullable
    public static Boolean extractHook(ExtractorBlockEntity dest) {
        return (Boolean) getItemHandler(dest, dest.getBlockState().getValue(ExtractorBlock.FACING)).map(itemHandlerResult -> {
            IItemHandler handler = (IItemHandler) itemHandlerResult.getKey();
            for (int i = 0; i < handler.getSlots(); i++) {
                ItemStack extractItem = handler.extractItem(i, 1, true);
                if (!extractItem.isEmpty()) {
                    for (int j = 0; j < dest.getContainerSize(); j++) {
                        ItemStack destStack = dest.getItem(j);
                        if (dest.canPlaceItem(j, extractItem) && (destStack.isEmpty() || (destStack.getCount() < destStack.getMaxStackSize() && destStack.getCount() < dest.getMaxStackSize() && ItemHandlerHelper.canItemStacksStack(extractItem, destStack)))) {
                            ItemStack extractItem2 = handler.extractItem(i, 1, false);
                            if (destStack.isEmpty()) {
                                dest.setItem(j, extractItem2);
                            } else {
                                destStack.grow(1);
                                dest.setItem(j, destStack);
                            }
                            dest.setChanged();
                            return true;
                        }
                    }
                }
            }
            return false;
        }).orElse(null);
    }

    public static boolean suckInItems(ExtractorBlockEntity p_145891_0_) {
        Boolean ret = extractHook(p_145891_0_);
        if (ret != null) {
            return ret.booleanValue();
        }
        Container iinventory = getSourceContainer(p_145891_0_, p_145891_0_.getBlockState());
        if (iinventory != null) {
            Direction direction = Direction.DOWN;
            switch (C01571.$SwitchMap$net$minecraft$core$Direction[p_145891_0_.getBlockState().getValue(HopperBlock.FACING).ordinal()]) {
                case 1:
                    direction = Direction.WEST;
                    break;
                case 2:
                    direction = Direction.SOUTH;
                    break;
                case 3:
                    direction = Direction.NORTH;
                    break;
                case 4:
                    direction = Direction.EAST;
                    break;
            }
            Direction finalDirection = direction;
            if (isEmptyContainer(iinventory, finalDirection)) {
                return false;
            }
            return getSlots(iinventory, finalDirection).anyMatch(p_213971_3_ -> {
                return tryTakeInItemFromSlot(p_145891_0_, iinventory, p_213971_3_, finalDirection);
            });
        }
        for (ItemEntity itementity : getFrontalItems(p_145891_0_, p_145891_0_.getBlockState())) {
            if (addItem(p_145891_0_, itementity)) {
                return true;
            }
        }
        return false;
    }

    /* renamed from: com.dairymoose.modernlife.tileentities.ExtractorBlockEntity$1 */
    /* loaded from: outputsrg.jar:com/dairymoose/modernlife/tileentities/ExtractorBlockEntity$1.class */
    public static /* synthetic */ class C01571 {
        static final /* synthetic */ int[] $SwitchMap$net$minecraft$core$Direction = new int[Direction.values().length];

        static {
            try {
                $SwitchMap$net$minecraft$core$Direction[Direction.EAST.ordinal()] = 1;
            } catch (NoSuchFieldError e) {
            }
            try {
                $SwitchMap$net$minecraft$core$Direction[Direction.NORTH.ordinal()] = 2;
            } catch (NoSuchFieldError e2) {
            }
            try {
                $SwitchMap$net$minecraft$core$Direction[Direction.SOUTH.ordinal()] = 3;
            } catch (NoSuchFieldError e3) {
            }
            try {
                $SwitchMap$net$minecraft$core$Direction[Direction.WEST.ordinal()] = 4;
            } catch (NoSuchFieldError e4) {
            }
        }
    }

    public static boolean tryTakeInItemFromSlot(IHorizontalHopper p_174915_0_, Container p_174915_1_, int p_174915_2_, Direction p_174915_3_) {
        ItemStack itemstack = p_174915_1_.getItem(p_174915_2_);
        if (!itemstack.isEmpty() && canTakeItemFromContainer(p_174915_1_, itemstack, p_174915_2_, p_174915_3_)) {
            ItemStack itemstack1 = itemstack.copy();
            ItemStack itemstack2 = addItem(p_174915_1_, p_174915_0_, p_174915_1_.removeItem(p_174915_2_, 1), (Direction) null);
            if (itemstack2.isEmpty()) {
                p_174915_1_.setChanged();
                return true;
            }
            p_174915_1_.setItem(p_174915_2_, itemstack1);
            return false;
        }
        return false;
    }

    public static boolean addItem(Container p_200114_0_, ItemEntity p_200114_1_) {
        boolean flag = false;
        ItemStack itemstack = p_200114_1_.getItem().copy();
        ItemStack itemstack1 = addItem((Container) null, p_200114_0_, itemstack, (Direction) null);
        if (itemstack1.isEmpty()) {
            flag = true;
            p_200114_1_.m_146870_();
        } else {
            p_200114_1_.setItem(itemstack1);
        }
        return flag;
    }

    public static ItemStack addItem(@Nullable Container p_59327_, Container p_59328_, ItemStack p_59329_, @Nullable Direction p_59330_) {
        if ((p_59328_ instanceof WorldlyContainer) && p_59330_ != null) {
            WorldlyContainer worldlycontainer = (WorldlyContainer) p_59328_;
            int[] aint = worldlycontainer.getSlotsForFace(p_59330_);
            for (int k = 0; k < aint.length && !p_59329_.isEmpty(); k++) {
                p_59329_ = tryMoveInItem(p_59327_, p_59328_, p_59329_, aint[k], p_59330_);
            }
        } else {
            int i = p_59328_.getContainerSize();
            for (int j = 0; j < i && !p_59329_.isEmpty(); j++) {
                p_59329_ = tryMoveInItem(p_59327_, p_59328_, p_59329_, j, p_59330_);
            }
        }
        return p_59329_;
    }

    private static boolean canPlaceItemInContainer(Container p_174920_0_, ItemStack p_174920_1_, int p_174920_2_, @Nullable Direction p_174920_3_) {
        if (p_174920_0_.canPlaceItem(p_174920_2_, p_174920_1_)) {
            return !(p_174920_0_ instanceof WorldlyContainer) || ((WorldlyContainer) p_174920_0_).canPlaceItemThroughFace(p_174920_2_, p_174920_1_, p_174920_3_);
        }
        return false;
    }

    private static boolean canTakeItemFromContainer(Container p_174921_0_, ItemStack p_174921_1_, int p_174921_2_, Direction p_174921_3_) {
        return !(p_174921_0_ instanceof WorldlyContainer) || ((WorldlyContainer) p_174921_0_).canTakeItemThroughFace(p_174921_2_, p_174921_1_, p_174921_3_);
    }

    private static ItemStack tryMoveInItem(@Nullable Container p_174916_0_, Container p_174916_1_, ItemStack p_174916_2_, int p_174916_3_, @Nullable Direction p_174916_4_) {
        ItemStack itemstack = p_174916_1_.getItem(p_174916_3_);
        if (canPlaceItemInContainer(p_174916_1_, p_174916_2_, p_174916_3_, p_174916_4_)) {
            boolean flag = false;
            boolean flag1 = p_174916_1_.isEmpty();
            if (itemstack.isEmpty()) {
                p_174916_1_.setItem(p_174916_3_, p_174916_2_);
                p_174916_2_ = ItemStack.EMPTY;
                flag = true;
            } else if (canMergeItems(itemstack, p_174916_2_)) {
                int i = p_174916_2_.getMaxStackSize() - itemstack.getCount();
                int j = Math.min(p_174916_2_.getCount(), i);
                p_174916_2_.shrink(j);
                itemstack.grow(j);
                flag = j > 0;
            }
            if (flag) {
                if (flag1 && (p_174916_1_ instanceof ExtractorBlockEntity)) {
                    ExtractorBlockEntity ExtractorBlockEntity1 = (ExtractorBlockEntity) p_174916_1_;
                    if (!ExtractorBlockEntity1.isOnCustomCooldown()) {
                        int k = 0;
                        if (p_174916_0_ instanceof ExtractorBlockEntity) {
                            ExtractorBlockEntity ExtractorBlockEntity = (ExtractorBlockEntity) p_174916_0_;
                            if (ExtractorBlockEntity1.tickedGameTime >= ExtractorBlockEntity.tickedGameTime) {
                                k = 1;
                            }
                        }
                        ExtractorBlockEntity1.setCooldown(8 - k);
                    }
                }
                p_174916_1_.setChanged();
            }
        }
        return p_174916_2_;
    }

    @Nullable
    private Container getAttachedContainer() {
        Direction direction = getBlockState().getValue(HopperBlock.FACING).getOpposite();
        return getContainerAt(getHopperLevel(), this.worldPosition.relative(direction));
    }

    @Nullable
    public static Container getSourceContainer(IHorizontalHopper p_145884_0_, BlockState state) {
        switch (C01571.$SwitchMap$net$minecraft$core$Direction[state.getValue(HopperBlock.FACING).ordinal()]) {
            case 1:
                return getContainerAt(p_145884_0_.getHopperLevel(), p_145884_0_.getLevelX() + 1.0d, p_145884_0_.getLevelY(), p_145884_0_.getLevelZ());
            case 2:
                return getContainerAt(p_145884_0_.getHopperLevel(), p_145884_0_.getLevelX(), p_145884_0_.getLevelY(), p_145884_0_.getLevelZ() - 1.0d);
            case 3:
                return getContainerAt(p_145884_0_.getHopperLevel(), p_145884_0_.getLevelX(), p_145884_0_.getLevelY(), p_145884_0_.getLevelZ() + 1.0d);
            case 4:
                return getContainerAt(p_145884_0_.getHopperLevel(), p_145884_0_.getLevelX() - 1.0d, p_145884_0_.getLevelY(), p_145884_0_.getLevelZ());
            default:
                return getContainerAt(p_145884_0_.getHopperLevel(), p_145884_0_.getLevelX(), p_145884_0_.getLevelY() + 1.0d, p_145884_0_.getLevelZ());
        }
    }

    public static List<ItemEntity> getFrontalItems(IHorizontalHopper p_200115_0_, BlockState state) {
        return (List) p_200115_0_.getSuckShape(state).toAabbs().stream().flatMap(p_200110_1_ -> {
            return p_200115_0_.getHopperLevel().m_6443_(ItemEntity.class, p_200110_1_.move(p_200115_0_.getLevelX() - 0.5d, p_200115_0_.getLevelY() - 0.5d, p_200115_0_.getLevelZ() - 0.5d), EntitySelector.ENTITY_STILL_ALIVE).stream();
        }).collect(Collectors.toList());
    }

    @Nullable
    public static Container getContainerAt(Level p_195484_0_, BlockPos p_195484_1_) {
        return getContainerAt(p_195484_0_, p_195484_1_.getX() + 0.5d, p_195484_1_.getY() + 0.5d, p_195484_1_.getZ() + 0.5d);
    }

    @Nullable
    public static Container getContainerAt(Level p_145893_0_, double p_145893_1_, double p_145893_3_, double p_145893_5_) {
        WorldlyContainer worldlyContainer = null;
        BlockPos blockpos = new BlockPos(p_145893_1_, p_145893_3_, p_145893_5_);
        BlockState blockstate = p_145893_0_.getBlockState(blockpos);
        WorldlyContainerHolder getBlock = blockstate.getBlock();
        if (getBlock instanceof WorldlyContainerHolder) {
            worldlyContainer = getBlock.getContainer(blockstate, p_145893_0_, blockpos);
        } else if (blockstate.m_155947_()) {
            WorldlyContainer blockEntity = p_145893_0_.getBlockEntity(blockpos);
            if (blockEntity instanceof Container) {
                worldlyContainer = (Container) blockEntity;
                if ((worldlyContainer instanceof ChestBlockEntity) && (getBlock instanceof ChestBlock)) {
                    worldlyContainer = ChestBlock.getContainer((ChestBlock) getBlock, blockstate, p_145893_0_, blockpos, true);
                }
            }
        }
        if (worldlyContainer == null) {
            List<Entity> list = p_145893_0_.getEntities((Entity) null, new AABB(p_145893_1_ - 0.5d, p_145893_3_ - 0.5d, p_145893_5_ - 0.5d, p_145893_1_ + 0.5d, p_145893_3_ + 0.5d, p_145893_5_ + 0.5d), EntitySelector.CONTAINER_ENTITY_SELECTOR);
            if (!list.isEmpty()) {
                worldlyContainer = (Container) list.get(p_145893_0_.random.nextInt(list.size()));
            }
        }
        return worldlyContainer;
    }

    private static boolean canMergeItems(ItemStack p_145894_0_, ItemStack p_145894_1_) {
        if (p_145894_0_.getItem() != p_145894_1_.getItem() || p_145894_0_.getDamageValue() != p_145894_1_.getDamageValue() || p_145894_0_.getCount() > p_145894_0_.getMaxStackSize()) {
            return false;
        }
        return ItemStack.tagMatches(p_145894_0_, p_145894_1_);
    }

    @Override // com.dairymoose.modernlife.tileentities.IHorizontalHopper
    public double getLevelX() {
        return this.worldPosition.getX() + 0.5d;
    }

    @Override // com.dairymoose.modernlife.tileentities.IHorizontalHopper
    public double getLevelY() {
        return this.worldPosition.getY() + 0.5d;
    }

    @Override // com.dairymoose.modernlife.tileentities.IHorizontalHopper
    public double getLevelZ() {
        return this.worldPosition.getZ() + 0.5d;
    }

    public void setCooldown(int p_145896_1_) {
        this.cooldownTime = p_145896_1_;
    }

    private boolean isOnCooldown() {
        return this.cooldownTime > 0;
    }

    public boolean isOnCustomCooldown() {
        return this.cooldownTime > 8;
    }

    protected NonNullList<ItemStack> getItems() {
        return this.items;
    }

    protected void setItems(NonNullList<ItemStack> p_199721_1_) {
        this.items = p_199721_1_;
    }

    public void entityInside(Entity p_200113_1_) {
        if (p_200113_1_ instanceof ItemEntity) {
            BlockPos blockpos = getBlockPos();
            if (Shapes.joinIsNotEmpty(Shapes.create(p_200113_1_.getBoundingBox().move(-blockpos.getX(), -blockpos.getY(), -blockpos.getZ())), getSuckShape(getBlockState()), BooleanOp.AND)) {
                tryMoveItems(() -> {
                    return Boolean.valueOf(addItem(this, (ItemEntity) p_200113_1_));
                });
            }
        }
    }

    protected AbstractContainerMenu m_6555_(int p_213906_1_, Inventory p_213906_2_) {
        return new HopperMenu(p_213906_1_, p_213906_2_, this);
    }

    protected IItemHandler createUnSidedHandler() {
        return new ExtractorItemHandler(this);
    }

    public long getLastUpdateTime() {
        return this.tickedGameTime;
    }
}