Applied-Energistics-2-tilera-Edition/src/main/java/appeng/container/implementations/ContainerMEMonitorable.java

package appeng.container.implementations;

import java.io.IOException;
import java.nio.BufferOverflowException;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.ICrafting;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;
import appeng.api.AEApi;
import appeng.api.config.Actionable;
import appeng.api.config.PowerMultiplier;
import appeng.api.config.SecurityPermissions;
import appeng.api.config.Settings;
import appeng.api.config.SortDir;
import appeng.api.config.SortOrder;
import appeng.api.config.ViewItems;
import appeng.api.implementations.guiobjects.IPortableCell;
import appeng.api.implementations.tiles.IMEChest;
import appeng.api.implementations.tiles.IViewCellStorage;
import appeng.api.networking.IGrid;
import appeng.api.networking.IGridHost;
import appeng.api.networking.IGridNode;
import appeng.api.networking.energy.IEnergyGrid;
import appeng.api.networking.security.BaseActionSource;
import appeng.api.networking.storage.IBaseMonitor;
import appeng.api.parts.IPart;
import appeng.api.storage.IMEMonitor;
import appeng.api.storage.IMEMonitorHandlerReceiver;
import appeng.api.storage.ITerminalHost;
import appeng.api.storage.data.IAEItemStack;
import appeng.api.storage.data.IItemList;
import appeng.api.util.IConfigManager;
import appeng.api.util.IConfigurableObject;
import appeng.container.AEBaseContainer;
import appeng.container.guisync.GuiSync;
import appeng.container.slot.SlotRestrictedInput;
import appeng.core.AELog;
import appeng.core.sync.network.NetworkHandler;
import appeng.core.sync.packets.PacketMEInventoryUpdate;
import appeng.core.sync.packets.PacketValueConfig;
import appeng.me.helpers.ChannelPowerSrc;
import appeng.util.ConfigManager;
import appeng.util.IConfigManagerHost;
import appeng.util.Platform;

public class ContainerMEMonitorable extends AEBaseContainer implements IConfigManagerHost, IConfigurableObject, IMEMonitorHandlerReceiver<IAEItemStack>
{

	final IMEMonitor<IAEItemStack> monitor;
	final IItemList<IAEItemStack> items = AEApi.instance().storage().createItemList();

	IConfigManager serverCM;
	final IConfigManager clientCM;

	@GuiSync(99)
	public boolean canAccessViewCells = false;

	@GuiSync(98)
	public boolean hasPower = false;

	public final SlotRestrictedInput[] cellView = new SlotRestrictedInput[5];

	public IConfigManagerHost gui;
	private IGridNode networkNode;
	private final ITerminalHost host;

	public IGridNode getNetworkNode()
	{
		return networkNode;
	}

	protected ContainerMEMonitorable(InventoryPlayer ip, ITerminalHost monitorable, boolean bindInventory) {
		super( ip, monitorable instanceof TileEntity ? (TileEntity) monitorable : null, monitorable instanceof IPart ? (IPart) monitorable : null );

		host = monitorable;
		clientCM = new ConfigManager( this );

		clientCM.registerSetting( Settings.SORT_BY, SortOrder.NAME );
		clientCM.registerSetting( Settings.VIEW_MODE, ViewItems.ALL );
		clientCM.registerSetting( Settings.SORT_DIRECTION, SortDir.ASCENDING );

		if ( Platform.isServer() )
		{
			serverCM = monitorable.getConfigManager();

			monitor = monitorable.getItemInventory();
			if ( monitor != null )
			{
				monitor.addListener( this, null );

				cellInv = monitor;

				if ( monitorable instanceof IPortableCell )
					powerSrc = (IPortableCell) monitorable;
				else if ( monitorable instanceof IMEChest )
					powerSrc = (IMEChest) monitorable;
				else if ( monitorable instanceof IGridHost )
				{
					IGridNode node = ((IGridHost) monitorable).getGridNode( ForgeDirection.UNKNOWN );
					if ( node != null )
					{
						networkNode = node;
						IGrid g = node.getGrid();
						if ( g != null )
							powerSrc = new ChannelPowerSrc( networkNode, (IEnergyGrid) g.getCache( IEnergyGrid.class ) );
					}
				}
			}
			else
				isContainerValid = false;
		}
		else
			monitor = null;

		canAccessViewCells = false;
		if ( monitorable instanceof IViewCellStorage )
		{
			for (int y = 0; y < 5; y++)
			{
				cellView[y] = new SlotRestrictedInput( SlotRestrictedInput.PlacableItemType.VIEW_CELL, ((IViewCellStorage) monitorable).getViewCellStorage(), y, 206, y * 18 + 8,
						invPlayer );
				cellView[y].allowEdit = canAccessViewCells;
				addSlotToContainer( cellView[y] );
			}
		}

		if ( bindInventory )
			bindPlayerInventory( ip, 0, 0 );
	}

	public ContainerMEMonitorable(InventoryPlayer ip, ITerminalHost monitorable) {
		this( ip, monitorable, true );
	}

