1 files changed, 36 insertions, 14 deletions

diff --git a/src/main/java/lv/enes/mc/eris_alchemy/recipe/SimplifiedRecipe.java b/src/main/java/lv/enes/mc/eris_alchemy/recipe/SimplifiedRecipe.java
index 469ed52..6bb1274 100644
--- a/src/main/java/lv/enes/mc/eris_alchemy/recipe/SimplifiedRecipe.java
+++ b/src/main/java/lv/enes/mc/eris_alchemy/recipe/SimplifiedRecipe.java
@@ -4,13 +4,17 @@ import com.google.gson.JsonDeserializationContext;
 import com.google.gson.JsonDeserializer;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonParseException;
+import earth.terrarium.chipped.common.recipe.ChippedRecipe;
 import jakarta.annotation.Nonnull;
+import lv.enes.mc.eris_alchemy.utils.ForeignUtils;
 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.Holder;
 import net.minecraft.core.RegistryAccess;
 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.item.crafting.Ingredient;
 import net.minecraft.world.item.crafting.Recipe;
@@ -21,20 +25,45 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
+import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 
 public record SimplifiedRecipe(ItemStack output, List<ItemStack> remainder, List<Supplier<Ingredient>> input) {
-        public SimplifiedRecipe(Recipe<?> recipe, RegistryAccess registryAccess) {
-                this(
+        public static List<SimplifiedRecipe> of(Recipe<?> recipe, RegistryAccess registryAccess) {
+                if (ForeignUtils.IS_CHIPPED_AVAILABLE && recipe instanceof ChippedRecipe chippedRecipe) {
+                        var remainder = List.<ItemStack>of();
+                        return chippedRecipe.tags()
+                                        .stream()
+                                        .flatMap(tag -> {
+                                                var items = tag.stream().map(Holder::value).toList();
+                                                Predicate<Item> isOutput = item -> ItemUtils.getId(item).getNamespace().equals("chipped");
+                                                var inputs = items.stream()
+                                                                .filter(item -> !isOutput.test(item))
+                                                                .map(Ingredient::of)
+                                                                .map(x -> (Supplier<Ingredient>) () -> x)
+                                                                .map(List::of)
+                                                                .toList();
+                                                var outputs = items.stream().filter(isOutput).map(Item::getDefaultInstance).toList();
+                                                return outputs.stream()
+                                                                .flatMap(
+                                                                                output ->
+                                                                                                inputs.stream()
+                                                                                                                .map(input -> new SimplifiedRecipe(output, remainder, input))
+                                                                );
+                                        })
+                                        .toList();
+                }
+
+                return List.of(new SimplifiedRecipe(
                                 RecipeUtils.getOutput(recipe, registryAccess),
-                                List.of(), // TODO:
+                                List.of(), // TODO
                                 RecipeUtils.getIngredients(recipe)
                                                 .stream()
                                                 .filter(ingredient -> !ingredient.isEmpty())
-                                                .map(x -> (Supplier<Ingredient>) () -> x)
+                                                .map(x -> (Supplier<Ingredient>)() -> x)
                                                 .toList()
-                );
+                ));
         }
 
         public Stream<ResourceLocation> dependencies() {
@@ -45,15 +74,8 @@ public record SimplifiedRecipe(ItemStack output, List<ItemStack> remainder, List
         }
 
         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));
+                return remainder.stream().anyMatch(stack -> ItemStack.isSameItem(stack, output))
+                                || input.stream().anyMatch(ingredient -> ingredient.get().test(output));
         }
 
         public boolean isAllowed(BannedRecipe ban) {