package org.tetawex.tileEntity;

import org.tetawex.block.AllBlocks;
import org.tetawex.block.Foundry;
import org.tetawex.block.Refinery;
import org.tetawex.handler.FoundryRecipes;
import org.tetawex.handler.RefineryRecipes;

import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;
import net.minecraft.item.ItemTool;
import net.minecraft.item.crafting.FurnaceRecipes;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.network.NetworkManager;
import net.minecraft.network.Packet;
import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
import net.minecraft.tileentity.TileEntity;
import cpw.mods.fml.common.registry.GameRegistry;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;

public class TileEntityFoundry extends TileEntity implements ISidedInventory {

    private static final int[] slotsTop = new int[] { 0 };
    private static final int[] slotsBottom = new int[] { 2, 1 };
    private static final int[] slotsSides = new int[] { 1 };

    public int discNumber=0;
    private ItemStack[] itemStacks = new ItemStack[3];//1=fuel,2=item,3=result
    public int refineTime;
    public int maxRefineTime=1600;
    public int energyLevel=0;
    public int maxEnergyLevel=128000;

    private String name;

    public void setName(String string)
    {
        name = string;
    }

    @Override
    public int getSizeInventory()
    {
        return itemStacks.length;
    }

    @Override
    public ItemStack getStackInSlot(int slot)
    {
        return itemStacks[slot];
    }

    @Override
    public ItemStack decrStackSize(int slot, int number)
    {
        if (itemStacks[slot] != null)
        {
            ItemStack itemstack;
            if (itemStacks[slot].stackSize <= number)
            {
                itemstack = itemStacks[slot];
                this.itemStacks[slot] = null;
                return itemstack;
            }
            else
            {
                itemstack = itemStacks[slot].splitStack(number);

                if (itemStacks[slot].stackSize == 0)
                {
                    itemStacks[slot] = null;
                }
                return itemstack;
            }
        }
        else
        {
            return null;
        }
    }

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

    @Override
    public void setInventorySlotContents(int slot, ItemStack itemstack)
    {
        itemStacks[slot] = itemstack;

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

    }

    @Override
    public String getInventoryName()
    {
        return this.hasCustomInventoryName() ? name : "Foundry";
    }

    @Override
    public boolean hasCustomInventoryName()
    {
        return name != null && name.length() > 0;
    }

