src/main/java/mekanism/api/transmitters/DynamicNetwork.java

package mekanism.api.transmitters;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Set;

import mekanism.api.Coord4D;
import mekanism.api.IClientTicker;
import mekanism.api.Range4D;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.common.util.ForgeDirection;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.eventhandler.Event;

public abstract class DynamicNetwork<A, N extends DynamicNetwork<A, N>> implements ITransmitterNetwork<A, N>, IClientTicker, INetworkDataHandler
{
	public LinkedHashSet<IGridTransmitter<N>> transmitters = new LinkedHashSet<IGridTransmitter<N>>();

	public HashMap<Coord4D, A> possibleAcceptors = new HashMap<Coord4D, A>();
	public HashMap<A, ForgeDirection> acceptorDirections = new HashMap<A, ForgeDirection>();

	private List<DelayQueue> updateQueue = new ArrayList<DelayQueue>();
	
	protected Range4D packetRange = null;

	protected int ticksSinceCreate = 0;
	
	protected int capacity = 0;
	protected double meanCapacity = 0;
	
	protected boolean fixed = false;

	protected boolean needsUpdate = false;

	protected abstract ITransmitterNetwork<A, N> create(IGridTransmitter<N>... varTransmitters);

	protected abstract ITransmitterNetwork<A, N> create(Collection<IGridTransmitter<N>> collection);

	protected abstract ITransmitterNetwork<A, N> create(Set<N> networks);
	
	protected void clearAround(IGridTransmitter<N> transmitter)
	{
		for(ForgeDirection side : ForgeDirection.VALID_DIRECTIONS)
		{
			Coord4D coord = Coord4D.get(transmitter.getTile()).getFromSide(side);
			
			if(possibleAcceptors.containsKey(coord))
			{
				clearIfNecessary(coord, transmitter, side.getOpposite());
			}
		}
	}
	
	protected void clearIfNecessary(Coord4D acceptor, IGridTransmitter<N> transmitter, ForgeDirection side)
	{
		if(getWorld() == null)
		{
			return;
		}
		
		if(acceptor.getTileEntity(getWorld()) == null || acceptor.getTileEntity(getWorld()).isInvalid() || transmitter.canConnectToAcceptor(side, true))
		{
			possibleAcceptors.remove(acceptor);
			acceptorDirections.remove(acceptor.getTileEntity(getWorld()));
		}
	}

	public void addAllTransmitters(Set<IGridTransmitter<N>> newTransmitters)
	{
		transmitters.addAll(newTransmitters);
		updateCapacity();
	}

	public boolean isFirst(IGridTransmitter<N> transmitter)
	{
		return transmitters.iterator().next().equals(transmitter);
	}
	
	@Override
	public void fullRefresh()
	{
		possibleAcceptors.clear();
		acceptorDirections.clear();
		
		for(IGridTransmitter<N> transmitter : transmitters)
		{
			refresh(transmitter);
		}
		
		refresh();
	}
	
	public Range4D getPacketRange()
	{
		if(packetRange == null)
		{
			return genPacketRange();
		}
		
		return packetRange;
	}
	
	public World getWorld()
	{
		if(getSize() == 0)
		{
			return null;
		}
		
		return transmitters.iterator().next().getTile().getWorldObj();
	}
	
	protected Range4D genPacketRange()
	{
		if(getSize() == 0)
		{
			deregister();
			return null;
		}
		
		Coord4D initCoord = Coord4D.get(transmitters.iterator().next().getTile());
		
		int minX = initCoord.xCoord;
		int minY = initCoord.yCoord;
		int minZ = initCoord.zCoord;
		int maxX = initCoord.xCoord;
		int maxY = initCoord.yCoord;
		int maxZ = initCoord.zCoord;
		
		for(IGridTransmitter transmitter : transmitters)
		{
			Coord4D coord = Coord4D.get(transmitter.getTile());
			
			if(coord.xCoord < minX) minX = coord.xCoord;
			if(coord.yCoord < minY) minY = coord.yCoord;
			if(coord.zCoord < minZ) minZ = coord.zCoord;
			if(coord.xCoord > maxX) maxX = coord.xCoord;
			if(coord.yCoord > maxY) maxY = coord.yCoord;
			if(coord.zCoord > maxZ) maxZ = coord.zCoord;
		}
		
		return new Range4D(minX, minY, minZ, maxX, maxY, maxZ, getWorld().provider.dimensionId);
	}

	@Override
	public void removeTransmitter(IGridTransmitter<N> transmitter)
	{
		transmitters.remove(transmitter);
		updateCapacity();
		
		if(transmitters.size() == 0)
		{
			deregister();
		}
	}

