[1.12.2] Get amount of fluidTank in GUI

I have a tileEntity with two FluidTanks but if i want to show the amount of fluid in one tank in the GUI the amount is always null. I tried many different solution but no one worked. I get the capacity of the tank in the gui but not the liquid in it or the amount of liquid which is is the tank, can anybody help me out?

My Block Class:

package io.yruel.moonshiners.block;

import io.yruel.moonshiners.Moonshiners;
import io.yruel.moonshiners.init.MoonshinersBlocks;
import io.yruel.moonshiners.tileentity.TileEntityBarrel;
import io.yruel.moonshiners.util.Reference;
import io.yruel.moonshiners.util.fluid.FluidUtils;
import mcp.MethodsReturnNonnullByDefault;
import net.minecraft.block.BlockHorizontal;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.block.SoundType;
import net.minecraft.block.material.Material;
import net.minecraft.block.properties.PropertyDirection;
import net.minecraft.block.state.BlockStateContainer;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.*;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraftforge.fluids.*;
import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
import net.minecraftforge.fluids.capability.IFluidHandler;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import javax.annotation.Nullable;
import javax.annotation.ParametersAreNonnullByDefault;
import java.util.Random;

@MethodsReturnNonnullByDefault
public class BlockBarrel extends BlockBase {

    public static final Logger LOGGER = LogManager.getLogger(Reference.ID);

    public static final PropertyDirection FACING = BlockHorizontal.FACING;

    public BlockBarrel(String name, Material material, float hardness, float resistance) {
        super(name, Material.WOOD, 3.0F, 5.0F);
        setSoundType(SoundType.WOOD);
        setDefaultState(this.getBlockState().getBaseState().withProperty(FACING, EnumFacing.NORTH));
    }

    @Override
    public Item getItemDropped(IBlockState state, Random rand, int fortune) {
        return Item.getItemFromBlock(MoonshinersBlocks.BARREL);
    }

    @Override
    @ParametersAreNonnullByDefault
    @SuppressWarnings("deprecation")
    public ItemStack getItem(World worldIn, BlockPos pos, IBlockState state) {
        return new ItemStack(MoonshinersBlocks.BARREL);
    }

    @Override
    public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) {
        if (!worldIn.isRemote) {
            final TileEntityBarrel tileEntity = (TileEntityBarrel) worldIn.getTileEntity(pos);
            ItemStack item = playerIn.getHeldItem(hand);
            // IFluidHandler handlerOutput = tileEntity.outputTank;

            if (item != FluidUtil.getFilledBucket(new FluidStack(FluidRegistry.WATER, 1000))) {
                IFluidHandler handler = tileEntity.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, EnumFacing.NORTH);
                FluidActionResult res = FluidUtils.interactWithFluidHandler(item, handler, playerIn);
                if (res.isSuccess()) {
                    playerIn.setHeldItem(hand, res.getResult());
                    return true;
                }
            }
            playerIn.openGui(Moonshiners.instance, Reference.GUI_BARREL, worldIn, pos.getX(), pos.getY(), pos.getZ());
            return true;
        }
        return true;
    }

    @Override
    public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state) {
        if (!worldIn.isRemote) {
            IBlockState north = worldIn.getBlockState(pos.north());
            IBlockState south = worldIn.getBlockState(pos.south());
            IBlockState west = worldIn.getBlockState(pos.west());
            IBlockState east = worldIn.getBlockState(pos.east());
            EnumFacing facing = state.getValue(FACING);

            if (facing == EnumFacing.NORTH && north.isFullBlock() && !south.isFullBlock()) facing = EnumFacing.SOUTH;
            else if (facing == EnumFacing.SOUTH && south.isFullBlock() && !north.isFullBlock()) facing = EnumFacing.NORTH;
            else if (facing == EnumFacing.WEST && west.isFullBlock() && !east.isFullBlock()) facing = EnumFacing.EAST;
            else if (facing == EnumFacing.EAST && east.isFullBlock() && !west.isFullBlock()) facing = EnumFacing.WEST;
            worldIn.setBlockState(pos, state.withProperty(FACING, facing), 2);
        }
    }

    public static void setState(boolean active, World worldIn, BlockPos pos) {
        IBlockState state = worldIn.getBlockState(pos);
        TileEntity tileEntity = worldIn.getTileEntity(pos);

        if (active) {
            worldIn.setBlockState(pos, MoonshinersBlocks.BARREL.getDefaultState().withProperty(FACING, state.getValue(FACING)), 3);
            worldIn.setBlockState(pos, MoonshinersBlocks.BARREL.getDefaultState().withProperty(FACING, state.getValue(FACING)), 3);
        }
        else {
            worldIn.setBlockState(pos, MoonshinersBlocks.BARREL.getDefaultState().withProperty(FACING, state.getValue(FACING)), 3);
            worldIn.setBlockState(pos, MoonshinersBlocks.BARREL.getDefaultState().withProperty(FACING, state.getValue(FACING)), 3);
        }

        if (tileEntity != null) {
            tileEntity.validate();
            worldIn.setTileEntity(pos, tileEntity);
        }
    }

    @Override
    public boolean hasTileEntity(IBlockState state) {
        return true;
    }

    @Nullable
    @Override
    @ParametersAreNonnullByDefault
    public TileEntity createTileEntity(World world, IBlockState state) {
        return new TileEntityBarrel();
    }

    @Override
    @ParametersAreNonnullByDefault
    public IBlockState getStateForPlacement(World world, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer, EnumHand hand) {
        return this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite());
    }

    @Override
    @SuppressWarnings("deprecation")
    public IBlockState withRotation(IBlockState state, Rotation rot) {
        return state.withProperty(FACING, rot.rotate(state.getValue(FACING)));
    }

    @Override
    @SuppressWarnings("deprecation")
    public IBlockState withMirror(IBlockState state, Mirror mirrorIn) {
        return state.withRotation(mirrorIn.toRotation(state.getValue(FACING)));
    }

    @Override
    protected BlockStateContainer createBlockState() {
        return new BlockStateContainer(this, FACING);
    }

    @Override
    @SuppressWarnings("deprecation")
    public IBlockState getStateFromMeta(int meta) {
        EnumFacing facing = EnumFacing.getFront(meta);
        if (facing.getAxis() == EnumFacing.Axis.Y) facing = EnumFacing.NORTH;
        return this.getDefaultState().withProperty(FACING, facing);
    }

    @Override
    public int getMetaFromState(IBlockState state) {
        return state.getValue(FACING).getIndex();
    }

    @Override
    @SuppressWarnings("deprecation")
    public boolean isOpaqueCube(IBlockState state) {
        return false;
    }

    @Override
    @SuppressWarnings("deprecation")
    public boolean isFullCube(IBlockState state) {
        return false;
    }
}

