package ihl.flexible_cable;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import ic2.api.network.INetworkClientTileEntityEventListener;
import ic2.api.network.INetworkTileEntityEventListener;
import ic2.api.recipe.IRecipeInput;
import ic2.core.ContainerBase;
import ic2.core.IHasGui;
import ic2.core.block.TileEntityInventory;
import ic2.core.block.invslot.InvSlot.Access;
import ihl.IHLMod;
import ihl.interfaces.IWire;
import ihl.recipes.IronWorkbenchRecipe;
import ihl.recipes.RecipeInputDetonator;
import ihl.recipes.RecipeInputDie;
import ihl.recipes.RecipeInputObjectInstance;
import ihl.utils.IHLUtils;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.NetworkManager;
import net.minecraft.network.play.server.S35PacketUpdateTileEntity;

public class IronWorkbenchTileEntity extends TileEntityInventory
		implements IHasGui, INetworkClientTileEntityEventListener, INetworkTileEntityEventListener {

	public static List<IronWorkbenchRecipe> recipes = new ArrayList<IronWorkbenchRecipe>();
	public int progress;
	public int currentSlot = -1;
	public final int maxProgress;
	public final InvSlotTool tools;
	public final InvSlotWorkspaceElement workspaceElements;
	public final InvSlotProcessableIronWorkbench inputMaterial;
	public final InvSlotOutputInProgress output;
	public boolean isGuiScreenOpened = false;
	private boolean startProcess = false;
	private boolean outputDefined = false;
	private EntityPlayer crafter;
	public ContainerBase<?> container;
	private Map<Integer, IronWorkbenchRecipe> slotRecipeMap = new HashMap<Integer, IronWorkbenchRecipe>();
	private boolean firstTick = true;

	public IronWorkbenchTileEntity() {
		this.maxProgress = 80;
		this.workspaceElements = new InvSlotWorkspaceElement(this, "workspaceElements", 3, Access.NONE, 6);
		this.tools = new InvSlotTool(this, "tools", 0, Access.IO, 12);
		this.inputMaterial = new InvSlotProcessableIronWorkbench(this, "input", 1, Access.IO, 12);
		this.output = new InvSlotOutputInProgress(this, "output", 2, 18);
	}

	public static void addRecipe(IronWorkbenchRecipe recipe) {
		IronWorkbenchTileEntity.recipes.add(recipe);
	}

	@Override
	public String getInventoryName() {
		return "ironWorkbench";
	}

	@Override
	public ItemStack getWrenchDrop(EntityPlayer player) {
		return IHLUtils.getThisModItemStack("ironWorkbench");
	}

	@Override
	@SideOnly(Side.CLIENT)
	public void updateEntityClient() {
		if (firstTick) {
			IHLMod.proxy.requestTileEntityInitdataFromClientToServer(xCoord, yCoord, zCoord);
			this.firstTick = false;
		}
	}

	@Override
	public void updateEntityServer() {
		if (this.isGuiScreenOpened) {
			if (this.output.isEmpty() && !outputDefined) {
				this.workspaceElements.reset();
				Iterator<IronWorkbenchRecipe> iwri = IronWorkbenchTileEntity.recipes.iterator();
				while (iwri.hasNext()) {
					IronWorkbenchRecipe recipe = iwri.next();
					if (recipe.isCanBeCrafted(this.tools.getItemStackList(), this.inputMaterial.getItemStackList(),
							this.workspaceElements.getItemStackList())) {
						if (recipe.workspaceElements == null || recipe.workspaceElements.isEmpty()
								|| this.workspaceElements.containsAndCanUse(recipe.workspaceElements)) {
							List<ItemStack> newOutputs = recipe.outputs;
							for (IRecipeInput rinput : recipe.tools) {
								if (rinput instanceof RecipeInputDie) {
									newOutputs = ((RecipeInputDie) rinput)
											.transformOutput(this.getMatchedItemStack(rinput), recipe.outputs);
								}
							}
							for (IRecipeInput rinput : recipe.materials) {
								if (rinput instanceof RecipeInputDetonator) {
									newOutputs = ((RecipeInputDetonator) rinput)
											.transformOutput(this.getMatchedItemStack(rinput), recipe.outputs);
								}
							}
							int slot = this.output.put(newOutputs);
							if (slot < 0)
								break;
							slotRecipeMap.put(slot, recipe);
							this.startProcess = false;
						}
					}
				}
				for (int i = 0; i < this.inputMaterial.size(); i++) {
					ItemStack stack = this.inputMaterial.get(i);
					if (stack != null && stack.getItem() instanceof IWire) {
						if (stack.stackTagCompound == null) {
							stack.stackTagCompound = new NBTTagCompound();
						}
						int fullLength = this.getFullLengthOfSameWires(stack);
						List<RecipeInputObjectInstance> list = this.getListOfSameWires(stack);
						ItemStack result = stack.copy();
						result.stackTagCompound.setInteger("length", fullLength);
						result.stackTagCompound.setInteger("fullLength", fullLength);
						IronWorkbenchRecipe recipe = new IronWorkbenchRecipe(null, list,
								Arrays.asList(new ItemStack[] { result }));
						int slot = this.output.put(recipe.outputs);
						if (slot < 0)
							break;
						slotRecipeMap.put(slot, recipe);
						this.startProcess = false;
						break;
					}
				}
				outputDefined = true;
			} else if (!this.output.isEmpty()) {
				Set<Integer> crafterEmptyInventorySlotsList = getCrafterEmptyInventorySlotsList();
				if (startProcess && crafterEmptyInventorySlotsList.size() >= this.slotRecipeMap.get(currentSlot).outputs
						.size()) {
					if (++this.progress >= this.maxProgress) {
						IronWorkbenchRecipe crecipe = this.slotRecipeMap.get(currentSlot);
						List<ItemStack> opts = this.output.getRecipeOutputs(currentSlot);
						int multiplier = this.inputMaterial.getMultiplier(crecipe.materials);
						Iterator<ItemStack> optsi = opts.iterator();
						Iterator<Integer> emptySlotsIterator = crafterEmptyInventorySlotsList.iterator();
						while (optsi.hasNext()) {
							int slot = emptySlotsIterator.next();
							ItemStack stack = optsi.next();
							if (stack.getItem() instanceof IWire) {
								this.crafter.inventory.mainInventory[slot] = IHLUtils
										.getWireItemStackCopyWithLengthMultiplied(stack, multiplier);
							} else {
								this.crafter.inventory.mainInventory[slot] = stack.copy();
								this.crafter.inventory.mainInventory[slot].stackSize *= multiplier;
							}
						}
						Iterator<ItemStack> emptyContainers = this.inputMaterial
								.substract(crecipe.materials, multiplier).iterator();
						while (emptyContainers.hasNext()) {
							if (emptySlotsIterator.hasNext()) {
								int slot = emptySlotsIterator.next();
								ItemStack stack = emptyContainers.next();
								this.crafter.inventory.mainInventory[slot] = stack.copy();
								this.crafter.inventory.mainInventory[slot].stackSize *= multiplier;
							} else {
								EntityItem eistack = new EntityItem(this.worldObj, this.xCoord, this.yCoord + 1,
										this.zCoord, emptyContainers.next());
								this.worldObj.spawnEntityInWorld(eistack);
							}
						}
						this.crafter.inventoryContainer.detectAndSendChanges();
						this.tools.damage(crecipe.tools);
						if (!crecipe.workspaceElements.isEmpty()) {
							this.workspaceElements.use(crecipe.workspaceElements);
						}
						this.resetOutput();
					}
				}
			}
		}
	}

	private ItemStack getMatchedItemStack(IRecipeInput rinput) {
		for (ItemStack tool : this.tools.getItemStackList()) {
			if (rinput.matches(tool)) {
				return tool;
			}
		}
		for (ItemStack material : this.inputMaterial.getItemStackList()) {
			if (rinput.matches(material)) {
				return material;
			}
		}

		return null;
	}

	private Set<Integer> getCrafterEmptyInventorySlotsList() {
		Set<Integer> list = new HashSet<Integer>(4);
		if (this.crafter != null) {
			for (int var1 = 0; var1 < this.crafter.inventory.mainInventory.length; ++var1) {
				if (this.crafter.inventory.mainInventory[var1] == null) {
					list.add(var1);
				}
			}
		}
		return list;
	}

	private List<RecipeInputObjectInstance> getListOfSameWires(ItemStack stack1) {
		List<RecipeInputObjectInstance> list = new ArrayList<RecipeInputObjectInstance>();
		for (int i = 0; i < this.inputMaterial.size(); i++) {
			ItemStack stack = this.inputMaterial.get(i);
			if (stack != null && ((IWire) stack1.getItem()).isSameWire(stack1, stack)) {
				list.add(new RecipeInputObjectInstance(stack));
			}
		}
		return list;
	}

	private int getFullLengthOfSameWires(ItemStack stack1) {
		int fullLength = 0;
		for (int i = 0; i < this.inputMaterial.size(); i++) {
			ItemStack stack = this.inputMaterial.get(i);
			if (stack != null && ((IWire) stack1.getItem()).isSameWire(stack1, stack)) {
				fullLength += IHLUtils.getWireLength(stack);
			}
		}
		return fullLength;
	}

	@Override
	@SideOnly(Side.CLIENT)
	public GuiScreen getGui(EntityPlayer player, boolean arg1) {
		return new IronWorkbenchGui(new IronWorkbenchContainer(player, this));
	}

	@Override
	public ContainerBase<?> getGuiContainer(EntityPlayer player) {
		resetOutput();
		this.isGuiScreenOpened = true;
		this.crafter = player;
		container = new IronWorkbenchContainer(player, this);
		return container;
	}

	@Override
	public void onGuiClosed(EntityPlayer arg0) {
		this.isGuiScreenOpened = false;
	}

	@Override
	public void onNetworkEvent(EntityPlayer player, int event) {
		if (event == 16) {
			this.isGuiScreenOpened = false;
			this.crafter = null;
			this.container = null;
			return;
		}
		for (int i = event; i >= 0; i--) {
			if (this.slotRecipeMap.containsKey(i)) {
				if (!this.slotRecipeMap.get(i).isCanBeCrafted(this.tools.getItemStackList(),
						this.inputMaterial.getItemStackList(), this.workspaceElements.getItemStackList())) {
					resetOutput();
				} else {
					this.currentSlot = i;
					this.startProcess = true;
					return;
				}
			}
		}
	}

	public void resetOutput() {
		this.output.clear();
		this.slotRecipeMap.clear();
		this.progress = 0;
		this.startProcess = false;
		this.currentSlot = -1;
		this.outputDefined = false;
	}

	public void dropContents() {
		for (int i = 0; i < this.tools.size(); i++) {
			if (this.tools.get(i) != null)
				this.worldObj.spawnEntityInWorld(
						new EntityItem(this.worldObj, this.xCoord, this.yCoord + 1, this.zCoord, this.tools.get(i)));
		}
		for (int i = 0; i < this.inputMaterial.size(); i++) {
			if (this.inputMaterial.get(i) != null)
				this.worldObj.spawnEntityInWorld(new EntityItem(this.worldObj, this.xCoord, this.yCoord + 1,
						this.zCoord, this.inputMaterial.get(i)));
		}
	}

	@Override
	public void onNetworkEvent(int event) {

	}

	public int gaugeProgressScaled(int i) {
		return this.progress * i / this.maxProgress;
	}

	@Override
	public boolean shouldRenderInPass(int pass) {
		return pass == 0;
	}

	public static void removeRecipeByOutput(List<ItemStack> recipeOutputsItems) {
		Iterator<IronWorkbenchRecipe> ri = recipes.iterator();
		while (ri.hasNext()) {
			IronWorkbenchRecipe recipe = ri.next();
			boolean removeEntry = false;
			Iterator<ItemStack> roi = recipe.outputs.iterator();
			while (roi.hasNext()) {
				if (IHLUtils.isItemStacksIsEqual(recipeOutputsItems.get(0), roi.next(), true)) {
					removeEntry = true;
				}
			}
			if (removeEntry) {
				ri.remove();
			}
		}

	}

	public static void removeRecipeByInput(List<IRecipeInput> recipeInputsTools1, List<IRecipeInput> recipeInputsItems1,
			List<ItemStack> recipeInputsMachines) {
		List<ItemStack> recipeInputsTools = IHLUtils.convertRecipeInputToItemStackList(recipeInputsTools1);
		List<ItemStack> recipeInputsItems = IHLUtils.convertRecipeInputToItemStackList(recipeInputsItems1);
		Iterator<IronWorkbenchRecipe> ri = recipes.iterator();
		while (ri.hasNext()) {
			IronWorkbenchRecipe recipe = ri.next();
			if (recipe.isCanBeCrafted(recipeInputsTools, recipeInputsItems, recipeInputsMachines)) {
				ri.remove();
			}
		}
	}

	@Override
	public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) {
		this.readFromNBT(pkt.func_148857_g());
	}

}