Item Battery

package electa.lumen.items;

import electa.lumen.Lumen;
import electa.lumen.lib.Constants;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import net.minecraftforge.fml.common.registry.GameRegistry;

import java.util.List;

public class ItemBattery extends Item {
    private static final double NOMINAL_CAPACITY = 20; // AH
    private static final double NOMINAL_VOLTAGE = 51.2; // V
    //private static final double sourceResistance = 40; // mOhm
    private static final double DISCHARGE_CUTOFF_VOLTAGE = 35.2; // V
    private static final double CHARGE_CUTOFF_VOLTAGE = 62.4; // V
    //private static final double ratedDischargeCurrent = 20; // A
    private static final double MAXIMUM_CONTINUOUS_DISCHARGE_CURRENT = 40; // A
    private static final double MAXIMUM_CONTINUOUS_CHARGE_CURRENT = 10; // A
    //private double standardChargeCurrent = 2; // A
    //private double batteryGrossWeight = 14; // kg (include bms)
    //private double chargingCycles = 1000; // times

    private static final String NAME = "battery";

    public ItemBattery(){
        maxStackSize = 1;
        setCreativeTab(Lumen.TAB_LUMEN);
        GameRegistry.registerItem(this, NAME);
        setMaxDamage(100);
        setUnlocalizedName(Constants.MODID + "_" + NAME);
    }

    public String getName(){
        return NAME;
    }

    // **********************  CONSTANTS ********************

    // in Wh
    public double getEnergyContent(){
        return NOMINAL_CAPACITY * NOMINAL_VOLTAGE * 72; // 1 mc uur == 50 seconden irl, 50sec = 1/72 uur
    }

    public double getNominalVoltage() {
        return NOMINAL_VOLTAGE;
    }

    public double getChargeCutoffVoltage() {
        return CHARGE_CUTOFF_VOLTAGE;
    }

    public double getDischargeCutoffVoltage() {
        return DISCHARGE_CUTOFF_VOLTAGE;
    }

    @SuppressWarnings("unchecked")
    @Override
    public void getSubItems(Item itemIn, CreativeTabs tab, List subItems) {
        ItemStack itemStack = new ItemStack(itemIn, 1, 0);
        setPowerIntegral(itemStack, -getEnergyContent());
        subItems.add(itemStack);
        subItems.add(new ItemStack(itemIn, 1, 100));
    }

    // ********************** ITEMSTACK SPECIFIC **********************
    public double getSOC(ItemStack stack) {
        return -getPowerIntegral(stack) / getEnergyContent();
    }

    public double getMaximumContinuousChargeCurrent(ItemStack stack) {
        if(getSOC(stack) >= 1){
            return 0;
        }
        return MAXIMUM_CONTINUOUS_CHARGE_CURRENT;
    }

    public double getMaximumContinuousDischargeCurrent(ItemStack stack) {
        if(getSOC(stack) == 0){
            return 0;
        }
        return MAXIMUM_CONTINUOUS_DISCHARGE_CURRENT;
    }

    public void update(ItemStack stack, double power, int tick){
        if(getSOC(stack) >= 1 && power < 0){
            setPowerIntegral(stack, -getEnergyContent());
            return;
        }else if(getSOC(stack) <= 0 && power > 0){
            setPowerIntegral(stack, 0);
            return;
        }
        double pI = getPowerIntegral(stack);
        double oldTick = getTickSincePowerChange(stack);
        double diff;
        // this is the first tick for the battery
        if(oldTick == 0){
            diff = 1/20.0;
        }else {
            diff = (tick - oldTick) / 20.0;
        }
        setPowerIntegral(stack, pI + (power * diff));
        setPower(stack, power);
        setTickSincePowerChange(stack, tick);
        stack.setItemDamage(100 - (int) (100 * getSOC(stack)));
    }

    public void resetTicks(ItemStack stack){
        setTickSincePowerChange(stack, 0);
    }

    private int getTickSincePowerChange(ItemStack stack){
        return getNbt(stack).getInteger("tickSincePowerChange");
    }

    private double getPowerIntegral(ItemStack stack) {
        return getNbt(stack).getDouble("powerIntegral");
    }

    private void setTickSincePowerChange(ItemStack stack, int tick){
        getNbt(stack).setInteger("tickSincePowerChange", tick);
    }


    private void setPowerIntegral(ItemStack stack, double powerIntegral) {
        getNbt(stack).setDouble("powerIntegral", powerIntegral);
    }

    private void setPower(ItemStack stack, double power) {
        getNbt(stack).setDouble("power", power);
    }

    @Override
    public void onCreated(ItemStack stack, World worldIn, EntityPlayer playerIn) {
        int piInt = 100 - stack.getItemDamage();
        NBTTagCompound nbt = getNbt(stack);
        nbt.setInteger("tickSincePowerChange", 0);
        nbt.setDouble("powerIntegral", piInt / 100.0);
        nbt.setDouble("power", 0);
    }

    @SuppressWarnings("unchecked")
    @Override
    public void addInformation(ItemStack stack, EntityPlayer playerIn, List tooltip, boolean advanced) {
        tooltip.add(String.valueOf( (int) (100 * getSOC(stack))) );
    }

    private NBTTagCompound getNbt(ItemStack stack) {
        NBTTagCompound nbt;
        if (!stack.hasTagCompound()){
            nbt = new NBTTagCompound();
            stack.setTagCompound(nbt);
        }else{
            nbt = stack.getTagCompound();
        }
        return nbt;
    }
}