My TileEntity:

package io.yruel.moonshiners.tileentity;

import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.ITickable;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.fluids.*;
import net.minecraftforge.fluids.capability.CapabilityFluidHandler;

import javax.annotation.Nullable;

public class TileEntityBarrel extends TileEntity implements ITickable {

    public FluidTank inputTank = new FluidTank(2000);

    public FluidTank outputTank = new FluidTank(2000);

    @Override
    public void update() {
     /*   if (this.inputTank.getFluidAmount() > 0) {
            this.getTank(0).drain(1, true);
        }*/
    }

    @Override
    public boolean hasCapability(Capability<?> capability, @Nullable EnumFacing facing) {
        if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) {
            return true;
        }
        return this.getCapability(capability, facing) != null;
    }

    @Nullable
    @Override
    public <T> T getCapability(Capability<T> capability, @Nullable EnumFacing facing) {
        if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) {
            if (facing == EnumFacing.NORTH) {
                return CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY.cast(inputTank);
            } else if (facing == EnumFacing.SOUTH) {
                return CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY.cast(outputTank);
            }
        }
        return super.getCapability(capability, facing);
    }

    public boolean isUsableByPlayer(EntityPlayer playerIn) {
        return !isInvalid() && playerIn.getDistanceSq(pos.add(0.5D, 0.5D, 0.5D)) <= 64.0D;
    }

    @Override
    public NBTTagCompound writeToNBT(NBTTagCompound compound) {
        if (this.inputTank != null && this.inputTank.getFluid() != null) {
            compound.setTag("fluidDataInput", inputTank.getFluid().writeToNBT(new NBTTagCompound()));
            compound.setTag("inputTank", inputTank.writeToNBT(new NBTTagCompound()));
        }
        if (this.outputTank != null && this.outputTank.getFluid() != null) {
            compound.setTag("fluidDataOutput", outputTank.getFluid().writeToNBT(new NBTTagCompound()));
            compound.setTag("outputTank", outputTank.writeToNBT(new NBTTagCompound()));
        }
        return super.writeToNBT(compound);
    }

    @Override
    public void readFromNBT(NBTTagCompound compound) {
        super.readFromNBT(compound);
        if (compound.hasKey("fluidDataInput")) {
            this.inputTank.setFluid(FluidStack.loadFluidStackFromNBT(compound.getCompoundTag("fluidDataInput")));
        }
        if (compound.hasKey("fluidDataOutput")) {
            this.outputTank.setFluid(FluidStack.loadFluidStackFromNBT(compound.getCompoundTag("fluidDataOutput")));
        }
        if (inputTank != null && inputTank.getFluid() != null && compound.hasKey("inputTank")) {
            inputTank.readFromNBT(compound.getCompoundTag("inputTank"));
        }
        if (this.inputTank != null) {
            this.inputTank.setTileEntity(this);
        }
        if (outputTank != null && outputTank.getFluid() != null && compound.hasKey("outputTank")) {
            inputTank.readFromNBT(compound.getCompoundTag("outputTank"));
        }
        if (this.outputTank != null) {
            this.outputTank.setTileEntity(this);
        }
    }
}

