Calculator.java

package org.styxl.slimefuncalculator;


import java.io.IOException;

import java.util.Map;

import org.bukkit.command.CommandSender;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;


public class Calculator {


    public static void calculateWrapper(CommandSender sender, String[] args) throws IOException {

        String mode = args[0];
        String[] order = Arrays.copyOfRange(args, 1, args.length);

        Map<String, Map<String, String>> itemDict = ItemDict.getItemDict();
        Map<String, Integer> recursionMap = new HashMap<String, Integer>();
        Map<String, String> dummyOrderItemRecipe = new HashMap<String, String>();

        for (int i = 0; i < (order.length); i += 2) {

            String item = order[i];
            Integer coefficient = Integer.valueOf(order[i + 1]);

            dummyOrderItemRecipe.put(item, Integer.toString(coefficient));

            if (mode == "normal") {

                Map<String, String> recipe = itemDict.get(item);

                for (String material : recipe.keySet()) {

                    itemDict.put(material, null); // block recursive calls for the "normal" usecase by turning all ingredients as "raw"

                }

            }

        }

        itemDict.put("dummyOrderItem", dummyOrderItemRecipe);

        Map<String, Map<String, Integer>> result = calculate("dummyOrderItem", 1, itemDict, new HashMap<String, Integer>(), new HashMap<String, Integer>());

        sendResult(sender, mode, dummyOrderItemRecipe, result);

    }


    public static Map<String, Map<String, Integer>> calculate(String item,
                                                              int n,
                                                              Map<String, Map<String, String>> itemDict,
                                                              Map<String, Integer> recursionMap,
                                                              Map<String, Integer> wasteMap) {


        Map<String, String> recipe = itemDict.get(item);

        if (recipe == null) {

            if (recursionMap.containsKey(item)) {

                recursionMap.put(item, recursionMap.get(item) + n);

            }

            else {

                recursionMap.put(item, n);

            }

        }

        else {

            for (Map.Entry<String, String> entry : recipe.entrySet()) {

                String material = entry.getKey();
                String coefficient = entry.getValue();

                int frac = coefficient.indexOf('/');

                if (frac == -1) {

                    calculate(material, Integer.parseInt(coefficient) * n, itemDict, recursionMap, wasteMap);

                }

                else {

                    // Handling fractions and by extension waste products
                    int nominator = Integer.parseInt(coefficient.substring(0, frac));
                    int denominator = Integer.parseInt(coefficient.substring(frac + 1, coefficient.length()));

                    int waste = 0;
                    int required = waste + n;

                    boolean found = false;
                    while (!found) {

                        if (required % denominator == 0) {

                            found = true;

                        }

                        else {

                            waste++;
                            required = waste + n;

                        }

                    }

                    int passedOnAmount = nominator * required;

                    if (waste != 0) {

                        wasteMap.put(item, waste);

                    }

                    calculate(material, passedOnAmount, itemDict, recursionMap, wasteMap);

                }

            }

        }

        Map<String, Map<String, Integer>> result = new HashMap<String, Map<String, Integer>>();
        result.put("materials", recursionMap);
        result.put("waste", wasteMap);

        return result;

    }


    public static void sendResult(CommandSender sender, String mode, Map<String, String> order, Map<String, Map<String, Integer>> result) {

        String introOrder = "";
        List<String> costs = new ArrayList<String>();

        for(Map.Entry<String, String> entry : order.entrySet()) {
            String material = entry.getKey();
            String amount = entry.getValue();
            introOrder += amount + " " + material + ", ";
        }

        introOrder = introOrder.substring(0, introOrder.length()-2); //remove trailing comma and whitespace

        for(Map.Entry<String, Integer> entry : result.get("materials").entrySet()) {
            String material = entry.getKey();
            Integer amount = entry.getValue();
            int stacks;

            if (amount >= 64) {
                stacks = amount / 64;
            }
            else {
                stacks = 0;
            }

            int stackLeftover = amount - stacks * 64;
            costs.add(String.format("%s: %d stacks, %d items", material, stacks, stackLeftover));
        }

        String intro = String.format("%s cost for %s is:", mode, introOrder);
        sender.sendMessage("----------------------SFC-------------------------");
        sender.sendMessage(intro);
        for(String item : costs) {
            sender.sendMessage(item);
        }
        Map<String, Integer> waste = result.get("waste");
        if (!waste.isEmpty()) {
            sender.sendMessage("Waste products:");
            for(Map.Entry<String, Integer> entry : waste.entrySet()) {

                sender.sendMessage(String.format("%s: %d", entry.getKey(), entry.getValue()));

            }
        }
        sender.sendMessage("----------------------SFC-------------------------");

    }


}