package mffs.base;

import mffs.MFFSHelper;
import mffs.Settings;
import mffs.TransferMode;
import mffs.api.ISpecialForceManipulation;
import mffs.api.card.ICard;
import mffs.api.fortron.IFortronFrequency;
import mffs.fortron.FortronHelper;
import mffs.fortron.FrequencyGrid;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTBase;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.NetworkManager;
import net.minecraft.network.Packet;
import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTank;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidHandler;
import universalelectricity.core.vector.Vector3;

public abstract class TileEntityFortron extends TileEntityFrequency
    implements IFluidHandler, IFortronFrequency, ISpecialForceManipulation {
    protected FluidTank fortronTank;
    private boolean markSendFortron;

    public TileEntityFortron() {
        this.fortronTank = new FluidTank(FortronHelper.FLUID_FORTRON, 0, 1000);
        this.markSendFortron = true;
    }

    @Override
    public void updateEntity() {
        super.updateEntity();
        if (!Settings.CONSERVE_PACKETS && super.ticks % 60L == 0L) {
            this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord);
        }
    }

    @Override
    public void invalidate() {
        if (this.markSendFortron) {
            MFFSHelper.transferFortron(
                this,
                FrequencyGrid.instance().getFortronTiles(
                    this.worldObj, new Vector3(this), 100, this.getFrequency()
                ),
                TransferMode.DRAIN,
                Integer.MAX_VALUE
            );
        }
        super.invalidate();
    }

    @Override
    public Packet getDescriptionPacket() {
        NBTTagCompound nbt = new NBTTagCompound();

        nbt.setInteger("fortron", this.fortronTank.getFluidAmount());
        nbt.setBoolean("isActive", this.isActive());

        return new S35PacketUpdateTileEntity(
            this.xCoord, this.yCoord, this.zCoord, this.getBlockMetadata(), nbt
        );
    }

    @Override
    public void onDataPacket(NetworkManager arg0, S35PacketUpdateTileEntity arg1) {
        NBTTagCompound nbt = arg1.func_148857_g();

        this.fortronTank.setFluid(
            new FluidStack(FortronHelper.FLUID_FORTRON, nbt.getInteger("fortron"))
        );
        this.isActive = nbt.getBoolean("isActive");
    }

    @Override
    public boolean preMove(final int x, final int y, final int z) {
        return true;
    }

    @Override
    public void move(final int x, final int y, final int z) {
        this.markSendFortron = false;
    }

    @Override
    public void postMove() {}

    @Override
    public void readFromNBT(final NBTTagCompound nbt) {
        super.readFromNBT(nbt);
        this.fortronTank.setFluid(
            FluidStack.loadFluidStackFromNBT(nbt.getCompoundTag("fortron"))
        );
    }

    @Override
    public void writeToNBT(final NBTTagCompound nbt) {
        super.writeToNBT(nbt);
        if (this.fortronTank.getFluid() != null) {
            final NBTTagCompound fortronCompound = new NBTTagCompound();
            this.fortronTank.getFluid().writeToNBT(fortronCompound);
            nbt.setTag("fortron", (NBTBase) fortronCompound);
        }
    }

    @Override
    public int
    fill(final ForgeDirection from, final FluidStack resource, final boolean doFill) {
        if (resource.getFluid() == FortronHelper.FLUID_FORTRON) {
            return this.fortronTank.fill(resource, doFill);
        }
        return 0;
    }

    @Override
    public boolean canFill(ForgeDirection arg0, Fluid arg1) {
        return arg1 == FortronHelper.FLUID_FORTRON
            && this.fortronTank.getFluidAmount() < this.fortronTank.getCapacity();
    }

    @Override
    public FluidStack
    drain(final ForgeDirection from, final int maxDrain, final boolean doDrain) {
        return this.fortronTank.drain(maxDrain, doDrain);
    }

    @Override
    public FluidStack drain(ForgeDirection arg0, FluidStack arg1, boolean arg2) {
        if (arg1.getFluid() != FortronHelper.FLUID_FORTRON)
            return null;

        return this.fortronTank.drain(arg1.amount, arg2);
    }

    @Override
    public boolean canDrain(ForgeDirection arg0, Fluid arg1) {
        return arg1 == FortronHelper.FLUID_FORTRON
            && this.fortronTank.getFluidAmount() > 0;
    }

    @Override
    public FluidTankInfo[] getTankInfo(ForgeDirection arg0) {
        return new FluidTankInfo[] { new FluidTankInfo(this.fortronTank) };
    }

    public void setFortronEnergy(final int joules) {
        this.fortronTank.setFluid(FortronHelper.getFortron(joules));
    }

    public int getFortronEnergy() {
        return FortronHelper.getAmount(this.fortronTank);
    }

    public int getFortronCapacity() {
        return this.fortronTank.getCapacity();
    }

    public int requestFortron(final int amount, final boolean doUse) {
        return FortronHelper.getAmount(this.fortronTank.drain(amount, doUse));
    }

    public int provideFortron(final int joules, final boolean doUse) {
        return this.fortronTank.fill(FortronHelper.getFortron(joules), doUse);
    }

    public ItemStack getCard() {
        final ItemStack itemStack = this.getStackInSlot(0);
        if (itemStack != null && itemStack.getItem() instanceof ICard) {
            return itemStack;
        }
        return null;
    }
}