package lv.enes.mc.eris_alchemy;

import lv.enes.mc.eris_alchemy.block.AlchemicalChestBlock;
import lv.enes.mc.eris_alchemy.block.EnergyCondenserBlock;
import lv.enes.mc.eris_alchemy.block.entity.AlchemicalChestEntity;
import lv.enes.mc.eris_alchemy.block.entity.EnergyCondenserEntity;
import lv.enes.mc.eris_alchemy.menu.AlchemicalChestMenu;
import lv.enes.mc.eris_alchemy.menu.EnergyCondenserMenu;
import lv.enes.mc.eris_alchemy.recipe.CovalenceRepair;
import net.fabricmc.fabric.api.screenhandler.v1.ExtendedScreenHandlerType;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.world.flag.FeatureFlags;
import net.minecraft.world.inventory.AbstractContainerMenu;
import net.minecraft.world.inventory.MenuType;
import net.minecraft.world.item.BlockItem;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.Rarity;
import net.minecraft.world.item.crafting.Recipe;
import net.minecraft.world.item.crafting.RecipeSerializer;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.block.entity.BlockEntityType;
import org.quiltmc.qsl.block.entity.api.QuiltBlockEntityTypeBuilder;
import org.quiltmc.qsl.block.extensions.api.QuiltBlockSettings;
import org.quiltmc.qsl.item.setting.api.QuiltItemSettings;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.function.BiConsumer;

import static net.minecraft.world.level.block.Blocks.ENDER_CHEST;

public final class ErisAlchemyRegistry {
	private ErisAlchemyRegistry() {}

	public static final class BlockEntities {
		private BlockEntities() {}

		private static final Map<ResourceLocation, BlockEntityType<?>> data = new LinkedHashMap<>();

		public static final BlockEntityType<AlchemicalChestEntity> ALCHEMICAL_CHEST = register(
				"alchemical_chest",
				QuiltBlockEntityTypeBuilder.create(AlchemicalChestEntity::new, Blocks.ALCHEMICAL_CHEST)
						.build()
		);

		public static final BlockEntityType<EnergyCondenserEntity> ENERGY_CONDENSER = register(
				"energy_condenser",
				QuiltBlockEntityTypeBuilder.create(EnergyCondenserEntity::new, Blocks.ENERGY_CONDENSER)
						.build()
		);

		public static void consume(BiConsumer<? super ResourceLocation, ? super BlockEntityType<?>> consumer) {
			data.forEach(consumer);
		}

		private static <T extends BlockEntity> BlockEntityType<T> register(String id, BlockEntityType<T> type) {
			data.put(new ResourceLocation(ErisAlchemy.ID, id), type);
			return type;
		}
	}

	public static final class Blocks {
		private Blocks() {}

		private static final Map<ResourceLocation, Block> data = new LinkedHashMap<>();

		public static final AlchemicalChestBlock ALCHEMICAL_CHEST = register(
				"alchemical_chest",
				new AlchemicalChestBlock(QuiltBlockSettings.copy(ENDER_CHEST))
		);

		public static final EnergyCondenserBlock ENERGY_CONDENSER = register(
				"energy_condenser",
				new EnergyCondenserBlock(QuiltBlockSettings.copy(ENDER_CHEST))
		);

		public static void consume(BiConsumer<? super ResourceLocation, ? super Block> consumer) {
			data.forEach(consumer);
		}

		private static <T extends Block> T register(String id, T block) {
			data.put(new ResourceLocation(ErisAlchemy.ID, id), block);
			return block;
		}
	}

	public static final class Items {
		private Items() {}

		private static final Map<ResourceLocation, Item> data = new LinkedHashMap<>();

		public static final Item ALCHEMICAL_CHEST =
				register(Blocks.ALCHEMICAL_CHEST, new QuiltItemSettings().rarity(Rarity.RARE));
		@SuppressWarnings("unused")
		public static final Item ENERGY_CONDENSER =
				register(Blocks.ENERGY_CONDENSER, new QuiltItemSettings().rarity(Rarity.EPIC));
		public static final Item LOW_COVALENCE_DUST =
				register("low_covalence_dust", new Item(new QuiltItemSettings().rarity(Rarity.COMMON)));
		@SuppressWarnings("unused")
		public static final Item MEDIUM_COVALENCE_DUST =
				register("medium_covalence_dust", new Item(new QuiltItemSettings().rarity(Rarity.UNCOMMON)));
		@SuppressWarnings("unused")
		public static final Item HIGH_COVALENCE_DUST =
				register("high_covalence_dust", new Item(new QuiltItemSettings().rarity(Rarity.RARE)));

		public static void consume(BiConsumer<? super ResourceLocation, ? super Item> consumer) {
			data.forEach(consumer);
		}

		private static BlockItem register(Block block, QuiltItemSettings settings) {
			return register(BuiltInRegistries.BLOCK.getKey(block), new BlockItem(block, settings));
		}

		private static <T extends Item> T register(String id, T item) {
			return register(new ResourceLocation(ErisAlchemy.ID, id), item);
		}

		private static <T extends Item> T register(ResourceLocation id, T item) {
			data.put(id, item);
			return item;
		}
	}

	public static final class Menus {
		private Menus() {}

		private static final Map<ResourceLocation, MenuType<?>> data = new LinkedHashMap<>();

		public static final MenuType<AlchemicalChestMenu> ALCHEMICAL_CHEST =
				register("alchemy_chest", AlchemicalChestMenu::new);
		public static final ExtendedScreenHandlerType<EnergyCondenserMenu> ENERGY_CONDENSER =
				registerExt("energy_condenser", EnergyCondenserMenu::new);

		public static void consume(BiConsumer<? super ResourceLocation, ? super MenuType<?>> consumer) {
			data.forEach(consumer);
		}

		private static <T extends AbstractContainerMenu> MenuType<T> register(
				String id,
				MenuType.MenuSupplier<T> supplier
		) {
			return registerCommon(id, new MenuType<>(supplier, FeatureFlags.VANILLA_SET));
		}

		private static <T extends AbstractContainerMenu> ExtendedScreenHandlerType<T> registerExt(
				String id,
				ExtendedScreenHandlerType.ExtendedFactory<T> supplier
		) {
			return registerCommon(id, new ExtendedScreenHandlerType<>(supplier));
		}

		private static <M extends AbstractContainerMenu, T extends MenuType<? extends M>> T registerCommon(
				String id,
				T menuType
		) {
			data.put(new ResourceLocation(ErisAlchemy.ID, id), menuType);
			return menuType;
		}
	}

	public static final class NetworkingConstants {
		private NetworkingConstants() {}

		public static final ResourceLocation UPDATE_EMCS
				= new ResourceLocation(ErisAlchemy.ID, "update_emcs");

		public static final ResourceLocation UPDATE_SYNCED_VALUE
				= new ResourceLocation(ErisAlchemy.ID, "update_synced_value");
	}

	public static final class RecipeSerializers {
		private RecipeSerializers() {}

		private static final Map<ResourceLocation, RecipeSerializer<?>> data = new LinkedHashMap<>();

		public static final RecipeSerializer<CovalenceRepair> COVALENCE_REPAIR =
				register("covalence_repair", new CovalenceRepair.Serializer());

		public static void consume(BiConsumer<? super ResourceLocation, ? super RecipeSerializer<?>> consumer) {
			data.forEach(consumer);
		}

		private static <T extends Recipe<?>> RecipeSerializer<T> register(String id, RecipeSerializer<T> serializer) {
			data.put(new ResourceLocation(ErisAlchemy.ID, id), serializer);
			return serializer;
		}
	}
}