package com.TechDweebGaming.MystTech.tileentity;

import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Items;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.ChatComponentText;
import net.minecraft.util.ChatComponentTranslation;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.IChatComponent;
import net.minecraft.util.ITickable;
import net.minecraft.world.World;
import cofh.api.energy.IEnergyReceiver;

import com.TechDweebGaming.MystTech.MystTech;
import com.TechDweebGaming.MystTech.gui.ContainerCompressor;
import com.TechDweebGaming.MystTech.gui.ModGuiHandler;
import com.TechDweebGaming.MystTech.item.ModItems;
import com.TechDweebGaming.MystTech.utility.LogHelper;

public class CompressorTileEntity extends TileEntity implements IInventory, IEnergyReceiver, ITickable {

	//Energy Variables
	public int EnergyBuffer = 0;
	public final int EnergyLimit = 10000;

	private ItemStack[] inventory;
	private String customName;

	public CompressorTileEntity() {
		this.inventory = new ItemStack[this.getSizeInventory()];
	}

	public String getCustomName() {
		return this.customName;
	}

	public void setCustomName(String customName) {
		this.customName = customName;
	}

	@Override
	public String getName() {
		return this.hasCustomName() ? this.customName : "Compressor";
	}

	@Override
	public boolean hasCustomName() {
		return this.customName != null && !this.customName.equals("");
	}

	@Override
	public IChatComponent getDisplayName() {
		return this.hasCustomName() ? new ChatComponentText(this.getName()) : new ChatComponentTranslation(this.getName());
	}

	@Override
	public int getSizeInventory() {
		return 2;
	}

	@Override
	public ItemStack getStackInSlot(int index) {
		if (index < 0 || index >= this.getSizeInventory()) {
			return null;
		}
		return this.inventory[index];
	}

	@Override
	public ItemStack decrStackSize(int index, int count) {
		if(this.getStackInSlot(index) != null) {
			ItemStack itemstack;

			if(this.getStackInSlot(index).stackSize <= count) {
				itemstack = this.getStackInSlot(index);
				this.setInventorySlotContents(index, null);
				this.markDirty();
				return itemstack;
			} else {
				itemstack = this.getStackInSlot(index).splitStack(count);

				if (this.getStackInSlot(index).stackSize <= 0) {
					this.setInventorySlotContents(index, null);
				} else {
					//Just to show that changes happened
					this.setInventorySlotContents(index, this.getStackInSlot(index));
				}

				this.markDirty();
				return itemstack;
			}
		} else {
			return null;
		}
	}

	//@Override - Tutorial says yes but eclipse says no...
	public ItemStack getStackInSlotOnClosing(int index) {
		ItemStack stack = this.getStackInSlot(index);
		this.setInventorySlotContents(index, null);
		return stack;
	}

	@Override
	public void setInventorySlotContents(int index, ItemStack stack) {
		if (index < 0 || index >= this.getSizeInventory()) {
			return;
		}

		if (stack != null && stack.stackSize > this.getInventoryStackLimit()) {
			stack.stackSize = this.getInventoryStackLimit();
		}

		if (stack != null && stack.stackSize == 0) {
			stack = null;
		}

		this.inventory[index] = stack;
		this.markDirty();
	}

	@Override
	public int getInventoryStackLimit() {
		return 64;
	}

	@Override
	public boolean isUseableByPlayer(EntityPlayer player) {
		return this.worldObj.getTileEntity(this.getPos()) == this && player.getDistanceSq(this.pos.add(0.5, 0.5, 0.5)) <= 64;
	}

	@Override
	public void openInventory(EntityPlayer player) {
		//Just so Eclipse doesn't yell at me
	}

	@Override
	public void closeInventory(EntityPlayer player) {
		//Just so Eclipse doesn't yell at me
	}

	@Override
	public boolean isItemValidForSlot(int index, ItemStack stack) {
		return true;
	}

	@Override
	public int getField(int id) {
	    return 0;
	}

	@Override
	public void setField(int id, int value) {
	//Just so Eclipse doesn't yell at me
	}

	@Override
	public int getFieldCount() {
	    return 0;
	}

	@Override
	public void clear() {
	    for (int i = 0; i < this.getSizeInventory(); i++)
	        this.setInventorySlotContents(i, null);
	}

	@Override
	public void writeToNBT(NBTTagCompound nbt) {
	    super.writeToNBT(nbt);

	    NBTTagList list = new NBTTagList();
	    for (int i = 0; i < this.getSizeInventory(); ++i) {
	        if (this.getStackInSlot(i) != null) {
	            NBTTagCompound stackTag = new NBTTagCompound();
	            stackTag.setByte("Slot", (byte) i);
	            this.getStackInSlot(i).writeToNBT(stackTag);
	            list.appendTag(stackTag);
	        }
	    }
	    nbt.setTag("Items", list);

	    if (this.hasCustomName()) {
	        nbt.setString("CustomName", this.getCustomName());
	    }

	    nbt.setInteger("EnergyBuffer", EnergyBuffer);
	}


	@Override
	public void readFromNBT(NBTTagCompound nbt) {
	    super.readFromNBT(nbt);

	    NBTTagList list = nbt.getTagList("Items", 10);
	    for (int i = 0; i < list.tagCount(); ++i) {
	        NBTTagCompound stackTag = list.getCompoundTagAt(i);
	        int slot = stackTag.getByte("Slot") & 255;
	        this.setInventorySlotContents(slot, ItemStack.loadItemStackFromNBT(stackTag));
	    }

	    if (nbt.hasKey("CustomName", 8)) {
	        this.setCustomName(nbt.getString("CustomName"));
	    }

	    EnergyBuffer = nbt.getInteger("EnergyBuffer");
	}

