package org.broken.cheststorage.Crafting;

import org.bukkit.Material;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;

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

public class CraftingUtility {

    private Inventory inventory;

    private List<String> listOfItems;

    private boolean ifChestFull = true;

    public CraftingUtility(Inventory inventory, List<String> listOfItemsToCraft) {
        this.inventory = inventory;
        this.listOfItems = listOfItemsToCraft;
    }

    public HashMap<Integer, ItemStack> checkCraftingRecipeExist() {
        HashMap<Integer, ItemStack> outputItemsIfNoSpaceInChest = new HashMap<>();
        for (Crafting craftingRecipe : Crafting.values()) {
            String recipeValues = craftingRecipe.toString();

            String matrialNameFirst = Crafting.valueOf(recipeValues).getmatrialName();
            String matrialNameSecond = Crafting.valueOf(recipeValues).getmatrialNames1();
            String matrialNameThird = Crafting.valueOf(recipeValues).getmatrialNames2();

            int itemAmountNeededFirst = Crafting.valueOf(recipeValues).getAmontNeededCrafting();
            int itemAmountNeededSecond = Crafting.valueOf(recipeValues).getAmontNeededCrafting1();
            int itemAmountNeededThird = Crafting.valueOf(recipeValues).getAmontNeededCrafting2();


            for (String itemListForCrafting : listOfItems) {

                Map<Material, Integer> mapvalues = getItemsAmount(craftingRecipe, itemListForCrafting, inventory);


                if (!mapvalues.isEmpty()) {
                    List<ItemStack> itemStacks = convertMatrialToItemstacks(mapvalues, craftingRecipe);
                    if (matrialNameFirst != null && matrialNameSecond == null && matrialNameThird == null) {

                        if (itemListForCrafting.equals(Crafting.valueOf(recipeValues).name()) &&
                                itemStacks.get(0) != null && itemStacks.get(0).getAmount() >= itemAmountNeededFirst) {
                            inventory.remove(Material.valueOf(matrialNameFirst));
                            Material getmatrialName = Material.valueOf(Crafting.valueOf(recipeValues).name());
                            outputItemsIfNoSpaceInChest = inventory.addItem(new ItemStack(getmatrialName, Crafting.valueOf(recipeValues).getNumberOutput() * itemStacks.get(0).getAmount()));

                        }
                    } else if (matrialNameFirst != null && matrialNameSecond != null && matrialNameThird == null) {
                        if (itemListForCrafting.equals(Crafting.valueOf(recipeValues).name()) &&
                                itemStacks.get(0) != null && itemStacks.get(0).getAmount() >= itemAmountNeededFirst &&
                                itemStacks.get(1) != null && itemStacks.get(1).getAmount() >= itemAmountNeededSecond) {
                            //System.out.println("2items recipe ");
                            takeItemsRecipeIngrediens(inventory, craftingRecipe, itemStacks);
                            Material getmatrialName = Material.valueOf(Crafting.valueOf(recipeValues).name());

                            outputItemsIfNoSpaceInChest = inventory.addItem(new ItemStack(getmatrialName, Crafting.valueOf(recipeValues).getNumberOutput()));

                            if (!outputItemsIfNoSpaceInChest.isEmpty()) {
                                inventory.addItem(new ItemStack(itemStacks.get(0).getType(), itemAmountNeededFirst));
                                inventory.addItem(new ItemStack(itemStacks.get(1).getType(), itemAmountNeededSecond));
                            }
                        }

                    } else if (matrialNameFirst != null && matrialNameSecond != null && matrialNameThird != null) {

                        if (itemListForCrafting.equals(Crafting.valueOf(recipeValues).name()) &&
                                itemStacks.get(0) != null && itemStacks.get(0).getAmount() >= itemAmountNeededFirst &&
                                itemStacks.get(1) != null && itemStacks.get(1).getAmount() >= itemAmountNeededSecond &&
                                itemStacks.get(2) != null && itemStacks.get(2).getAmount() >= itemAmountNeededThird) {
                            System.out.println("matrial of items ");
                            takeItemsRecipeIngrediens(inventory, craftingRecipe, itemStacks);
                            Material getmatrialName = Material.valueOf(Crafting.valueOf(recipeValues).name());

                            outputItemsIfNoSpaceInChest = inventory.addItem(new ItemStack(getmatrialName, Crafting.valueOf(recipeValues).getNumberOutput()));

                        }
                    }
                }
            }
        }
        return outputItemsIfNoSpaceInChest;
    }

