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;
import com.google.common.collect.Lists;

public abstract class PoweredTileEntity extends TileEntity implements IPowerDevice
{
	public double voltage, amps;
	public boolean state = false;

	@Override
	public void updateEntity()
	{
		super.updateEntity();

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

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

		if(!this.state)
		{
			this.voltage = 0;
		}

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

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

	private boolean isConnectedToAnything(PoweredTileEntity poweredTileEntity) {
		List<PoweredTileEntity> list = new ArrayList<PoweredTileEntity>();
		list.add(poweredTileEntity.getTop());
		list.add(poweredTileEntity.getBack());
		list.add(poweredTileEntity.getBottom());
		list.add(poweredTileEntity.getLeft());
		list.add(poweredTileEntity.getRight());
		list.add(poweredTileEntity.getFront());
		for(PoweredTileEntity te : list)
		{
			if(te instanceof TileEntitySolarPanel || te instanceof TileEntityRepulsionGenerator || te instanceof TileEntityPowerline || te instanceof TileEntityR2PConvertor){
				if(te instanceof TileEntityR2PConvertor)
				{
					TileEntityR2PConvertor ter = (TileEntityR2PConvertor) te;
					if(ter.isActiveRedstoneWireAttached)
					{
						return true;
					}
					else
					{
						return false;
					}
				}
				return true;
			}
		}
		return false;
	}

	public boolean isPowerSource(){
		if(this.canOutputPower() && getPowerSourceTile(this) == this){
			return true;
		}
		return false;
	}
	public void outputPower()
	{
		double voltage = this.getVoltageAfterApplyingResistance();
		List<PoweredTileEntity> list = Lists.newArrayList(this.children);
		for(PoweredTileEntity e : list)
		{
			this.outputPowerToTile(e, voltage);
		}
	}

	public void outputPowerToTile(PoweredTileEntity tile, double voltage)
	{
		if (tile != null && tile.getPowerSourceTile(tile) == 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 void updateChildren()
	{
		if(this.children.size() > 0)
		{
			if(this.children.contains(this))
			{
				this.children.remove(this);
			}
			if(this.children.size() > 0)
			{
				List <PoweredTileEntity> list = Lists.newArrayList(this.children);
				for(PoweredTileEntity te : list)
				{
					if(te == null);
					else
					{
						te.state = this.state;
						te.updateChildren();
					}
				}
			}
		}
	}

	@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(PoweredTileEntity e){
		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;
	}
}