Proper recipe selection for output overflow in LCR and other multiblocks (#2247)

* Implement Stream<FindRecipeResult> findRecipesWithResult for GT_RecipeMap

* Change ProcessingLogic.process to actually use new  findRecipesWithResult

* Change ProcessingLogic.process to start finding something only for OUTPUT_FULL result

* Refactor ProcessingLogic.process to make logic more readable

* Replace while with for loop, remove NOT_FOUND return in end of findRecipesWithResult

* Apply spotless

* Make findRecipe use findRecipes, add annotation to GT_Recipe and FindRecipeResult for processRecipe and make method protected, replace wildcard imports

* Remake isRecipeWithOutputFullFound

* Add @Nonnull to methods

* Apply spotless

* Remove Stream version of findRecipeWithResult, replace with predicate one. Add GT_Predicated_Recipe_Map class for utilizing this method. Changes some existent recipe maps to inherit from base class.

* Remove GT_Predicated_Recipe_Map, add Predicate directly to GT_Recipe_Map#findRecipeWithResult. Add AdvancedRecipeValidatorPredicate and FindRecipeWithAdvancedValidatorResult to allow store validation calculations for further use and proper errors displaying.

* Fix InsufficientVoltage errors

* Changes according to review comments. Integrate FindRecipeWithAdvancedValidatorResult to FindRecipeResult, rename AdvancedRecipeValidatorPredicate, encapsulate AdvancedRecipeValidatorPredicate fields, fixes some typos, etc

* Moves InsufficientVoltage check to GT_ParallelHelper. Removes FindRecipeResult#State#INSUFFICIENT_VOLTAGE

* Return an old findRecipeWithResult

* Renames things, call old methods for singleblocks

* Renames things, makes FindRecipeResult ctor private

* Apply spotless

* Move RecipeValidator, fix comments typos

5 files changed, 269 insertions, 91 deletions

diff --git a/src/main/java/gregtech/api/logic/ProcessingLogic.java b/src/main/java/gregtech/api/logic/ProcessingLogic.java
index 6fa25a6c40..345a3e59dd 100644
--- a/src/main/java/gregtech/api/logic/ProcessingLogic.java
+++ b/src/main/java/gregtech/api/logic/ProcessingLogic.java
@@ -9,12 +9,11 @@ import javax.annotation.Nullable;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.fluids.FluidStack;
 
+import org.jetbrains.annotations.NotNull;
+
 import gregtech.api.interfaces.tileentity.IRecipeLockable;
 import gregtech.api.interfaces.tileentity.IVoidable;
-import gregtech.api.recipe.check.CheckRecipeResult;
-import gregtech.api.recipe.check.CheckRecipeResultRegistry;
-import gregtech.api.recipe.check.FindRecipeResult;
-import gregtech.api.recipe.check.SingleRecipeCheck;
+import gregtech.api.recipe.check.*;
 import gregtech.api.util.GT_OverclockCalculator;
 import gregtech.api.util.GT_ParallelHelper;
 import gregtech.api.util.GT_Recipe;
@@ -275,7 +274,6 @@ public class ProcessingLogic {
             maxParallel = maxParallelSupplier.get();
         }
 
-        FindRecipeResult findRecipeResult;
         if (isRecipeLocked && recipeLockableMachine != null && recipeLockableMachine.getSingleRecipeCheck() != null) {
             // Recipe checker is already built, we'll use it
             SingleRecipeCheck singleRecipeCheck = recipeLockableMachine.getSingleRecipeCheck();
@@ -284,45 +282,81 @@ public class ProcessingLogic {
             if (singleRecipeCheck.checkRecipeInputs(false, 1, inputItems, inputFluids) == 0) {
                 return CheckRecipeResultRegistry.NO_RECIPE;
             }
-            findRecipeResult = FindRecipeResult.ofSuccess(
+
+            return processRecipe(
                 recipeLockableMachine.getSingleRecipeCheck()
                     .getRecipe());
-        } else {
-            findRecipeResult = findRecipe(recipeMap);
         }
 
-        GT_Recipe recipe;
-        CheckRecipeResult result;
-        if (findRecipeResult.isSuccessful()) {
-            recipe = findRecipeResult.getRecipeNonNull();
-            result = validateRecipe(recipe);
-            if (!result.wasSuccessful()) {
-                return result;
-            } else {
-                if (recipe.mCanBeBuffered) {
-                    lastRecipe = recipe;
-                } else {
-                    lastRecipe = null;
-                }
+        FindRecipeResult findRecipeResult = findRecipe(recipeMap);
+        // If processRecipe is not overridden, advanced recipe validation logic is used, and we can reuse calculations.
+        if (findRecipeResult.hasRecipeValidator()) {
+            RecipeValidator recipeValidator = findRecipeResult.getRecipeValidator();
+
+            // There are two cases:
+            // 1 - there are actually no matching recipes
+            // 2 - there are some matching recipes, but we rejected it due to our advanced validation (e.g. OUTPUT_FULL)
+            if (findRecipeResult.getState() == FindRecipeResult.State.NOT_FOUND
+                && recipeValidator.getFirstCheckResult() != null) {
+                // Here we're handling case 2
+                // If there are matching recipes but our validation rejected them,
+                // we should return a first one to display a proper error in the machine GUI
+                return recipeValidator.getFirstCheckResult();
             }
-        } else {
-            if (findRecipeResult.getState() == FindRecipeResult.State.INSUFFICIENT_VOLTAGE) {
-                return CheckRecipeResultRegistry.insufficientPower(findRecipeResult.getRecipeNonNull().mEUt);
-            } else {
-                return CheckRecipeResultRegistry.NO_RECIPE;
+
+            // If everything is ok, reuse our calculations
+            if (recipeValidator.isExecutedAtLeastOnce() && findRecipeResult.isSuccessful()) {
+                return applyRecipe(
+                    findRecipeResult.getRecipeNonNull(),
+                    recipeValidator.getLastParallelHelper(),
+                    recipeValidator.getLastOverclockCalculator(),
+                    recipeValidator.getLastCheckResult());
             }
         }
 
+        if (!findRecipeResult.isSuccessful()) {
+            return CheckRecipeResultRegistry.NO_RECIPE;
+        }
+
+        return processRecipe(findRecipeResult.getRecipeNonNull());
+    }
+
+    /**
+     * Checks if supplied recipe is valid for process.
+     * If so, additionally performs input consumption, output calculation with parallel, and overclock calculation.
+     *
+     * @param recipe The recipe which will be checked and processed
+     */
+    @Nonnull
+    protected CheckRecipeResult processRecipe(@Nonnull GT_Recipe recipe) {
+        CheckRecipeResult result = validateRecipe(recipe);
+        if (!result.wasSuccessful()) {
+            return result;
+        }
+
         GT_ParallelHelper helper = createParallelHelper(recipe);
         GT_OverclockCalculator calculator = createOverclockCalculator(recipe);
         helper.setCalculator(calculator);
         helper.build();
 
+        return applyRecipe(recipe, helper, calculator, result);
+    }
+
+    /**
+     * Applies the recipe and calculated parameters
+     */
+    private CheckRecipeResult applyRecipe(@NotNull GT_Recipe recipe, GT_ParallelHelper helper,
+        GT_OverclockCalculator calculator, CheckRecipeResult result) {
         if (!helper.getResult()
             .wasSuccessful()) {
             return helper.getResult();
         }
 
+        if (recipe.mCanBeBuffered) {
+            lastRecipe = recipe;
+        } else {
+            lastRecipe = null;
+        }
         calculatedParallels = helper.getCurrentParallel();
 
         if (calculator.getConsumption() == Long.MAX_VALUE) {
@@ -360,14 +394,25 @@ public class ProcessingLogic {
     @Nonnull
     protected FindRecipeResult findRecipe(@Nullable GT_Recipe_Map map) {
         if (map == null) return FindRecipeResult.NOT_FOUND;
-        return map.findRecipeWithResult(
+
+        RecipeValidator recipeValidator = new RecipeValidator(
+            this::validateRecipe,
+            this::createParallelHelper,
+            this::createOverclockCalculator);
+
+        FindRecipeResult findRecipeResult = map.findRecipeWithResult(
             lastRecipe,
+            recipeValidator,
             false,
             false,
             amperageOC ? availableVoltage * availableAmperage : availableVoltage,
             inputFluids,
             specialSlotItem,
             inputItems);
+
+        findRecipeResult.setRecipeValidator(recipeValidator);
+
+        return findRecipeResult;
     }
 
     /**
diff --git a/src/main/java/gregtech/api/recipe/check/FindRecipeResult.java b/src/main/java/gregtech/api/recipe/check/FindRecipeResult.java
index 5791cb05e1..fa0e251fa1 100644
--- a/src/main/java/gregtech/api/recipe/check/FindRecipeResult.java
+++ b/src/main/java/gregtech/api/recipe/check/FindRecipeResult.java
@@ -5,6 +5,8 @@ import java.util.Objects;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
+import org.jetbrains.annotations.NotNull;
+
 import gregtech.api.util.GT_Recipe;
 
 /**
@@ -17,6 +19,8 @@ public class FindRecipeResult {
     private final State state;
     @Nullable
     private final GT_Recipe recipe;
+    @Nullable
+    private RecipeValidator recipeValidator;
 
     private FindRecipeResult(@Nonnull State state, @Nullable GT_Recipe recipe) {
         this.state = state;
@@ -41,7 +45,7 @@ public class FindRecipeResult {
     }
 
     /**
-     * You should use this ONLY WHEN state == FOUND or INSUFFICIENT_VOLTAGE.
+     * You should use this ONLY WHEN state == FOUND.
      */
     @Nonnull
     public GT_Recipe getRecipeNonNull() {
@@ -49,17 +53,35 @@ public class FindRecipeResult {
     }
 
     /**
-     * Successfully found recipe.
+     * Gets recipeValidator if it is not null.
+     * Be sure to call hasRecipeValidator before to determine if recipeValidator exists
+     *
+     * @return not null recipe validator
      */
-    public static FindRecipeResult ofSuccess(@Nonnull GT_Recipe recipe) {
-        return new FindRecipeResult(State.FOUND, Objects.requireNonNull(recipe));
+    @NotNull
+    public RecipeValidator getRecipeValidator() {
+        return Objects.requireNonNull(recipeValidator);
+    }
+
+    /**
+     * Sets recipeValidator which used to get this result
+     */
+    public void setRecipeValidator(@Nullable RecipeValidator recipeValidator) {
+        this.recipeValidator = recipeValidator;
     }
 
     /**
-     * Recipe was found, but voltage is not sufficient to run.
+     * Gets if this result has recipeValidator
      */
-    public static FindRecipeResult ofInsufficientVoltage(@Nonnull GT_Recipe recipe) {
-        return new FindRecipeResult(State.INSUFFICIENT_VOLTAGE, Objects.requireNonNull(recipe));
+    public boolean hasRecipeValidator() {
+        return recipeValidator != null;
+    }
+
+    /**
+     * Successfully found recipe.
+     */
+    public static FindRecipeResult ofSuccess(@Nonnull GT_Recipe recipe) {
+        return new FindRecipeResult(State.FOUND, Objects.requireNonNull(recipe));
     }
 
     /**
@@ -82,10 +104,6 @@ public class FindRecipeResult {
          */
         FOUND(true),
         /**
-         * Recipe was found, but voltage is not sufficient to run.
-         */
-        INSUFFICIENT_VOLTAGE(false),
-        /**
          * No recipe found.
          */
         NOT_FOUND(false),
diff --git a/src/main/java/gregtech/api/recipe/check/RecipeValidator.java b/src/main/java/gregtech/api/recipe/check/RecipeValidator.java
new file mode 100644
index 0000000000..8fb7b87cfe
--- /dev/null
+++ b/src/main/java/gregtech/api/recipe/check/RecipeValidator.java
@@ -0,0 +1,80 @@
+package gregtech.api.recipe.check;
+
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import gregtech.api.util.GT_OverclockCalculator;
+import gregtech.api.util.GT_ParallelHelper;
+import gregtech.api.util.GT_Recipe;
+
+/**
+ * Predicate for simple recipe validation.
+ * Also store some validation results for reusing it
+ */
+public class RecipeValidator implements Predicate<GT_Recipe> {
+
+    private CheckRecipeResult firstCheckResult;
+    private CheckRecipeResult lastCheckResult;
+    private GT_ParallelHelper lastParallelHelper;
+    private GT_OverclockCalculator lastOverclockCalculator;
+    private boolean wasExecutedAtLeastOnce = false;
+    private final Function<GT_Recipe, CheckRecipeResult> recipeValidator;
+    private final Function<GT_Recipe, GT_ParallelHelper> parallelHelperFactory;
+    private final Function<GT_Recipe, GT_OverclockCalculator> overclockCalculatorFactory;
+
+    public RecipeValidator(Function<GT_Recipe, CheckRecipeResult> recipeValidator,
+        Function<GT_Recipe, GT_ParallelHelper> parallelHelperFactory,
+        Function<GT_Recipe, GT_OverclockCalculator> overclockCalculatorFactory) {
+        this.recipeValidator = recipeValidator;
+        this.parallelHelperFactory = parallelHelperFactory;
+        this.overclockCalculatorFactory = overclockCalculatorFactory;
+    }
+
+    @Override
+    public boolean test(GT_Recipe recipe) {
+        wasExecutedAtLeastOnce = true;
+        CheckRecipeResult checkRecipeResult = checkRecipe(recipe);
+        if (firstCheckResult == null) {
+            firstCheckResult = checkRecipeResult;
+        }
+        return checkRecipeResult.wasSuccessful();
+    }
+
+    private CheckRecipeResult checkRecipe(GT_Recipe recipe) {
+        lastCheckResult = recipeValidator.apply(recipe);
+
+        if (!lastCheckResult.wasSuccessful()) {
+            return lastCheckResult;
+        }
+
+        lastParallelHelper = parallelHelperFactory.apply(recipe);
+        lastOverclockCalculator = overclockCalculatorFactory.apply(recipe);
+        lastParallelHelper.setCalculator(lastOverclockCalculator);
+        lastParallelHelper.build();
+
+        return lastParallelHelper.getResult();
+    }
+
+    public Boolean isExecutedAtLeastOnce() {
+        return wasExecutedAtLeastOnce;
+    }
+
+    /**
+     * Gets first check result in case if nothing matching recipe found.
+     */
+    public CheckRecipeResult getFirstCheckResult() {
+        return firstCheckResult;
+    }
+
+    public CheckRecipeResult getLastCheckResult() {
+        return lastCheckResult;
+    }
+
+    public GT_ParallelHelper getLastParallelHelper() {
+        return lastParallelHelper;
+    }
+
+    public GT_OverclockCalculator getLastOverclockCalculator() {
+        return lastOverclockCalculator;
+    }
+}
diff --git a/src/main/java/gregtech/api/util/GT_ParallelHelper.java b/src/main/java/gregtech/api/util/GT_ParallelHelper.java
index b44e9167f5..13fe6290f3 100644
--- a/src/main/java/gregtech/api/util/GT_ParallelHelper.java
+++ b/src/main/java/gregtech/api/util/GT_ParallelHelper.java
@@ -215,7 +215,7 @@ public class GT_ParallelHelper {
 
     /**
      * Set if we should consume inputs or not when trying for parallels
-     * 
+     *
      * @param consume Should we consume inputs
      */
     public GT_ParallelHelper setConsumption(boolean consume) {
@@ -251,7 +251,7 @@ public class GT_ParallelHelper {
 
     /**
      * Sets if we should calculate outputs with the parallels we found or not
-     * 
+     *
      * @param calculateOutputs Should we calculate outputs with the helper or not
      */
     public GT_ParallelHelper setOutputCalculation(boolean calculateOutputs) {
@@ -402,6 +402,11 @@ public class GT_ParallelHelper {
                 .setEUtDiscount(eutModifier);
         }
 
+        final int tRecipeEUt = (int) Math.ceil(recipe.mEUt * eutModifier);
+        if (availableEUt < tRecipeEUt) {
+            result = CheckRecipeResultRegistry.insufficientPower(tRecipeEUt);
+        }
+
         // Save the original max parallel before calculating our overclocking under 1 tick
         int originalMaxParallel = maxParallel;
         double tickTimeAfterOC = calculator.setParallel(originalMaxParallel)
@@ -450,7 +455,6 @@ public class GT_ParallelHelper {
 
         maxParallelBeforeBatchMode = Math.min(maxParallel, maxParallelBeforeBatchMode);
 
-        final int tRecipeEUt = (int) Math.ceil(recipe.mEUt * eutModifier);
         // Consume inputs to determine normal parallel
         if (recipeCheck != null) {
             int actualMaxParallel = (int) Math.min(maxParallelBeforeBatchMode, availableEUt / tRecipeEUt);
diff --git a/src/main/java/gregtech/api/util/GT_Recipe.java b/src/main/java/gregtech/api/util/GT_Recipe.java
index 2442e5b720..cc2a2b0626 100644
--- a/src/main/java/gregtech/api/util/GT_Recipe.java
+++ b/src/main/java/gregtech/api/util/GT_Recipe.java
@@ -30,19 +30,11 @@ import static net.minecraft.util.EnumChatFormatting.GRAY;
 import static net.minecraft.util.StatCollector.translateToLocal;
 
 import java.awt.Rectangle;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Consumer;
 import java.util.function.Function;
+import java.util.function.Predicate;
 import java.util.function.Supplier;
 
 import javax.annotation.Nonnull;
@@ -3999,9 +3991,40 @@ public class GT_Recipe implements Comparable<GT_Recipe> {
          * @return Result of the recipe search
          */
         @Nonnull
-        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, boolean aNotUnificated,
+        public final FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, boolean aNotUnificated,
             boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids, ItemStack aSpecialSlot,
             ItemStack... aInputs) {
+            return findRecipeWithResult(
+                aRecipe,
+                recipe -> aVoltage * mAmperage >= recipe.mEUt,
+                aNotUnificated,
+                aDontCheckStackSizes,
+                aVoltage,
+                aFluids,
+                aSpecialSlot,
+                aInputs);
+        }
+
+        /**
+         * finds a Recipe matching the aFluid and ItemStack Inputs.
+         *
+         * @param aRecipe              in case this is != null it will try to use this Recipe first when looking things
+         *                             up.
+         * @param aIsValidRecipe       predicate to help identify, if the recipe matches our machine
+         * @param aNotUnificated       if this is T the Recipe searcher will unificate the ItemStack Inputs
+         * @param aDontCheckStackSizes if set to false will only return recipes that can be executed at least once with
+         *                             the provided input
+         * @param aVoltage             Voltage of the Machine or Long.MAX_VALUE if it has no Voltage
+         * @param aFluids              the Fluid Inputs
+         * @param aSpecialSlot         the content of the Special Slot, the regular Manager doesn't do anything with
+         *                             this, but some custom ones do.
+         * @param aInputs              the Item Inputs
+         * @return Result of the recipe search
+         */
+        @Nonnull
+        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, Predicate<GT_Recipe> aIsValidRecipe,
+            boolean aNotUnificated, boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids,
+            ItemStack aSpecialSlot, ItemStack... aInputs) {
             // No Recipes? Well, nothing to be found then.
             if (mRecipeList.isEmpty()) return NOT_FOUND;
 
@@ -4032,9 +4055,9 @@ public class GT_Recipe implements Comparable<GT_Recipe> {
                 && aRecipe.isRecipeInputEqual(false, aDontCheckStackSizes, aFluids, aInputs)) {
                     if (!isSpecialSlotSensitive
                         || GT_Utility.areStacksEqualOrNull((ItemStack) aRecipe.mSpecialItems, aSpecialSlot)) {
-                        return aRecipe.mEnabled && aVoltage * mAmperage >= aRecipe.mEUt
-                            ? FindRecipeResult.ofSuccess(aRecipe)
-                            : FindRecipeResult.ofInsufficientVoltage(aRecipe);
+                        if (aRecipe.mEnabled && aIsValidRecipe.test(aRecipe)) {
+                            return ofSuccess(aRecipe);
+                        }
                     }
                 }
 
@@ -4045,9 +4068,9 @@ public class GT_Recipe implements Comparable<GT_Recipe> {
                     && tRecipe.isRecipeInputEqual(false, aDontCheckStackSizes, aFluids, aInputs)) {
                         if (!isSpecialSlotSensitive
                             || GT_Utility.areStacksEqualOrNull((ItemStack) tRecipe.mSpecialItems, aSpecialSlot)) {
-                            return tRecipe.mEnabled && aVoltage * mAmperage >= tRecipe.mEUt
-                                ? FindRecipeResult.ofSuccess(tRecipe)
-                                : FindRecipeResult.ofInsufficientVoltage(tRecipe);
+                            if (tRecipe.mEnabled && aIsValidRecipe.test(tRecipe)) {
+                                return ofSuccess(tRecipe);
+                            }
                         }
                     }
                 tRecipes = mRecipeItemMap.get(new GT_ItemStack(tStack, true));
@@ -4055,9 +4078,9 @@ public class GT_Recipe implements Comparable<GT_Recipe> {
                     && tRecipe.isRecipeInputEqual(false, aDontCheckStackSizes, aFluids, aInputs)) {
                         if (!isSpecialSlotSensitive
                             || GT_Utility.areStacksEqualOrNull((ItemStack) tRecipe.mSpecialItems, aSpecialSlot)) {
-                            return tRecipe.mEnabled && aVoltage * mAmperage >= tRecipe.mEUt
-                                ? FindRecipeResult.ofSuccess(tRecipe)
-                                : FindRecipeResult.ofInsufficientVoltage(tRecipe);
+                            if (tRecipe.mEnabled && aIsValidRecipe.test(tRecipe)) {
+                                return ofSuccess(tRecipe);
+                            }
                         }
                     }
             }
@@ -4072,9 +4095,9 @@ public class GT_Recipe implements Comparable<GT_Recipe> {
                     && tRecipe.isRecipeInputEqual(false, aDontCheckStackSizes, aFluids, aInputs)) {
                         if (!isSpecialSlotSensitive
                             || GT_Utility.areStacksEqualOrNull((ItemStack) tRecipe.mSpecialItems, aSpecialSlot)) {
-                            return tRecipe.mEnabled && aVoltage * mAmperage >= tRecipe.mEUt
-                                ? FindRecipeResult.ofSuccess(tRecipe)
-                                : FindRecipeResult.ofInsufficientVoltage(tRecipe);
+                            if (tRecipe.mEnabled && aIsValidRecipe.test(tRecipe)) {
+                                return ofSuccess(tRecipe);
+                            }
                         }
                     }
             }
@@ -4941,9 +4964,9 @@ public class GT_Recipe implements Comparable<GT_Recipe> {
 
         @Nonnull
         @Override
-        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, boolean aNotUnificated,
-            boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids, ItemStack aSpecialSlot,
-            ItemStack... aInputs) {
+        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, Predicate<GT_Recipe> aIsValidRecipe,
+            boolean aNotUnificated, boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids,
+            ItemStack aSpecialSlot, ItemStack... aInputs) {
             if (aInputs == null || aInputs.length == 0 || aInputs[0] == null) return NOT_FOUND;
             if (aRecipe != null && aRecipe.isRecipeInputEqual(false, true, aFluids, aInputs))
                 return FindRecipeResult.ofSuccess(aRecipe);
@@ -4998,9 +5021,9 @@ public class GT_Recipe implements Comparable<GT_Recipe> {
 
         @Nonnull
         @Override
-        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, boolean aNotUnificated,
-            boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids, ItemStack aSpecialSlot,
-            ItemStack... aInputs) {
+        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, Predicate<GT_Recipe> aIsValidRecipe,
+            boolean aNotUnificated, boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids,
+            ItemStack aSpecialSlot, ItemStack... aInputs) {
             if (aInputs == null || aInputs.length == 0 || aInputs[0] == null) return NOT_FOUND;
             if (aRecipe != null && aRecipe.isRecipeInputEqual(false, true, aFluids, aInputs))
                 return FindRecipeResult.ofSuccess(aRecipe);
@@ -5118,12 +5141,13 @@ public class GT_Recipe implements Comparable<GT_Recipe> {
 
         @Nonnull
         @Override
-        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, boolean aNotUnificated,
-            boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids, ItemStack aSpecialSlot,
-            ItemStack... aInputs) {
+        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, Predicate<GT_Recipe> aIsValidRecipe,
+            boolean aNotUnificated, boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids,
+            ItemStack aSpecialSlot, ItemStack... aInputs) {
             if (aInputs == null || aInputs.length == 0 || !ItemList.IC2_Scrapbox.isStackEqual(aInputs[0], false, true))
                 return super.findRecipeWithResult(
                     aRecipe,
+                    aIsValidRecipe,
                     aNotUnificated,
                     aDontCheckStackSizes,
                     aVoltage,
@@ -5133,6 +5157,7 @@ public class GT_Recipe implements Comparable<GT_Recipe> {
             ItemStack tOutput = GT_ModHandler.getRandomScrapboxDrop();
             if (tOutput == null) return super.findRecipeWithResult(
                 aRecipe,
+                aIsValidRecipe,
                 aNotUnificated,
                 aDontCheckStackSizes,
                 aVoltage,
@@ -5193,11 +5218,12 @@ public class GT_Recipe implements Comparable<GT_Recipe> {
 
         @Nonnull
         @Override
-        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, boolean aNotUnificated,
-            boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids, ItemStack aSpecialSlot,
-            ItemStack... aInputs) {
+        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, Predicate<GT_Recipe> aIsValidRecipe,
+            boolean aNotUnificated, boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids,
+            ItemStack aSpecialSlot, ItemStack... aInputs) {
             FindRecipeResult result = super.findRecipeWithResult(
                 aRecipe,
+                aIsValidRecipe,
                 aNotUnificated,
                 aDontCheckStackSizes,
                 aVoltage,
@@ -5293,9 +5319,9 @@ public class GT_Recipe implements Comparable<GT_Recipe> {
 
         @Nonnull
         @Override
-        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, boolean aNotUnificated,
-            boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids, ItemStack aSpecialSlot,
-            ItemStack... aInputs) {
+        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, Predicate<GT_Recipe> aIsValidRecipe,
+            boolean aNotUnificated, boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids,
+            ItemStack aSpecialSlot, ItemStack... aInputs) {
             if (aInputs == null || aInputs.length == 0 || aInputs[0] == null) return NOT_FOUND;
             if (aRecipe != null && aRecipe.isRecipeInputEqual(false, true, aFluids, aInputs))
                 return FindRecipeResult.ofSuccess(aRecipe);
@@ -5348,12 +5374,13 @@ public class GT_Recipe implements Comparable<GT_Recipe> {
 
         @Nonnull
         @Override
-        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, boolean aNotUnificated,
-            boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids, ItemStack aSpecialSlot,
-            ItemStack... aInputs) {
+        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, Predicate<GT_Recipe> aIsValidRecipe,
+            boolean aNotUnificated, boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids,
+            ItemStack aSpecialSlot, ItemStack... aInputs) {
             if (aInputs == null || aInputs.length == 0 || aInputs[0] == null || !GregTech_API.sPostloadFinished)
                 return super.findRecipeWithResult(
                     aRecipe,
+                    aIsValidRecipe,
                     aNotUnificated,
                     aDontCheckStackSizes,
                     aVoltage,
@@ -5362,6 +5389,7 @@ public class GT_Recipe implements Comparable<GT_Recipe> {
                     aInputs);
             FindRecipeResult result = super.findRecipeWithResult(
                 aRecipe,
+                aIsValidRecipe,
                 aNotUnificated,
                 aDontCheckStackSizes,
                 aVoltage,
@@ -5466,12 +5494,13 @@ public class GT_Recipe implements Comparable<GT_Recipe> {
 
         @Nonnull
         @Override
-        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, boolean aNotUnificated,
-            boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids, ItemStack aSpecialSlot,
-            ItemStack... aInputs) {
+        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, Predicate<GT_Recipe> aIsValidRecipe,
+            boolean aNotUnificated, boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids,
+            ItemStack aSpecialSlot, ItemStack... aInputs) {
 
             FindRecipeResult result = super.findRecipeWithResult(
                 aRecipe,
+                aIsValidRecipe,
                 true,
                 aDontCheckStackSizes,
                 aVoltage,
@@ -5535,11 +5564,12 @@ public class GT_Recipe implements Comparable<GT_Recipe> {
 
         @Nonnull
         @Override
-        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, boolean aNotUnificated,
-            boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids, ItemStack aSpecialSlot,
-            ItemStack... aInputs) {
+        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, Predicate<GT_Recipe> aIsValidRecipe,
+            boolean aNotUnificated, boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids,
+            ItemStack aSpecialSlot, ItemStack... aInputs) {
             FindRecipeResult result = super.findRecipeWithResult(
                 aRecipe,
+                aIsValidRecipe,
                 aNotUnificated,
                 aDontCheckStackSizes,
                 aVoltage,
@@ -5637,11 +5667,12 @@ public class GT_Recipe implements Comparable<GT_Recipe> {
 
         @Nonnull
         @Override
-        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, boolean aNotUnificated,
-            boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids, ItemStack aSpecialSlot,
-            ItemStack... aInputs) {
+        public FindRecipeResult findRecipeWithResult(GT_Recipe aRecipe, Predicate<GT_Recipe> aIsValidRecipe,
+            boolean aNotUnificated, boolean aDontCheckStackSizes, long aVoltage, FluidStack[] aFluids,
+            ItemStack aSpecialSlot, ItemStack... aInputs) {
             FindRecipeResult result = super.findRecipeWithResult(
                 aRecipe,
+                aIsValidRecipe,
                 aNotUnificated,
                 aDontCheckStackSizes,
                 aVoltage,