PoweredTileEntity

package com.arisux.avp.entities.tile;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;

import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.NetworkManager;
import net.minecraft.network.Packet;
import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;

import com.arisux.avp.interfaces.IPowerDevice;

public abstract class PoweredTileEntity extends TileEntity implements IPowerDevice
{
    public double voltage, amps;
    public boolean circuitConnectedToPower;
    public ArrayList<PoweredTileEntity> arrayAdded = new ArrayList<PoweredTileEntity>();
    @Override
    public void updateEntity()
    {
        super.updateEntity();

        if (this.isVoltageInOperatingRange())
        {
            this.onVoltageTick();
        }

        if (this.voltage > this.getMaxOperatingVoltage())
        {
            this.onOverloadTick();
        }

        if (this.voltage <= this.getMinOperatingVoltage())
        {
            this.onUnderloadTick();
        }

        if (this.getPowerSourceTile() == null)
        {
            this.voltage = 0;
        }

        if (this.canOutputPower())
        {
            this.outputPower();
        }

        if(!this.isConnectedToPower(this))
        {
            this.circuitConnectedToPower = false;
            this.voltage = 0;
        }
    }

    public boolean isConnectedToPower(PoweredTileEntity e){
        try{
        List<PoweredTileEntity> list = new ArrayList<PoweredTileEntity>();
        list.add(e);
        list.add(e.getTop());
        list.add(e.getBack());
        list.add(e.getBottom());
        list.add(e.getLeft());
        list.add(e.getRight());
        list.add(e.getFront());

        for(PoweredTileEntity te : list){
            if(arrayAdded.contains(te)){
            if(e instanceof TileEntitySolarPanel || e instanceof TileEntityRepulsionGenerator){
                arrayAdded.add(te);
                return true;
            }
            else{
                arrayAdded.add(te.getTop());
                if(isConnectedToPower(te.getTop())){
                    return isConnectedToPower(te.getTop());
                }
                arrayAdded.add(te.getBack());
                if(isConnectedToPower(te.getBack())){
                    return isConnectedToPower(te.getBack());
                }
                arrayAdded.add(te.getBottom());
                if(isConnectedToPower(te.getBottom())){
                    return isConnectedToPower(te.getBottom());
                }
                arrayAdded.add(te.getLeft());
                if(isConnectedToPower(te.getLeft())){
                    return isConnectedToPower(te.getLeft());
                }
                arrayAdded.add(te.getRight());
                if(isConnectedToPower(te.getRight())){
                    return isConnectedToPower(te.getRight());
                }
                arrayAdded.add(te.getFront());
                if(isConnectedToPower(te.getFront())){
                    return isConnectedToPower(te.getRight());
                }

                else if(!isConnectedToPower(te.getFront()) && !isConnectedToPower(te.getRight()) && !isConnectedToPower(te.getLeft()) && !isConnectedToPower(te.getBottom()) && !isConnectedToPower(te.getBack()) && !isConnectedToPower(te.getTop())){
                    return false;
                }
            }
            }
        }
        }catch(NullPointerException exception){
            //Nothin
        }
        return false;
    }

        //while(ite.hasNext()){
        //  PoweredTileEntity e = ite.next();
        //  if (e instanceof TileEntitySolarPanel || e instanceof TileEntityRepulsionGenerator){
        //      arrayAdded.add(e);
        //      circuitConnectedToPower = true;
        //      return true;
        //  }
        //  else if (e instanceof TileEntityPowerline || e instanceof TileEntityTransformer || e instanceof TileEntityNegativeTransformer || e instanceof TileEntityCryostasisTube){
        //      if(arrayAdded.contains(e)){
        //          break;
        //      }
        //      else{
        //          ite.add(e.getTop());
        //          ite.add(e.getBack());
        //          ite.add(e.getBottom());
        //          ite.add(e.getLeft());
        //          ite.add(e.getRight());
        //          ite.add(e.getFront());
        //          arrayAdded.add(e);
        //          ite = list.listIterator();
        ///     }
        /// }
        /// else if(e == null){
        //      circuitConnectedToPower = false;
            //  return false;
        //  }
        //}
        //  return false;
    //}
    public void outputPower()
    {
        double voltage = this.getVoltageAfterApplyingResistance();

        this.outputPowerToTile(this.getTop(), voltage);
        this.outputPowerToTile(this.getBottom(), voltage);
        this.outputPowerToTile(this.getFront(), voltage);
        this.outputPowerToTile(this.getBack(), voltage);
        this.outputPowerToTile(this.getLeft(), voltage);
        this.outputPowerToTile(this.getRight(), voltage);
    }

