1 files changed, 99 insertions, 0 deletions

diff --git a/src/main/java/lv/enes/mc/eris_alchemy/EmcLoader.java b/src/main/java/lv/enes/mc/eris_alchemy/EmcLoader.java
new file mode 100644
index 0000000..dd4613f
--- /dev/null
+++ b/src/main/java/lv/enes/mc/eris_alchemy/EmcLoader.java
@@ -0,0 +1,99 @@
+package lv.enes.mc.eris_alchemy;
+
+import com.google.gson.reflect.TypeToken;
+import jakarta.annotation.Nonnull;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.packs.resources.ResourceManager;
+import org.quiltmc.qsl.resource.loader.api.reloader.SimpleSynchronousResourceReloader;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.*;
+
+import static lv.enes.mc.eris_alchemy.ErisAlchemy.GSON;
+
+public class EmcLoader implements SimpleSynchronousResourceReloader {
+        public static final EmcLoader INSTANCE = new EmcLoader();
+
+        @Nonnull
+        @Override
+        public ResourceLocation getQuiltId() {
+                return new ResourceLocation(ErisAlchemy.ID, "emc_loader");
+        }
+
+        @Override
+        public void onResourceManagerReload(ResourceManager manager) {
+                var itemValues = loadAllFiles(manager, "item_emcs", new HashMap<>(), EmcLoader::loadEmcValues);
+                var itemTagValues = loadAllFiles(manager, "item_tag_emcs", new HashMap<>(), EmcLoader::loadEmcValues);
+                var blockTagValues = loadAllFiles(manager, "block_tag_emcs", new HashMap<>(), EmcLoader::loadEmcValues);
+
+                var fakeRecipes = loadAllFiles(manager, "fake_recipes", new ArrayList<>(), EmcLoader::loadFakeRecipes);
+
+                Emc.reloadData(itemValues, itemTagValues, blockTagValues, fakeRecipes);
+        }
+
+        private static <T> T loadAllFiles(
+                        ResourceManager manager,
+                        String path,
+                        T arg,
+                        Loader<T> loader
+        ) {
+                manager.listResources(
+                                ErisAlchemy.ID + "/" + path,
+                                loc -> loc.getPath().endsWith(".json") || loc.getPath().endsWith(".json5")
+                ).forEach((id, res) -> {
+                        ErisAlchemy.LOGGER.info("Loading {}:{}...", id.getNamespace(), id.getPath());
+                        try (var is = res.open()) {
+                                loader.loadFile(arg, id, is);
+                        } catch (IOException e) {
+                                ErisAlchemy.LOGGER.error(
+                                                "Error occured while reading {}:{}",
+                                                id.getNamespace(),
+                                                id.getPath(),
+                                                e
+                                );
+                        }
+                });
+                return arg;
+        }
+
+        private static void loadEmcValues(Map<ResourceLocation, OptionalDouble> map, ResourceLocation id, InputStream is)
+                        throws IOException
+        {
+                try (var reader = new InputStreamReader(is)) {
+                        var json = GSON.fromJson(reader, new TypeToken<Map<ResourceLocation, Double>>(){});
+                        json.forEach((item, newEmcRaw) -> {
+                                var newEmc = newEmcRaw == null ? OptionalDouble.empty() : OptionalDouble.of(newEmcRaw);
+                                var oldEmc = map.get(item);
+                                if (oldEmc != null && !newEmc.equals(oldEmc)) {
+                                        var oldStr = oldEmc.isEmpty() ? "NONE" : Double.toString(oldEmc.getAsDouble());
+                                        var newStr = newEmc.isEmpty() ? "NONE" : Double.toString(newEmc.getAsDouble());
+                                        ErisAlchemy.LOGGER.warn(
+                                                        "Redefining the EMC value for {} from {} to {}",
+                                                        item,
+                                                        oldStr,
+                                                        newStr
+                                        );
+                                }
+                                map.put(item, newEmc);
+                        });
+                }
+        }
+
+        private static void loadFakeRecipes(List<SimplifiedRecipe> recipes, ResourceLocation id, InputStream is)
+                throws IOException
+        {
+                try (var reader = new InputStreamReader(is)) {
+                        var json = GSON.fromJson(reader, new TypeToken<List<SimplifiedRecipe>>(){});
+                        recipes.addAll(json);
+                }
+        }
+
+        @FunctionalInterface
+        private interface Loader<T> {
+                void loadFile(T arg, ResourceLocation id, InputStream is) throws IOException;
+        }
+
+        private EmcLoader() {}
+}