// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) braces deadcode fieldsfirst

package net.minecraft.src;

import java.util.*;

// Referenced classes of package net.minecraft.src:
// TileEntity, IInventory, ItemStack, NBTTagCompound,
// NBTTagList, World, EntityPlayer

public class PCma_TileEntityRoaster extends TileEntity implements IInventory, PCco_ISelectiveInventory {
	@Override
	public boolean canInsertStack(int slot, ItemStack stack) {
		return stack != null && (PCco_Utils.isFuel(stack) || stack.itemID == Block.netherrack.blockID);
	}

	private ItemStack roasterContents[];
	private Random random;
	public static final int MAXSTACK = 16, SIZE = 9;
	public int burnTime = 0;
	public int netherTime = 0;
	public int netherActionTime = 100;
	private boolean noNetherrack = false;


	public PCma_TileEntityRoaster() {
		roasterContents = new ItemStack[SIZE];
		random = new Random();
	}


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


	@Override
	public ItemStack getStackInSlot(int i) {
		return roasterContents[i];
	}


	@Override
	public ItemStack decrStackSize(int i, int j) {
		if (roasterContents[i] != null) {
			if (roasterContents[i].stackSize <= j) {
				ItemStack itemstack = roasterContents[i];
				roasterContents[i] = null;
				onInventoryChanged();
				return itemstack;
			}
			ItemStack itemstack1 = roasterContents[i].splitStack(j);
			if (roasterContents[i].stackSize == 0) {
				roasterContents[i] = null;
			}
			onInventoryChanged();
			return itemstack1;
		} else {
			return null;
		}
	}


	@Override
	public void setInventorySlotContents(int i, ItemStack itemstack) {
		roasterContents[i] = itemstack;
		if (itemstack != null && itemstack.stackSize > getInventoryStackLimit()) {
			itemstack.stackSize = getInventoryStackLimit();
		}
		onInventoryChanged();
	}


	@Override
	public String getInvName() {
		return "Roaster";
	}


	@Override
	public void readFromNBT(NBTTagCompound nbttagcompound) {
		super.readFromNBT(nbttagcompound);
		NBTTagList nbttaglist = nbttagcompound.getTagList("Items");
		roasterContents = new ItemStack[getSizeInventory()];
		for (int i = 0; i < nbttaglist.tagCount(); i++) {
			NBTTagCompound nbttagcompound1 = (NBTTagCompound) nbttaglist.tagAt(i);
			int j = nbttagcompound1.getByte("Slot") & 0xff;
			if (j >= 0 && j < roasterContents.length) {
				roasterContents[j] = ItemStack.loadItemStackFromNBT(nbttagcompound1);
			}
		}

		burnTime = nbttagcompound.getInteger("burning");
		netherTime = nbttagcompound.getInteger("netherTime");
		netherActionTime = nbttagcompound.getInteger("netherActionTime");
	}


	@Override
	public void writeToNBT(NBTTagCompound nbttagcompound) {
		super.writeToNBT(nbttagcompound);
		NBTTagList nbttaglist = new NBTTagList();
		for (int i = 0; i < roasterContents.length; i++) {
			if (roasterContents[i] != null) {
				NBTTagCompound nbttagcompound1 = new NBTTagCompound();
				nbttagcompound1.setByte("Slot", (byte) i);
				roasterContents[i].writeToNBT(nbttagcompound1);
				nbttaglist.appendTag(nbttagcompound1);
			}
		}

		nbttagcompound.setTag("Items", nbttaglist);
		nbttagcompound.setInteger("burning", burnTime);
		nbttagcompound.setInteger("netherTime", netherTime);
		nbttagcompound.setInteger("netherActionTime", netherActionTime);
	}


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


	@Override
	public boolean isUseableByPlayer(EntityPlayer entityplayer) {
		if (worldObj.getBlockTileEntity(xCoord, yCoord, zCoord) != this) {
			return false;
		}
		return entityplayer.getDistanceSq(xCoord + 0.5D, yCoord + 0.5D, zCoord + 0.5D) <= 64D;
	}


	@Override
	public void openChest() {
	}


	@Override
	public void closeChest() {
		noNetherrack = false; // force check for netherrack
	}


	public boolean canUpdate() {
		return true;
	}


	@Override
	public void updateEntity() {
		// not powered -> off
		if (!PCma_BlockRoaster.isIndirectlyPowered(worldObj, xCoord, yCoord, zCoord)) return;

		boolean laser = worldObj.getBlockId(xCoord, yCoord + 1, zCoord) == mod_PCmachines.laser.blockID;

		if (burnTime > 0) burnTime -= laser ? 4 : 2; // laser consumes more
														// fuel.
		if (burnTime <= 0) addFuelForTime(40);
		if (!laser) smeltItems();
		if (!laser && burnTime > 0) burnCreatures();

		if (netherTime > 0) {
			netherTime--;
		}

		if (netherTime <= 0 && !noNetherrack) addNetherrack();

		if (netherActionTime > 0 && netherTime > 0) {
			netherActionTime--;
		}

		if (netherActionTime <= 0) {
			int success = 0;
			for (int i = 0; i < 10; i++) {
				if (netherAction()) success++;
				if (success == 4) break;
			}

			//
			WorldChunkManager worldchunkmanager = worldObj.getWorldChunkManager();
			if (worldchunkmanager != null) {
				BiomeGenBase biomegenbase = worldchunkmanager.getBiomeGenAt(xCoord, zCoord);
				if (biomegenbase instanceof BiomeGenHell) {
					netherActionTime = 50 + random.nextInt(150);
				} else {
					netherActionTime = 100 + random.nextInt(200);
				}
			} else {
				netherActionTime = 100 + random.nextInt(200);
			}

		}

	}