    public boolean checkIfChestFull() {

        if (checkCraftingRecipeExist().isEmpty()) {
            ifChestFull = checkCraftingRecipeExist().isEmpty();
        }
        ifChestFull = true;
        return true;
    }

    public List<ItemStack> convertMatrialToItemstacks(Map<Material, Integer> values, Crafting value) {
        List<ItemStack> itemstacks = new ArrayList<>();

        ItemStack recipeMatrial = null;
        ItemStack recipeMatrialSecond = null;
        ItemStack recipeMatrialThird = null;

        if (value.getmatrialName() != null && values.containsKey(Material.valueOf(value.getmatrialName()))) {
            Material matrialNameFirst = Material.valueOf(value.getmatrialName());
            int itemAmount = values.get(matrialNameFirst);
            recipeMatrial = new ItemStack(matrialNameFirst, itemAmount);
        }
        if (value.getmatrialNames1() != null && values.containsKey(Material.valueOf(value.getmatrialNames1()))) {
            Material matrialNameSecond = Material.valueOf(value.getmatrialNames1());
            int itemAmountSecond = values.get(matrialNameSecond);
            recipeMatrialSecond = new ItemStack(matrialNameSecond, itemAmountSecond);
        }
        if (value.getmatrialNames2() != null && values.containsKey(Material.valueOf(value.getmatrialNames2()))) {
            Material matrialNameThird = Material.valueOf(value.getmatrialNames2());
            int itemAmountThird = values.get(matrialNameThird);
            recipeMatrialThird = new ItemStack(matrialNameThird, itemAmountThird);
        }

        itemstacks.add(recipeMatrial);
        itemstacks.add(recipeMatrialSecond);
        itemstacks.add(recipeMatrialThird);

        return itemstacks;
    }

    public Map<Material, Integer> getItemsAmount(Crafting values, String listOfItems, Inventory inventory) {
        Map<Material, Integer> map = new HashMap<>();
        int amountFirst = 0;
        int amountSecond = 0;
        int amountThird = 0;

        for (ItemStack itemStacks : inventory) {
            if (listOfItems.equals(values.toString()) && itemStacks != null) {
                if (itemStacks.getType().toString().equals(values.getmatrialName())) {
                    amountFirst += itemStacks.getAmount();
                    map.put(itemStacks.getType(), amountFirst);

                } else if (itemStacks.getType().toString().equals(values.getmatrialNames1())) {
                    amountSecond += itemStacks.getAmount();
                    map.put(itemStacks.getType(), amountSecond);

                } else if (itemStacks.getType().toString().equals(values.getmatrialNames2())) {
                    amountThird += itemStacks.getAmount();
                    map.put(itemStacks.getType(), amountThird);
                }
            }
        }
        return map;
    }

    public void getItemsInventory(Inventory inventory, String matrialName) {
        for (int i = 0; i < inventory.getSize(); i++) {
            ItemStack itemStacks = inventory.getContents()[i];
            if (itemStacks != null && itemStacks.isSimilar(new ItemStack(Material.valueOf(matrialName)))) {
                inventory.setItem(i, new ItemStack(Material.AIR));
            }

        }
    }

    public void takeItemsRecipeIngrediens(Inventory inventory, Crafting values, List<ItemStack> itemStacks) {
        for (ItemStack itemStack : itemStacks)
            if (itemStack != null && itemStack.getType().toString().equals(values.getmatrialName())) {
                getItemsInventory(inventory, values.getmatrialName());
                itemStack.setAmount(itemStack.getAmount() - values.getAmontNeededCrafting());
                inventory.addItem(itemStack);
            } else if (itemStack != null && itemStack.getType().toString().equals(values.getmatrialNames1())) {
                getItemsInventory(inventory, values.getmatrialNames1());
                itemStack.setAmount(itemStack.getAmount() - values.getAmontNeededCrafting1());
                inventory.addItem(itemStack);
            } else if (itemStack != null && itemStack.getType().toString().equals(values.getmatrialNames2())) {
                getItemsInventory(inventory, values.getmatrialNames2());
                itemStack.setAmount(itemStack.getAmount() - values.getAmontNeededCrafting2());
                inventory.addItem(itemStack);

            }
    }

}