1 files changed, 99 insertions, 72 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());
         }