    public void outputPowerToTile(PoweredTileEntity tile, double voltage)
    {
        if (tile != null && tile.getPowerSourceTile() == this)
        {
            tile.setVoltage(voltage);
        }
        else if(tile != null && tile instanceof TileEntityPowerline && tile.getVoltage() == 0){
            tile.setVoltage(this.getVoltage());
        }
    }

    @Override
    public abstract void onVoltageTick();

    @Override
    public abstract void onOverloadTick();

    @Override
    public abstract void onUnderloadTick();

    @Override
    public Packet getDescriptionPacket()
    {
        NBTTagCompound nbtTag = new NBTTagCompound();
        this.writeToNBT(nbtTag);
        return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, 1, nbtTag);
    }

    @Override
    public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity packet)
    {
        readFromNBT(packet.func_148857_g());
    }

    @Override
    public void writeToNBT(NBTTagCompound tag)
    {
        super.writeToNBT(tag);

        tag.setDouble("Volts", this.voltage);
        tag.setDouble("Amps", this.amps);
    }

    @Override
    public void readFromNBT(NBTTagCompound tag)
    {
        super.readFromNBT(tag);

        this.voltage = tag.getDouble("Volts");
        this.amps = tag.getDouble("Amps");
    }

    public void setVoltage(double voltageIn)
    {
        this.voltage = voltageIn;
    }

    public double getVoltageAfterApplyingResistance()
    {
        return this.getVoltage() - this.getResistance() <= 0 ? 0 : this.getVoltage() - this.getResistance();
    }

    public void setAmps(double ampsIn)
    {
        this.amps = ampsIn;
    }

    public PoweredTileEntity getPoweredTileAt(int x, int y, int z)
    {
        return this.worldObj.getTileEntity(x, y, z) instanceof PoweredTileEntity ? (PoweredTileEntity) this.worldObj.getTileEntity(x, y, z) : null;
    }

    public PoweredTileEntity getPowerSourceTile()
    {
        if (getTop() != null && getTop().isOutputVoltageHigherThan(this) && getTop().canOutputPower())
        {
            return getTop();
        }
        if (getBottom() != null && getBottom().isOutputVoltageHigherThan(this) && getBottom().canOutputPower())
        {
            return getBottom();
        }
        if (getFront() != null && getFront().isOutputVoltageHigherThan(this) && getFront().canOutputPower())
        {
            return getFront();
        }
        if (getBack() != null && getBack().isOutputVoltageHigherThan(this) && getBack().canOutputPower())
        {
            return getBack();
        }
        if (getLeft() != null && getLeft().isOutputVoltageHigherThan(this) && getLeft().canOutputPower())
        {
            return getLeft();
        }
        if (getRight() != null && getRight().isOutputVoltageHigherThan(this) && getRight().canOutputPower())
        {
            return getRight();
        }
        if (getTop() instanceof TileEntityTransformer)
        {
            TileEntityTransformer t = (TileEntityTransformer)getTop();
            if(!t.isOriginalPowerSourceAttached()){
                return null;
            }
            return (PoweredTileEntity) t.getPowerSource();
        }
        if (getBottom() instanceof TileEntityTransformer)
        {
            TileEntityTransformer t = (TileEntityTransformer)getBottom();
            if(!t.isOriginalPowerSourceAttached()){
                return null;
            }
            return (PoweredTileEntity) t.getPowerSource();
        }
        if (getFront() instanceof TileEntityTransformer)
        {
            TileEntityTransformer t = (TileEntityTransformer)getFront();
            if(!t.isOriginalPowerSourceAttached()){
                return null;
            }
            return (PoweredTileEntity) t.getPowerSource();
        }
        if (getBack() instanceof TileEntityTransformer)
        {
            TileEntityTransformer t = (TileEntityTransformer)getBack();
            if(!t.isOriginalPowerSourceAttached()){
                return null;
            }
            return (PoweredTileEntity) t.getPowerSource();
        }
        if (getLeft() instanceof TileEntityTransformer)
        {
            TileEntityTransformer t = (TileEntityTransformer)getLeft();
            if(!t.isOriginalPowerSourceAttached()){
                return null;
            }
            return (PoweredTileEntity) t.getPowerSource();
        }
        if (getRight() instanceof TileEntityTransformer)
        {
            TileEntityTransformer t = (TileEntityTransformer)getRight();
            if(!t.isOriginalPowerSourceAttached()){
                return null;
            }
            return (PoweredTileEntity) t.getPowerSource();
        }
        if (getTop() instanceof TileEntityNegativeTransformer)
        {
            TileEntityNegativeTransformer t = (TileEntityNegativeTransformer)getTop();
            if(!t.isOriginalPowerSourceAttached()){
                return null;
            }
            return (PoweredTileEntity) t.getPowerSource();
        }
        if (getBottom() instanceof TileEntityNegativeTransformer)
        {
            TileEntityNegativeTransformer t = (TileEntityNegativeTransformer)getBottom();
            if(!t.isOriginalPowerSourceAttached()){
                return null;
            }
            return (PoweredTileEntity) t.getPowerSource();
        }
        if (getFront() instanceof TileEntityNegativeTransformer)
        {
            TileEntityNegativeTransformer t = (TileEntityNegativeTransformer)getFront();
            if(!t.isOriginalPowerSourceAttached()){
                return null;
            }
            return (PoweredTileEntity) t.getPowerSource();
        }
        if (getBack() instanceof TileEntityNegativeTransformer)
        {
            TileEntityNegativeTransformer t = (TileEntityNegativeTransformer)getBack();
            if(!t.isOriginalPowerSourceAttached()){
                return null;
            }
            return (PoweredTileEntity) t.getPowerSource();
        }
        if (getLeft() instanceof TileEntityNegativeTransformer)
        {
            TileEntityNegativeTransformer t = (TileEntityNegativeTransformer)getLeft();
            if(!t.isOriginalPowerSourceAttached()){
                return null;
            }
            return (PoweredTileEntity) t.getPowerSource();
        }
        if (getRight() instanceof TileEntityNegativeTransformer)
        {
            TileEntityNegativeTransformer t = (TileEntityNegativeTransformer)getRight();
            if(!t.isOriginalPowerSourceAttached()){
                return null;
            }
            return (PoweredTileEntity) t.getPowerSource();
        }
        return null;
    }

    public boolean isVoltageInOperatingRange()
    {
        return this.getVoltage() < this.getMaxOperatingVoltage() && this.getVoltage() > this.getMinOperatingVoltage();
    }

    public boolean isPowered()
    {
        return this.getVoltage() != 0;
    }

    public boolean isOutputVoltageLessThan(PoweredTileEntity device)
    {
        return this.getVoltage() < device.getVoltage();
    }

    public boolean isOutputVoltageHigherThan(PoweredTileEntity device)
    {
        return this.getVoltage() > device.getVoltage();
    }

    public PoweredTileEntity getTop()
    {
        return this.getPoweredTileAt(this.xCoord, this.yCoord + 1, this.zCoord);
    }

    public PoweredTileEntity getBottom()
    {
        return this.getPoweredTileAt(this.xCoord, this.yCoord - 1, this.zCoord);
    }

    public PoweredTileEntity getFront()
    {
        return this.getPoweredTileAt(this.xCoord, this.yCoord, this.zCoord - 1);
    }

    public PoweredTileEntity getBack()
    {
        return this.getPoweredTileAt(this.xCoord, this.yCoord, this.zCoord + 1);
    }

    public PoweredTileEntity getRight()
    {
        return this.getPoweredTileAt(this.xCoord - 1, this.yCoord, this.zCoord);
    }

    public PoweredTileEntity getLeft()
    {
        return this.getPoweredTileAt(this.xCoord + 1, this.yCoord, this.zCoord);
    }

    @Override
    public double getVoltage()
    {
        return this.voltage;
    }

    @Override
    public double getMaxOperatingVoltage()
    {
        return 140;
    }

    @Override
    public double getMinOperatingVoltage()
    {
        return 110;
    }

    @Override
    public double getAmperage()
    {
        return this.amps;
    }

    @Override
    public double getMaxOperatingAmps()
    {
        return 4;
    }

    @Override
    public double getMinOperatingAmps()
    {
        return 1;
    }

    @Override
    public double getResistance()
    {
        return 0.1;
    }

    @Override
    public boolean canOutputPower()
    {
        return false;
    }
}