Untitled

    override fun onSlotClick(slotIndex: Int, button: Int, actionType: SlotActionType?, player: PlayerEntity?) {
        if (CookingUtensilHandler.cookingUtensilIsCooking[cookingUtensil.utensilLocation] == true) {
            return
        }

        if (actionType == SlotActionType.SWAP) {
            return
        }

        when (slotIndex) {
            in bookmarkSlots -> {
                return
            }

            in ingredientSlots -> {
                return super.onSlotClick(slotIndex, button, actionType, player)
            }

            msgSlot -> {
                if (isMaster) {
                    return super.onSlotClick(slotIndex, button, actionType, player)
                } else {
                    return
                }
            }

            spatulaSlot -> {
                return super.onSlotClick(slotIndex, button, actionType, player)
            }

            cookSlot -> {
                if (CookingUtensilHandler.cookingUtensilIsCooking[cookingUtensil.utensilLocation] == true) {
                    return
                }

                if (!cursorStack.isEmpty) {
                    return
                }

                // check if player has the mastery level to use the spatula
                val spatulaStack = inventory.getStack(spatulaSlot)

                if (spatulaStack.item !== Items.WOODEN_HOE) {
                    fail("spatula")
                    CoroutineScope(Dispatchers.IO).launch {
                        delay(1000)
                        KitchenCraft.server!!.execute {
                            inventory.setStack(spatulaFeedbackSlot, ItemStack.EMPTY)
                        }
                    }
                    return
                }

                if (spatulaStack.hasNbt() && spatulaStack.nbt!!.contains("SpatulaUse")) {
                    val spatulaTier = spatulaStack.nbt!!.getInt("CustomModelData")
                    when (spatulaTier) {
                        2 -> {
                            if (playerProgress!!.masteryLevel < 10) {
                                fail("spatulaMastery")
                                CoroutineScope(Dispatchers.IO).launch {
                                    delay(1000)
                                    KitchenCraft.server!!.execute {
                                        inventory.setStack(spatulaFeedbackSlot, ItemStack.EMPTY)
                                    }
                                }
                                return
                            }
                        }

                        3 -> {
                            if (playerProgress!!.masteryLevel < 40) {
                                fail("spatulaMastery")
                                CoroutineScope(Dispatchers.IO).launch {
                                    delay(1000)
                                    KitchenCraft.server!!.execute {
                                        inventory.setStack(spatulaFeedbackSlot, ItemStack.EMPTY)
                                    }
                                }
                                return
                            }
                        }
                    }
                }

                val ingredientSlotList = ingredientSlots.map { inventory.getStack(it) }
                val matchingRecipe = FoodHandler.findMatchingRecipe(ingredientSlotList)
                inventory.setStack(feedbackSlot, ItemStack.EMPTY)
                if (spatulaStack.isEmpty || spatulaStack.item !== Items.WOODEN_HOE || !spatulaStack.hasNbt() || !spatulaStack.nbt!!.contains(
                        "SpatulaUse"
                    )
                ) {
                    fail("spatula")
                    CoroutineScope(Dispatchers.IO).launch {
                        delay(1000)
                        KitchenCraft.server!!.execute {
                            inventory.setStack(spatulaFeedbackSlot, ItemStack.EMPTY)
                        }
                    }
                    return
                }

                if (matchingRecipe != null && matchingRecipe.minimumMasteryLevel <= playerProgress!!.masteryLevel) {
                    CookingUtensilHandler.cookingUtensilIsCooking[cookingUtensil.utensilLocation] = true
                    //  KitchenCraft.logger.info("KitchenCraft: Found matching recipe: ${matchingRecipe.name}")
                    startCooking(matchingRecipe)
                    inventory.setStack(feedbackSlot, correctItemStack())

                    succeedSound()

                    val headStack = player!!.inventory.armor[3]

                    manageIngredients(headStack)

                } else {
                    inventory.setStack(feedbackSlot, incorrectItemStack())

                    if (matchingRecipe == null) {
                        fail("noRecipe")
                    } else {
                        fail("mastery")
                    }
                }
            }

            progressSlot -> {
                return
            }

            in playerInventorySlots -> {
                // find empty ingredient slot
                val emptyIngredientSlot = ingredientSlots.find { inventory.getStack(it).isEmpty }

                if (emptyIngredientSlot != null) {
                    return super.onSlotClick(slotIndex, button, actionType, player)
                }

                return
            }

            else -> {
                return
            }
        }

        return super.onSlotClick(slotIndex, button, actionType, player)
    }