    @Override
    public int getInventoryStackLimit()
    {
        return 64;
    }
    @Override
    public Packet getDescriptionPacket() {
        NBTTagCompound tag = new NBTTagCompound();
        writeToNBT(tag);
        return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, 0, tag);
    }
    @Override
    public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) {
        readFromNBT(pkt.func_148857_g());
    }
    public void readFromNBT(NBTTagCompound tagCompound)
    {
        super.readFromNBT(tagCompound);
        NBTTagList tagList = tagCompound.getTagList("Items", 10);
        itemStacks = new ItemStack[getSizeInventory()];

        for (int i = 0; i < tagList.tagCount(); ++i)
        {
            NBTTagCompound tagCompound1 = tagList.getCompoundTagAt(i);
            byte byte0 = tagCompound1.getByte("Slot");

            if (byte0 >= 0 && byte0 < itemStacks.length)
            {
                itemStacks[byte0] = ItemStack.loadItemStackFromNBT(tagCompound1);
            }
        }

        refineTime = tagCompound.getShort("RefineTime");
        energyLevel = tagCompound.getInteger("EnergyLevel");
        discNumber = tagCompound.getShort("DiscNumber");
        //System.out.println(discNumber);

        if (tagCompound.hasKey("Foundry", 8))
        {
            name = tagCompound.getString("Foundry");
        }
    }

    public void writeToNBT(NBTTagCompound tagCompound)
    {
        super.writeToNBT(tagCompound);
        tagCompound.setShort("RefineTime", (short) refineTime);
        tagCompound.setShort("DiscNumber", (short) discNumber);

        tagCompound.setInteger("EnergyLevel", energyLevel);
        NBTTagList tagList = new NBTTagList();

        for (int i = 0; i < itemStacks.length; ++i)
        {
            if (itemStacks[i] != null)
            {
                NBTTagCompound tagCompound1 = new NBTTagCompound();
                tagCompound1.setByte("Slot", (byte) i);
                itemStacks[i].writeToNBT(tagCompound1);
                tagList.appendTag(tagCompound1);
            }
        }

        tagCompound.setTag("Items", tagList);

        if (hasCustomInventoryName())
        {
            tagCompound.setString("Foundry", name);
        }
    }

    @SideOnly(Side.CLIENT)
    public int getCookProgressScaled(int barHeight)
    {
        return this.refineTime * barHeight / maxRefineTime;
    }

    @SideOnly(Side.CLIENT)
    public int getEnergyLevelScaled(int barHeight)
    {

        return energyLevel * barHeight / maxEnergyLevel;
    }

    public boolean isBurning()
    {
        if (energyLevel > 0 && canSmelt())
        {
            return true;
        }
        else return false;
    }

    public void updateEntity()
    {
        boolean flag = (energyLevel > 0 && canSmelt());
        boolean flag1 = false;

        if (!worldObj.isRemote)
        {
                    flag1 = true;
                    if (itemStacks[1] != null&&energyLevel+4000<=maxEnergyLevel)
                    {
                        itemStacks[1].stackSize--;

                        if (itemStacks[1].stackSize == 0)
                        {
                            itemStacks[1] = itemStacks[1].getItem().getContainerItem(itemStacks[1]);
                        }
                            energyLevel+=4000;
                    }

            if (canSmelt()&&energyLevel>0)
            {
                refineTime++;
                if (refineTime == maxRefineTime)
                {
                    refineTime = 0;
                    smeltItem();
                    flag1 = true;
                }
            }
            else
            {
                refineTime = 0;
            }
            if (energyLevel > 0 && canSmelt())
            {
                energyLevel-=10 ;
            }
            //System.out.println("Server: "+discNumber);
            flag1=true;
        }
        Foundry.updateBlockState(isBurning(), worldObj, xCoord, yCoord, zCoord);
        if (flag1)
        {
            markDirty();
        }
    }

    private boolean canSmelt()
    {
        if (itemStacks[0] == null)
        {
            return false;
        }
        else
        {
            ItemStack itemstack = FoundryRecipes.smelting().getSmeltingResult(itemStacks[0],discNumber);
            if (itemstack == null) return false;
            if (itemStacks[0].stackSize<FoundryRecipes.smelting().getRequiredNumber(itemStacks[0],discNumber)) return false;
            if (itemStacks[2] == null) return true;
            if (!itemStacks[2].isItemEqual(itemstack)) return false;
            int result = itemStacks[2].stackSize + itemstack.stackSize;
            return result <= getInventoryStackLimit() && result <= itemStacks[2].getMaxStackSize();
        }
    }

    public void smeltItem()
    {
        if (canSmelt())
        {
            ItemStack itemstack = FoundryRecipes.smelting().getSmeltingResult(itemStacks[0],discNumber);

            if (this.itemStacks[2] == null)
            {
                this.itemStacks[2] = itemstack.copy();
            }
            else if (itemStacks[2].getItem() == itemstack.getItem())
            {
                itemStacks[2].stackSize += itemstack.stackSize;
            }

            itemStacks[0].stackSize-=FoundryRecipes.smelting().getRequiredNumber(itemStacks[0],discNumber);

            if(itemStacks[0].stackSize < 1)
            {
                itemStacks[0] = null;
            }
        }
    }

    public static int getItemBurnTime(ItemStack itemstack)
    {
        if(itemstack == null)
        {
            return 0;
        }
        else
        {
            Item item = itemstack.getItem();

            /*if(item instanceof ItemBlock && Block.getBlockFromItem(item) != Blocks.air){
                Block block = Block.getBlockFromItem(item);

                if(block == TMBlock.tutBlock){
                    return 200;
                }

                if(block.getMaterial() == Material.rock){
                    return 300;
                }
            }*/

            if(item == Item.getItemFromBlock(Blocks.redstone_block)) return 6400;
            //if(item instanceof ItemTool && ((ItemTool) item).getToolMaterialName().equals("EMERALD")) return 300;
            return GameRegistry.getFuelValue(itemstack);
        }
    }

    public static boolean isItemFuel(ItemStack itemstack)
    {
        return getItemBurnTime(itemstack) > 0;
    }

    @Override
    public boolean isUseableByPlayer(EntityPlayer player)
    {
        return this.worldObj.getTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : player.getDistanceSq((double) this.xCoord + 0.5D, (double) this.yCoord + 0.5D, (double) this.zCoord + 0.5D) <= 64.0D;
    }

    @Override
    public void openInventory()
    {

    }

    @Override
    public void closeInventory()
    {

    }

    @Override
    public boolean isItemValidForSlot(int slot, ItemStack itemstack)
    {
        return slot == 2 ? false : (slot == 1 ? isItemFuel(itemstack) : true);
    }

    @Override
    public int[] getAccessibleSlotsFromSide(int side)
    {
        return side == 0 ? slotsBottom : (side == 1 ? slotsTop : slotsSides);
    }

    @Override
    public boolean canInsertItem(int slot, ItemStack itemstack, int side)
    {
        return this.isItemValidForSlot(slot, itemstack);
    }

    @Override
    public boolean canExtractItem(int slot, ItemStack itemstack, int side)
    {
        return side != 0 || slot != 1 || itemstack.getItem() == Items.bucket;
    }

}