package ihl.recipes;

import ic2.api.recipe.IRecipeInput;
import ic2.api.recipe.RecipeInputItemStack;
import ic2.api.recipe.RecipeInputOreDict;
import ihl.interfaces.IWire;
import ihl.utils.IHLUtils;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.FluidStack;

public class UniversalRecipeInput {

	private final List<IRecipeInputFluid> fluidInputs = new ArrayList<IRecipeInputFluid>();
	private final List<IRecipeInput> itemInputs = new ArrayList<IRecipeInput>();
	private int multiplier = Integer.MAX_VALUE;

	public UniversalRecipeInput(Object[] fluidStacks, Object[] iRecipeInputs) {
		if (fluidStacks != null) {
			for (Object material : fluidStacks) {
				if (material == null) {
					throw new NullPointerException("Recipe input cannot be null!");
				}
				if (material instanceof FluidStack) {
					fluidInputs.add(new RecipeInputFluidStack((FluidStack) material));
				} else {
					fluidInputs.add((IRecipeInputFluid) material);
				}
			}
		}
		if (iRecipeInputs != null) {
			for (Object material : iRecipeInputs) {
				if (material == null) {
					throw new NullPointerException("Recipe input cannot be null!");
				}
				if (material instanceof ItemStack) {
					ItemStack stack = (ItemStack) material;
					String oreDictName = IHLUtils.getFirstOreDictNameExcludingTagAny(stack);
					if (stack.getItem() instanceof IWire) {
						itemInputs.add(new RecipeInputWire(stack));
					} else if (!oreDictName.isEmpty() && oreDictName.length() > 3) {
						itemInputs.add(new RecipeInputOreDict(oreDictName, stack.stackSize));
					} else {
						itemInputs.add(new RecipeInputItemStack(stack));
					}
				} else {
					itemInputs.add((IRecipeInput) material);
				}
			}
		}
	}

	public boolean matches(List<FluidStack> fluidInputs1, List<ItemStack> itemInputs1) {
		return this.adjustAmounts(fluidInputs1, itemInputs1, false, false);
	}

	public List<IRecipeInputFluid> getFluidInputs() {
		return fluidInputs;
	}

	public List<IRecipeInput> getItemInputs() {
		return itemInputs;
	}

	public boolean matches(UniversalRecipeInput input) {
		List<IRecipeInput> rInputs = input.getItemInputs();
		Iterator<IRecipeInput> ii = rInputs.iterator();
		List<ItemStack> rInputsItems = new ArrayList<ItemStack>();
		while (ii.hasNext()) {
			IRecipeInput is = ii.next();
			rInputsItems.add(is.getInputs().get(0));
		}
		List<FluidStack> rInputsFluids = new ArrayList<FluidStack>();
		List<IRecipeInputFluid> rInputsF = input.getFluidInputs();
		Iterator<IRecipeInputFluid> iiF = rInputsF.iterator();
		while (iiF.hasNext()) {
			IRecipeInputFluid is = iiF.next();
			rInputsFluids.add(is.getInputs().get(0));
		}
		return this.matches(rInputsFluids, rInputsItems);
	}

