ChargerTileEntity

package me.onVoid.helpfuladdons.charger;

import cofh.api.energy.EnergyStorage;
import cofh.api.energy.IEnergyContainerItem;
import cofh.api.energy.IEnergyHandler;
import cofh.api.energy.IEnergyReceiver;
import cofh.api.energy.IEnergyStorage;
import cofh.api.energy.ItemEnergyContainer;
import cofh.api.energy.TileEnergyHandler;
import cpw.mods.fml.common.FMLCommonHandler;
import ic2.api.item.ElectricItem;
import ic2.api.item.IElectricItem;
import ic2.api.item.IElectricItemManager;
import ic2.api.item.ISpecialElectricItem;
import net.minecraft.block.Block;
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.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.server.gui.IUpdatePlayerListBox;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ChatComponentText;
import net.minecraft.util.IChatComponent;
import net.minecraftforge.common.util.ForgeDirection;
import ic2.api.item.IElectricItem;
import ic2.api.item.IElectricItemManager;

public class ChargerTileEntity extends TileEnergyHandler implements ISidedInventory, IEnergyReceiver, IEnergyStorage, IEnergyHandler {

    private String localizedName;

    public static int OneEUEquals_RF = 4; //1 EU = 4 RF

    public static int RFChargeAmt = 7000;
    public static int EUChargeAmt = RFChargeAmt / OneEUEquals_RF;

    public static int charging;
    public static int chargingDC;
    public static int chargingDC2;

    private ItemStack[] slots = new ItemStack[11];

    private static final int[] slots_top = new int[]{0,1,2,3,4,5,6,7,8};
    private static final int[] slots_bottom = new int[]{9};
    private static final int[] slots_side = new int[]{9};

    public static EnergyStorage storage;
    public static int MAX_RECEIVE = 15000;
    public static int CAPACITY = 600000;


    public ChargerTileEntity(){
        storage = new EnergyStorage(CAPACITY, MAX_RECEIVE);
    }

    @Override
    public int getEnergyStored() {
        return storage.getEnergyStored();
    }

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

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

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

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

    public boolean hasCustomInventoryName() {
        return this.localizedName != null && this.localizedName.length() > 0;
    }

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

    public void openInventory() {
    }

    public void closeInventory() {
    }

    @Override
    public boolean canInsertItem(int i, ItemStack is, int j) {
        return this.isItemValidForSlot(j, is);
    }

    @Override
    public boolean canExtractItem(int i, ItemStack is, int j) {
        if (j == 9 || j == 10){
            return true;
        } else {
            return false;
        }
    }

    @Override
    public int[] getAccessibleSlotsFromSide(int var1) {
        if (var1 == 0){
            return slots_bottom;
        } else if (var1 == 1){
            return slots_top;
        } else {
            return slots_side;
        }
    }

    @Override
    public boolean isItemValidForSlot(int i, ItemStack is) {
        if (i == 9 || i == 10){
            return false;
        } else {
            return true;
        }
    }

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

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

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

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

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

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

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

    @Override
    public boolean canConnectEnergy(ForgeDirection from) {
        return true;
    }

