package com.halestormxv.tile_entity;

import com.halestormxv.blocks.CelestialCraft_blocks;
import com.halestormxv.blocks.CelestialFurnace;
import com.halestormxv.handler.CelestialFurnaceRecipes;
import com.halestormxv.item.CelestialCraft_items;

import cpw.mods.fml.common.registry.GameRegistry;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
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.tileentity.TileEntity;

public class TileEntityCelestialFurnace extends TileEntity implements ISidedInventory {

    //Slots Definitions
    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};

    private ItemStack[] slots = new ItemStack[3]; //Slots in the Furnace

    public int furnaceSpeed = 45; //Speed at which the furnace cooks.

    public int furnaceBurnTime; //number of ticks furnace will keep burning
    public int currentBurnTime; //number of ticks that a fresh copy of the currently burning item would keep the furnace burning for

    public int furnaceCookTime; //number of ticks that the current items has been cooking for.

    private String localizedName;

    public void setGuiDisplayName(String displayName){
        this.localizedName = displayName;
    }

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

    @Override
    public ItemStack getStackInSlot(int slot) {
        return this.slots[slot];
    }

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

                if (this.slots[par1].stackSize == 0){
                    this.slots[par1] = null;
                }
                return itemstack;
            }
        }else{
            return null;
        }
    }

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

    }

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

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

    }

    @Override
    public String getInventoryName() {
        return this.hasCustomInventoryName() ? this.localizedName : "container.celestialFurnace";
    }

    @Override
    public boolean hasCustomInventoryName() {
        // TODO Auto-generated method stub
        return this.localizedName != null && this.localizedName.length() > 0;
    }

    @Override
    public int getInventoryStackLimit() {
        // TODO Auto-generated method stub
        return 64;
    }

    public void readFromNBT(NBTTagCompound nbt){
        super.readFromNBT(nbt);
        NBTTagList tagList = nbt.getTagList("Items", 10);
        this.slots = new ItemStack[this.getSizeInventory()];

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

            if(byte0 >= 0 && byte0 < this.slots.length){
                this.slots[byte0] = ItemStack.loadItemStackFromNBT(compound);
            }
        }

        this.furnaceBurnTime = (int)nbt.getShort("BurnTime");
        this.furnaceCookTime = (int)nbt.getShort("CookTime");
        this.currentBurnTime = (int)nbt.getShort("CurrentBurnTime");

        if(nbt.hasKey("CustomName")){
            this.localizedName = nbt.getString("CustomName");
        }
    }

    public void writeToNBT(NBTTagCompound nbt){
        super.writeToNBT(nbt);
        nbt.setShort("BurnTime", (short) this.furnaceBurnTime);
        nbt.setShort("CookTime", (short) this.furnaceCookTime);
        nbt.setShort("CurrentBurnTime", (short) this.currentBurnTime);
        NBTTagList tagList = new NBTTagList();

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

        nbt.setTag("Items", tagList);

        if(this.hasCustomInventoryName()){
            nbt.setString("CustomName", this.localizedName);
        }
    }

    @SideOnly(Side.CLIENT)
    public int getCookProgressScaled(int par1){
        return this.furnaceCookTime * par1 / this.furnaceSpeed;
    }

    @SideOnly(Side.CLIENT)
    public int getBurnTimeRemainingScaled(int par1){
        if(this.currentBurnTime == 0){
            this.currentBurnTime = this.furnaceSpeed;
        }
        return this.furnaceBurnTime * par1 / this.currentBurnTime;
    }

    public boolean isBurning(){
        return this.furnaceBurnTime > 0;
    }

    public void updateEntity(){
        boolean flag = this.furnaceBurnTime > 0;
        boolean flag1 = false;

        if(this.isBurning()){
            --this.furnaceBurnTime;
        }

        if(!this.worldObj.isRemote){
            if(this.furnaceBurnTime == 0 && this.canSmelt() || this.furnaceBurnTime == 0 && this.canCelestialSmelt()){
                this.currentBurnTime = this.furnaceBurnTime = getItemBurnTime(this.slots[1]);

                if(this.isBurning()){
                    flag1 = true;
                    if(this.slots[1] != null){
                        --this.slots[1].stackSize;

                        if(this.slots[1].stackSize == 0){
                            this.slots[1] = this.slots[1].getItem().getContainerItem(this.slots[1]);
                        }
                    }
                }
            }

            if(this.isBurning() && this.canSmelt() || this.isBurning() && this.canCelestialSmelt()){
                ++this.furnaceCookTime;
                if(this.furnaceCookTime == this.furnaceSpeed){
                    this.furnaceCookTime = 0;
                    this.smeltItem();
                    this.celestialSmeltItem();
                    flag1 = true;
                }
            }else{
                this.furnaceCookTime = 0;
            }
        }

        if(flag != this.isBurning()){
            flag1 = true;
            CelestialFurnace.updateCelestialFurnaceBlockState(this.furnaceBurnTime > 0, this.worldObj, this.xCoord, this.yCoord, this.zCoord);
        }

        if(flag1){
            this.markDirty();
        }
    }

    public boolean canSmelt(){
        if(this.slots[0] == null){
            return false;
        }else{
            ItemStack itemstack = FurnaceRecipes.smelting().getSmeltingResult(this.slots[0]);
            if(itemstack == null) return false;
            if(this.slots[2] == null) return true;
            if(!this.slots[2].isItemEqual(itemstack)) return false;

            int result = this.slots[2].stackSize + itemstack.stackSize;
            return ( result <= getInventoryStackLimit() && result <= itemstack.getMaxStackSize() );
        }
    }

    public boolean canCelestialSmelt(){
        if(this.slots[0] == null){
            return false;
        }else{
            ItemStack itemstack = CelestialFurnaceRecipes.smelting().getSmeltingResult(this.slots[0]);
            if(itemstack == null) return false;
            if(this.slots[2] == null) return true;
            if(!this.slots[2].isItemEqual(itemstack)) return false;

            int result = this.slots[2].stackSize + itemstack.stackSize;
            return ( result <= getInventoryStackLimit() && result <= itemstack.getMaxStackSize() );
        }
    }

    public void smeltItem(){
        if(this.canSmelt())
        {
            ItemStack itemstack = FurnaceRecipes.smelting().getSmeltingResult(this.slots[0]);
            if(this.slots[2] == null){
                this.slots[2] = itemstack.copy();
            }else if(this.slots[2].isItemEqual(itemstack)){
                this.slots[2].stackSize += itemstack.stackSize;
            }
            --this.slots[0].stackSize;
            ++this.slots[2].stackSize;
            ++this.slots[2].stackSize;

            if (this.slots[0].stackSize <= 0 ){
                this.slots[0] = null;
            }
        }
    }

    public void celestialSmeltItem(){
        if(this.canCelestialSmelt())
        {
            ItemStack itemstack = CelestialFurnaceRecipes.smelting().getSmeltingResult(this.slots[0]);
            if(this.slots[2] == null){
                this.slots[2] = itemstack.copy();
            }else if(this.slots[2].isItemEqual(itemstack)){
                this.slots[2].stackSize += itemstack.stackSize;
            }
            --this.slots[0].stackSize;
            if (this.slots[0].stackSize <= 0 ){
                this.slots[0] = null;
            }
        }
    }

    //Check if item is burnable
    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 == CelestialCraft_blocks.GalaxyStone){
                    return 3800;
                }
                if(block.getMaterial() == Material.rock){
                    return 300;
                }
            }
            if(item == CelestialCraft_items.starSeedItem) return 2400;
            if(item == Items.lava_bucket) return 100;
            if(item instanceof ItemTool && ((ItemTool) item).getToolMaterialName().equals(("EMERALD"))) return 400;
            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
    //What can be placed into furnace slots
    public boolean isItemValidForSlot(int par1, ItemStack itemstack) {
        return par1 == 2 ? false : (par1 == 1 ? isItemFuel(itemstack) : true);
    }

    @Override
    //What Sides access which slots
    public int[] getAccessibleSlotsFromSide(int par1) {
        return par1 == 0 ? slotsBottom : (par1 == 1 ? slotsTop : slotsSides);
    }

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

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

}