package lv.enes.mc.eris_alchemy.client;

import lv.enes.mc.eris_alchemy.block.entity.AlchemicalChestEntity;
import lv.enes.mc.eris_alchemy.block.entity.EnergyCondenserEntity;
import net.fabricmc.fabric.api.client.rendering.v1.BuiltinItemRendererRegistry.DynamicItemRenderer;
import net.minecraft.client.gui.screens.MenuScreens.ScreenConstructor;
import net.minecraft.client.gui.screens.Screen;
import net.minecraft.client.gui.screens.inventory.MenuAccess;
import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
import net.minecraft.client.renderer.blockentity.ChestRenderer;
import net.minecraft.world.inventory.AbstractContainerMenu;
import net.minecraft.world.inventory.MenuType;
import net.minecraft.world.level.ItemLike;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.block.entity.BlockEntityType;

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

import static lv.enes.mc.eris_alchemy.ErisAlchemyRegistry.*;

public final class ErisAlchemyClientRegistry {
	private ErisAlchemyClientRegistry() {}

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

		@FunctionalInterface
		public interface Consumer {
			<T extends BlockEntity> void consume(BlockEntityType<? extends T> type, BlockEntityRendererProvider<T> provider);
		}

		public static void consume(Consumer consumer) {
			data.values().forEach(pair -> pair.beConsumed(consumer));
		}

		private record Pair<T extends BlockEntity>(
				BlockEntityType<? extends T> type,
				BlockEntityRendererProvider<T> provider
		) {
			public void beConsumed(Consumer consumer) {
				consumer.consume(type, provider);
			}
		}

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

		private static <T extends BlockEntity> void register(
				BlockEntityType<? extends T> type,
				BlockEntityRendererProvider<T> provider
		) {
			data.put(type, new Pair<>(type, provider));
		}

		static {
			register(BlockEntities.ALCHEMICAL_CHEST, ChestRenderer::new);
			register(BlockEntities.ENERGY_CONDENSER, ChestRenderer::new);
		}
	}

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

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

		private static final Map<ItemLike, DynamicItemRenderer> data = new LinkedHashMap<>();

		private static void register(ItemLike item, DynamicItemRenderer renderer) {
			data.put(item, renderer);
		}

		static {
			register(
					Items.ALCHEMICAL_CHEST,
					new ChestItemRenderer<>(Blocks.ALCHEMICAL_CHEST, AlchemicalChestEntity::new)::renderByItem
			);
			register(
					Items.ENERGY_CONDENSER,
					new ChestItemRenderer<>(Blocks.ENERGY_CONDENSER, EnergyCondenserEntity::new)::renderByItem
			);
		}
	}

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

		@FunctionalInterface
		public interface Consumer {
			<M extends AbstractContainerMenu, S extends Screen & MenuAccess<M>>
			void consume(MenuType<? extends M> menu, ScreenConstructor<M, S> constructor);
		}

		public static void consume(Consumer consumer) {
			data.values().forEach(pair -> pair.beConsumed(consumer));
		}

		private record Pair<M extends AbstractContainerMenu, S extends Screen & MenuAccess<M>>(
			MenuType<? extends M> menu,
			ScreenConstructor<M, S> constructor
		) {
			public void beConsumed(Consumer consumer) {
				consumer.consume(menu, constructor);
			}
		}

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

		private static <M extends AbstractContainerMenu, S extends Screen & MenuAccess<M>> void register(
			MenuType<? extends M> menu,
			ScreenConstructor<M, S> constructor
		) {
			data.put(menu, new Pair<>(menu, constructor));
		}

		static {
			register(Menus.ALCHEMICAL_CHEST, AlchemicalChestScreen::new);
			register(Menus.ENERGY_CONDENSER, EnergyCondenserScreen::new);
		}
	}
}