package appeng.items.materials;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.Entity;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.util.Vec3;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.oredict.OreDictionary;
import appeng.api.config.Upgrades;
import appeng.api.implementations.IUpgradeableHost;
import appeng.api.implementations.items.IItemGroup;
import appeng.api.implementations.items.IStorageComponent;
import appeng.api.implementations.items.IUpgradeModule;
import appeng.api.parts.IPartHost;
import appeng.api.parts.SelectedPart;
import appeng.client.texture.MissingIcon;
import appeng.core.AEConfig;
import appeng.core.features.AEFeature;
import appeng.core.features.AEFeatureHandler;
import appeng.core.features.IStackSrc;
import appeng.core.features.MaterialStackSrc;
import appeng.items.AEBaseItem;
import appeng.util.InventoryAdaptor;
import appeng.util.Platform;

import com.google.common.collect.ImmutableSet;

public class ItemMultiMaterial extends AEBaseItem implements IStorageComponent, IUpgradeModule
{

	HashMap<Integer, MaterialType> dmgToMaterial = new HashMap();

	public static ItemMultiMaterial instance;

	public ItemMultiMaterial() {
		super( ItemMultiMaterial.class );
		setfeature( EnumSet.of( AEFeature.Core ) );
		setHasSubtypes( true );
		instance = this;
	}

	class SlightlyBetterSort implements Comparator<String>
	{

		Pattern p;

		public SlightlyBetterSort(Pattern p) {
			this.p = p;
		}

		@Override
		public int compare(String o1, String o2)
		{
			try
			{
				Matcher a = p.matcher( o1 );
				Matcher b = p.matcher( o2 );
				if ( a.find() && b.find() )
				{
					int ia = Integer.parseInt( a.group( 1 ) );
					int ib = Integer.parseInt( b.group( 1 ) );
					return Integer.compare( ia, ib );
				}
			}
			catch (Throwable t)
			{
				// ek!
			}
			return o1.compareTo( o2 );
		}
	}

	@Override
	public void addInformation(ItemStack is, EntityPlayer player, List details, boolean moar)
	{
		super.addInformation( is, player, details, moar );

		MaterialType mt = getTypeByStack( is );
		if ( mt == null )
			return;

		if ( mt == MaterialType.NamePress )
		{
			NBTTagCompound c = Platform.openNbtData( is );
			details.add( c.getString( "InscribeName" ) );
		}

		Upgrades u = getType( is );
		if ( u != null )
		{
			List<String> textList = new LinkedList();
			for (Entry<ItemStack, Integer> j : u.getSupported().entrySet())
			{
				String name = null;

				int limit = j.getValue();

				if ( j.getKey().getItem() instanceof IItemGroup )
				{
					IItemGroup ig = (IItemGroup) j.getKey().getItem();
					String str = ig.getUnlocalizedGroupName( u.getSupported().keySet(), j.getKey() );
					if ( str != null )
						name = Platform.gui_localize( str ) + (limit > 1 ? " (" + limit + ")" : "");
				}

				if ( name == null )
					name = j.getKey().getDisplayName() + (limit > 1 ? " (" + limit + ")" : "");

				if ( !textList.contains( name ) )
					textList.add( name );
			}

			Pattern p = Pattern.compile( "(\\d+)[^\\d]" );
			SlightlyBetterSort s = new SlightlyBetterSort( p );
			Collections.sort( textList, s );
			details.addAll( textList );
		}
	}

	public IStackSrc createMaterial(MaterialType mat)
	{
		if ( !mat.isRegistered() )
		{
			boolean enabled = true;
			for (AEFeature f : mat.getFeature())
				enabled = enabled && AEConfig.instance.isFeatureEnabled( f );

			if ( enabled )
			{
				mat.itemInstance = this;
				int newMaterialNum = mat.damageValue;
				mat.markReady();

				IStackSrc output = mat.stackSrc = new MaterialStackSrc( mat );

				if ( dmgToMaterial.get( newMaterialNum ) == null )
					dmgToMaterial.put( newMaterialNum, mat );
				else
					throw new RuntimeException( "Meta Overlap detected." );

				return output;
			}

			return null;
		}
		else
			throw new RuntimeException( "Cannot create the same material twice..." );
	}

	public void unduplicate()
	{
		for (MaterialType mt : ImmutableSet.copyOf( dmgToMaterial.values() ))
		{
			if ( mt.getOreName() != null )
			{
				ItemStack replacement = null;

				String names[] = mt.getOreName().split( "," );

				for (String name : names)
				{
					if ( replacement != null )
						break;

					ArrayList<ItemStack> options = OreDictionary.getOres( name );
					if ( options != null && options.size() > 0 )
					{
						for (ItemStack is : options)
						{
							if ( is != null && is.getItem() != null )
							{
								replacement = is.copy();
								break;
							}
						}
					}
				}

				if ( replacement == null || AEConfig.instance.useAEVersion( mt ) )
				{
					// continue using the AE2 item.
					for (String name : names)
						OreDictionary.registerOre( name, mt.stack( 1 ) );
				}
				else
				{
					if ( mt.itemInstance == this )
						dmgToMaterial.remove( mt.damageValue );

					mt.itemInstance = replacement.getItem();
					mt.damageValue = replacement.getItemDamage();
				}

			}
		}
	}

	public MaterialType getTypeByStack(ItemStack is)
	{
		if ( dmgToMaterial.containsKey( is.getItemDamage() ) )
			return dmgToMaterial.get( is.getItemDamage() );
		return MaterialType.InvalidType;
	}

