/*
 * This file is part of Applied Energistics 2.
 * Copyright (c) 2013 - 2015, 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.block.networking;


import java.util.EnumSet;
import java.util.List;
import java.util.Random;

import net.minecraft.block.Block;
import net.minecraft.client.particle.EffectRenderer;
import net.minecraft.client.particle.EntityDiggingFX;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.util.Vec3;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;

import cpw.mods.fml.common.registry.GameRegistry;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;

import powercrystals.minefactoryreloaded.api.rednet.connectivity.IRedNetConnection;
import powercrystals.minefactoryreloaded.api.rednet.connectivity.RedNetConnectionType;

import appeng.api.parts.IPart;
import appeng.api.parts.IPartHost;
import appeng.api.parts.PartItemStack;
import appeng.api.parts.SelectedPart;
import appeng.api.util.AEColor;
import appeng.block.AEBaseTileBlock;
import appeng.client.render.BusRenderHelper;
import appeng.client.render.blocks.RendererCableBus;
import appeng.client.texture.ExtraBlockTextures;
import appeng.core.AEConfig;
import appeng.core.Api;
import appeng.core.CommonHelper;
import appeng.core.features.AECableBusFeatureHandler;
import appeng.core.features.AEFeature;
import appeng.helpers.AEGlassMaterial;
import appeng.helpers.Reflected;
import appeng.integration.IntegrationRegistry;
import appeng.integration.IntegrationType;
import appeng.integration.abstraction.IFMP;
import appeng.parts.ICableBusContainer;
import appeng.parts.NullCableBusContainer;
import appeng.tile.AEBaseTile;
import appeng.tile.networking.TileCableBus;
import appeng.tile.networking.TileCableBusTESR;
import appeng.transformer.annotations.Integration.Interface;
import appeng.transformer.annotations.Integration.Method;
import appeng.util.Platform;


@Interface( iface = "powercrystals.minefactoryreloaded.api.rednet.connectivity.IRedNetConnection", iname = IntegrationType.MFR )
public class BlockCableBus extends AEBaseTileBlock implements IRedNetConnection
{

	private static final ICableBusContainer NULL_CABLE_BUS = new NullCableBusContainer();
	private static Class<? extends TileEntity> noTesrTile;
	private static Class<? extends TileEntity> tesrTile;

	/**
	 * Immibis MB Support.
	 *
	 * It will look for a field named ImmibisMicroblocks_TransformableBlockMarker or
	 * ImmibisMicroblocks_TransformableTileEntityMarker, modifiers, type, etc can be ignored.
	 */
	@Reflected
	private static final boolean ImmibisMicroblocks_TransformableBlockMarker = true;

	private int myColorMultiplier = 0xffffff;

	public BlockCableBus()
	{
		super( AEGlassMaterial.INSTANCE );
		this.setLightOpacity( 0 );
		this.isFullSize = this.isOpaque = false;

		// this will actually be overwritten later through setupTile and the combined layers
		this.setTileEntity( TileCableBus.class );
		this.setFeature( EnumSet.of( AEFeature.Core ) );
	}

	@Override
	public void randomDisplayTick( final World world, final int x, final int y, final int z, final Random r )
	{
		this.cb( world, x, y, z ).randomDisplayTick( world, x, y, z, r );
	}

	@Override
	public void onNeighborBlockChange( final World w, final int x, final int y, final int z, final Block meh )
	{
		this.cb( w, x, y, z ).onNeighborChanged();
	}

	@Override
	public Item getItemDropped( final int i, final Random r, final int k )
	{
		return null;
	}

	@Override
	public int getRenderBlockPass()
	{
		if( AEConfig.instance.isFeatureEnabled( AEFeature.AlphaPass ) )
		{
			return 1;
		}
		return 0;
	}

	@Override
	public int colorMultiplier( final IBlockAccess world, final int x, final int y, final int z )
	{
		return this.myColorMultiplier;
	}

	@Override
	public int isProvidingWeakPower( final IBlockAccess w, final int x, final int y, final int z, final int side )
	{
		return this.cb( w, x, y, z ).isProvidingWeakPower( ForgeDirection.getOrientation( side ).getOpposite() );
	}

	@Override
	public boolean canProvidePower()
	{
		return true;
	}

	@Override
	public void onEntityCollidedWithBlock( final World w, final int x, final int y, final int z, final Entity e )
	{
		this.cb( w, x, y, z ).onEntityCollision( e );
	}

	@Override
	public int isProvidingStrongPower( final IBlockAccess w, final int x, final int y, final int z, final int side )
	{
		return this.cb( w, x, y, z ).isProvidingStrongPower( ForgeDirection.getOrientation( side ).getOpposite() );
	}

	@Override
	public int getLightValue( final IBlockAccess world, final int x, final int y, final int z )
	{
		final Block block = world.getBlock( x, y, z );
		if( block != null && block != this )
		{
			return block.getLightValue( world, x, y, z );
		}
		if( block == null )
		{
			return 0;
		}
		return this.cb( world, x, y, z ).getLightValue();
	}

	@Override
	public boolean isLadder( final IBlockAccess world, final int x, final int y, final int z, final EntityLivingBase entity )
	{
		return this.cb( world, x, y, z ).isLadder( entity );
	}

	@Override
	public boolean isSideSolid( final IBlockAccess w, final int x, final int y, final int z, final ForgeDirection side )
	{
		return this.cb( w, x, y, z ).isSolidOnSide( side );
	}

	@Override
	public boolean isReplaceable( final IBlockAccess world, final int x, final int y, final int z )
	{
		return this.cb( world, x, y, z ).isEmpty();
	}

	@SuppressWarnings( "deprecation" )
	@Override
	public boolean removedByPlayer( final World world, final EntityPlayer player, final int x, final int y, final int z )
	{
		if( player.capabilities.isCreativeMode )
		{
			final AEBaseTile tile = this.getTileEntity( world, x, y, z );
			if( tile != null )
			{
				tile.disableDrops();
			}
			// maybe ray trace?
		}
		return super.removedByPlayer( world, player, x, y, z );
	}

	@Override
	public boolean canConnectRedstone( final IBlockAccess w, final int x, final int y, final int z, final int side )
	{
		switch( side )
		{
			case -1:
			case 4:
				return this.cb( w, x, y, z ).canConnectRedstone( EnumSet.of( ForgeDirection.UP, ForgeDirection.DOWN ) );
			case 0:
				return this.cb( w, x, y, z ).canConnectRedstone( EnumSet.of( ForgeDirection.NORTH ) );
			case 1:
				return this.cb( w, x, y, z ).canConnectRedstone( EnumSet.of( ForgeDirection.EAST ) );
			case 2:
				return this.cb( w, x, y, z ).canConnectRedstone( EnumSet.of( ForgeDirection.SOUTH ) );
			case 3:
				return this.cb( w, x, y, z ).canConnectRedstone( EnumSet.of( ForgeDirection.WEST ) );
		}
		return false;
	}

	@Override
	public boolean canRenderInPass( final int pass )
	{
		BusRenderHelper.INSTANCE.setPass( pass );

		if( AEConfig.instance.isFeatureEnabled( AEFeature.AlphaPass ) )
		{
			return true;
		}

		return pass == 0;
	}

	@Override
	public ItemStack getPickBlock( final MovingObjectPosition target, final World world, final int x, final int y, final int z, final EntityPlayer player )
	{
		final Vec3 v3 = target.hitVec.addVector( -x, -y, -z );
		final SelectedPart sp = this.cb( world, x, y, z ).selectPart( v3 );

		if( sp.part != null )
		{
			return sp.part.getItemStack( PartItemStack.Pick );
		}
		else if( sp.facade != null )
		{
			return sp.facade.getItemStack();
		}

		return null;
	}

	@Override
	@SideOnly( Side.CLIENT )
	public boolean addHitEffects( final World world, final MovingObjectPosition target, final EffectRenderer effectRenderer )
	{
		final Object object = this.cb( world, target.blockX, target.blockY, target.blockZ );
		if( object instanceof IPartHost )
		{
			final IPartHost host = (IPartHost) object;

			for( final ForgeDirection side : ForgeDirection.values() )
			{
				final IPart p = host.getPart( side );
				final IIcon ico = this.getIcon( p );

				if( ico == null )
				{
					continue;
				}

				final byte b0 = (byte) ( Platform.getRandomInt() % 2 == 0 ? 1 : 0 );

				for( int i1 = 0; i1 < b0; ++i1 )
				{
					for( int j1 = 0; j1 < b0; ++j1 )
					{
						for( int k1 = 0; k1 < b0; ++k1 )
						{
							final double d0 = target.blockX + ( i1 + 0.5D ) / b0;
							final double d1 = target.blockY + ( j1 + 0.5D ) / b0;
							final double d2 = target.blockZ + ( k1 + 0.5D ) / b0;

							final double dd0 = target.hitVec.xCoord;
							final double dd1 = target.hitVec.yCoord;
							final double dd2 = target.hitVec.zCoord;
							final EntityDiggingFX fx = ( new EntityDiggingFX( world, dd0, dd1, dd2, d0 - target.blockX - 0.5D, d1 - target.blockY - 0.5D, d2 - target.blockZ - 0.5D, this, 0 ) ).applyColourMultiplier( target.blockX, target.blockY, target.blockZ );

							fx.setParticleIcon( ico );

							effectRenderer.addEffect( fx );
						}
					}
				}
			}
		}

		return true;
	}

	@Override
	@SideOnly( Side.CLIENT )
	public boolean addDestroyEffects( final World world, final int x, final int y, final int z, final int meta, final EffectRenderer effectRenderer )
	{
		final Object object = this.cb( world, x, y, z );
		if( object instanceof IPartHost )
		{
			final IPartHost host = (IPartHost) object;

			for( final ForgeDirection side : ForgeDirection.values() )
			{
				final IPart p = host.getPart( side );
				final IIcon ico = this.getIcon( p );

				if( ico == null )
				{
					continue;
				}

				final byte b0 = 3;

				for( int i1 = 0; i1 < b0; ++i1 )
				{
					for( int j1 = 0; j1 < b0; ++j1 )
					{
						for( int k1 = 0; k1 < b0; ++k1 )
						{
							final double d0 = x + ( i1 + 0.5D ) / b0;
							final double d1 = y + ( j1 + 0.5D ) / b0;
							final double d2 = z + ( k1 + 0.5D ) / b0;
							final EntityDiggingFX fx = ( new EntityDiggingFX( world, d0, d1, d2, d0 - x - 0.5D, d1 - y - 0.5D, d2 - z - 0.5D, this, meta ) ).applyColourMultiplier( x, y, z );

							fx.setParticleIcon( ico );

							effectRenderer.addEffect( fx );
						}
					}
				}
			}
		}

		return true;
	}

	@Override
	public void onNeighborChange( final IBlockAccess w, final int x, final int y, final int z, final int tileX, final int tileY, final int tileZ )
	{
		if( Platform.isServer() )
		{
			this.cb( w, x, y, z ).onNeighborChanged();
		}
	}

	private IIcon getIcon( final IPart p )
	{
		if( p == null )
		{
			return null;
		}

		try
		{
			final IIcon ico = p.getBreakingTexture();
			if( ico != null )
			{
				return ico;
			}
		}
		catch( final Throwable t )
		{
			// nothing.
		}

		final ItemStack is = p.getItemStack( PartItemStack.Network );
		if( is == null || is.getItem() == null )
		{
			return null;
		}

		return is.getItem().getIcon( is, 0 );
	}

	private ICableBusContainer cb( final IBlockAccess w, final int x, final int y, final int z )
	{
		final TileEntity te = w.getTileEntity( x, y, z );
		ICableBusContainer out = null;

		if( te instanceof TileCableBus )
		{
			out = ( (TileCableBus) te ).getCableBus();
		}
		else if( IntegrationRegistry.INSTANCE.isEnabled( IntegrationType.FMP ) )
		{
			out = ( (IFMP) IntegrationRegistry.INSTANCE.getInstance( IntegrationType.FMP ) ).getCableContainer( te );
		}

		return out == null ? NULL_CABLE_BUS : out;
	}

	@Override
	@SideOnly( Side.CLIENT )
	protected RendererCableBus getRenderer()
	{
		return new RendererCableBus();
	}

	@Override
	public IIcon getIcon( final IBlockAccess w, final int x, final int y, final int z, final int s )
	{
		return this.getIcon( s, 0 );
	}

	@Override
	public IIcon getIcon( final int direction, final int metadata )
	{
		final IIcon i = super.getIcon( direction, metadata );
		if( i != null )
		{
			return i;
		}

		return ExtraBlockTextures.BlockQuartzGlassB.getIcon();
	}

	@Override
	public boolean onActivated( final World w, final int x, final int y, final int z, final EntityPlayer player, final int side, final float hitX, final float hitY, final float hitZ )
	{
		return this.cb( w, x, y, z ).activate( player, Vec3.createVectorHelper( hitX, hitY, hitZ ) );
	}

	@Override
	public void registerBlockIcons( final IIconRegister iconRegistry )
	{

	}

	@Override
	public boolean recolourBlock( final World world, final int x, final int y, final int z, final ForgeDirection side, final int colour )
	{
		return this.recolourBlock( world, x, y, z, side, colour, null );
	}

	public boolean recolourBlock( final World world, final int x, final int y, final int z, final ForgeDirection side, final int colour, final EntityPlayer who )
	{
		try
		{
			return this.cb( world, x, y, z ).recolourBlock( side, AEColor.values()[colour], who );
		}
		catch( final Throwable ignored )
		{
		}
		return false;
	}

	@Override
	@SideOnly( Side.CLIENT )
	public void getCheckedSubBlocks( final Item item, final CreativeTabs tabs, final List<ItemStack> itemStacks )
	{
		// do nothing
	}

	@Override
	public <T extends AEBaseTile> T getTileEntity( final IBlockAccess w, final int x, final int y, final int z )
	{
		final TileEntity te = w.getTileEntity( x, y, z );

		if( noTesrTile.isInstance( te ) )
		{
			return (T) te;
		}

		if( tesrTile != null && tesrTile.isInstance( te ) )
		{
			return (T) te;
		}

		return null;
	}

	@Override
	protected void setFeature( final EnumSet<AEFeature> f )
	{
		final AECableBusFeatureHandler featureHandler = new AECableBusFeatureHandler( f, this, this.featureSubName );
		this.setHandler( featureHandler );
	}

	public void setupTile()
	{
		noTesrTile = Api.INSTANCE.partHelper().getCombinedInstance( TileCableBus.class.getName() );
		this.setTileEntity( noTesrTile );
		GameRegistry.registerTileEntity( noTesrTile, "BlockCableBus" );
		if( Platform.isClient() )
		{
			tesrTile = Api.INSTANCE.partHelper().getCombinedInstance( TileCableBusTESR.class.getName() );
			GameRegistry.registerTileEntity( tesrTile, "ClientOnly_TESR_CableBus" );
			CommonHelper.proxy.bindTileEntitySpecialRenderer( tesrTile, this );
		}
	}

	@Override
	@Method( iname = IntegrationType.MFR )
	public RedNetConnectionType getConnectionType( final World world, final int x, final int y, final int z, final ForgeDirection side )
	{
		return this.cb( world, x, y, z ).canConnectRedstone( EnumSet.allOf( ForgeDirection.class ) ) ? RedNetConnectionType.CableSingle : RedNetConnectionType.None;
	}

	public void setRenderColor( final int color )
	{
		this.myColorMultiplier = color;
	}

	public static Class<? extends TileEntity> getTesrTile()
	{
		return BlockCableBus.tesrTile;
	}

	public static Class<? extends TileEntity> getNoTesrTile()
	{
		return BlockCableBus.noTesrTile;
	}
}