Bukkit

	private static Map<RecursiveItemData, Double> prices;
	private static Set<RecursiveItemData> missingPrices;
	
	public RecursiveItems() {
		prices = new HashMap<RecursiveItemData, Double>();
		missingPrices = new HashSet<RecursiveItemData>();
	}

    public static Collection<ItemStack> getRecipeIngredients(Recipe recipe) {
        if (recipe instanceof ShapedRecipe) {
			return ((ShapedRecipe)recipe).getIngredientMap().values();
        } else if (recipe instanceof ShapelessRecipe) {
			return ((ShapelessRecipe)recipe).getIngredientList();
	} else if (recipe instanceof FurnaceRecipe) {
			List<ItemStack> tmpResult = new ArrayList<ItemStack>();
			tmpResult.add(((FurnaceRecipe)recipe).getInput());
			return tmpResult;
	}
        return null;
    }
    
    public static List<RecursiveItemData> itemStackArrayToRecursiveItemDataList(final ItemStack[] itemInputs)
    {
    	List<RecursiveItemData> tmpList = new ArrayList<RecursiveItemData>();
    	
    	int prevItemIndex = -1;
    	RecursiveItemData nextItemData;
    	
        for (ItemStack itemInput: itemInputs)
        {
        	prevItemIndex = -1;
        	nextItemData = new RecursiveItemData(itemInput.getAmount(), itemInput.getTypeId(), itemInput.getData().getData());
			if (!tmpList.isEmpty())
			{
				prevItemIndex = Collections.binarySearch(tmpList, nextItemData);
				if (prevItemIndex >= 0)
				{
					tmpList.get(prevItemIndex).addAmount(itemInput.getAmount());
					continue;
				}
			}
			if (prevItemIndex < -1)
			{
				tmpList.add(Math.abs(prevItemIndex) + 1, nextItemData);
			}
			else
			{
				tmpList.add(nextItemData);
				Collections.sort(tmpList);
			}	
        }
        
        return tmpList;
    }
    
    private static RecursiveItemData takeItems(ItemStack[] inventory, RecursiveItemData takeItem)
    {
        int remainingAmount = takeItem.getAmount();
        
        short maxDurability = Material.getMaterial(takeItem.getType()).getMaxDurability();
        short remainingDamage = maxDurability;
        
        ItemStack itemSlot;
        
        for (int i = 0; i < inventory.length; i++)
        {
        	itemSlot = inventory[i];
        	
            if (itemSlot != null && itemSlot.getData() != null && itemSlot.getTypeId() == takeItem.getType() && itemSlot.getData().getData() == takeItem.getData())
            {
            	if (itemSlot.getDurability() >= 0)
            	{
            		if (itemSlot.getDurability() < remainingDamage)
            		{
            			remainingDamage -= itemSlot.getDurability();
            			continue;
            		}
            		else if (itemSlot.getDurability() > remainingDamage)
            		{
            			itemSlot.setDurability((short)(itemSlot.getDurability() - remainingDamage));
            			remainingDamage = maxDurability;
            		}
            	}
                if (remainingAmount > itemSlot.getAmount())
                {
                	remainingAmount -= itemSlot.getAmount();
                    itemSlot.setAmount(0);
                }
                else
                {
                	if (remainingAmount < itemSlot.getAmount())
                	{
                		itemSlot.setAmount(itemSlot.getAmount() - remainingAmount);
                	}
                	else
                	{
                		remainingAmount = 0;
                		itemSlot.setAmount(0);
                	}
                    break;
                }
            }
        }
        return new RecursiveItemData((int)(takeItem.getAmount() - remainingAmount), takeItem.getType(), takeItem.getData(), (maxDurability - remainingDamage));
    }

	private static List<List<RecursiveItemData>> getAllRecipesFor(ItemStack forItem)
	{
		List<List<RecursiveItemData>> ritems = new ArrayList<List<RecursiveItemData>>();

		List<Recipe> recipes = Bukkit.getServer().getRecipesFor(forItem);
		if (recipes == null || recipes.isEmpty())
		{
			return null;
		}
		
		Iterator<Recipe> recipesIterator = recipes.iterator();
		ItemStack currentItem;
		Recipe currentRecipe;
		
		while (recipesIterator.hasNext())
		{
			currentRecipe = recipesIterator.next();
			if (currentRecipe == null)
				continue;
			
			List<RecursiveItemData> ingitems = new ArrayList<RecursiveItemData>();
			Iterator<ItemStack> ingredientsIterator = getRecipeIngredients(currentRecipe).iterator();
			while (ingredientsIterator.hasNext())
			{
				currentItem = ingredientsIterator.next();
				ingitems.add(new RecursiveItemData(currentItem.getAmount(), currentItem.getTypeId(), currentItem.getData().getData(), currentItem.getDurability()));
			}	
			ritems.add(ingitems);
		}
		
		return ritems;
	}
	
	private static List<List<RecursiveItemData>> getAllRecipesFor(RecursiveItemData forItem)
	{
		return getAllRecipesFor(new ItemStack(Material.getMaterial(forItem.getType()), forItem.getAmount()));
	}
	
	public static Double getCachedPrice(RecursiveItemData forItem) {
		if (forItem != null) {
			Double tmpPrice = null;
			tmpPrice = prices.get(forItem);
			if (tmpPrice != null) {
				return (tmpPrice * forItem.getAmount());
			} else {
				missingPrices.add(forItem);
			}
		}
		return null;
	}

	public static Double getBestItemListPrice(RecursiveItemData forItem)
	{
		Double tmpPrice = null;
		tmpPrice = prices.get(forItem);
		if (tmpPrice != null) {
			return (tmpPrice * forItem.getAmount());
		}
		List<List<RecursiveItemData>> ritemsList = getAllRecipesFor(forItem);
		if (ritemsList == null || ritemsList.isEmpty())
		{
			log.warning("NO RECIPE FOR " + forItem.getType() + ":" + forItem.getData() + "!");
			return null;
		}
		
		RecursiveItemListPriceResultSet tmpRes = new RecursiveItemListPriceResultSet();
		
		Iterator<List<RecursiveItemData>> rlistIterator = ritemsList.iterator();
		List<RecursiveItemData> currentList;
		Iterator<RecursiveItemData> clistIterator;
		RecursiveItemData ritem;

		double tmpSum = 0;
		
		// OUTER LOOP FOR ALL AVAILABLE RECIPES
		outer: while (rlistIterator.hasNext())
		{
			currentList = rlistIterator.next();
			clistIterator = currentList.iterator();
			// INNER LOOP FOR ITEMS NEEDED IN CURRENT RECIPE
			while (clistIterator.hasNext()) {
				ritem = clistIterator.next();
				tmpPrice = getBestItemListPrice(ritem);
				if (tmpPrice == null) {
					log.info("    > could not calculate price!");
					// NO PRICE AVAILABLE - CONTINUE WITH NEXT RECIPE
					continue outer;
				}
				tmpSum += tmpPrice;
			}
			if (tmpSum > 0) {
				tmpRes.addToList(currentList, tmpSum);
			}
		}
		log.info("PRICE SUM: " + String.valueOf(tmpSum));
		if (tmpRes.getList().isEmpty()) {
			missingPrices.add(forItem);
			log.warning("Missing price for " + forItem.getType() + ":" + forItem.getData() + " in recursion!");
		}
		return tmpRes.getCheapest().getPricesSum();
	}