    @Override
    public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) {
        return storage.receiveEnergy(maxReceive, simulate);
    }

    @Override
    public int getEnergyStored(ForgeDirection from) {
        return storage.getEnergyStored();
    }

    @Override
    public int getMaxEnergyStored(ForgeDirection from) {
        return storage.getMaxEnergyStored();
    }

    @Override
    public int extractEnergy(int maxExtract, boolean simulate) {
        return storage.extractEnergy(maxExtract, simulate);
    }

    @Override
    public int receiveEnergy(int maxReceive, boolean simulate) {
        return storage.receiveEnergy(maxReceive, simulate);
    }

    @Override
    public int getMaxEnergyStored() {
        return storage.getMaxEnergyStored();
    }

    @Override
    public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) {
        return storage.extractEnergy(maxExtract, simulate);
    }

    public void checkTen(){
        chargingDC = 0;
        if (slots[10].getItem() instanceof ItemEnergyContainer){
            chargingDC = ((ItemEnergyContainer)slots[10].getItem()).getEnergyStored(slots[10]);
        } else if (slots[10].getItem() instanceof IEnergyContainerItem){
            chargingDC = ((IEnergyContainerItem)slots[10].getItem()).getEnergyStored(slots[10]);
        }
    }

    public void chargeRFItemEnergyContainer(){
        if (((ItemEnergyContainer)slots[10].getItem()).getEnergyStored(slots[10])
                == ((ItemEnergyContainer)slots[10].getItem()).getMaxEnergyStored(slots[10])){
            slots[9] = slots[10].copy();
            this.setInventorySlotContents(10, null);
        } else {
            int x = 0;
            if (storage.getEnergyStored() >= RFChargeAmt){
        x = ((ItemEnergyContainer)slots[10].getItem()).receiveEnergy(slots[10], RFChargeAmt, false);
            } else {
                x = ((ItemEnergyContainer)slots[10].getItem()).receiveEnergy(slots[10], storage.getEnergyStored(), false);
            }
        extractEnergy(x, false);
        }
    }

    public void chargeRFIEnergyContainerItem(){
        if (((IEnergyContainerItem)slots[10].getItem()).getEnergyStored(slots[10])
                == ((IEnergyContainerItem)slots[10].getItem()).getMaxEnergyStored(slots[10])){
            slots[9] = slots[10].copy();
            this.setInventorySlotContents(10, null);
    } else {
        int x = 0;
            if (storage.getEnergyStored() >= RFChargeAmt){
        x = ((IEnergyContainerItem)slots[10].getItem()).receiveEnergy(slots[10], RFChargeAmt, false);
            } else {
                x = ((IEnergyContainerItem)slots[10].getItem()).receiveEnergy(slots[10], storage.getEnergyStored(), false);
            }
        extractEnergy(x, false);
        }
    }

    public void chargeEUIElectricItem(){
        if (ElectricItem.manager.getCharge(slots[10]) == ((IElectricItem)slots[10].getItem()).getMaxCharge(slots[10])){
            slots[9] = slots[10].copy();
            this.setInventorySlotContents(10, null);
        } else {
            if (storage.getEnergyStored() >= EUChargeAmt * OneEUEquals_RF){
        ElectricItem.manager.charge(slots[10],
                (double)EUChargeAmt, ((IElectricItem)slots[10].getItem()).getTier(slots[10]), false, false);
            } else {
                ElectricItem.manager.charge(slots[10],
                        (double)(storage.getEnergyStored() / OneEUEquals_RF), ((IElectricItem)slots[10].getItem()).getTier(slots[10]), false, false);
            }
            charging = ((int)ElectricItem.manager.getCharge(slots[10]) * OneEUEquals_RF) - chargingDC;
            extractEnergy(charging, false);
            chargingDC = chargingDC + charging;
            charging = 0;
        }
    }

    public void chargeEUISpecialElectricItem(){
        if (ElectricItem.manager.getCharge(slots[10]) == ((ISpecialElectricItem)slots[10].getItem()).getMaxCharge(slots[10])){
            slots[9] = slots[10].copy();
            this.setInventorySlotContents(10, null);
        } else {
            if (storage.getEnergyStored() >= EUChargeAmt * OneEUEquals_RF){
        ElectricItem.manager.charge(slots[10],
                (double)EUChargeAmt, ((ISpecialElectricItem)slots[10].getItem()).getTier(slots[10]), false, false);
            } else {
                ElectricItem.manager.charge(slots[10],
                        (double)(storage.getEnergyStored() / OneEUEquals_RF), ((IElectricItem)slots[10].getItem()).getTier(slots[10]), false, false);
            }
            charging = ((int)ElectricItem.manager.getCharge(slots[10]) * OneEUEquals_RF) - chargingDC;
            extractEnergy(charging, false);
            chargingDC = chargingDC + charging;
            charging = 0;
        }
    }

    @Override
    public void updateEntity(){
        if (slots[10] == null){
            charging = 0;
            chargingDC = 0;
            if (slots[0] != null){
                slots[10] = slots[0].copy();
                checkTen();
                this.setInventorySlotContents(0, null);
            } else if (slots[1] != null){
                slots[10] = slots[1].copy();
                checkTen();
                this.setInventorySlotContents(1, null);
            } else if (slots[2] != null){
                slots[10] = slots[2].copy();
                checkTen();
                this.setInventorySlotContents(2, null);
            } else if (slots[3] != null){
                slots[10] = slots[3].copy();
                checkTen();
                this.setInventorySlotContents(3, null);
            } else if (slots[4] != null){
                slots[10] = slots[4].copy();
                checkTen();
                this.setInventorySlotContents(4, null);
            } else if (slots[5] != null){
                slots[10] = slots[5].copy();
                checkTen();
                this.setInventorySlotContents(5, null);
            } else if (slots[6] != null){
                slots[10] = slots[6].copy();
                checkTen();
                this.setInventorySlotContents(6, null);
            } else if (slots[7] != null){
                slots[10] = slots[7].copy();
                checkTen();
                this.setInventorySlotContents(7, null);
            } else if (slots[8] != null){
                slots[10] = slots[8].copy();
                checkTen();
                this.setInventorySlotContents(8, null);
            }
        } else {
            if (storage.getEnergyStored() > 0){
                    if (slots[10].getItem() instanceof ItemEnergyContainer){
                        chargeRFItemEnergyContainer();
                    } else if (slots[10].getItem() instanceof IEnergyContainerItem){
                        chargeRFIEnergyContainerItem();
                    } else if (slots[10].getItem() instanceof IElectricItem){
                        chargeEUIElectricItem();
                    } else if (slots[10].getItem() instanceof ISpecialElectricItem){
                        chargeEUISpecialElectricItem();
                    }
            }
        }
    }

}