Applied-Energistics-2-tilera-Edition/src/main/java/appeng/me/cache/TickManagerCache.java

/*
 * This file is part of Applied Energistics 2.
 * Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved.
 *
 * Applied Energistics 2 is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Applied Energistics 2 is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
 */

package appeng.me.cache;


import java.util.HashMap;
import java.util.PriorityQueue;

import net.minecraft.crash.CrashReport;
import net.minecraft.crash.CrashReportCategory;
import net.minecraft.util.ReportedException;

import appeng.api.networking.IGrid;
import appeng.api.networking.IGridHost;
import appeng.api.networking.IGridNode;
import appeng.api.networking.IGridStorage;
import appeng.api.networking.ticking.IGridTickable;
import appeng.api.networking.ticking.ITickManager;
import appeng.api.networking.ticking.TickRateModulation;
import appeng.api.networking.ticking.TickingRequest;
import appeng.me.cache.helpers.TickTracker;


public class TickManagerCache implements ITickManager
{

	private final IGrid myGrid;
	private final HashMap<IGridNode, TickTracker> alertable = new HashMap<IGridNode, TickTracker>();
	private final HashMap<IGridNode, TickTracker> sleeping = new HashMap<IGridNode, TickTracker>();
	private final HashMap<IGridNode, TickTracker> awake = new HashMap<IGridNode, TickTracker>();
	private final PriorityQueue<TickTracker> upcomingTicks = new PriorityQueue<TickTracker>();
	private long currentTick = 0;

	public TickManagerCache( final IGrid g )
	{
		this.myGrid = g;
	}

	public long getCurrentTick()
	{
		return this.currentTick;
	}

	public long getAvgNanoTime( final IGridNode node )
	{
		TickTracker tt = this.awake.get( node );

		if( tt == null )
		{
			tt = this.sleeping.get( node );
		}

		if( tt == null )
		{
			return -1;
		}

		return tt.getAvgNanos();
	}

	@Override
	public void onUpdateTick()
	{
		TickTracker tt = null;
		try
		{
			this.currentTick++;
			while( !this.upcomingTicks.isEmpty() )
			{
				tt = this.upcomingTicks.peek();
				final int diff = (int) ( this.currentTick - tt.getLastTick() );
				if( diff >= tt.getCurrentRate() )
				{
					// remove tt..
					this.upcomingTicks.poll();
					final TickRateModulation mod = tt.getGridTickable().tickingRequest( tt.getNode(), diff );

					switch( mod )
					{
						case FASTER:
							tt.setRate( tt.getCurrentRate() - 2 );
							break;
						case IDLE:
							tt.setRate( tt.getRequest().maxTickRate );
							break;
						case SAME:
							break;
						case SLEEP:
							this.sleepDevice( tt.getNode() );
							break;
						case SLOWER:
							tt.setRate( tt.getCurrentRate() + 1 );
							break;
						case URGENT:
							tt.setRate( 0 );
							break;
						default:
							break;
					}

					if( this.awake.containsKey( tt.getNode() ) )
					{
						this.addToQueue( tt );
					}
				}
				else
				{
					return; // done!
				}
			}
		}
		catch( final Throwable t )
		{
			final CrashReport crashreport = CrashReport.makeCrashReport( t, "Ticking GridNode" );
			final CrashReportCategory crashreportcategory = crashreport.makeCategory( tt.getGridTickable().getClass().getSimpleName() + " being ticked." );
			tt.addEntityCrashInfo( crashreportcategory );
			throw new ReportedException( crashreport );
		}
	}

	private void addToQueue( final TickTracker tt )
	{
		tt.setLastTick( this.currentTick );
		this.upcomingTicks.add( tt );
	}

	@Override
	public void removeNode( final IGridNode gridNode, final IGridHost machine )
	{
		if( machine instanceof IGridTickable )
		{
			this.alertable.remove( gridNode );
			this.sleeping.remove( gridNode );
			this.awake.remove( gridNode );
		}
	}

	@Override
	public void addNode( final IGridNode gridNode, final IGridHost machine )
	{
		if( machine instanceof IGridTickable )
		{
			final TickingRequest tr = ( (IGridTickable) machine ).getTickingRequest( gridNode );
			if( tr != null )
			{
				final TickTracker tt = new TickTracker( tr, gridNode, (IGridTickable) machine, this.currentTick, this );

				if( tr.canBeAlerted )
				{
					this.alertable.put( gridNode, tt );
				}

				if( tr.isSleeping )
				{
					this.sleeping.put( gridNode, tt );
				}
				else
				{
					this.awake.put( gridNode, tt );
					this.addToQueue( tt );
				}
			}
		}
	}

	@Override
	public void onSplit( final IGridStorage storageB )
	{

	}

	@Override
	public void onJoin( final IGridStorage storageB )
	{

	}

	@Override
	public void populateGridStorage( final IGridStorage storage )
	{

	}

	@Override
	public boolean alertDevice( final IGridNode node )
	{
		final TickTracker tt = this.alertable.get( node );
		if( tt == null )
		{
			return false;
		}
		// throw new RuntimeException(
		// "Invalid alerted device, this node is not marked as alertable, or part of this grid." );

		// set to awake, this is for sanity.
		this.sleeping.remove( node );
		this.awake.put( node, tt );

		// configure sort.
		tt.setLastTick( tt.getLastTick() - tt.getRequest().maxTickRate );
		tt.setCurrentRate( tt.getRequest().minTickRate );

		// prevent dupes and tick build up.
		this.upcomingTicks.remove( tt );
		this.upcomingTicks.add( tt );

		return true;
	}

	@Override
	public boolean sleepDevice( final IGridNode node )
	{
		if( this.awake.containsKey( node ) )
		{
			final TickTracker gt = this.awake.get( node );
			this.awake.remove( node );
			this.sleeping.put( node, gt );

			return true;
		}

		return false;
	}

	@Override
	public boolean wakeDevice( final IGridNode node )
	{
		if( this.sleeping.containsKey( node ) )
		{
			final TickTracker gt = this.sleeping.get( node );
			this.sleeping.remove( node );
			this.awake.put( node, gt );
			this.addToQueue( gt );

			return true;
		}

		return false;
	}
}