ItemBuilder.java

package me.koalaoncaffeine.itemstack;

import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.inventory.ItemFlag;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.material.MaterialData;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@FunctionalInterface
public interface ItemBuilder extends Supplier<ItemStack> {

    ItemStack getItem();

    static ItemBuilder of(ItemStack item) {
        return () -> item;
    }

    static ItemBuilder of(Material material) {
        return () -> new ItemStack(material);
    }

    static ItemBuilder of(Material material, int amount) {
        return () -> new ItemStack(material, amount);
    }

    static ItemBuilder of(Material material, int amount, byte damage) {
        return () -> new ItemStack(material, amount, damage);
    }

    static ItemBuilder of(Material material, int amount, byte damage, byte data) {
        return () -> new ItemStack(material, amount, damage, data);
    }

    default ItemBuilder setType(Material type) {
        getItem().setType(type);
        return of(getItem());
    }

    default ItemBuilder setAmount(int amount) {
        getItem().setAmount(amount);
        return this;
    }

    default ItemBuilder setName(String name) {
        applyMeta(itemMeta -> itemMeta.setDisplayName(name));
        return this;
    }

    default ItemBuilder addLore(String... lore) {
        List<String> newLore = getItem().getItemMeta().getLore();
        newLore.addAll(Arrays.asList(lore));
        applyMeta(itemMeta -> itemMeta.setLore(newLore));
        return this;
    }

    default ItemBuilder addLore(Object remove, String... lore) {
        List<String> newLore = getItem().getItemMeta().getLore();
        newLore.addAll(Arrays.asList(lore));
        newLore.remove(remove.toString());
        applyMeta(itemMeta -> itemMeta.setLore(newLore));
        return this;
    }

    default ItemBuilder removeLore(String... lore) {
        applyMeta(itemMeta -> itemMeta.getLore().removeAll(Stream.of(lore).map(line -> ChatColor.translateAlternateColorCodes('&', line)).collect(Collectors.toList())));
        return this;
    }

    default ItemBuilder removeLore(int... lore) {
        for (int i : lore) {
            applyMeta(itemMeta -> itemMeta.getLore().remove(i));
        }
        return this;
    }

    default ItemBuilder setLore(String... lines) {
        setLore(Arrays.asList(lines));
        return this;
    }

    default ItemBuilder setLore(List<String> lore) {
        applyMeta(itemMeta -> itemMeta.setLore(lore.stream().map(line -> ChatColor.translateAlternateColorCodes('&', line)).collect(Collectors.toList())));
        return this;
    }

    default ItemBuilder setData(MaterialData data) {
        getItem().setData(data);
        return this;
    }

    default ItemBuilder setDurability(int durability) {
        getItem().setDurability((short) durability);
        return this;
    }

    default ItemBuilder setMeta(ItemMeta meta) {
        getItem().setItemMeta(meta);
        return this;
    }

    default ItemBuilder applyMeta(Consumer<ItemMeta> action) {
        return applyMeta(ItemMeta.class, action);
    }

    default <T extends ItemMeta> ItemBuilder applyMeta(Class<T> metaType, Consumer<T> action) {
        if (!getItem().hasItemMeta())
            getItem().setItemMeta(new ItemStack(getItem()).getItemMeta());
        final ItemMeta meta = getItem().getItemMeta();
        if (meta != null) {
            action.accept(metaType.cast(meta));
            getItem().setItemMeta(meta);
        }
        return this;
    }

    default ItemBuilder addEnchantment(Enchantment enchantment) {
        addEnchantment(enchantment, 1);
        return this;
    }

    default ItemBuilder addEnchantment(Enchantment enchantment, int level) {
        getItem().addEnchantment(enchantment, level);
        return this;
    }

    default ItemBuilder addEnchantment(Map<Enchantment, Integer> enchantments) {
        getItem().addEnchantments(enchantments);
        return this;
    }

    default ItemBuilder addUnsafeEnchantment(Enchantment enchantment) {
        addUnsafeEnchantment(enchantment, 1);
        return this;
    }

    default ItemBuilder addUnsafeEnchantment(Enchantment enchantment, int level) {
        getItem().addUnsafeEnchantment(enchantment, level);
        return this;
    }

    default ItemBuilder addUnsafeEnchantment(Map<Enchantment, Integer> enchantments) {
        getItem().addUnsafeEnchantments(enchantments);
        return this;
    }

    default ItemBuilder setFlags(ItemFlag... flags) {
        return applyMeta(itemMeta -> {
            itemMeta.getItemFlags().forEach(itemMeta.getItemFlags()::remove);
            itemMeta.addItemFlags(flags);
        });
    }

    default ItemBuilder addFlags(ItemFlag... flags) {
        return applyMeta(itemMeta -> itemMeta.addItemFlags(flags));
    }

    default ItemBuilder removeFlags(ItemFlag... flags) {
        return applyMeta(itemMeta -> itemMeta.removeItemFlags(flags));
    }

    default ItemBuilder setUnbreakable(boolean unbreakable) {
        return applyMeta(itemMeta -> itemMeta.spigot().setUnbreakable(unbreakable));
    }

	@Override
    default ItemStack get() {
        return getItem();
    }

}