path: root/src/main/java/lv/enes/mc/eris_alchemy/Emc.java

package lv.enes.mc.eris_alchemy;

import jakarta.annotation.Nullable;
import lv.enes.mc.eris_alchemy.ErisAlchemyRegistry.NetworkingConstants;
import lv.enes.mc.eris_alchemy.block.EmcStorageBlock;
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;
import net.minecraft.network.FriendlyByteBuf;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.tags.TagKey;
import net.minecraft.world.item.BlockItem;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.crafting.Ingredient;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.Block;
import org.quiltmc.loader.api.minecraft.ClientOnly;
import org.quiltmc.qsl.networking.api.PacketByteBufs;
import org.quiltmc.qsl.networking.api.ServerPlayConnectionEvents;
import org.quiltmc.qsl.networking.api.ServerPlayNetworking;
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 {
	private Emc() {}

	private static final Map<ResourceLocation, OptionalDouble> ITEM_VALUES = new HashMap<>();
	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<>());

	private static final DecimalFormat FORMATTER = new DecimalFormat("0");
	static {
		FORMATTER.setMaximumFractionDigits(1);
	}

	private static ServerLevel overworld = null;

	public static String formatEmc(double value) {
		return FORMATTER.format(value);
	}

	/** Returns the EMC for one item not the entire stack.
	 * @see #getTotal(ItemStack)  */
	public static OptionalDouble get(ItemStack stack) {
		if (stack.isEmpty()) {
			return OptionalDouble.empty();
		}

		var item = stack.getItem();
		var itemId = ItemUtils.getId(item);
		return get(itemId)
				.stream()
				.map(value -> {
					if (item instanceof BlockItem blockItem
							&& blockItem.getBlock() instanceof EmcStorageBlock block) {
						return value + block.getStoredEmc(stack);
					}

					return value;
				})
				.findFirst();
	}

	/** getTotal = get * count */
	public static OptionalDouble getTotal(ItemStack stack) {
		return get(stack).stream()
				.map(x -> x * stack.getCount())
				.filter(x -> x > 0)
				.findFirst();
	}

	public static OptionalDouble get(ResourceLocation itemId) {
		return VALUES.getOrDefault(itemId, OptionalDouble.empty());
	}

	@ClientOnly
	public static void initClient(Minecraft ignoredClient) {
		ClientPlayNetworking.registerGlobalReceiver(
				NetworkingConstants.UPDATE_EMCS,
				(client, handler, buf, responseSender) -> syncFrom(buf)
		);
	}

	public static void initServer(MinecraftServer server) {
		overworld = server.overworld();
		reinit();
		warnOfMissingValues();

		ServerPlayConnectionEvents.JOIN.register((handler, sender, server1) -> syncTo(handler.getPlayer()));
	}

	public static void reloadData(
			Map<ResourceLocation, OptionalDouble> itemValues,
			Map<ResourceLocation, OptionalDouble> itemTagValues,
			Map<ResourceLocation, OptionalDouble> blockTagValues,
			List<SimplifiedRecipe> fakeRecipes,
			List<BannedRecipe> bannedRecipes
	) {
		ITEM_VALUES.clear();
		ITEM_VALUES.putAll(itemValues);

		ITEM_TAG_VALUES.clear();
		itemTagValues.forEach((id, value) -> ITEM_TAG_VALUES.put(TagKey.create(Registries.ITEM, id), value));

		BLOCK_TAG_VALUES.clear();
		blockTagValues.forEach((id, value) -> BLOCK_TAG_VALUES.put(TagKey.create(Registries.BLOCK, id), value));

		FAKE_RECIPES.clear();
		FAKE_RECIPES.addAll(fakeRecipes);

		BANNED_RECIPES.clear();
		BANNED_RECIPES.addAll(bannedRecipes);

		reinit();
		warnOfMissingValues();
	}

	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(Emc::getTotal)
				.flatMapToDouble(OptionalDouble::stream)
				.average();
	}

	private static OptionalDouble calcEmcForRecipe(SimplifiedRecipe recipe) {
		if (recipe.input().isEmpty()) {
			return OptionalDouble.empty();
		}

		var inputEmcOpt = recipe.input()
				.stream()
				.map(Supplier::get)
				.map(Emc::calcEmcForIngredient)
				.collect(new OptionalDoubleSummer());

		if (inputEmcOpt.isEmpty()) {
			return OptionalDouble.empty();
		}

		var remainderEmcOpt = recipe.remainder()
				.stream()
				.map(Emc::getTotal)
				.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 Stream<SimplifiedRecipe> getRecipes(@Nullable Level world) {
		var recipes = FAKE_RECIPES.stream();

		if (world != null) {
			recipes = Stream.concat(
					recipes,
					world.getRecipeManager()
							.getRecipes()
							.stream()
							.map(recipe -> SimplifiedRecipe.of(recipe, world.registryAccess()))
							.flatMap(List::stream)
			);
		}

		return recipes;
	}

	private static void reinit() {
		VALUES.clear();
		VALUES.putAll(ITEM_VALUES);
		ITEM_TAG_VALUES.forEach(
				(tag, emcValue) -> BuiltInRegistries.ITEM
						.getTagOrEmpty(tag)
						.forEach(holder -> VALUES.putIfAbsent(ItemUtils.getId(holder), emcValue))
		);
		BLOCK_TAG_VALUES.forEach(
				(tag, emcValue) -> BuiltInRegistries.BLOCK
						.getTagOrEmpty(tag)
						.forEach(holder -> VALUES.putIfAbsent(ItemUtils.getId(holder), emcValue))
		);

		ErisAlchemy.LOGGER.info("Calculating EMC values from recipes...");
		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 -> calcEmc(id, recipes).ifPresent(v -> VALUES.put(id, OptionalDouble.of(v))));

		if (ForeignUtils.isClassAvailable("earth.terrarium.chipped.common.recipes.ChippedRecipe")) {
			reinitForChipped(sortedItems, recipes);
		}

		ErisAlchemy.LOGGER.info("Done calculating EMC values...");

		sync();
	}

	private static void reinitForChipped(
			Set<ResourceLocation> items,
			HashMap<ResourceLocation, List<SimplifiedRecipe>> recipes
	) {
		items.stream()
				.filter(id -> !VALUES.containsKey(id))
				.forEach(item -> {
					var myRecipes = recipes.getOrDefault(item, List.of())
							.stream()
							.filter(SimplifiedRecipe::fromChipped)
							.toList();

					if (myRecipes.size() != 1) {
						if (!myRecipes.isEmpty()) {
							ErisAlchemy.LOGGER.warn("Item {} has multiple chipped recipes, skipping...", item);
						}
						return;
					}

					var recipe = myRecipes.get(0);
					if (recipe.input().size() != 1) {
						ErisAlchemy.LOGGER.warn("Chipped recipe for {} has multiple inputs, skipping...", item);
						return;
					}

					var stacks = recipe.input().get(0).get().getItems();
					if (stacks.length != 1) {
						ErisAlchemy.LOGGER.warn("Chipped recipe for {} has multiple stack inputs, skipping...", item);
						return;
					}

					var inputId = ItemUtils.getId(stacks[0]);
					if (VALUES.containsKey(inputId)) {
						VALUES.put(item, VALUES.get(inputId));
					}
				});
	}

	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());
	}

	private static void syncFrom(FriendlyByteBuf buf) {
		var map = buf.readMap(FriendlyByteBuf::readResourceLocation, BufUtils::readOptionalDouble);
		VALUES.clear();
		VALUES.putAll(map);
	}

	private static FriendlyByteBuf syncTo(FriendlyByteBuf buf) {
		buf.writeMap(VALUES, FriendlyByteBuf::writeResourceLocation, BufUtils::writeOptionalDouble);
		return buf;
	}

	private static void syncTo(Collection<ServerPlayer> players) {
		var buf = syncTo(PacketByteBufs.create());
		ServerPlayNetworking.send(players, NetworkingConstants.UPDATE_EMCS, buf);
	}

	private static void syncTo(ServerPlayer player) {
		var buf = syncTo(PacketByteBufs.create());
		ServerPlayNetworking.send(player, NetworkingConstants.UPDATE_EMCS, buf);
	}

	private static void warnOfMissingValues() {
		if (overworld == null) {
			return;
		}

		BuiltInRegistries.ITEM
				.keySet()
				.stream()
				.filter(item -> !VALUES.containsKey(item))
				.forEach(item -> ErisAlchemy.LOGGER.warn("No EMC value for '{}' known", item));
	}
}