My Container:

package io.yruel.moonshiners.container;

import io.yruel.moonshiners.tileentity.TileEntityBarrel;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.Slot;

public class ContainerBarrel extends Container {
    private final TileEntityBarrel tileEntity;

    public ContainerBarrel(InventoryPlayer player, TileEntityBarrel tileEntity) {
        this.tileEntity = tileEntity;

        for (int y = 0; y < 3; y++) {
            for (int x = 0; x < 9; x++) {
                this.addSlotToContainer(new Slot(player, x + y * 9 + 9, 8 + x * 18, 84 + y * 18));
            }
        }

        for (int x = 0; x < 9; x++) {
            this.addSlotToContainer(new Slot(player, x, 8 + x * 18, 142));
        }
    }

    @Override
    public boolean canInteractWith(EntityPlayer playerIn) {
        return this.tileEntity.isUsableByPlayer(playerIn);
    }
}

And my GUI:

package io.yruel.moonshiners.gui;

import io.yruel.moonshiners.container.ContainerBarrel;
import io.yruel.moonshiners.tileentity.TileEntityBarrel;
import io.yruel.moonshiners.util.Reference;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.client.renderer.texture.TextureMap;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidRegistry;
import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
import net.minecraftforge.fml.client.config.GuiUtils;
import org.lwjgl.opengl.GL11;

import java.awt.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class GuiBarrel extends GuiContainer {
    private static final ResourceLocation TEXTURES = new ResourceLocation(Reference.ID + ":textures/gui/barrel.png");
    private final InventoryPlayer player;
    private final TileEntityBarrel tileEntity;

    protected Rectangle fluidBar = new Rectangle(36, 12, 16, 60);

    public GuiBarrel(InventoryPlayer player, TileEntityBarrel tileEntity) {
        super(new ContainerBarrel(player, tileEntity));
        this.player = player;
        this.tileEntity = tileEntity;
    }

    @Override
    protected void drawGuiContainerBackgroundLayer(float partialTicks, int mouseX, int mouseY) {
        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
        this.mc.getTextureManager().bindTexture(TEXTURES);
        this.drawTexturedModalRect(this.guiLeft, this.guiTop, 0, 0, this.xSize, this.ySize);

        this.renderFluid();

        if (this.isPointInRegion(fluidBar.x, fluidBar.y, fluidBar.width, fluidBar.height, mouseX, mouseY)) {
            List<String> inputFluid = new ArrayList<>();
            //inputFluid.add(Objects.requireNonNull(tileEntity.inputTank.getFluid()).amount + " / " + tileEntity.inputTank.getCapacity() + " MB");
            inputFluid.add(tileEntity.inputTank.getFluidAmount() + " / " + tileEntity.inputTank.getCapacity() + " MB");
            GuiUtils.drawHoveringText(inputFluid, mouseX, mouseY, mc.displayWidth, mc.displayHeight, -1, mc.fontRenderer);
        }
    }

    private void renderFluid() {
        Fluid fluid = FluidRegistry.WATER;
        TextureAtlasSprite fluidTexture = mc.getTextureMapBlocks().getTextureExtry(fluid.getStill().toString());
        mc.renderEngine.bindTexture(TextureMap.LOCATION_BLOCKS_TEXTURE);
        int fluidHeight = (int) ((double) (tileEntity.inputTank.getFluidAmount()) / (double) (tileEntity.inputTank.getCapacity()) * fluidBar.height);
        if (tileEntity.inputTank.getFluidAmount() == 0) {
            fluidHeight = 0;
        }
        if (tileEntity.inputTank.getFluidAmount() == tileEntity.inputTank.getCapacity()) {
            fluidHeight = fluidBar.height;
        }
        this.drawTexturedModalRect(this.guiLeft + fluidBar.x, this.guiTop + fluidBar.y + (fluidBar.height - fluidHeight), fluidTexture, fluidBar.width, fluidHeight);
    }
}