package al132.alchemistry.recipes

import al132.alchemistry.blocks.ModBlocks
import al132.alchemistry.chemistry.CompoundRegistry
import al132.alchemistry.chemistry.ElementRegistry
import al132.alchemistry.items.ModItems
import al132.alchemistry.utils.extensions.toCompoundStack
import al132.alchemistry.utils.extensions.toDict
import al132.alchemistry.utils.extensions.toElementStack
import al132.alchemistry.utils.extensions.toStack
import net.minecraft.init.Blocks
import net.minecraft.init.Items
import net.minecraft.item.ItemStack
import net.minecraftforge.fluids.FluidRegistry
import net.minecraftforge.fml.common.IFuelHandler
import net.minecraftforge.fml.common.registry.GameRegistry
import net.minecraftforge.oredict.OreDictionary
import java.util.*

/**
 * Created by al132 on 1/16/2017.
 */

data class DissolverOreData(val prefix: String, val quantity: Int, val strs: List<String>) {
    fun toDictName(index: Int) = prefix + strs[index].first().toUpperCase() + strs[index].substring(1)
    val size = strs.size
}

//TODO clean this file up, it's a hot mess
object ModRecipes {

    val metals: List<String> = listOf("aluminum",
            "bismuth",
            "cobalt",
            "copper",
            "gold",
            "iridium",
            "iron",
            "lead",
            "magnesium",
            "nickel",
            "platinum",
            "silver",
            "thorium",
            "tin",
            "titanium",
            "tungsten",
            "uranium",
            "zinc")

    val metalOreData: List<DissolverOreData> = listOf(
            DissolverOreData("ingot", 16, metals),
            DissolverOreData("ore", 32, metals),
            DissolverOreData("dust", 16, metals),
            DissolverOreData("block", 144, metals),
            DissolverOreData("nugget", 1, metals))

    var electrolyzerRecipes = ArrayList<ElectrolyzerRecipe>()
    var dissolverRecipes = ArrayList<DissolverRecipe>()
    var combinerRecipes = ArrayList<CombinerRecipe>()


    fun init() {
        initBlockRecipes()
        initDissolverRecipes() //before combiner, so combiner can use reversible recipes
        initCombinerRecipes()
        initElectrolyzerRecipes()
        initFuelHandler()
    }


    fun initBlockRecipes() {
        GameRegistry.addShapedRecipe(ItemStack(ModBlocks.chemical_combiner),
                "#D#",
                "#O#",
                "#P#",
                '#', Items.IRON_INGOT, 'D', Items.DIAMOND, 'P', Blocks.PISTON, 'O', Blocks.OBSIDIAN)

        GameRegistry.addShapedRecipe(ItemStack(ModBlocks.chemical_dissolver),
                "#B#",
                "#M#",
                "#P#",
                '#', Items.IRON_INGOT, 'B', Items.ENDER_PEARL, 'P', Blocks.PISTON, 'M', Blocks.MAGMA)

        GameRegistry.addShapedRecipe(ItemStack(ModBlocks.electrolyzer),
                "#Q#",
                "GQG",
                "#P#",
                '#', Items.IRON_INGOT, 'G', Items.GOLD_INGOT, 'P', Blocks.PISTON, 'Q', Blocks.QUARTZ_BLOCK)

    }