	@Override
	public IIcon getIconFromDamage(int dmg)
	{
		if ( dmgToMaterial.containsKey( dmg ) )
			return dmgToMaterial.get( dmg ).IIcon;
		return new MissingIcon( this );
	}

	private String nameOf(ItemStack is)
	{
		if ( is == null )
			return "null";

		MaterialType mt = getTypeByStack( is );
		if ( mt == null )
			return "null";

		return AEFeatureHandler.getName( ItemMultiMaterial.class, mt.name() );
	}

	@Override
	public String getUnlocalizedName(ItemStack is)
	{
		return "item.appliedenergistics2." + nameOf( is );
	}

	@Override
	public void registerIcons(IIconRegister icoRegister)
	{
		for (MaterialType mat : MaterialType.values())
		{
			if ( mat.damageValue != -1 )
			{
				ItemStack what = new ItemStack( this, 1, mat.damageValue );
				if ( getTypeByStack( what ) != MaterialType.InvalidType )
				{
					String tex = "appliedenergistics2:" + nameOf( what );
					mat.IIcon = icoRegister.registerIcon( tex );
				}
			}
		}
	}

	@Override
	public boolean hasCustomEntity(ItemStack is)
	{
		return getTypeByStack( is ).hasCustomEntity();
	}

	@Override
	public Entity createEntity(World w, Entity location, ItemStack itemstack)
	{
		Class<? extends Entity> droppedEntity = getTypeByStack( itemstack ).getCustomEntityClass();
		Entity eqi;

		try
		{
			eqi = droppedEntity.getConstructor( World.class, double.class, double.class, double.class, ItemStack.class ).newInstance( w, location.posX,
					location.posY, location.posZ, itemstack );
		}
		catch (Throwable t)
		{
			throw new RuntimeException( t );
		}

		eqi.motionX = location.motionX;
		eqi.motionY = location.motionY;
		eqi.motionZ = location.motionZ;

		if ( location instanceof EntityItem && eqi instanceof EntityItem )
			((EntityItem) eqi).delayBeforeCanPickup = ((EntityItem) location).delayBeforeCanPickup;

		return eqi;
	}

	@Override
	public int getBytes(ItemStack is)
	{
		switch (getTypeByStack( is ))
		{
		case Cell1kPart:
			return 1024;
		case Cell4kPart:
			return 1024 * 4;
		case Cell16kPart:
			return 1024 * 16;
		case Cell64kPart:
			return 1024 * 64;
		default:
		}
		return 0;
	}

	@Override
	public boolean isStorageComponent(ItemStack is)
	{
		switch (getTypeByStack( is ))
		{
		case Cell1kPart:
		case Cell4kPart:
		case Cell16kPart:
		case Cell64kPart:
			return true;
		default:
		}
		return false;
	}

	@Override
	public Upgrades getType(ItemStack itemstack)
	{
		switch (getTypeByStack( itemstack ))
		{
		case CardCapacity:
			return Upgrades.CAPACITY;
		case CardFuzzy:
			return Upgrades.FUZZY;
		case CardRedstone:
			return Upgrades.REDSTONE;
		case CardSpeed:
			return Upgrades.SPEED;
		case CardInverter:
			return Upgrades.INVERTER;
		case CardCrafting:
			return Upgrades.CRAFTING;
		default:
			return null;
		}
	}

	@Override
	public boolean onItemUseFirst(ItemStack is, EntityPlayer player, World world, int x, int y, int z, int side, float hitX, float hitY, float hitZ)
	{
		if ( player.isSneaking() )
		{
			TileEntity te = world.getTileEntity( x, y, z );
			IInventory upgrades = null;

			if ( te instanceof IPartHost )
			{
				SelectedPart sp = ((IPartHost) te).selectPart( Vec3.createVectorHelper( hitX, hitY, hitZ ) );
				if ( sp.part instanceof IUpgradeableHost )
					upgrades = ((IUpgradeableHost) sp.part).getInventoryByName( "upgrades" );
			}
			else if ( te instanceof IUpgradeableHost )
				upgrades = ((IUpgradeableHost) te).getInventoryByName( "upgrades" );

			if ( upgrades != null && is != null && is.getItem() instanceof IUpgradeModule )
			{
				IUpgradeModule um = (IUpgradeModule) is.getItem();
				Upgrades u = um.getType( is );

				if ( u != null )
				{
					InventoryAdaptor ad = InventoryAdaptor.getAdaptor( upgrades, ForgeDirection.UNKNOWN );
					if ( ad != null )
					{
						if ( player.worldObj.isRemote )
							return false;

						player.inventory.setInventorySlotContents( player.inventory.currentItem, ad.addItems( is ) );
						return true;
					}
				}
			}
		}

		return super.onItemUseFirst( is, player, world, x, y, z, side, hitX, hitY, hitZ );
	}

	@Override
	public void getSubItems(Item par1, CreativeTabs par2CreativeTabs, List cList)
	{
		List<MaterialType> types = Arrays.asList( MaterialType.values() );
		Collections.sort( types, new Comparator<MaterialType>() {

			@Override
			public int compare(MaterialType o1, MaterialType o2)
			{
				return o1.name().compareTo( o2.name() );
			}

		} );

		for (MaterialType mat : types)
		{
			if ( mat.damageValue >= 0 && mat.isRegistered() && mat.itemInstance == this )
				cList.add( new ItemStack( this, 1, mat.damageValue ) );
		}
	}
}