public class BoilerBlockEntity extends BlockEntity implements MenuProvider {

    private final ItemStackHandler itemHandler = new ItemStackHandler(Constants.BOILER_SLOTS) {
        @Override
        protected void onContentsChanged(int slot) {
            setChanged();
            if(!level.isClientSide()) {
                level.sendBlockUpdated(getBlockPos(), getBlockState(), getBlockState(), 3);
            }
        }
        @Override
        public boolean isItemValid(int slot, @NotNull ItemStack stack) {
            return switch (slot) {
                case 0 -> stack.getCapability(ForgeCapabilities.FLUID_HANDLER_ITEM).isPresent();
                default -> super.isItemValid(slot,stack);
            };
        }
    };

    private final FluidTank WATER_TANK = new FluidTank(5000) {
        @Override
        protected void onContentsChanged() {
            setChanged();
            if(!level.isClientSide()) {
                level.sendBlockUpdated(getBlockPos(), getBlockState(), getBlockState(), 3);
            }
        }
        @Override
        public boolean isFluidValid(FluidStack stack) {
            return stack.getFluid() == Fluids.WATER;
        }
    };
    public void setWaterFluid(FluidStack stack) {
        this.WATER_TANK.setFluid(stack);
    }
    public FluidStack getWaterFluid() {
        return this.WATER_TANK.getFluid();
    }


    private final FluidTank PP_TANK = new FluidTank(5000) {
        @Override
        protected void onContentsChanged() {
            setChanged();
            if(!level.isClientSide()) {
                level.sendBlockUpdated(getBlockPos(), getBlockState(), getBlockState(), 3);
            }
        }
        @Override
        public boolean isFluidValid(FluidStack stack) {
            return stack.getFluid() == ModFluids.SOURCE_GROWPYMPARTICLES.get() ||
                    stack.getFluid() == ModFluids.SOURCE_SHRINKPYMPARTICLES.get();
        }
    };
    public void setPPFluid(FluidStack stack) {
        this.PP_TANK.setFluid(stack);
    }
    public FluidStack getPPFluid() {
        return this.PP_TANK.getFluid();
    }



    private LazyOptional<IFluidHandler> lazyPPFluidHandler = LazyOptional.empty();
    private LazyOptional<IFluidHandler> lazyWaterFluidHandler = LazyOptional.empty();
    private LazyOptional<IItemHandler> lazyItemHandler = LazyOptional.empty();

    protected final ContainerData data;
    private int progress = 0;
    private int maxProgress = 100;


    public BoilerBlockEntity(BlockPos pos, BlockState state) {
        super(ModBlockEntities.BOILER.get(), pos, state);
        this.data = new ContainerData() {
            @Override
            public int get(int i) {
                return switch (i) {
                  case 0 -> BoilerBlockEntity.this.progress;
                  case 1 -> BoilerBlockEntity.this.maxProgress;
                  default -> 0;
                };
            }
            @Override
            public void set(int i, int value) {
                switch (i) {
                    case 0 -> BoilerBlockEntity.this.progress = value;
                    case 1 -> BoilerBlockEntity.this.maxProgress = value;
                };
            }
            @Override
            public int getCount() {
                return 2;
            }
        };
    }
    @Override
    public Component getDisplayName() {
        return Component.empty();
    }

    @Nullable
    @Override
    public AbstractContainerMenu createMenu(int id, Inventory inventory, Player player) {
        return new BoilerMenu(id, inventory, this, this.data);
    }

    @Override
    public @NotNull <T> LazyOptional<T> getCapability(@NotNull Capability<T> cap, @Nullable Direction side) {
        if(cap == ForgeCapabilities.ITEM_HANDLER) {
            return lazyItemHandler.cast();
        }

        // Dont know if this would be a problem
        if(cap == ForgeCapabilities.FLUID_HANDLER) {
            return lazyPPFluidHandler.cast();
        }
        if(cap == ForgeCapabilities.FLUID_HANDLER) {
            return lazyWaterFluidHandler.cast();
        }

        return super.getCapability(cap, side);
    }

    @Override
    public void onLoad() {
        super.onLoad();
        lazyItemHandler = LazyOptional.of(() -> itemHandler);
        lazyWaterFluidHandler = LazyOptional.of(() -> WATER_TANK);
        lazyPPFluidHandler = LazyOptional.of(() -> PP_TANK);
    }
    @Override
    public void invalidateCaps() {
        super.invalidateCaps();
        lazyItemHandler.invalidate();
        lazyWaterFluidHandler.invalidate();
        lazyPPFluidHandler.invalidate();
    }

    // Not working
    @Override
    protected void saveAdditional(CompoundTag tag) {
        tag.put("inventory", itemHandler.serializeNBT());
        tag = WATER_TANK.writeToNBT(tag);
        tag = PP_TANK.writeToNBT(tag);
        super.saveAdditional(tag);
    }
    // Not working
    @Override
    public void load(CompoundTag tag) {
        super.load(tag);
        itemHandler.deserializeNBT(tag.getCompound("inventory"));
        WATER_TANK.readFromNBT(tag);
        PP_TANK.readFromNBT(tag);
    }

    public void drops() {
        SimpleContainer inventory = new SimpleContainer(itemHandler.getSlots());
        for (int i = 0; i < itemHandler.getSlots(); i++) {
            inventory.setItem(i, itemHandler.getStackInSlot(i));
        }
        Containers.dropContents(this.level, this.worldPosition, inventory);
    }