	public void smeltItems() {
		List<EntityItem> items = worldObj.getEntitiesWithinAABB(net.minecraft.src.EntityItem.class,
				AxisAlignedBB.getBoundingBoxFromPool(xCoord, yCoord, zCoord, xCoord + 1, yCoord + 2, zCoord + 1));

		nextItem: for (EntityItem eitem : items) {

			if (eitem.isDead || Arrays.asList(mod_PCmachines.optDoNotSmelt).contains(String.valueOf(eitem.item.itemID))) {
				continue nextItem;
			}
			ItemStack result = getResult(eitem.item);
			if (result == null) continue nextItem;

			if (burnTime <= getItemSmeltTime(eitem.item)) {
				if (!addFuelForItem(eitem.item)) continue nextItem;
			}

			if (burnTime >= getItemSmeltTime(eitem.item)) {
				// DO smelting.
				burnTime -= getItemSmeltTime(eitem.item);
				EntityItem entityitem = new EntityItem(worldObj, eitem.posX - 0.1F + random.nextFloat() * 0.2F, eitem.posY, eitem.posZ - 0.1F + random.nextFloat() * 0.2F, result.copy());
				entityitem.motionX = eitem.motionX;
				entityitem.motionY = eitem.motionY;
				entityitem.motionZ = eitem.motionZ;
				worldObj.spawnEntityInWorld(entityitem);
				if (--eitem.item.stackSize <= 0) {
					eitem.setDead();
				}
			}
		}
	}


	public void burnCreatures() {
		if (burnTime <= 0) return;

		List<EntityLiving> entities = worldObj.getEntitiesWithinAABB(net.minecraft.src.EntityLiving.class,
				AxisAlignedBB.getBoundingBoxFromPool(xCoord, yCoord, zCoord, xCoord + 1, yCoord + 2, zCoord + 1));

		nextEliving: for (EntityLiving eliving : entities) {
			if (eliving.isDead) {
				continue nextEliving;
			}
			eliving.dealFireDamage(5);
			if (!eliving.isWet()) {
				eliving.setFire(20);

			}
		}
	}


	public boolean netherAction() {
		int x = -6 + random.nextInt(13);
		int z = -6 + random.nextInt(13);

		for (int y = -2; y <= 2; y++) {
			int id = worldObj.getBlockId(xCoord + x, yCoord + y, zCoord + z);
			int meta = worldObj.getBlockMetadata(xCoord + x, yCoord + y, zCoord + z);

			if (id == Block.netherStalk.blockID) {
				if (meta < 3) {
					worldObj.setBlockMetadataWithNotify(xCoord + x, yCoord + y, zCoord + z, ++meta);
					return true;
				}
			}

			if (id == Block.gravel.blockID) {
				worldObj.setBlockWithNotify(xCoord + x, yCoord + y, zCoord + z, Block.slowSand.blockID);
				return true;
			}
		}
		return false;
	}


	private boolean addFuelForItem(ItemStack itemstack) {
		for (int s = 0; s < getSizeInventory(); s++) {
			int bt = getItemBurnTime(getStackInSlot(s));
			if (bt > 0) {
				burnTime += bt;
				decrStackSize(s, 1);
				if (burnTime >= getItemSmeltTime(itemstack)) return true;
			}
		}
		if (burnTime >= getItemSmeltTime(itemstack)) return true;
		return false;
	}


	private boolean addFuelForTime(int time) {
		for (int s = 0; s < getSizeInventory(); s++) {
			int bt = getItemBurnTime(getStackInSlot(s));
			if (bt > 0) {
				burnTime += bt;
				decrStackSize(s, 1);
				if (burnTime >= time) return true;
			}
		}
		if (burnTime >= time) return true;
		return false;
	}


	private void addNetherrack() {
		for (int s = 0; s < getSizeInventory(); s++) {
			if (getStackInSlot(s) != null && getStackInSlot(s).itemID == Block.netherrack.blockID) {
				netherTime += 600;
				decrStackSize(s, 1);
				noNetherrack = false;
				return;
			}
		}
		noNetherrack = true;
	}


	private ItemStack getResult(ItemStack item) {
		return FurnaceRecipes.smelting().getSmeltingResult(item.getItem().shiftedIndex);
	}


	private int getItemBurnTime(ItemStack itemstack) {
		if (itemstack == null) {
			return 0;
		}
		int i = itemstack.getItem().shiftedIndex;
		if (i < 256 && Block.blocksList[i].blockMaterial == Material.wood) {
			return 300;
		}
		if (i == Item.stick.shiftedIndex) {
			return 100;
		}
		if (i == Item.coal.shiftedIndex) {
			return 1600;
		}
		if (i == Item.bucketLava.shiftedIndex) {
			return 20000;
		}
		if (i == Block.sapling.blockID) {
			return 100;
		}
		if (i == Item.blazeRod.shiftedIndex) {
			return 2400;
		} else {
			return ModLoader.addAllFuel(i, itemstack.getItemDamage());
		}
	}


	private int getItemSmeltTime(ItemStack stack) {
		if (stack.getItem() instanceof ItemFood) {
			return 180;
		}
		if (stack.itemID == Block.wood.blockID) {
			return 300;
		}
		return 350;
	}


	@Override
	public ItemStack getStackInSlotOnClosing(int par1) {
		if (roasterContents[par1] != null) {
			ItemStack itemstack = roasterContents[par1];
			roasterContents[par1] = null;
			return itemstack;
		} else {
			return null;
		}
	}
}
