How to make custom recipe type for my minecraft 1.21.4 mod

[JCS-Mecabricks]

Description

I am adding a custom recipe type for my custom Block entity that can bake items but I get errors. Can someone help me? Here is the file in case you need it.

package github.jcsmecabricks.customcrops.block.entity.custom;

import github.jcsmecabricks.customcrops.block.custom.PastryStationBlock;
import github.jcsmecabricks.customcrops.block.entity.ImplementedInventory;
import github.jcsmecabricks.customcrops.block.entity.ModBlockEntities;
import github.jcsmecabricks.customcrops.item.ModItems;
import github.jcsmecabricks.customcrops.recipe.ModRecipes;
import github.jcsmecabricks.customcrops.recipe.PastryStationRecipe;
import github.jcsmecabricks.customcrops.recipe.PastryStationRecipeInput;
import github.jcsmecabricks.customcrops.screen.custom.PastryScreenHandler;
import net.fabricmc.fabric.api.screenhandler.v1.ExtendedScreenHandlerFactory;
import net.minecraft.block.BlockState;
import net.minecraft.block.entity.BlockEntity;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.entity.player.PlayerInventory;
import net.minecraft.inventory.Inventories;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NbtCompound;
import net.minecraft.network.listener.ClientPlayPacketListener;
import net.minecraft.network.packet.Packet;
import net.minecraft.network.packet.s2c.play.BlockEntityUpdateS2CPacket;
import net.minecraft.recipe.RecipeEntry;
import net.minecraft.registry.RegistryWrapper;
import net.minecraft.screen.PropertyDelegate;
import net.minecraft.screen.ScreenHandler;
import net.minecraft.server.network.ServerPlayerEntity;
import net.minecraft.text.Text;
import net.minecraft.util.collection.DefaultedList;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import org.jetbrains.annotations.Nullable;

import java.util.Optional;

public class PastryStationBlockEntity extends BlockEntity implements ExtendedScreenHandlerFactory, ImplementedInventory {
private final DefaultedList inventory = DefaultedList.ofSize(4, ItemStack.EMPTY);

private static final int INPUT_SLOT = 1;
private static final int OUTPUT_SLOT = 2;

protected final PropertyDelegate propertyDelegate;
private int progress = 0;
private int maxProgress = 72;
private final int DEFAULT_MAX_PROGRESS = 72;

public PastryStationBlockEntity(BlockPos pos, BlockState state) {
    super(ModBlockEntities.PASTRY_BE, pos, state);
    this.propertyDelegate = new PropertyDelegate() {
        @Override
        public int get(int index) {
            return switch (index) {
                case 0 -> PastryStationBlockEntity.this.progress;
                case 1 -> PastryStationBlockEntity.this.maxProgress;
                default -> 0;
            };
        }

        @Override
        public void set(int index, int value) {
            switch (index) {
                case 0: PastryStationBlockEntity.this.progress = value;
                case 1: PastryStationBlockEntity.this.maxProgress = value;
            }
        }

        @Override
        public int size() {
            return 2;
        }
    };
}

@Override
public BlockPos getScreenOpeningData(ServerPlayerEntity player) {
    return this.pos;
}

@Override
public DefaultedList<ItemStack> getItems() {
    return inventory;
}

@Override
public Text getDisplayName() {
    return Text.translatable("gui.custom-crops.pastry_station");

}

@Nullable
@Override
public ScreenHandler createMenu(int syncId, PlayerInventory playerInventory, PlayerEntity player) {
    return new PastryScreenHandler(syncId, playerInventory, this, propertyDelegate);
}

@Override
protected void writeNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registryLookup) {
    super.writeNbt(nbt, registryLookup);
    Inventories.writeNbt(nbt, inventory, registryLookup);
    nbt.putInt("pastry_station.progress", progress);
    nbt.putInt("pastry_station.max_progress", maxProgress);
}

@Override
protected void readNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registryLookup) {
    Inventories.readNbt(nbt, inventory, registryLookup);
    progress = nbt.getInt("pastry_station.progress");
    maxProgress = nbt.getInt("pastry_station.max_progress");
    super.readNbt(nbt, registryLookup);
}

public void tick(World world, BlockPos pos, BlockState state) {
    boolean isLit = state.get(PastryStationBlock.LIT);

    if (hasRecipe() && canInsertIntoOutputSlot()) {
        increaseCraftingProgress();
        if (!isLit) {
            world.setBlockState(pos, state.with(PastryStationBlock.LIT, true), 3);
            markDirty(world, pos, state);
        }

        if (hasCraftingFinished()) {
            craftItem();
            resetProgress();
        }
    } else {
        if (isLit) {
            world.setBlockState(pos, state.with(PastryStationBlock.LIT, false), 3);
            resetProgress();
        }
    }
}


private void resetProgress() {
    this.progress = 0;
    this.maxProgress = DEFAULT_MAX_PROGRESS;
}

private void craftItem() {
    this.removeStack(INPUT_SLOT, 1);
    this.setStack(OUTPUT_SLOT, new ItemStack(ModItems.STRAWBERRY_LEMONADE,
            this.getStack(OUTPUT_SLOT).getCount() + 1));
}

private boolean hasCraftingFinished() {
    return this.progress >= this.maxProgress;
}

private void increaseCraftingProgress() {
    this.progress++;
}

private boolean canInsertIntoOutputSlot() {
    return this.getStack(OUTPUT_SLOT).isEmpty() ||
            this.getStack(OUTPUT_SLOT).getCount() < this.getStack(OUTPUT_SLOT).getMaxCount();
}

private boolean hasRecipe() {
    Optional<RecipeEntry<PastryStationRecipe>> recipe = getCurrentRecipe();
    if(recipe.isEmpty()) {
        return false;
    }
}

private Optional<RecipeEntry<PastryStationRecipe>> getCurrentRecipe() {
    return this.getWorld().getRecipeManager().getFirstMatch(ModRecipes.PASTRY_TYPE, new PastryStationRecipeInput(inventory.get(INPUT_SLOT)), this.getWorld());
}

private boolean canInsertItemIntoOutputSlot(ItemStack output) {
    return this.getStack(OUTPUT_SLOT).isEmpty() || this.getStack(OUTPUT_SLOT).getItem() == output.getItem();
}

private boolean canInsertAmountIntoOutputSlot(int count) {
    return this.getStack(OUTPUT_SLOT).getMaxCount() >= this.getStack(OUTPUT_SLOT).getCount() + count;
}

@Nullable
@Override
public Packet<ClientPlayPacketListener> toUpdatePacket() {
    return BlockEntityUpdateS2CPacket.create(this);
}

}