10 files changed, 425 insertions, 92 deletions

diff --git a/src/main/java/lv/enes/mc/eris_alchemy/Emc.java b/src/main/java/lv/enes/mc/eris_alchemy/Emc.java
index 2e7e2d7..d058b94 100644
--- a/src/main/java/lv/enes/mc/eris_alchemy/Emc.java
+++ b/src/main/java/lv/enes/mc/eris_alchemy/Emc.java
@@ -2,9 +2,9 @@ package lv.enes.mc.eris_alchemy;
 
 import jakarta.annotation.Nullable;
 import lv.enes.mc.eris_alchemy.ErisAlchemyRegistry.NetworkingConstants;
-import lv.enes.mc.eris_alchemy.utils.BufUtils;
-import lv.enes.mc.eris_alchemy.utils.ItemUtils;
-import lv.enes.mc.eris_alchemy.utils.PlayerUtils;
+import lv.enes.mc.eris_alchemy.recipe.BannedRecipe;
+import lv.enes.mc.eris_alchemy.recipe.SimplifiedRecipe;
+import lv.enes.mc.eris_alchemy.utils.*;
 import net.minecraft.client.Minecraft;
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.core.registries.Registries;
@@ -27,6 +27,7 @@ import org.quiltmc.qsl.networking.api.client.ClientPlayNetworking;
 
 import java.text.DecimalFormat;
 import java.util.*;
