package pl.faxu.cobblestonedrops;

import com.google.common.base.Suppliers;
import com.mojang.logging.LogUtils;
import com.mojang.serialization.Codec;
import com.mojang.serialization.codecs.RecordCodecBuilder;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import net.minecraft.advancements.critereon.ItemPredicate;
import net.minecraft.client.Minecraft;
import net.minecraft.data.DataGenerator;
import net.minecraft.world.item.*;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.storage.loot.LootContext;
import net.minecraft.world.level.storage.loot.predicates.LootItemBlockStatePropertyCondition;
import net.minecraft.world.level.storage.loot.predicates.LootItemCondition;
import net.minecraft.world.level.storage.loot.predicates.MatchTool;
import net.minecraftforge.api.distmarker.Dist;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.common.data.GlobalLootModifierProvider;
import net.minecraftforge.common.loot.IGlobalLootModifier;
import net.minecraftforge.common.loot.LootModifier;
import net.minecraftforge.data.event.GatherDataEvent;
import net.minecraftforge.eventbus.api.IEventBus;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
import net.minecraftforge.event.server.ServerStartingEvent;
import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
import net.minecraftforge.registries.DeferredRegister;
import net.minecraftforge.registries.ForgeRegistries;
import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;

import java.util.function.Supplier;

// The value here should match an entry in the META-INF/mods.toml file
@Mod(CobblestoneDrops.MODID)
public class CobblestoneDrops
{
    // Define mod id in a common place for everything to reference
    public static final String MODID = "cobblestonedrops";
    // Directly reference a slf4j logger
    private static final Logger LOGGER = LogUtils.getLogger();
    // Create a Deferred Register to hold Blocks which will all be registered under the "examplemod" namespace
    public static final DeferredRegister<Block> BLOCKS = DeferredRegister.create(ForgeRegistries.BLOCKS, MODID);
    // Create a Deferred Register to hold Items which will all be registered under the "examplemod" namespace
    public static final DeferredRegister<Item> ITEMS = DeferredRegister.create(ForgeRegistries.ITEMS, MODID);

    public CobblestoneDrops()
    {
        LOGGER.info("[CD_DEBUG] Add listeners");
        IEventBus modEventBus = FMLJavaModLoadingContext.get().getModEventBus();

        // Register the commonSetup method for modloading
        modEventBus.addListener(this::commonSetup);

        // Register the Deferred Register to the mod event bus so blocks get registered
        BLOCKS.register(modEventBus);
        // Register the Deferred Register to the mod event bus so items get registered
        ITEMS.register(modEventBus);

        // Register ourselves for server and other game events we are interested in
        MinecraftForge.EVENT_BUS.register(this);
    }

    private void commonSetup(final FMLCommonSetupEvent event)
    {
        // Some common setup code
        LOGGER.info("[CD_DEBUG] HELLO FROM COMMON SETUP");
        LOGGER.info("[CD_DEBUG] DIRT BLOCK >> {}", ForgeRegistries.BLOCKS.getKey(Blocks.DIRT));
    }

    // You can use SubscribeEvent and let the Event Bus discover methods to call
    @SubscribeEvent
    public void onServerStarting(ServerStartingEvent event)
    {
        // Do something when the server starts
        LOGGER.info("[CD_DEBUG] HELLO from server starting");
    }

    // You can use EventBusSubscriber to automatically register all static methods in the class annotated with @SubscribeEvent
    @Mod.EventBusSubscriber(modid = MODID, bus = Mod.EventBusSubscriber.Bus.MOD, value = Dist.CLIENT)
    public static class ClientModEvents
    {
        @SubscribeEvent
        public static void onClientSetup(FMLClientSetupEvent event)
        {
            // Some client setup code
            LOGGER.info("[CD_DEBUG] HELLO FROM CLIENT SETUP");
            LOGGER.info("[CD_DEBUG] MINECRAFT NAME >> {}", Minecraft.getInstance().getUser().getName());
        }
    }

    @Mod.EventBusSubscriber(modid = MODID, bus = Mod.EventBusSubscriber.Bus.MOD)
    public static class ServerModEvents
    {
        @SubscribeEvent
        public static void runData(GatherDataEvent event)
        {
            LOGGER.info("[CD_DEBUG] Event happened");
            event.getGenerator().addProvider(event.includeServer(), new DataProvider(event.getGenerator(), MODID));
        }

        private static class DataProvider extends GlobalLootModifierProvider
        {
            public DataProvider(DataGenerator gen, String modid)
            {
                super(gen, modid);
            }

            @Override
            protected void start()
            {
                LOGGER.info("[CD_DEBUG] Add events");
                add("wheat_harvest", new WheatSeedsConverterModifier(
                        new LootItemCondition[] {
                                MatchTool.toolMatches(ItemPredicate.Builder.item().of(Items.DIAMOND_PICKAXE)).build(),
                                LootItemBlockStatePropertyCondition.hasBlockStateProperties(Blocks.COBBLESTONE).build()
                        },
                        1, Items.COBBLESTONE, Items.IRON_BLOCK)
                );

            }

            private static class WheatSeedsConverterModifier extends LootModifier {
                public static final Supplier<Codec<WheatSeedsConverterModifier>> CODEC = Suppliers.memoize(() -> RecordCodecBuilder.create(inst -> codecStart(inst).and(
                        inst.group(
                                Codec.INT.fieldOf("numSeeds").forGetter(m -> m.numSeedsToConvert),
                                ForgeRegistries.ITEMS.getCodec().fieldOf("seedItem").forGetter(m -> m.itemToCheck),
                                ForgeRegistries.ITEMS.getCodec().fieldOf("replacement").forGetter(m -> m.itemReward)
                        )).apply(inst, WheatSeedsConverterModifier::new)
                ));

                private final int numSeedsToConvert;
                private final Item itemToCheck;
                private final Item itemReward;
                public WheatSeedsConverterModifier(LootItemCondition[] conditionsIn, int numSeeds, Item itemCheck, Item reward) {
                    super(conditionsIn);
                    numSeedsToConvert = numSeeds;
                    itemToCheck = itemCheck;
                    itemReward = reward;
                    LOGGER.info("[CD_DEBUG] Does it even happen?");
                }

                @NotNull
                @Override
                public ObjectArrayList<ItemStack> doApply(ObjectArrayList<ItemStack> generatedLoot, LootContext context) {
                    //
                    // Additional conditions can be checked, though as much as possible should be parameterized via JSON data.
                    // It is better to write a new ILootCondition implementation than to do things here.
                    //
                    LOGGER.info("[CD_DEBUG] Loot changed");
                    generatedLoot.add(new ItemStack(Items.IRON_BLOCK, 1));
                    return generatedLoot;
                }

                @Override
                public Codec<? extends IGlobalLootModifier> codec() {
                    return CODEC.get();
                }
            }
        }

    }
}