    fun initDissolverRecipes() {


        for (compound in CompoundRegistry.compounds) {
            dissolverRecipes.add(DissolverRecipe(stack = compound.toItemStack(1), inputQuantity = 1,
                    _outputs = ProbabilitySetDSL.create {
                        addGroup {
                            for (component in compound.components) {
                                addItemStack {
                                    component.compound.toItemStack(component.quantity)
                                }
                            }
                        }
                    }))
        }

        if (OreDictionary.doesOreNameExist("itemSilicon")) {
            dissolverRecipes.add(DissolverRecipe(dictName = "itemSilicon", reversible = true,
                    _outputs = ProbabilitySetDSL.create {
                        addStack { ProbabilityStack("silicon".toElementStack(16)) }
                    }))
        }

        dissolverRecipes.add(DissolverRecipe(stack = Items.GUNPOWDER.toStack(), reversible = true,
                _outputs = ProbabilitySetDSL.create {
                    addGroup {
                        addItemStack { "potassium_nitrate".toCompoundStack(2) }
                        addItemStack { "sulfur".toElementStack(8) }
                        addItemStack { "carbon".toElementStack(8) }
                    }
                }
        ))

        //dissolverRecipes = ImmutableList.Builder<DissolverRecipe>()
        dissolverRecipes.add(DissolverRecipe(dictName = "logWood", inputQuantity = 1,
                _outputs = ProbabilitySetDSL.create {
                    addStack { ProbabilityStack("cellulose", quantity = 1) }
                    /*  testing stuff --
                      addStack { ProbabilityStack("cellulose", 4, 5) }
                      addStack { ProbabilityStack("cellulose", 2, 1) }
                      addGroup {
                          probability = 5
                          addItemStack { CompoundRegistry.get("cellulose")!!.toItemStack(20) }
                          addItemStack { ItemStack(Items.IRON_INGOT) }
                      }*/
                }))

        for (list in metalOreData) {
            for (index in 0 until list.size) {
                val elementName = list.strs[index]
                val oreName = list.toDictName(index)
                if (OreDictionary.doesOreNameExist(oreName)) {
                    dissolverRecipes.add(DissolverRecipe(dictName = oreName, inputQuantity = 1,
                            _outputs = ProbabilitySetDSL.create {
                                addStack {
                                    ProbabilityStack(item = ModItems.elements,
                                            meta = ElementRegistry.getMeta(elementName),
                                            quantity = list.quantity)
                                }
                            }))
                }
            }
        }

        dissolverRecipes.add(DissolverRecipe(stack = ItemStack(Blocks.IRON_BARS),
                _outputs = ProbabilitySetDSL.create {
                    addStack {
                        ProbabilityStack(item = ModItems.elements,
                                meta = ElementRegistry.getMeta("iron"),
                                quantity = 6)
                    }
                }))
    }


    fun initElectrolyzerRecipes() {
        electrolyzerRecipes.add(ElectrolyzerRecipe(FluidRegistry.WATER, 30,
                ItemStack(ModItems.elements, 2, ElementRegistry.get("hydrogen")!!.meta),
                ItemStack(ModItems.elements, 1, ElementRegistry.get("oxygen")!!.meta)))
    }


    fun initFuelHandler() {
        val fuelHandler = IFuelHandler { fuel ->
            if (fuel.item == ModItems.elements) {
                when (fuel.itemDamage) {
                    ElementRegistry.get("hydrogen")!!.meta -> return@IFuelHandler 10
                    ElementRegistry.get("carbon")!!.meta -> return@IFuelHandler 200
                }
            }
            return@IFuelHandler 0
        }

        GameRegistry.registerFuelHandler(fuelHandler)
    }


    fun initCombinerRecipes() {

        combinerRecipes.add(CombinerRecipe(Items.COAL.toStack(), listOf("carbon".toElementStack(8))))
        combinerRecipes.add(CombinerRecipe(Items.COAL.toStack(meta = 1), listOf(ItemStack.EMPTY, "carbon".toElementStack(4))))

        for (entry in metals) {
            val dustOutput: ItemStack? = OreDictionary.getOres(entry.toDict("dust")).firstOrNull()
            dustOutput?.let {
                combinerRecipes.add(CombinerRecipe(dustOutput,
                        listOf(entry.toElementStack(4), entry.toElementStack(4), entry.toElementStack(4),
                                entry.toElementStack(4))))
            }

            val ingotOutput: ItemStack? = OreDictionary.getOres(entry.toDict("ingot")).firstOrNull()
            ingotOutput?.let {
                combinerRecipes.add(CombinerRecipe(ingotOutput,
                        listOf(entry.toElementStack(16))))
            }

            val oreOutput: ItemStack? = OreDictionary.getOres(entry.toDict("ore")).firstOrNull()
            oreOutput?.let {
                combinerRecipes.add(CombinerRecipe(oreOutput,
                        listOf(ItemStack.EMPTY, ItemStack.EMPTY, ItemStack.EMPTY,
                                ItemStack.EMPTY, entry.toElementStack(8), ItemStack.EMPTY,
                                entry.toElementStack(8), entry.toElementStack(8), entry.toElementStack(8))))
            }
        }

        for (compound in CompoundRegistry.compounds) {
            if (compound.isReversible) {
                combinerRecipes.add(CombinerRecipe(compound.toItemStack(1),
                        compound.toItemStackList()))
            }
        }

        for (recipe in dissolverRecipes) {
            if (recipe.reversible) {
                combinerRecipes.add(CombinerRecipe(recipe.inputs[0],
                        recipe.outputs.toStackList()
                ))
            }
        }

        var carbon = "carbon".toElementStack(quantity = 64)
        combinerRecipes.add(CombinerRecipe(Items.DIAMOND.toStack(),
                listOf(carbon, carbon, carbon,
                        carbon, ItemStack.EMPTY, carbon,
                        carbon, carbon, carbon)))
    }
}