VoidExtractorTileEntity

package net.prefixaut.voidmod.tileentitys;

import static net.prefixaut.voidmod.api.VoidBlocks.*;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.common.util.ForgeDirection;
import net.prefixaut.voidmod.VoidRecipeManager;

import net.prefixaut.voidmod.api.VoidBlocks;
import net.prefixaut.voidmod.api.VoidRecipes;

import net.prefixaut.voidmod.blocks.VoidExtractorBlock;
import net.prefixaut.voidmod.utility.IC2EnergyTier;
import ic2.api.energy.event.EnergyTileLoadEvent;
import ic2.api.energy.event.EnergyTileUnloadEvent;
import ic2.api.energy.tile.IEnergySink;
import ic2.api.tile.IWrenchable;

import java.util.ArrayList;
import java.util.List;

public class VoidExtractorTileEntity extends TileEntity implements ISidedInventory, IEnergySink, IWrenchable {

    private boolean initialized, active;

    private IC2EnergyTier euTier = IC2EnergyTier.LV;
    private int maxenergy = 10000;
    private int maxvoidmatter = 10000;
    private int energyDraw = euTier.getEUperTick();
    private ItemStack workingOn;

    private static final int[]
            slotsTop = new int[]{0},
            slotsBottom = new int[]{1},
            slotsLeft = new int[]{0},
            slotsRight = new int[]{1},
            slotsFront = new int[]{0,1},
            slotsBack = new int[]{0,1};
    private ItemStack[] slots = new ItemStack[2];

    public int maxWorktime = 200;
    public int currentWorktime;
    public int energy, voidmatter = 0;
    public String name = "VoidConsumer";

    public static void initialize() {
        VoidRecipes.voidextractor = VoidRecipeManager.getVoidExtractorManager();

        VoidRecipeManager.getVoidExtractorManager().addVoidItem(new ItemStack(voidedStone), 50);
        VoidRecipeManager.getVoidExtractorManager().addVoidItem(new ItemStack(impureVoidBlock), 100);
        VoidRecipeManager.getVoidExtractorManager().addVoidItem(new ItemStack(pureVoidBlock), 1000);
    }

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

    @Override
    public ItemStack getStackInSlot(int slot) {
        try {
            return slots[slot];
        } catch (Exception e) {
            return null;
        }
    }

    @Override
    public ItemStack decrStackSize(int slot, int amount) {
        try {
            ItemStack stack = slots[slot].copy();
            if (stack != null) {
                if (stack.stackSize <= amount) {
                    slots[slot] = null;
                    return stack;
                }
                stack.stackSize =- amount;
                slots[slot].stackSize -= amount;
                return stack;
            } else return null;
        } catch (Exception e) {
            return null;
        }
    }

    @Override
    public ItemStack getStackInSlotOnClosing(int slot) {
        return null;
    }

    @Override
    public void setInventorySlotContents(int slot, ItemStack item) {
        slots[slot] = item;
    }

    @Override
    public String getInventoryName() {
        return name;
    }

    @Override
    public boolean hasCustomInventoryName() {
        return name != null && !name.equals("");
    }

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

    @Override
    public boolean isUseableByPlayer(EntityPlayer player) {
        return true;
    }

    @Override
    public void openInventory() {
    }

    @Override
    public void closeInventory() {
    }