	@Override
	public ItemStack removeStackFromSlot(int index) {
		return null;
	}

	public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumFacing side, float hitX, float hitY, float hitZ) {
	    if (!world.isRemote) {
	        player.openGui(MystTech.instance, ModGuiHandler.MOD_COMPRESSOR_TILE_ENTITY_GUI, world, pos.getX(), pos.getY(), pos.getZ());
	    }
	    return true;
	}

	 @Override
	    public boolean shouldRefresh(World parWorld, BlockPos parPos, IBlockState parOldState, IBlockState parNewState) {
	        return false;
	    }

	@Override
	public boolean canConnectEnergy(EnumFacing facing) {
		return true;
	}

	@Override
	public int receiveEnergy(EnumFacing facing, int maxReceive, boolean simulate) {
		int receive = Math.min(maxReceive, EnergyLimit - EnergyBuffer);
		if (!simulate && receive > 0) {
			EnergyBuffer += receive;
			markDirty();
		}
		return receive;
	}

	@Override
	public int getEnergyStored(EnumFacing facing) {
		return EnergyBuffer;
	}

	@Override
	public int getMaxEnergyStored(EnumFacing facing) {
		return EnergyLimit;
	}

	public int getPowerLevel() {
		return EnergyBuffer;
	}

	@Override
	public void update() {
		ItemStack input = this.getStackInSlot(0);
		ItemStack output = this.getStackInSlot(1);
		//ItemStacks
		ItemStack CreeperEssence = new ItemStack(ModItems.CreeperEssence);
		ItemStack CreeperSkull = new ItemStack(Items.skull, 1, 4);
		ItemStack Bone = new ItemStack(Items.bone);
		ItemStack Bonemeal = new ItemStack(Items.dye, 5, 15);
		ItemStack ChickenNugget = new ItemStack(ModItems.ChickenNugget);
		ItemStack CookedChicken = new ItemStack(Items.cooked_chicken);
		//Running Check
		if(input != null) {
			//SYNTAX FOR NEW COMPRESSOR RECIPES (anything in <> you fill in!)
			//this.checkCompressorRecipes(input, output, <Ingredient>, <Result>, <Power Usage>);
			this.checkCompressorRecipes(input, output, CreeperEssence, CreeperSkull, 2500);
			this.checkCompressorRecipes(input, output, Bone, Bonemeal, 100);
			this.checkCompressorRecipes(input, output, CookedChicken, ChickenNugget, 100);
			//INACTIVE: this.checkCompressorRecipes(input, output, Bonemeal, Bone, 500);
		}
	}

	public boolean haveEnoughEnergy(int energyUsage) {
		if (EnergyBuffer > energyUsage) {
			return true;
		} else {
			return false;
		}
	}

	public void checkCompressorRecipes(ItemStack parItemStackInput, ItemStack parItemStackOutput, ItemStack reqItemStackInput, ItemStack reqItemStackOutput, int energyCost) {
		if(haveEnoughEnergy(energyCost) == true) {
			if (parItemStackInput.stackSize > 0) {
				if (ItemStack.areItemsEqual(parItemStackInput, reqItemStackInput)) {
					processCompression(parItemStackInput, parItemStackOutput, reqItemStackOutput, energyCost);
				}
			}
		}
	}

	public boolean canCompressorRun() {
		ItemStack input = this.getStackInSlot(0);
		ItemStack output = this.getStackInSlot(1);
		if (EnergyBuffer > 0) {
			if (input.stackSize < 2) {
				if (output == null) {
					return true;
				}
			}
		}
		return false;
	}

	public void processCompression(ItemStack parItemStackInput, ItemStack parItemStackOutput, ItemStack reqItemStackOutput, int energyUsage) {
		//Consume Power
		int prevEnergyBuffer = EnergyBuffer;
		EnergyBuffer = prevEnergyBuffer - energyUsage;
		//Process Items
		if (parItemStackOutput.stackSize <= 1 && parItemStackInput.stackSize <= 1) {
			setInventorySlotContents(0, null);
			setInventorySlotContents(1, reqItemStackOutput);
		} else if (parItemStackOutput.stackSize <= 1 && parItemStackInput.stackSize > 1) {
			parItemStackInput.stackSize--;
			setInventorySlotContents(0, parItemStackInput);
			setInventorySlotContents(1, reqItemStackOutput);
		} else if (parItemStackOutput.stackSize > 1 && parItemStackInput.stackSize <= 1) {
			setInventorySlotContents(0, null);
			parItemStackOutput.stackSize++;
			setInventorySlotContents(1, parItemStackOutput);
		} else if (parItemStackOutput.stackSize > 1 && parItemStackInput.stackSize > 1) {
			parItemStackInput.stackSize--;
			parItemStackOutput.stackSize--;
			setInventorySlotContents(0, parItemStackInput);
			setInventorySlotContents(0, parItemStackOutput);
		} else {
			LogHelper.info("A compressor recipe has errored! Please reoprt this immedeitally so I can fix it, as it should not be possible! ~Best Regards, TechDG");
		}
		markDirty();
	}
 }