	public boolean adjustAmounts(List<FluidStack> fluidInputs1, List<ItemStack> itemInputs1, boolean doCheckAmounts,
			boolean doAdjustAmounts) {
		this.multiplier = Integer.MAX_VALUE;
		if (incorrectInputAmount(fluidInputs1, itemInputs1)) {
			return false;
		}
		if (fluidInputs1 != null) {
			Iterator<IRecipeInputFluid> fi = fluidInputs.iterator();
			while (fi.hasNext()) {
				IRecipeInputFluid fs = fi.next();
				FluidStack fs1 = getMatchedFluidStack(fs, fluidInputs1);
				if (fs1 == null || !fs.matches(fs1)) {
					multiplier = 0;
					return false;
				} else if (doCheckAmounts && fs1.amount < fs.getAmount()) {
					multiplier = 0;
					return false;
				} else if (doAdjustAmounts) {
					if (fs.getAmount() > 0) {
						int multiplier1 = fs1.amount / fs.getAmount();
						if (multiplier1 < multiplier) {
							multiplier = multiplier1;
						}
					}
					fs1.amount -= fs.getAmount();
					if (fs1.amount <= 0)
						fs1 = null;
				}
			}
		}
		if (itemInputs1 != null) {
			Iterator<IRecipeInput> ii = itemInputs.iterator();
			while (ii.hasNext()) {
				IRecipeInput is = ii.next();
				ItemStack is1 = getMatchedItemStack(is, itemInputs1);
				if (is1 == null || !is.matches(is1)) {
					multiplier = 0;
					return false;
				} else if (doCheckAmounts && is1.stackSize < is.getAmount()) {
					multiplier = 0;
					return false;
				} else if (doAdjustAmounts) {
					if (is.getAmount() > 0) {
						int multiplier1 = is1.stackSize / is.getAmount();
						if (multiplier1 < multiplier) {
							multiplier = multiplier1;
						}
					}
					if (IHLUtils.reduceItemStackAmountUsingIRecipeInput(is, is1)) {
						is1 = null;
					}
				}
			}
		}
		return true;
	}

	private ItemStack getMatchedItemStack(IRecipeInput is, List<ItemStack> itemInputs1) {
		for (ItemStack is1 : itemInputs1) {
			if (is1 != null) {
				if (is.matches(is1)) {
					return is1;
				}
			}
		}
		return null;
	}

	private FluidStack getMatchedFluidStack(IRecipeInputFluid fs, List<FluidStack> fluidInputs1) {
		for (FluidStack fs1 : fluidInputs1) {
			if (fs.matches(fs1)) {
				return fs1;
			}
		}
		return null;
	}

	public boolean adjustAmounts(UniversalRecipeInput input, boolean doAdjustAmounts) {
		List<IRecipeInput> rInputs = input.getItemInputs();
		Iterator<IRecipeInput> ii = rInputs.iterator();
		List<ItemStack> rInputsItems = new ArrayList<ItemStack>();
		while (ii.hasNext()) {
			IRecipeInput is = ii.next();
			rInputsItems.add(is.getInputs().get(0));
		}
		List<FluidStack> rInputsFluids = new ArrayList<FluidStack>();
		List<IRecipeInputFluid> rInputsF = input.getFluidInputs();
		Iterator<IRecipeInputFluid> iiF = rInputsF.iterator();
		while (iiF.hasNext()) {
			IRecipeInputFluid is = iiF.next();
			rInputsFluids.add(is.getInputs().get(0));
		}
		return this.adjustAmounts(rInputsFluids, rInputsItems, true, doAdjustAmounts);
	}

	public int getMultiplierAndAdjustAmounts(List<FluidStack> fluidInputs1, List<ItemStack> itemInputs1) {
		if (this.adjustAmounts(fluidInputs1, itemInputs1, true, true)) {
			if (multiplier < Integer.MAX_VALUE) {
				return multiplier;
			} else
				return 1;
		} else {
			return 0;
		}
	}

	public boolean containItemStack(ItemStack ingredient) {
		if (itemInputs == null || itemInputs.isEmpty()) {
			return false;
		}
		Iterator<IRecipeInput> ii = itemInputs.iterator();
		while (ii.hasNext()) {
			IRecipeInput is = ii.next();
			if (is.matches(ingredient)) {
				return true;
			}
		}
		return false;
	}

	public boolean containFluidStack(FluidStack fluidStack) {
		if (fluidInputs == null || fluidInputs.isEmpty()) {
			return false;
		}
		Iterator<IRecipeInputFluid> ii = fluidInputs.iterator();
		while (ii.hasNext()) {
			IRecipeInputFluid is = ii.next();
			if (is != null && is.matches(fluidStack)) {
				return true;
			}
		}
		return false;
	}

	private boolean incorrectInputAmount(List<FluidStack> fluidInputs1, List<ItemStack> itemInputs1) {
		return (fluidInputs.size() > 0 && fluidInputs1 == null) || (itemInputs.size() > 0 && itemInputs1 == null)
				|| (fluidInputs1 != null && fluidInputs.size() > fluidInputs1.size())
				|| (itemInputs1 != null && itemInputs.size() > itemInputs1.size());
	}
}