package ShadoTECH.TileEntity;

import java.util.List;

import ic2.api.energy.event.EnergyTileLoadEvent;
import ic2.api.energy.event.EnergyTileUnloadEvent;
import ic2.api.energy.tile.IEnergySink;
import ic2.api.energy.tile.IEnergySource;
import ic2.api.energy.tile.IEnergyTile;
import ic2.api.network.INetworkDataProvider;
import ic2.api.network.INetworkUpdateListener;
import ic2.api.tile.IWrenchable;
import net.minecraft.entity.player.EntityPlayer;
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 cofh.api.energy.*;

public class TileEntity_Energy_Converter extends TileEntity implements IEnergySink, IEnergyHandler
{
    public double energy = 0.0D;
    public double maxEnergy = 10000.0D;
    private boolean init;
    private int eu_rf = 3;

    public void readFromNBT(NBTTagCompound tag)
    {
        super.readFromNBT(tag);
        if(tag.hasKey("energy"))
        {
            this.energy = tag.getDouble("energy");
        }
    }

    public void writeToNBT(NBTTagCompound tag)
    {
        super.writeToNBT(tag);
        tag.setDouble("energy", this.energy);
    }

    @Override
    public void updateEntity()
    {
        if(!init && worldObj != null)
        {
            if(!worldObj.isRemote)
            {
                EnergyTileLoadEvent loadEvent = new EnergyTileLoadEvent(this);
                MinecraftForge.EVENT_BUS.post(loadEvent);
            }
            init = true;
        }
    }

    @Override
    public void invalidate()
    {
        EnergyTileUnloadEvent unloadEvent = new EnergyTileUnloadEvent(this);
        MinecraftForge.EVENT_BUS.post(unloadEvent);
    }

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

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

    @Override
    public int getSinkTier()
    {
        return 3;
    }

    @Override
    public double injectEnergy(ForgeDirection directionFrom, double amount, double voltage)
    {
        if(this.energy >= this.maxEnergy) return amount;
        double openEnergy = this.maxEnergy - this.energy;
        if(openEnergy >= amount)
        {
            this.energy += amount;
            return 0.0D;
        }
        else if(amount > openEnergy)
        {
            this.energy = this.maxEnergy;
            return amount - openEnergy;
        }
        return 0;
    }

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

    @Override
    public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate)
    {
        if(this.energy < 0) this.energy = 0;
        return 200;
    }

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

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

    @Override
    public int getMaxEnergyStored(ForgeDirection from)
    {
        return (int) this.maxEnergy;
    }
    //RF
}