/*
* 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.tile.storage;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import io.netty.buffer.ByteBuf;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.EnumFacing;
import appeng.api.AEApi;
import appeng.api.implementations.tiles.IChestOrDrive;
import appeng.api.networking.GridFlags;
import appeng.api.networking.events.MENetworkCellArrayUpdate;
import appeng.api.networking.events.MENetworkChannelsChanged;
import appeng.api.networking.events.MENetworkEventSubscribe;
import appeng.api.networking.events.MENetworkPowerStatusChange;
import appeng.api.networking.security.BaseActionSource;
import appeng.api.networking.security.MachineSource;
import appeng.api.networking.storage.IStorageGrid;
import appeng.api.storage.ICellHandler;
import appeng.api.storage.IMEInventory;
import appeng.api.storage.IMEInventoryHandler;
import appeng.api.storage.StorageChannel;
import appeng.api.storage.data.IAEItemStack;
import appeng.api.util.AECableType;
import appeng.api.util.AEPartLocation;
import appeng.api.util.DimensionalCoord;
import appeng.helpers.IPriorityHost;
import appeng.me.GridAccessException;
import appeng.me.storage.DriveWatcher;
import appeng.me.storage.MEInventoryHandler;
import appeng.tile.TileEvent;
import appeng.tile.events.TileEventType;
import appeng.tile.grid.AENetworkInvTile;
import appeng.tile.inventory.AppEngInternalInventory;
import appeng.tile.inventory.InvOperation;
import appeng.util.Platform;
public class TileDrive extends AENetworkInvTile implements IChestOrDrive, IPriorityHost
{
private static final int BIT_POWER_MASK = 0x80000000;
private static final int BIT_BLINK_MASK = 0x24924924;
private static final int BIT_STATE_MASK = 0xDB6DB6DB;
private final int[] sides = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
private final AppEngInternalInventory inv = new AppEngInternalInventory( this, 10 );
private final ICellHandler[] handlersBySlot = new ICellHandler[10];
private final DriveWatcher<IAEItemStack>[] invBySlot = new DriveWatcher[10];
private final BaseActionSource mySrc;
private boolean isCached = false;
private List<MEInventoryHandler> items = new LinkedList<MEInventoryHandler>();
private List<MEInventoryHandler> fluids = new LinkedList<MEInventoryHandler>();
private int priority = 0;
private boolean wasActive = false;
/**
* The state of all cells inside a drive as bitset, using the following format.
*
* Bit 31: power state. 0 = off, 1 = on.
* Bit 30: undefined
* Bit 29-0: 3 bits as state of each cell with the cell in slot 0 located in the 3 least significant bits.
*
* Cell states:
* Bit 2: blink. 0 = off, 1 = on.
* Bit 1-0: cell status
*
*
*/
private int state = 0;
public TileDrive()
{
this.mySrc = new MachineSource( this );
this.getProxy().setFlags( GridFlags.REQUIRE_CHANNEL );
}
@TileEvent( TileEventType.NETWORK_WRITE )
public void writeToStream_TileDrive( final ByteBuf data )
{
int newState = 0;
if( this.getProxy().isActive() )
{
newState |= BIT_POWER_MASK;
}
for( int x = 0; x < this.getCellCount(); x++ )
{
newState |= ( this.getCellStatus( x ) << ( 3 * x ) );
}
data.writeInt( newState );
}
@Override
public int getCellCount()
{
return 10;
}
@Override
public int getCellStatus( final int slot )
{
if( Platform.isClient() )
{
return ( this.state >> ( slot * 3 ) ) & 3;
}
final ItemStack cell = this.inv.getStackInSlot( 2 );
final ICellHandler ch = this.handlersBySlot[slot];
final MEInventoryHandler handler = this.invBySlot[slot];
if( handler == null )
{
return 0;
}
if( handler.getChannel() == StorageChannel.ITEMS )
{
if( ch != null )
{
return ch.getStatusForCell( cell, handler.getInternal() );
}
}
if( handler.getChannel() == StorageChannel.FLUIDS )
{
if( ch != null )
{
return ch.getStatusForCell( cell, handler.getInternal() );
}
}
return 0;
}
@Override
public boolean isPowered()
{
if( Platform.isClient() )
{
return ( this.state & BIT_POWER_MASK ) == BIT_POWER_MASK;
}
return this.getProxy().isActive();
}
@Override
public boolean isCellBlinking( final int slot )
{
return ( ( this.state >> ( slot * 3 + 2 ) ) & 0x01 ) == 0x01;
}
@TileEvent( TileEventType.NETWORK_READ )
public boolean readFromStream_TileDrive( final ByteBuf data )
{
final int oldState = this.state;
this.state = data.readInt();
return ( this.state & BIT_STATE_MASK ) != ( oldState & BIT_STATE_MASK );
}
@TileEvent( TileEventType.WORLD_NBT_READ )
public void readFromNBT_TileDrive( final NBTTagCompound data )
{
this.isCached = false;
this.priority = data.getInteger( "priority" );
}
@TileEvent( TileEventType.WORLD_NBT_WRITE )
public void writeToNBT_TileDrive( final NBTTagCompound data )
{
data.setInteger( "priority", this.priority );
}
@MENetworkEventSubscribe
public void powerRender( final MENetworkPowerStatusChange c )
{
this.recalculateDisplay();
}
private void recalculateDisplay()
{
final boolean currentActive = this.getProxy().isActive();
int newState = 0;
if( currentActive )
{
newState |= BIT_POWER_MASK;
}
if( this.wasActive != currentActive )
{
this.wasActive = currentActive;
try
{
this.getProxy().getGrid().postEvent( new MENetworkCellArrayUpdate() );
}
catch( final GridAccessException e )
{
// :P
}
}
for( int x = 0; x < this.getCellCount(); x++ )
{
newState |= ( this.getCellStatus( x ) << ( 3 * x ) );
}
if( newState != this.state )
{
this.state = newState;
this.markForUpdate();
}
}
@MENetworkEventSubscribe
public void channelRender( final MENetworkChannelsChanged c )
{
this.recalculateDisplay();
}
@Override
public AECableType getCableConnectionType( final AEPartLocation dir )
{
return AECableType.SMART;
}
@Override
public DimensionalCoord getLocation()
{
return new DimensionalCoord( this );
}
@Override
public IInventory getInternalInventory()
{
return this.inv;
}
@Override
public boolean isItemValidForSlot( final int i, final ItemStack itemstack )
{
return itemstack != null && AEApi.instance().registries().cell().isCellHandled( itemstack );
}
@Override
public void onChangeInventory( final IInventory inv, final int slot, final InvOperation mc, final ItemStack removed, final ItemStack added )
{
if( this.isCached )
{
this.isCached = false; // recalculate the storage cell.
this.updateState();
}
try
{
this.getProxy().getGrid().postEvent( new MENetworkCellArrayUpdate() );
final IStorageGrid gs = this.getProxy().getStorage();
Platform.postChanges( gs, removed, added, this.mySrc );
}
catch( final GridAccessException ignored )
{
}
this.markForUpdate();
}
@Override
public int[] getAccessibleSlotsBySide( final EnumFacing side )
{
return this.sides;
}
private void updateState()
{
if( !this.isCached )
{
this.items = new LinkedList();
this.fluids = new LinkedList();
double power = 2.0;
for( int x = 0; x < this.inv.getSizeInventory(); x++ )
{
final ItemStack is = this.inv.getStackInSlot( x );
this.invBySlot[x] = null;
this.handlersBySlot[x] = null;
if( is != null )
{
this.handlersBySlot[x] = AEApi.instance().registries().cell().getHandler( is );
if( this.handlersBySlot[x] != null )
{
IMEInventoryHandler cell = this.handlersBySlot[x].getCellInventory( is, this, StorageChannel.ITEMS );
if( cell != null )
{
power += this.handlersBySlot[x].cellIdleDrain( is, cell );
final DriveWatcher<IAEItemStack> ih = new DriveWatcher( cell, is, this.handlersBySlot[x], this );
ih.setPriority( this.priority );
this.invBySlot[x] = ih;
this.items.add( ih );
}
else
{
cell = this.handlersBySlot[x].getCellInventory( is, this, StorageChannel.FLUIDS );
if( cell != null )
{
power += this.handlersBySlot[x].cellIdleDrain( is, cell );
final DriveWatcher<IAEItemStack> ih = new DriveWatcher( cell, is, this.handlersBySlot[x], this );
ih.setPriority( this.priority );
this.invBySlot[x] = ih;
this.fluids.add( ih );
}
}
}
}
}
this.getProxy().setIdlePowerUsage( power );
this.isCached = true;
}
}
@Override
public void onReady()
{
super.onReady();
this.updateState();
}
@Override
public List<IMEInventoryHandler> getCellArray( final StorageChannel channel )
{
if( this.getProxy().isActive() )
{
this.updateState();
return (List) ( channel == StorageChannel.ITEMS ? this.items : this.fluids );
}
return new ArrayList();
}
@Override
public int getPriority()
{
return this.priority;
}
@Override
public void setPriority( final int newValue )
{
this.priority = newValue;
this.markDirty();
this.isCached = false; // recalculate the storage cell.
this.updateState();
try
{
this.getProxy().getGrid().postEvent( new MENetworkCellArrayUpdate() );
}
catch( final GridAccessException e )
{
// :P
}
}
@Override
public void blinkCell( final int slot )
{
this.state |= 1 << ( slot * 3 + 2 );
this.recalculateDisplay();
}
@Override
public void saveChanges( final IMEInventory cellInventory )
{
this.worldObj.markChunkDirty( this.pos, this );
}
}