	@Override
	public void detectAndSendChanges()
	{
		if ( Platform.isServer() )
		{
			if ( monitor != host.getItemInventory() )
				isContainerValid = false;
			
			for (Enum set : serverCM.getSettings())
			{
				Enum sideLocal = serverCM.getSetting( set );
				Enum sideRemote = clientCM.getSetting( set );

				if ( sideLocal != sideRemote )
				{
					clientCM.putSetting( set, sideLocal );
					for (Object crafter : this.crafters)
					{
						try
						{
							NetworkHandler.instance.sendTo( new PacketValueConfig( set.name(), sideLocal.name() ), (EntityPlayerMP) crafter );
						}
						catch (IOException e)
						{
							AELog.error( e );
						}
					}
				}
			}

			if ( !items.isEmpty() )
			{
				try
				{
					IItemList<IAEItemStack> monitorCache = monitor.getStorageList();

					PacketMEInventoryUpdate piu = new PacketMEInventoryUpdate();

					for (IAEItemStack is : items)
					{
						IAEItemStack send = monitorCache.findPrecise( is );
						if ( send == null )
						{
							is.setStackSize( 0 );
							piu.appendItem( is );
						}
						else
							piu.appendItem( send );
					}

					if ( !piu.isEmpty() )
					{
						items.resetStatus();

						for (Object c : this.crafters)
						{
							if ( c instanceof EntityPlayer )
								NetworkHandler.instance.sendTo( piu, (EntityPlayerMP) c );
						}
					}
				}
				catch (IOException e)
				{
					AELog.error( e );
				}
			}

			updatePowerStatus();

			boolean oldCanAccessViewCells = canAccessViewCells;
			canAccessViewCells = hasAccess( SecurityPermissions.BUILD, false );
			if ( canAccessViewCells != oldCanAccessViewCells )
			{
				for (int y = 0; y < 5; y++)
				{
					if ( cellView[y] != null )
						cellView[y].allowEdit = canAccessViewCells;
				}
			}

			super.detectAndSendChanges();
		}
	}

	protected void updatePowerStatus()
	{
		try
		{
			if ( networkNode != null )
				hasPower = networkNode.isActive();
			else if ( powerSrc instanceof IEnergyGrid )
				hasPower = ((IEnergyGrid) powerSrc).isNetworkPowered();
			else
				hasPower = powerSrc.extractAEPower( 1, Actionable.SIMULATE, PowerMultiplier.CONFIG ) > 0.8;
		}
		catch (Throwable t)
		{
			// :P
		}
	}

	@Override
	public void addCraftingToCrafters(ICrafting c)
	{
		super.addCraftingToCrafters( c );
		queueInventory( c );
	}

	public void queueInventory(ICrafting c)
	{
		if ( Platform.isServer() && c instanceof EntityPlayer && monitor != null )
		{
			try
			{
				PacketMEInventoryUpdate piu = new PacketMEInventoryUpdate();
				IItemList<IAEItemStack> monitorCache = monitor.getStorageList();

				for (IAEItemStack send : monitorCache)
				{
					try
					{
						piu.appendItem( send );
					}
					catch (BufferOverflowException boe)
					{
						NetworkHandler.instance.sendTo( piu, (EntityPlayerMP) c );

						piu = new PacketMEInventoryUpdate();
						piu.appendItem( send );
					}
				}

				NetworkHandler.instance.sendTo( piu, (EntityPlayerMP) c );
			}
			catch (IOException e)
			{
				AELog.error( e );
			}

		}
	}

	@Override
	public void onListUpdate()
	{
		for (Object c : this.crafters)
		{
			if ( c instanceof ICrafting )
			{
				ICrafting cr = (ICrafting) c;
				queueInventory( cr );
			}
		}
	}

	@Override
	public void onUpdate(String field, Object oldValue, Object newValue)
	{
		if ( field.equals( "canAccessViewCells" ) )
		{
			for (int y = 0; y < 5; y++)
				if ( cellView[y] != null )
					cellView[y].allowEdit = canAccessViewCells;
		}

		super.onUpdate( field, oldValue, newValue );
	}

	@Override
	public void onContainerClosed(EntityPlayer player)
	{
		super.onContainerClosed( player );
		if ( monitor != null )
			monitor.removeListener( this );
	}

	@Override
	public void removeCraftingFromCrafters(ICrafting c)
	{
		super.removeCraftingFromCrafters( c );

		if ( this.crafters.isEmpty() && monitor != null )
			monitor.removeListener( this );
	}

	@Override
	public void postChange(IBaseMonitor<IAEItemStack> monitor, Iterable<IAEItemStack> change, BaseActionSource source)
	{
		for (IAEItemStack is : change)
			items.add( is );
	}

	@Override
	public boolean isValid(Object verificationToken)
	{
		return true;
	}

	@Override
	public void updateSetting(IConfigManager manager, Enum settingName, Enum newValue)
	{
		if ( gui != null )
			gui.updateSetting( manager, settingName, newValue );
	}

	@Override
	public IConfigManager getConfigManager()
	{
		if ( Platform.isServer() )
			return serverCM;
		return clientCM;
	}

	public ItemStack[] getViewCells()
	{
		ItemStack[] list = new ItemStack[cellView.length];

		for (int x = 0; x < cellView.length; x++)
			list[x] = cellView[x].getStack();

		return list;
	}
}