package ihl.recipes;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.oredict.OreDictionary;
import ic2.api.recipe.IMachineRecipeManager;
import ic2.api.recipe.RecipeOutput;
import ic2.core.IC2;
import ihl.IHLMod;
import ihl.metallurgy.Crucible;
import ihl.utils.IHLUtils;

public class UniversalRecipeManager {
	
	private final Map<UniversalRecipeInput, UniversalRecipeOutput> recipes = new HashMap();
	
    public void addRecipe(UniversalRecipeInput input, UniversalRecipeOutput output)
    {
        if (input == null)
        {
            throw new NullPointerException("The recipe input is null");
        }
        else
        {
            if (output.getFluidOutputs() == null || output.getItemOutputs() == null ||(output.getFluidOutputs().size()==0 && output.getItemOutputs().size()==0))
            {
                    throw new NullPointerException("The output is empty");
            }
        }

            Iterator var8 = this.recipes.keySet().iterator();

            while (var8.hasNext())
            {
            	UniversalRecipeInput existingInput = (UniversalRecipeInput)var8.next();
                    if (existingInput.matches(input))
                    {
                    	Iterator<ItemStack> ilist1 = existingInput.getItemInputs().iterator();
                    	Iterator<ItemStack> ilist2 = input.getItemInputs().iterator();
                    	while(ilist1.hasNext())
                    	{
                    		ItemStack is = ilist1.next();
                    		System.out.println("Item:"+is.getDisplayName());
                    		int[] arrayIDs = OreDictionary.getOreIDs(is);
                    		if(arrayIDs.length>0)
                    		{
                    			System.out.println("Registered in ore dictionary as:");
                    			for(int i=0;i<arrayIDs.length;i++)
                    			{
                    				System.out.println(OreDictionary.getOreName(arrayIDs[i]));
                    			}
                    		}
                    	}
                    	System.out.println("recipe 2:");
                    	while(ilist2.hasNext())
                    	{
                    		ItemStack is = ilist2.next();
                    		System.out.println("Item:"+is.getDisplayName());
                    		int[] arrayIDs = OreDictionary.getOreIDs(is);
                    		if(arrayIDs.length>0)
                    		{
                    			System.out.println("Registered in ore dictionary as:");
                    			for(int i=0;i<arrayIDs.length;i++)
                    			{
                    				System.out.println(OreDictionary.getOreName(arrayIDs[i]));
                    			}
                    		}
                    	}
                        throw new RuntimeException("Ambiguous recipe.");
                    }
            }

            this.recipes.put(input, output);
     }
    

    public UniversalRecipeOutput getOutputFor(UniversalRecipeInput input, boolean adjustInput, boolean inputAffectOutput)
    {
        if (input == null)
        {
            return null;
        }
        else
        {
            Iterator i$ = this.recipes.entrySet().iterator();

            while (true)
            {
                if (i$.hasNext())
                {
                    Entry entry = (Entry)i$.next();
                    UniversalRecipeInput recipeInput = (UniversalRecipeInput)entry.getKey();

                    if (!recipeInput.matches(input))
                    {
                        continue;
                    }

                    if (recipeInput.adjustAmounts(input, false))
                    {
                        UniversalRecipeOutput output = (UniversalRecipeOutput)entry.getValue();
                        if (adjustInput)
                        {
                        	if(inputAffectOutput)
                        	{
                            	int mulipier = recipeInput.getMultiplierAndAdjustAmounts(input);
                            	return output.copyWithMultiplier(mulipier);
                        	}
                        	else
                        	{
                            	recipeInput.adjustAmounts(input, true);
                        	}
                        }
                        return output;
                    }
                }

                return null;
            }
        }
    }

    public Map<UniversalRecipeInput, UniversalRecipeOutput> getRecipes()
    {
        return this.recipes;
    }


	public UniversalRecipeInput getRecipeInput(UniversalRecipeInput input) {
        if (input == null)
        {
            return null;
        }
        else
        {
            Iterator i$ = this.recipes.entrySet().iterator();

            while (true)
            {
                if (i$.hasNext())
                {
                    Entry entry = (Entry)i$.next();
                    UniversalRecipeInput recipeInput = (UniversalRecipeInput)entry.getKey();

                    if (!recipeInput.matches(input))
                    {
                        continue;
                    }

                    if (recipeInput.adjustAmounts(input, false))
                    {
                        return recipeInput;
                    }
                }

                return null;
            }
        }
	}

}