	@Override
	public void register()
	{
		try {
			IGridTransmitter<N> aTransmitter = transmitters.iterator().next();

			if(aTransmitter instanceof TileEntity)
			{
				if(!((TileEntity)aTransmitter).getWorldObj().isRemote)
				{
					TransmitterNetworkRegistry.getInstance().registerNetwork(this);
				}
				else {
					MinecraftForge.EVENT_BUS.post(new ClientTickUpdate(this, (byte)1));
				}
			}
		} catch(NoSuchElementException e) {}
	}

	@Override
	public void deregister()
	{
		transmitters.clear();

		if(FMLCommonHandler.instance().getEffectiveSide().isServer())
		{
			TransmitterNetworkRegistry.getInstance().removeNetwork(this);
		}
		else {
			MinecraftForge.EVENT_BUS.post(new ClientTickUpdate(this, (byte)0));
		}
	}

	@Override
	public int getSize()
	{
		return transmitters.size();
	}

	@Override
	public int getAcceptorSize()
	{
		return possibleAcceptors.size();
	}

	public synchronized void updateCapacity() 
	{
		updateMeanCapacity();
		capacity = (int)meanCapacity * transmitters.size();
	}

    /**
     * Override this if things can have variable capacity along the network.
     * @return An 'average' value of capacity. Calculate it how you will.
     */
	protected synchronized void updateMeanCapacity() 
	{
		if(transmitters.size() > 0) 
		{
			meanCapacity = transmitters.iterator().next().getCapacity();
		} 
		else {
			meanCapacity = 0;
		}
	}
	
    public int getCapacity()
    {
    	return capacity;
    }

    public double getMeanCapacity()
    {
    	return meanCapacity;
    }
	
	@Override
	public void tick()
	{
		boolean didFix = false;

		if(!fixed)
		{
			ticksSinceCreate++;

			if(transmitters.size() == 0)
			{
				deregister();
				return;
			}

			if(ticksSinceCreate > 1200)
			{
				ticksSinceCreate = 0;
				fixMessedUpNetwork(transmitters.iterator().next());
				didFix = true;
			}
		}

		if(!didFix)
		{
			onUpdate();
		}
	}

	public void onUpdate()
	{
		if(FMLCommonHandler.instance().getEffectiveSide().isServer())
		{
			Iterator<DelayQueue> i = updateQueue.iterator();

			try {
				while(i.hasNext())
				{
					DelayQueue q = i.next();

					if(q.delay > 0)
					{
						q.delay--;
					}
					else {
						needsUpdate = true;
						i.remove();
					}
				}
			} catch(Exception e) {}
		}
	}

	@Override
	public synchronized void fixMessedUpNetwork(IGridTransmitter<N> transmitter)
	{
		if(transmitter instanceof TileEntity)
		{
			NetworkFinder finder = new NetworkFinder(((TileEntity)transmitter).getWorldObj(), getTransmissionType(), Coord4D.get((TileEntity)transmitter));
			List<Coord4D> partNetwork = finder.exploreNetwork();
			Set<IGridTransmitter<N>> newTransporters = new HashSet<IGridTransmitter<N>>();

			for(Coord4D node : partNetwork)
			{
				TileEntity nodeTile = node.getTileEntity(((TileEntity)transmitter).getWorldObj());

				if(TransmissionType.checkTransmissionType(nodeTile, getTransmissionType(), (TileEntity)transmitter))
				{
					((IGridTransmitter<N>)nodeTile).removeFromTransmitterNetwork();
					newTransporters.add((IGridTransmitter<N>)nodeTile);
				}
			}

			ITransmitterNetwork<A, N> newNetwork = create(newTransporters);
			newNetwork.fullRefresh();
			newNetwork.setFixed(true);
			deregister();
		}
	}