    @Override
    public boolean isItemValidForSlot(int slot, ItemStack item) {
        try {
            boolean ret;
            switch (slot) {
                case 0: ret = VoidRecipeManager.getVoidExtractorManager().getRecipes().containsKey(item);
                        break;
                case 1: ret = VoidRecipeManager.energyItems.contains(item);
                        break;
                default: ret = false;
                        break;
            }
            return ret;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    @Override
    public int[] getAccessibleSlotsFromSide(int side) {
        switch (side) {
            case 0: return slotsBottom;
            case 1: return slotsTop;
            case 2: return slotsFront;
            case 3: return slotsBack;
            case 4: return slotsLeft;
            case 5: return slotsRight;
            default: return null;
        }
    }

    @Override
    public boolean canInsertItem(int slot, ItemStack item, int side) {
        if (!VoidRecipeManager.getVoidExtractorManager().isValidItem(item)) return false;
        int[] array;
        switch (side) {
            case 0: array = slotsBottom;
                    break;
            case 1: array = slotsTop;
                    break;
            case 2: array = slotsFront;
                    break;
            case 3: array = slotsBack;
                    break;
            case 4: array = slotsLeft;
                    break;
            case 5: array = slotsRight;
                    break;
            default: array = null;
        }
        if (array == null) return false;
        for (int i=0; i < array.length; i++) {
            if (array[i] == slot) return true;
        }
        return false;
    }

    @Override
    public boolean canExtractItem(int slot, ItemStack item, int side) {
        return false;
    }

    @Override
    public void readFromNBT(NBTTagCompound nbt) {
        super.readFromNBT(nbt);
        if (nbt.hasKey("energy")) {
            this.energy = (int) nbt.getDouble("energy");
        }
        if (nbt.hasKey("voidmatter")) {
            this.voidmatter = (int) nbt.getInteger("voidmatter");
        }
    }

    @Override
    public void writeToNBT(NBTTagCompound nbt) {
        super.writeToNBT(nbt);
        nbt.setDouble("energy", this.energy);
        nbt.setDouble("voidmatter", voidmatter);
        worldObj.notifyBlockChange(xCoord, yCoord, zCoord, worldObj.getBlock(xCoord, yCoord, zCoord));
    }

    private void updateStatus() {
        System.out.println("Update-Status");
        VoidExtractorBlock b = (VoidExtractorBlock) worldObj.getBlock(xCoord, yCoord, zCoord);
        b.updateActivity(active, worldObj, xCoord, yCoord, zCoord, this);

    }

    private int c = 1;
    @Override
    public void updateEntity() {
        super.updateEntity();
        if (!this.initialized && worldObj != null) {
            if (!worldObj.isRemote) {
                EnergyTileLoadEvent load = new EnergyTileLoadEvent(this);
                MinecraftForge.EVENT_BUS.post(load);
            }
            this.initialized = true;
        }
        if (!active) {
//          Starting
            if (energy >= energyDraw) {
                if (this.getStackInSlot(0) != null){
                    if (VoidRecipeManager.getVoidExtractorManager().isValidItem(this.getStackInSlot(0))) {
                        energy -= energyDraw;
                        active = true;
                        currentWorktime = 0;
                        workingOn = this.getStackInSlot(0).copy();
                        this.decrStackSize(0, 1);
                        this.updateStatus();
                        return;
                    }
                }
            }
        } else {
            if (currentWorktime < maxWorktime) {
                if (energy >= energyDraw) {
                    energy -= energyDraw;
                    currentWorktime++;
                    return;
                }
            } else {
//              Finishing
                if (VoidRecipeManager.getVoidExtractorManager().getVoidMatter(workingOn) > (maxvoidmatter - voidmatter)) {
//                  It would produce too much, so it stops until it can fill up the buffer again.
                    return;
                }
                energy -= energyDraw;
                active = false;
                currentWorktime = 0;
                voidmatter += VoidRecipeManager.getVoidExtractorManager().getVoidMatter(workingOn);
                workingOn = null;
                this.updateStatus();
                return;
            }
        }
    }

    @Override
    public void invalidate() {
        System.out.println("DEBUG: Invalidating TileEntity [" + this + "]");
        EnergyTileUnloadEvent unload = new EnergyTileUnloadEvent(this);
        MinecraftForge.EVENT_BUS.post(unload);
        super.invalidate();
    }

    /*
     * -==========| GUI Display |==========-
     */

    public int getWorktimeScaled(int size) {
        return ((this.currentWorktime * size) / this.maxWorktime);
    }

    public int getEnergyBufferScaled(int size) {
        return ((this.energy * size) / this.maxenergy);
    }

    public int getEnergyLoadingScaled(int size) {
        int tmp = ((this.energy * size) / (this.energyDraw * this.maxWorktime));
        if (tmp > size) tmp = size;
        return tmp;
    }

    public int getVoidMatterScaled(int size) {
        return ((this.voidmatter * size) / this.maxvoidmatter);
    }

    public int getMaxEnergy() {
        return this.maxenergy;
    }

    public int getEnergy() {
        return this.energy;
    }

    public int getMaxVoid() {
        return this.maxenergy;
    }

    public int getVoid() {
        return this.voidmatter;
    }

    public boolean isActive() {
        return active;
    }

    public boolean hasEnergy() {
        return this.energy >= this.energyDraw;
    }

    /*
     * -==========| IC 2 Enegery Stuff |==========-
     */

    @Override
    public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction) {
        return true;
    }

    @Override
    public double getDemandedEnergy() {
        return this.maxenergy - this.energy;
    }

    @Override
    public int getSinkTier() {
        return euTier.getTier();
    }

    @Override
    public double injectEnergy(ForgeDirection directionFrom, double amount, double voltage) {
        if (energy == maxenergy) return amount;
        else if ((energy + amount) > maxenergy) {
            double tmp = energy + amount;
            energy = maxenergy;
            return tmp - maxenergy;
        } else {
            energy += amount;
            return 0;
        }
    }

    @Override
    public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) {
        return false;
    }

    @Override
    public short getFacing() {
        return 0;
    }

    @Override
    public void setFacing(short facing) {

    }

    @Override
    public boolean wrenchCanRemove(EntityPlayer entityPlayer) {
        return true;
    }

    @Override
    public float getWrenchDropRate() {
        return 1;
    }

    @Override
    public ItemStack getWrenchDrop(EntityPlayer entityPlayer) {
        return new ItemStack(VoidBlocks.voidExtractor);
    }

}