+import java.util.function.Supplier;
 import java.util.stream.Stream;
 
 public final class Emc {
@@ -36,6 +37,7 @@ public final class Emc {
         private static final Map<TagKey<Item>, OptionalDouble> ITEM_TAG_VALUES = new HashMap<>();
         private static final Map<TagKey<Block>, OptionalDouble> BLOCK_TAG_VALUES = new HashMap<>();
         private static final List<SimplifiedRecipe> FAKE_RECIPES = new ArrayList<>();
+        private static final List<BannedRecipe> BANNED_RECIPES = new ArrayList<>();
 
         private static final Map<ResourceLocation, OptionalDouble> VALUES = Collections.synchronizedMap(new HashMap<>());
 
@@ -102,7 +104,8 @@ public final class Emc {
                         Map<ResourceLocation, OptionalDouble> itemValues,
                         Map<ResourceLocation, OptionalDouble> itemTagValues,
                         Map<ResourceLocation, OptionalDouble> blockTagValues,
-                        List<SimplifiedRecipe> fakeRecipes
+                        List<SimplifiedRecipe> fakeRecipes,
+                        List<BannedRecipe> bannedRecipes
         ) {
                 ITEM_VALUES.clear();
                 ITEM_VALUES.putAll(itemValues);
@@ -116,86 +119,69 @@ public final class Emc {
                 FAKE_RECIPES.clear();
                 FAKE_RECIPES.addAll(fakeRecipes);
 
+                BANNED_RECIPES.clear();
+                BANNED_RECIPES.addAll(bannedRecipes);
+
                 reinit();
                 warnOfMissingValues();
         }
 
-        private static OptionalDouble calculateEmcForIngredient(
-                        List<SimplifiedRecipe> recipes,
-                        Set<ResourceLocation> configured,
-                        Ingredient ingredient
+        private static OptionalDouble calcEmc(
+                        ResourceLocation item,
+                        Map<ResourceLocation, List<SimplifiedRecipe>> allRecipes
         ) {
+                return allRecipes.getOrDefault(item, List.of())
+                                .stream()
+                                .map(Emc::calcEmcForRecipe)
+                                .flatMapToDouble(OptionalDouble::stream)
+                                .average();
+        }
+
+        private static OptionalDouble calcEmcForIngredient(Ingredient ingredient) {
                 return Arrays.stream(ingredient.getItems())
-                                .map(stack -> configEmc(recipes, configured, ItemUtils.getId(stack.getItem())).stream()
-                                                .map(x -> x * stack.getCount())
-                                                .findFirst())
-                                .filter(OptionalDouble::isPresent)
-                                .mapToDouble(OptionalDouble::getAsDouble)
-                                .filter(x -> x > 0)
+                                .map(Emc::get)
+                                .flatMapToDouble(OptionalDouble::stream)
                                 .average();
         }
 
-        private static OptionalDouble calculateEmcForRecipe(
-                        List<SimplifiedRecipe> recipes,
-                        Set<ResourceLocation> configured,
-                        SimplifiedRecipe recipe
-        ) {
-                try {
-                        if (recipe.input().isEmpty()) {
-                                return OptionalDouble.empty();
-                        }
-
-                        var inputEmc = recipe.input()
-                                        .stream()
-                                        .map(ingredient -> calculateEmcForIngredient(recipes, configured, ingredient))
-                                        .mapToDouble(OptionalDouble::orElseThrow)
-                                        .sum();
-
-                        var remainderEmc = recipe.remainder()
-                                        .stream()
-                                        .map(remainder -> configEmc(recipes, configured, ItemUtils.getId(remainder)))
-                                        .mapToDouble(OptionalDouble::orElseThrow)
-                                        .sum();
-
-                        if (remainderEmc > inputEmc) {
-                                ErisAlchemy.LOGGER.warn("Recipe generating {} creates too much EMC out of thin air!", recipe.output());
-                                return OptionalDouble.empty();
-                        }
-
-                        var outputDivisor = (double) recipe.output().getCount();
-
-                        return OptionalDouble.of((inputEmc - remainderEmc) / outputDivisor);
-                } catch (NoSuchElementException e) {
+        private static OptionalDouble calcEmcForRecipe(SimplifiedRecipe recipe) {
+                if (recipe.input().isEmpty()) {
                         return OptionalDouble.empty();
                 }
-        }
 
-        private static OptionalDouble configEmc(
-                        List<SimplifiedRecipe> recipes,
-                        Set<ResourceLocation> configured,
-                        ResourceLocation itemId
-        ) {
-                var res = get(itemId);
-                if (res.isPresent() || configured.contains(itemId)) {
-                        return res;
+                var inputEmcOpt = recipe.input()
+                                .stream()
+                                .map(Supplier::get)
+                                .map(Emc::calcEmcForIngredient)
+                                .collect(new OptionalDoubleSummer());
+
+                if (inputEmcOpt.isEmpty()) {
+                        return OptionalDouble.empty();
                 }
 
-                configured.add(itemId);
-                var item = BuiltInRegistries.ITEM.get(itemId);
-                res = recipes.stream()
-                                .filter(recipe -> recipe.output().is(item))
-                                .map(recipe -> calculateEmcForRecipe(recipes, configured, recipe))
-                                .flatMapToDouble(OptionalDouble::stream)
-                                .average();
-                res.ifPresentOrElse(
-                                emc -> VALUES.put(itemId, OptionalDouble.of(emc)),
-                                () -> configured.remove(itemId)
-                );
-                return res;
+                var remainderEmcOpt = recipe.remainder()
+                                .stream()
+                                .map(Emc::get)
+                                .collect(new OptionalDoubleSummer());
+
+                if (remainderEmcOpt.isEmpty()) {
+                        return OptionalDouble.empty();
+                }
+
+                var inputEmc = inputEmcOpt.getAsDouble();
+                var remainderEmc = remainderEmcOpt.getAsDouble();
+                if (remainderEmc > inputEmc) {
+                        ErisAlchemy.LOGGER.warn("Recipe generating {} creates too much EMC out of thin air!", recipe.output());
+                        return OptionalDouble.empty();
+                }
+
+                var outputDivisor = (double) recipe.output().getCount();
+
+                return OptionalDouble.of((inputEmc - remainderEmc) / outputDivisor);
         }
 
-        private static List<SimplifiedRecipe> getRecipes(@Nullable Level world) {
-                Stream<SimplifiedRecipe> recipes = FAKE_RECIPES.stream();
+        private static Stream<SimplifiedRecipe> getRecipes(@Nullable Level world) {
+                var recipes = FAKE_RECIPES.stream();
 
                 if (world != null) {
                         recipes = Stream.concat(
@@ -207,7 +193,7 @@ public final class Emc {
                         );
                 }
 
-                return recipes.toList();
+                return recipes;
         }
 
         private static void reinit() {
@@ -225,14 +211,55 @@ public final class Emc {
                 );
 
                 ErisAlchemy.LOGGER.info("Calculating EMC values from recipes...");
-                var recipes = getRecipes(overworld);
-                var configured = new HashSet<>(VALUES.keySet());
-                BuiltInRegistries.ITEM.keySet().forEach(item -> configEmc(recipes, configured, item));
+                var recipes = new HashMap<ResourceLocation, List<SimplifiedRecipe>>();
+                getRecipes(overworld)
+                                .filter(recipe -> !recipe.hasDuplication())
+                                .filter(recipe -> recipe.isAllowed(BANNED_RECIPES))
+                                .forEach(recipe ->
+                                                recipes
+                                                                .computeIfAbsent(ItemUtils.getId(recipe.output()), k -> new ArrayList<>())
+                                                                .add(recipe)
+                                );
+                var sortedItems = sorted(recipes);
+                sortedItems.stream()
+                                .filter(id -> !VALUES.containsKey(id))
+                                .forEach(id -> VALUES.put(id, calcEmc(id, recipes)));
                 ErisAlchemy.LOGGER.info("Done calculating EMC values...");
 
                 sync();
         }
 
+        private static void sortDps(
+                        Set<ResourceLocation> permSorted,
+                        ConsList<ResourceLocation> tmpSorted,
+                        ResourceLocation item,
+                        Map<ResourceLocation, List<SimplifiedRecipe>> data
+        ) {
+                if (permSorted.contains(item)) {
+                        return;
+                }
+
+                var newTmpSorted = ConsList.cons(item, tmpSorted);
+
+                if (tmpSorted.contains(item)) {
+                        ErisAlchemy.LOGGER.warn("Cycle in recipes detected: {}, breaking here", newTmpSorted);
+                        return;
+                }
+
+                data.getOrDefault(item, List.of())
+                                .stream()
+                                .flatMap(SimplifiedRecipe::dependencies)
+                                .distinct()
+                                .forEach(dep -> sortDps(permSorted, newTmpSorted, dep, data));
+                permSorted.add(item);
+        }
+
+        private static Set<ResourceLocation> sorted(Map<ResourceLocation, List<SimplifiedRecipe>> unsorted) {
+                var res = new LinkedHashSet<ResourceLocation>();
+                unsorted.forEach((item, recipes) -> sortDps(res, ConsList.nil(), item, unsorted));
+                return res;
+        }
+
         private static void sync() {
                 syncTo(PlayerUtils.all());
         }
diff --git a/src/main/java/lv/enes/mc/eris_alchemy/EmcLoader.java b/src/main/java/lv/enes/mc/eris_alchemy/EmcLoader.java
index dd4613f..373e561 100644
--- a/src/main/java/lv/enes/mc/eris_alchemy/EmcLoader.java
+++ b/src/main/java/lv/enes/mc/eris_alchemy/EmcLoader.java
@@ -2,6 +2,8 @@ package lv.enes.mc.eris_alchemy;
 
 import com.google.gson.reflect.TypeToken;
 import jakarta.annotation.Nonnull;
+import lv.enes.mc.eris_alchemy.recipe.BannedRecipe;
+import lv.enes.mc.eris_alchemy.recipe.SimplifiedRecipe;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.packs.resources.ResourceManager;
 import org.quiltmc.qsl.resource.loader.api.reloader.SimpleSynchronousResourceReloader;
@@ -30,7 +32,9 @@ public class EmcLoader implements SimpleSynchronousResourceReloader {
 
                 var fakeRecipes = loadAllFiles(manager, "fake_recipes", new ArrayList<>(), EmcLoader::loadFakeRecipes);
 
-                Emc.reloadData(itemValues, itemTagValues, blockTagValues, fakeRecipes);
+                var bannedRecipes = loadAllFiles(manager, "cycle_cut", new ArrayList<>(), EmcLoader::loadBannedRecipes);
+
+                Emc.reloadData(itemValues, itemTagValues, blockTagValues, fakeRecipes, bannedRecipes);
         }
 
         private static <T> T loadAllFiles(
@@ -58,6 +62,15 @@ public class EmcLoader implements SimpleSynchronousResourceReloader {
                 return arg;
         }
 
+        private static void loadBannedRecipes(List<BannedRecipe> recipes, ResourceLocation id, InputStream is)
+                        throws IOException
+        {
+                try (var reader = new InputStreamReader(is)) {
+                        var json = GSON.fromJson(reader, new TypeToken<List<BannedRecipe>>(){});
+                        recipes.addAll(json);
+                }
+        }
+
         private static void loadEmcValues(Map<ResourceLocation, OptionalDouble> map, ResourceLocation id, InputStream is)
                         throws IOException
         {
diff --git a/src/main/java/lv/enes/mc/eris_alchemy/ErisAlchemy.java b/src/main/java/lv/enes/mc/eris_alchemy/ErisAlchemy.java
index 1d363c2..644a2a4 100644
--- a/src/main/java/lv/enes/mc/eris_alchemy/ErisAlchemy.java
+++ b/src/main/java/lv/enes/mc/eris_alchemy/ErisAlchemy.java
@@ -2,6 +2,9 @@ package lv.enes.mc.eris_alchemy;
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
+import lv.enes.mc.eris_alchemy.recipe.BannedRecipe;
+import lv.enes.mc.eris_alchemy.recipe.SimplifiedRecipe;
+import lv.enes.mc.eris_alchemy.utils.IngredientProvider;
 import lv.enes.mc.eris_alchemy.utils.PlayerUtils;
 import net.fabricmc.fabric.api.itemgroup.v1.FabricItemGroup;
 import net.minecraft.core.Registry;
@@ -11,6 +14,7 @@ import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.packs.PackType;
 import net.minecraft.world.item.CreativeModeTab;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.crafting.Ingredient;
 import org.quiltmc.loader.api.ModContainer;
 import org.quiltmc.qsl.base.api.entrypoint.ModInitializer;
 import org.quiltmc.qsl.lifecycle.api.event.ServerLifecycleEvents;
@@ -20,6 +24,8 @@ import org.slf4j.LoggerFactory;
 
 public class ErisAlchemy implements ModInitializer {
         public static final Gson GSON = new GsonBuilder()
+                        .registerTypeAdapter(BannedRecipe.class, new BannedRecipe.Deserializer())
+                        .registerTypeAdapter(Ingredient.class, new IngredientProvider())
                         .registerTypeAdapter(ResourceLocation.class, new ResourceLocation.Serializer())
                         .registerTypeAdapter(SimplifiedRecipe.class, new SimplifiedRecipe.Deserializer())
                         .create();
diff --git a/src/main/java/lv/enes/mc/eris_alchemy/recipe/BannedRecipe.java b/src/main/java/lv/enes/mc/eris_alchemy/recipe/BannedRecipe.java
new file mode 100644
index 0000000..d94222c
--- /dev/null
+++ b/src/main/java/lv/enes/mc/eris_alchemy/recipe/BannedRecipe.java
@@ -0,0 +1,40 @@
+package lv.enes.mc.eris_alchemy.recipe;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParseException;
+import lv.enes.mc.eris_alchemy.utils.IngredientProvider;
+import net.minecraft.world.item.crafting.Ingredient;
+
+import java.lang.reflect.Type;
+import java.util.function.Supplier;
+
+public record BannedRecipe(Supplier<Ingredient> input, Supplier<Ingredient> output) {
+        public static BannedRecipe deserialize(JsonElement el) {
+                if (el.isJsonPrimitive() && el.getAsJsonPrimitive().isString()) {
+                        return deserialize(el.getAsString());
+                } else {
+                        // TODO: Verbose object representation
+                        throw new JsonParseException("Banned recipes should all be strings");
+                }
+        }
+
+        public static BannedRecipe deserialize(String str) {
+                var split = str.indexOf("->");
+                var input = IngredientProvider.deserialize(str.substring(0, split).trim());
+                var output = IngredientProvider.deserialize(str.substring(split + 2).trim());
+                return new BannedRecipe(input, output);
+        }
+
+        public static class Deserializer implements JsonDeserializer<BannedRecipe> {
+                @Override
+                public BannedRecipe deserialize(
+                                JsonElement el,
+                                Type t,
+                                JsonDeserializationContext ctx
+                ) throws JsonParseException {
+                        return BannedRecipe.deserialize(el);
+                }
+        }
+}
diff --git a/src/main/java/lv/enes/mc/eris_alchemy/SimplifiedRecipe.java b/src/main/java/lv/enes/mc/eris_alchemy/recipe/SimplifiedRecipe.java
index ef69b84..469ed52 100644
--- a/src/main/java/lv/enes/mc/eris_alchemy/SimplifiedRecipe.java
+++ b/src/main/java/lv/enes/mc/eris_alchemy/recipe/SimplifiedRecipe.java
@@ -1,7 +1,12 @@
-package lv.enes.mc.eris_alchemy;
+package lv.enes.mc.eris_alchemy.recipe;
 
-import com.google.gson.*;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParseException;
 import jakarta.annotation.Nonnull;
+import lv.enes.mc.eris_alchemy.utils.IngredientProvider;
+import lv.enes.mc.eris_alchemy.utils.ItemUtils;
 import lv.enes.mc.eris_alchemy.utils.RecipeUtils;
 import net.minecraft.core.RegistryAccess;
 import net.minecraft.core.registries.BuiltInRegistries;
@@ -12,18 +17,58 @@ import net.minecraft.world.item.crafting.Recipe;
 import net.minecraft.world.item.crafting.ShapedRecipe;
 
 import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
+import java.util.Objects;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
 
-public record SimplifiedRecipe(ItemStack output, List<ItemStack> remainder, List<Ingredient> input) {
+public record SimplifiedRecipe(ItemStack output, List<ItemStack> remainder, List<Supplier<Ingredient>> input) {
         public SimplifiedRecipe(Recipe<?> recipe, RegistryAccess registryAccess) {
                 this(
                                 RecipeUtils.getOutput(recipe, registryAccess),
                                 List.of(), // TODO:
-                                RecipeUtils.getIngredients(recipe).stream().filter(ingredient -> !ingredient.isEmpty()).toList()
+                                RecipeUtils.getIngredients(recipe)
+                                                .stream()
+                                                .filter(ingredient -> !ingredient.isEmpty())
+                                                .map(x -> (Supplier<Ingredient>) () -> x)
+                                                .toList()
                 );
         }
 
-        static class Deserializer implements JsonDeserializer<SimplifiedRecipe> {
+        public Stream<ResourceLocation> dependencies() {
+                return Stream.concat(
+                                input.stream().map(Supplier::get).map(Ingredient::getItems).flatMap(Arrays::stream),
+                                remainder.stream()
+                ).map(ItemUtils::getId);
+        }
+
+        public boolean hasDuplication() {
+                var outputId = ItemUtils.getId(output);
+                var outputsInRemainder = remainder.stream()
+                                .map(ItemUtils::getId)
+                                .anyMatch(id -> Objects.equals(id, outputId));
+                if (outputsInRemainder) {
+                        return true;
+                }
+
+                return input.stream().anyMatch(ingredient -> ingredient.get().test(output));
+        }
+
+        public boolean isAllowed(BannedRecipe ban) {
+                if (!ban.output().get().test(output())) {
+                        return true;
+                }
+
+                return dependencies().noneMatch(dep -> ban.input().get().test(ItemUtils.get(dep).getDefaultInstance()));
+        }
+
+        public boolean isAllowed(Collection<BannedRecipe> bans) {
+                return bans.stream().allMatch(this::isAllowed);
+        }
+
+        public static class Deserializer implements JsonDeserializer<SimplifiedRecipe> {
                 @Nonnull
                 @Override
                 public SimplifiedRecipe deserialize(
@@ -46,23 +91,12 @@ public record SimplifiedRecipe(ItemStack output, List<ItemStack> remainder, List
                         return new SimplifiedRecipe(output, remainder, input);
                 }
 
-                private List<Ingredient> parseInputs(JsonElement el) {
+                private List<Supplier<Ingredient>> parseInputs(JsonElement el) {
                         if (el.isJsonArray()) {
-                                return el.getAsJsonArray().asList().stream().map(this::parseInput).map(Ingredient::of).toList();
+                                return el.getAsJsonArray().asList().stream().map(IngredientProvider::deserialize).toList();
                         }
 
-                        return List.of(Ingredient.of(parseInput(el)));
-                }
-
-                private ItemStack parseInput(JsonElement el) {
-                        if (el.isJsonObject()) {
-                                return ShapedRecipe.itemStackFromJson(el.getAsJsonObject());
-                        } else if (el.isJsonPrimitive() && el.getAsJsonPrimitive().isString()) {
-                                var id = new ResourceLocation(el.getAsString());
-                                return BuiltInRegistries.ITEM.get(id).getDefaultInstance();
-                        } else {
-                                throw new JsonParseException("Every recipe input should be an object or a string");
-                        }
+                        return List.of(IngredientProvider.deserialize(el));
                 }
 
                 private ItemStack parseOutputOrRemainder(JsonElement el) {
diff --git a/src/main/java/lv/enes/mc/eris_alchemy/utils/ConsList.java b/src/main/java/lv/enes/mc/eris_alchemy/utils/ConsList.java
new file mode 100644
index 0000000..bbab8a6
--- /dev/null
+++ b/src/main/java/lv/enes/mc/eris_alchemy/utils/ConsList.java
@@ -0,0 +1,103 @@
+package lv.enes.mc.eris_alchemy.utils;
+
+import jakarta.annotation.Nonnull;
+
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+public sealed abstract class ConsList<E> {
+        public static <E> ConsList<E> cons(E car, ConsList<E> cdr) {
+                return new Cons<>(car, cdr);
+        }
+
+        public static <E> ConsList<E> nil() {
+                return Nil.of();
+        }
+
+        @Nonnull
+        public abstract Optional<E> car();
+
+        @Nonnull
+        public abstract ConsList<E> cdr();
+
+        public boolean contains(E elem) {
+                return stream().anyMatch(x -> Objects.equals(x, elem));
+        }
+
+        public Stream<E> stream() {
+                var car = car();
+                if (car.isEmpty()) {
+                        return Stream.empty();
+                }
+
+                return Stream.<Supplier<Stream<E>>>of(
+                                                () -> Stream.of(car.get()),
+                                                () -> cdr().stream()
+                                )
+                                .flatMap(Supplier::get);
+        }
+
+        @Override
+        public String toString() {
+                if (car().isEmpty()) {
+                        return "[]";
+                }
+
+                var sb = new StringBuilder("[");
+                sb.append(car().get());
+                stream().skip(1)
+                                .forEach(x -> {
+                                        sb.append(" -> ");
+                                        sb.append(x);
+                                });
+                sb.append("]");
+                return sb.toString();
+        }
+
+        private static final class Cons<E> extends ConsList<E> {
+                private final E car;
+                private final ConsList<E> cdr;
+
+                public Cons(E car, ConsList<E> cdr) {
+                        this.car = car;
+                        this.cdr = cdr;
+                }
+
+                @Nonnull
+                @Override
+                public Optional<E> car() {
+                        return Optional.of(car);
+                }
+
+                @Nonnull
+                @Override
+                public ConsList<E> cdr() {
+                        return cdr;
+                }
+        }
+
+        private static final class Nil<E> extends ConsList<E> {
+                private static final Nil<?> INSTANCE = new Nil<>();
+
+                @SuppressWarnings("unchecked")
+                public static <E> Nil<E> of() {
+                        return (Nil<E>)INSTANCE;
+                }
+
+                private Nil(){}
+
+                @Nonnull
+                @Override
+                public Optional<E> car() {
+                        return Optional.empty();
+                }
+
+                @Nonnull
+                @Override
+                public ConsList<E> cdr() {
+                        return Nil.of();
+                }
+        }
+}
diff --git a/src/main/java/lv/enes/mc/eris_alchemy/utils/IngredientProvider.java b/src/main/java/lv/enes/mc/eris_alchemy/utils/IngredientProvider.java
new file mode 100644
index 0000000..e859114
--- /dev/null
+++ b/src/main/java/lv/enes/mc/eris_alchemy/utils/IngredientProvider.java
@@ -0,0 +1,44 @@
+package lv.enes.mc.eris_alchemy.utils;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParseException;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.item.crafting.Ingredient;
+import net.minecraft.world.item.crafting.ShapedRecipe;
+
+import java.lang.reflect.Type;
+import java.util.function.Supplier;
+
+public class IngredientProvider implements JsonDeserializer<Supplier<Ingredient>> {
+        public static Supplier<Ingredient> deserialize(JsonElement el) {
+                if (el.isJsonObject()) {
+                        return () -> Ingredient.of(ShapedRecipe.itemStackFromJson(el.getAsJsonObject()));
+                } else if (el.isJsonPrimitive() && el.getAsJsonPrimitive().isString()) {
+                        return deserialize(el.getAsString().strip());
+                } else {
+                        throw new JsonParseException("Every ingredient should be an object or a string");
+                }
+        }
+
+        public static Supplier<Ingredient> deserialize(String str) {
+                if (str.startsWith("#")) {
+                        var tag = TagKey.create(Registries.ITEM, new ResourceLocation(str.substring(1).strip()));
+                        return () -> Ingredient.of(tag);
+                } else {
+                        return () -> Ingredient.of(ItemUtils.get(new ResourceLocation(str)));
+                }
+        }
+
+        @Override
+        public Supplier<Ingredient> deserialize(
+                        JsonElement el,
+                        Type t,
+                        JsonDeserializationContext c
+        ) {
+                return IngredientProvider.deserialize(el);
+        }
+}
diff --git a/src/main/java/lv/enes/mc/eris_alchemy/utils/ItemUtils.java b/src/main/java/lv/enes/mc/eris_alchemy/utils/ItemUtils.java
index 4414d06..7ac7358 100644
--- a/src/main/java/lv/enes/mc/eris_alchemy/utils/ItemUtils.java
+++ b/src/main/java/lv/enes/mc/eris_alchemy/utils/ItemUtils.java
@@ -3,10 +3,15 @@ package lv.enes.mc.eris_alchemy.utils;
 import net.minecraft.core.Holder;
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.ItemLike;
 
 public final class ItemUtils {
+        public static Item get(ResourceLocation id) {
+                return BuiltInRegistries.ITEM.get(id);
+        }
+
         public static <I extends ItemLike> ResourceLocation getId(Holder<I> holder) {
                 return getId(holder.value());
         }
diff --git a/src/main/java/lv/enes/mc/eris_alchemy/utils/OptionalDoubleSummer.java b/src/main/java/lv/enes/mc/eris_alchemy/utils/OptionalDoubleSummer.java
new file mode 100644
index 0000000..04b6ca8
--- /dev/null
+++ b/src/main/java/lv/enes/mc/eris_alchemy/utils/OptionalDoubleSummer.java
@@ -0,0 +1,47 @@
+package lv.enes.mc.eris_alchemy.utils;
+
+import java.util.OptionalDouble;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collector;
+
+public class OptionalDoubleSummer implements Collector<OptionalDouble, Ref<OptionalDouble>, OptionalDouble> {
+        @Override
+        public Supplier<Ref<OptionalDouble>> supplier() {
+                return () -> new Ref<>(OptionalDouble.of(0));
+        }
+
+        @Override
+        public BiConsumer<Ref<OptionalDouble>, OptionalDouble> accumulator() {
+                return (ref, od) -> {
+                        if (ref.getValue().isPresent()) {
+                                if (od.isPresent()) {
+                                        ref.setValue(OptionalDouble.of(ref.getValue().getAsDouble() + od.getAsDouble()));
+                                } else {
+                                        ref.setValue(OptionalDouble.empty());
+                                }
+                        }
+                };
+        }
+
+        @Override
+        public BinaryOperator<Ref<OptionalDouble>> combiner() {
+                return (ref1, ref2) -> {
+                        accumulator().accept(ref1, ref2.getValue());
+                        return ref1;
+                };
+        }
+
+        @Override
+        public Function<Ref<OptionalDouble>, OptionalDouble> finisher() {
+                return Ref::getValue;
+        }
+
+        @Override
+        public Set<Characteristics> characteristics() {
+                return Set.of(Characteristics.UNORDERED);
+        }
+}
diff --git a/src/main/java/lv/enes/mc/eris_alchemy/utils/Ref.java b/src/main/java/lv/enes/mc/eris_alchemy/utils/Ref.java
new file mode 100644
index 0000000..dc2624a
--- /dev/null
+++ b/src/main/java/lv/enes/mc/eris_alchemy/utils/Ref.java
@@ -0,0 +1,14 @@
+package lv.enes.mc.eris_alchemy.utils;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Setter
+@Getter
+public class Ref<T> {
+        private T value;
+
+        public Ref(T value) {
+                this.value = value;
+        }
+}