	@Override
	public synchronized void split(IGridTransmitter<N> splitPoint)
	{
		if(splitPoint instanceof TileEntity)
		{
			removeTransmitter(splitPoint);

			TileEntity[] connectedBlocks = new TileEntity[6];
			boolean[] dealtWith = {false, false, false, false, false, false};
			List<ITransmitterNetwork<A, N>> newNetworks = new ArrayList<ITransmitterNetwork<A, N>>();

			for(ForgeDirection side : ForgeDirection.VALID_DIRECTIONS)
			{
				TileEntity sideTile = Coord4D.get((TileEntity)splitPoint).getFromSide(side).getTileEntity(((TileEntity)splitPoint).getWorldObj());

				if(sideTile != null)
				{
					connectedBlocks[side.ordinal()] = sideTile;
				}
			}

			for(int count = 0; count < connectedBlocks.length; count++)
			{
				TileEntity connectedBlockA = connectedBlocks[count];

				if(TransmissionType.checkTransmissionType(connectedBlockA, getTransmissionType()) && !dealtWith[count])
				{
					NetworkFinder finder = new NetworkFinder(((TileEntity)splitPoint).getWorldObj(), getTransmissionType(), Coord4D.get(connectedBlockA), Coord4D.get((TileEntity)splitPoint));
					List<Coord4D> partNetwork = finder.exploreNetwork();

					for(int check = count; check < connectedBlocks.length; check++)
					{
						if(check == count)
						{
							continue;
						}

						TileEntity connectedBlockB = connectedBlocks[check];

						if(TransmissionType.checkTransmissionType(connectedBlockB, getTransmissionType()) && !dealtWith[check])
						{
							if(partNetwork.contains(Coord4D.get(connectedBlockB)))
							{
								dealtWith[check] = true;
							}
						}
					}

					Set<IGridTransmitter<N>> newNetCables = new HashSet<IGridTransmitter<N>>();

					for(Coord4D node : finder.iterated)
					{
						TileEntity nodeTile = node.getTileEntity(((TileEntity)splitPoint).getWorldObj());

						if(TransmissionType.checkTransmissionType(nodeTile, getTransmissionType()))
						{
							if(nodeTile != splitPoint)
							{
								newNetCables.add((IGridTransmitter<N>)nodeTile);
							}
						}
					}

					newNetworks.add(create(newNetCables));
				}
			}

			if(newNetworks.size() > 0)
			{
				onNetworksCreated((List)newNetworks);

				for(ITransmitterNetwork<A, N> network : newNetworks)
				{
					network.fullRefresh();
				}
			}

			deregister();
		}
	}

	@Override
	public void onNetworksCreated(List<N> networks) {}

	@Override
	public void setFixed(boolean value)
	{
		fixed = value;
	}

	@Override
	public boolean needsTicks()
	{
		return getSize() > 0;
	}

	@Override
	public void clientTick()
	{
		ticksSinceCreate++;

		if(ticksSinceCreate == 5 && getSize() > 0)
		{
			TileEntity tile = (TileEntity)transmitters.iterator().next();
			MinecraftForge.EVENT_BUS.post(new NetworkClientRequest(tile));
		}
	}

	@Override
	public boolean canMerge(List<ITransmitterNetwork<?, ?>> networks)
	{
		return true;
	}

	public static class ClientTickUpdate extends Event
	{
		public DynamicNetwork network;
		public byte operation; /*0 remove, 1 add*/

		public ClientTickUpdate(DynamicNetwork net, byte b)
		{
			network = net;
			operation = b;
		}
	}

	public static class NetworkClientRequest extends Event
	{
		public TileEntity tileEntity;

		public NetworkClientRequest(TileEntity tile)
		{
			tileEntity = tile;
		}
	}

	public void addUpdate(EntityPlayer player)
	{
		updateQueue.add(new DelayQueue(player));
	}

	public static class NetworkFinder
	{
		public TransmissionType transmissionType;

		public World worldObj;
		public Coord4D start;

		public List<Coord4D> iterated = new ArrayList<Coord4D>();
		public List<Coord4D> toIgnore = new ArrayList<Coord4D>();

		public NetworkFinder(World world, TransmissionType type, Coord4D location, Coord4D... ignore)
		{
			worldObj = world;
			start = location;

			transmissionType = type;

			if(ignore != null)
			{
				for(int i = 0; i < ignore.length; i++)
				{
					toIgnore.add(ignore[i]);
				}
			}
		}

		public void loopAll(Coord4D location)
		{
			if(TransmissionType.checkTransmissionType(location.getTileEntity(worldObj), transmissionType))
			{
				iterated.add(location);
			}
			else {
				toIgnore.add(location);
			}

			for(ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS)
			{
				Coord4D obj = location.getFromSide(direction);

				if(!iterated.contains(obj) && !toIgnore.contains(obj))
				{
					TileEntity tileEntity = obj.getTileEntity(worldObj);

					if(!(tileEntity instanceof IBlockableConnection) || ((IBlockableConnection)tileEntity).canConnectMutual(direction.getOpposite()))
					{
						if(TransmissionType.checkTransmissionType(tileEntity, transmissionType, location.getTileEntity(worldObj)))
						{
							loopAll(obj);
						}
					}
				}
			}
		}

		public List<Coord4D> exploreNetwork()
		{
			loopAll(start);

			return iterated;
		}
	}

	public static class DelayQueue
	{
		public EntityPlayer player;
		public int delay;

		public DelayQueue(EntityPlayer p)
		{
			player = p;
			delay = 5;
		}
	}
}