    public static void tick(Level level, BlockPos pos, BlockState state, BoilerBlockEntity entity) {
        if(level.isClientSide) return;

        if(hasSPPRecipe(entity) && hasEnoughWaterFluid(entity)) {
            entity.progress++;
            setChanged(level, pos, state);

            if (entity.progress >= entity.maxProgress) {
                craftPP(entity);
            }
        } else if(hasGPPRecipe(entity) && hasEnoughWaterFluid(entity)) {
            entity.progress++;
            setChanged(level, pos, state);

            if (entity.progress >= entity.maxProgress) {
                craftPP(entity);
            }
        } else {
            entity.resetProgress();
            setChanged(level, pos, state);
        }

        if(hasWaterFluidInSlot0(entity)) {
            transferWaterFluidToFluidTank(entity);
        }
    }

    private static void craftPP(BoilerBlockEntity entity) {
        // Remove water
        // Remove items
        // Add pp
        int drainAmount = Math.min(entity.WATER_TANK.getSpace(), 1000);
        entity.WATER_TANK.drain(drainAmount, IFluidHandler.FluidAction.EXECUTE);

        entity.PP_TANK.fill(
                new FluidStack(ModFluids.SOURCE_PP.get(), 500),
                IFluidHandler.FluidAction.EXECUTE);

        entity.resetProgress();
    }


    private static boolean hasEnoughWaterFluid(BoilerBlockEntity entity) {
        return entity.WATER_TANK.getFluidAmount() > 500;
    }

    private static void transferWaterFluidToFluidTank(BoilerBlockEntity entity) {
        entity.itemHandler.getStackInSlot(0).getCapability(ForgeCapabilities.FLUID_HANDLER_ITEM).ifPresent(handler -> {
            int drainAmount = Math.min(entity.WATER_TANK.getSpace(), 1000);

            FluidStack stack = handler.drain(drainAmount, IFluidHandler.FluidAction.SIMULATE);
            if(entity.WATER_TANK.isFluidValid(stack)) {
                stack = handler.drain(drainAmount, IFluidHandler.FluidAction.EXECUTE);
                fillTankWaterFluid(entity, stack, handler.getContainer());
            }
        });
    }
    private static void fillTankWaterFluid(BoilerBlockEntity entity, FluidStack stack, ItemStack container) {
        entity.WATER_TANK.fill(stack, IFluidHandler.FluidAction.EXECUTE);
        entity.itemHandler.extractItem(0, 1, false);
        entity.itemHandler.insertItem(0, container, false);
        //entity.level.sendBlockUpdated(entity.worldPosition, entity.getBlockState(),entity.getBlockState(), Block.UPDATE_ALL);
        System.out.println("filled with water");
    }
    private static boolean hasWaterFluidInSlot0(BoilerBlockEntity entity) {
        return entity.itemHandler.getStackInSlot(0).getCount() > 0;
    }


    private void resetProgress() {
        this.progress = 0;
        setChanged();
        level.sendBlockUpdated(getBlockPos(), getBlockState(), getBlockState(), 3);
    }
    private static boolean hasSPPRecipe(BoilerBlockEntity entity) {
        SimpleContainer inv = new SimpleContainer(entity.itemHandler.getSlots());
        for(int i = 0; i < entity.itemHandler.getSlots(); i++) {
            inv.setItem(i, entity.itemHandler.getStackInSlot(i));
        }

        boolean[] materialsFound = {false, false, false};
        int additional = 0;

        for (int i = 4; i <= 12; i++) {
            ItemStack stack = entity.itemHandler.getStackInSlot(i);
            if (!stack.isEmpty()) {
                Item item = stack.getItem();
                if (item == Items.EMMERALD)) {
                    materialsFound[0] = true;
                } else if (item == Items.DIAMOND) {
                    materialsFound[1] = true;
                } else if (item == Items.REDSTONE) {
                    materialsFound[2] = true;
                } else {
                    additional++;
                }
            }
        }
        return materialsFound[0] && materialsFound[1] && materialsFound[2] && additional == 0;
    }

    private static boolean hasGPPRecipe(BoilerBlockEntity entity) {
        SimpleContainer inv = new SimpleContainer(entity.itemHandler.getSlots());
        for(int i = 0; i < entity.itemHandler.getSlots(); i++) {
            inv.setItem(i, entity.itemHandler.getStackInSlot(i));
        }

        boolean[] materialsFound = {false, false, false};
        int additional = 0;

        for (int i = 4; i <= 12; i++) {
            ItemStack stack = entity.itemHandler.getStackInSlot(i);
            if (!stack.isEmpty()) {
                Item item = stack.getItem();
                if (item == Items.EMERALD) {
                    materialsFound[0] = true;
                } else if (item == Items.DIAMOND) {
                    materialsFound[1] = true;
                } else if (item == Items.BONE_MEAL) {
                    materialsFound[2] = true;
                } else {
                    additional++;
                }
            }
        }
        return materialsFound[0] && materialsFound[1] && materialsFound[2] && additional == 0;
    }


    /*Synchronization to the client*/
    @Nullable
    @Override
    public Packet<ClientGamePacketListener> getUpdatePacket() {
        return ClientboundBlockEntityDataPacket.create(this);
    }
    @Override
    public CompoundTag getUpdateTag() {
        return saveWithoutMetadata();
    }
    @Override
    public void onDataPacket(Connection net, ClientboundBlockEntityDataPacket pkt) {
        super.onDataPacket(net, pkt);
        if (Minecraft.getInstance().player.containerMenu instanceof BoilerMenu menu && menu.blockEntity == this) {
            menu.setWaterFluid(getWaterFluid());
            menu.setPPFluid(getPPFluid());
        }
    }
}