TF-EssentialsX/Essentials/src/com/earth2me/essentials/MetaItemStack.java

package com.earth2me.essentials;

import com.earth2me.essentials.textreader.BookInput;
import com.earth2me.essentials.textreader.BookPager;
import com.earth2me.essentials.textreader.IText;
import com.earth2me.essentials.utils.FormatUtil;
import com.earth2me.essentials.utils.NumberUtil;
import com.google.common.base.Joiner;
import net.ess3.api.IEssentials;
import org.bukkit.Color;
import org.bukkit.DyeColor;
import org.bukkit.FireworkEffect;
import org.bukkit.Material;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.*;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;

import java.util.*;
import java.util.logging.Level;
import java.util.regex.Pattern;

import static com.earth2me.essentials.I18n.tl;


public class MetaItemStack {
    private static final Map<String, DyeColor> colorMap = new HashMap<String, DyeColor>();
    private static final Map<String, FireworkEffect.Type> fireworkShape = new HashMap<String, FireworkEffect.Type>();

    static {
        for (DyeColor color : DyeColor.values()) {
            colorMap.put(color.name(), color);
        }
        for (FireworkEffect.Type type : FireworkEffect.Type.values()) {
            fireworkShape.put(type.name(), type);
        }
    }

    private final transient Pattern splitPattern = Pattern.compile("[:+',;.]");
    private ItemStack stack;
    private FireworkEffect.Builder builder = FireworkEffect.builder();
    private PotionEffectType pEffectType;
    private PotionEffect pEffect;
    private boolean validFirework = false;
    private boolean validPotionEffect = false;
    private boolean validPotionDuration = false;
    private boolean validPotionPower = false;
    private boolean completePotion = false;
    private int power = 1;
    private int duration = 120;

    public MetaItemStack(final ItemStack stack) {
        this.stack = stack.clone();
    }

    public ItemStack getItemStack() {
        return stack;
    }

    public boolean isValidFirework() {
        return validFirework;
    }

    public boolean isValidPotion() {
        return validPotionEffect && validPotionDuration && validPotionPower;
    }

    public FireworkEffect.Builder getFireworkBuilder() {
        return builder;
    }

    public PotionEffect getPotionEffect() {
        return pEffect;
    }

    public boolean completePotion() {
        return completePotion;
    }

    private void resetPotionMeta() {
        pEffect = null;
        pEffectType = null;
        validPotionEffect = false;
        validPotionDuration = false;
        validPotionPower = false;
        completePotion = true;
    }

    public boolean canSpawn(final IEssentials ess) {
        try {
            ess.getServer().getUnsafe().modifyItemStack(stack, "{}");
            return true;
        } catch (NullPointerException npe) {
            if (ess.getSettings().isDebug()) {
                ess.getLogger().log(Level.INFO, "Itemstack is invalid", npe);
            }
            return false;
        } catch (NoSuchMethodError nsme) {
            return true;
        } catch (Throwable throwable) {
            if (ess.getSettings().isDebug()) {
                ess.getLogger().log(Level.INFO, "Itemstack is invalid", throwable);
            }
            return false;
        }
    }

    public void parseStringMeta(final CommandSource sender, final boolean allowUnsafe, String[] string, int fromArg, final IEssentials ess) throws Exception {
        if (string[fromArg].startsWith("{") && hasMetaPermission(sender, "vanilla", false, true, ess)) {
            try {
                stack = ess.getServer().getUnsafe().modifyItemStack(stack, Joiner.on(' ').join(Arrays.asList(string).subList(fromArg, string.length)));
            } catch (NullPointerException npe) {
                if (ess.getSettings().isDebug()) {
                    ess.getLogger().log(Level.INFO, "Itemstack is invalid", npe);
                }
            } catch (NoSuchMethodError nsme) {
                throw new Exception(tl("noMetaJson"), nsme);
            } catch (Throwable throwable) {
                throw new Exception(throwable.getMessage(), throwable);
            }
        } else {
            for (int i = fromArg; i < string.length; i++) {
                addStringMeta(sender, allowUnsafe, string[i], ess);
            }
            if (validFirework) {
                if (!hasMetaPermission(sender, "firework", true, true, ess)) {
                    throw new Exception(tl("noMetaFirework"));
                }
                FireworkEffect effect = builder.build();
                FireworkMeta fmeta = (FireworkMeta) stack.getItemMeta();
                fmeta.addEffect(effect);
                if (fmeta.getEffects().size() > 1 && !hasMetaPermission(sender, "firework-multiple", true, true, ess)) {
                    throw new Exception(tl("multipleCharges"));
                }
                stack.setItemMeta(fmeta);
            }
        }
    }

    public void addStringMeta(final CommandSource sender, final boolean allowUnsafe, final String string, final IEssentials ess) throws Exception {
        final String[] split = splitPattern.split(string, 2);
        if (split.length < 1) {
            return;
        }

        if (split.length > 1 && split[0].equalsIgnoreCase("name") && hasMetaPermission(sender, "name", false, true, ess)) {
            final String displayName = FormatUtil.replaceFormat(split[1].replace('_', ' '));
            final ItemMeta meta = stack.getItemMeta();
            meta.setDisplayName(displayName);
            stack.setItemMeta(meta);
        } else if (split.length > 1 && (split[0].equalsIgnoreCase("lore") || split[0].equalsIgnoreCase("desc")) && hasMetaPermission(sender, "lore", false, true, ess)) {
            final List<String> lore = new ArrayList<String>();
            for (String line : split[1].split("\\|")) {
                lore.add(FormatUtil.replaceFormat(line.replace('_', ' ')));
            }
            final ItemMeta meta = stack.getItemMeta();
            meta.setLore(lore);
            stack.setItemMeta(meta);
        } else if (split.length > 1 && (split[0].equalsIgnoreCase("player") || split[0].equalsIgnoreCase("owner")) && stack.getType() == Material.SKULL_ITEM && hasMetaPermission(sender, "head", false, true, ess)) {
            if (stack.getDurability() == 3) {
                final String owner = split[1];
                final SkullMeta meta = (SkullMeta) stack.getItemMeta();
                meta.setOwner(owner);
                stack.setItemMeta(meta);
            } else {
                throw new Exception(tl("onlyPlayerSkulls"));
            }
        } else if (split.length > 1 && split[0].equalsIgnoreCase("book") && stack.getType() == Material.WRITTEN_BOOK && (hasMetaPermission(sender, "book", true, true, ess) || hasMetaPermission(sender, "chapter-" + split[1].toLowerCase(Locale.ENGLISH), true, true, ess))) {
            final BookMeta meta = (BookMeta) stack.getItemMeta();
            final IText input = new BookInput("book", true, ess);
            final BookPager pager = new BookPager(input);

            List<String> pages = pager.getPages(split[1]);
            meta.setPages(pages);
            stack.setItemMeta(meta);
        } else if (split.length > 1 && split[0].equalsIgnoreCase("author") && stack.getType() == Material.WRITTEN_BOOK && hasMetaPermission(sender, "author", false, true, ess)) {
            final String author = FormatUtil.replaceFormat(split[1]);
            final BookMeta meta = (BookMeta) stack.getItemMeta();
            meta.setAuthor(author);
            stack.setItemMeta(meta);
        } else if (split.length > 1 && split[0].equalsIgnoreCase("title") && stack.getType() == Material.WRITTEN_BOOK && hasMetaPermission(sender, "title", false, true, ess)) {
            final String title = FormatUtil.replaceFormat(split[1].replace('_', ' '));
            final BookMeta meta = (BookMeta) stack.getItemMeta();
            meta.setTitle(title);
            stack.setItemMeta(meta);
        } else if (split.length > 1 && split[0].equalsIgnoreCase("power") && stack.getType() == Material.FIREWORK && hasMetaPermission(sender, "firework-power", false, true, ess)) {
            final int power = NumberUtil.isInt(split[1]) ? Integer.parseInt(split[1]) : 0;
            final FireworkMeta meta = (FireworkMeta) stack.getItemMeta();
            meta.setPower(power > 3 ? 4 : power);
            stack.setItemMeta(meta);
        } else if (stack.getType() == Material.FIREWORK) //WARNING - Meta for fireworks will be ignored after this point.
        {
            addFireworkMeta(sender, false, string, ess);
        } else if (stack.getType() == Material.POTION) //WARNING - Meta for potions will be ignored after this point.
        {
            addPotionMeta(sender, false, string, ess);
        } else if (split.length > 1 && (split[0].equalsIgnoreCase("color") || split[0].equalsIgnoreCase("colour")) && (stack.getType() == Material.LEATHER_BOOTS || stack.getType() == Material.LEATHER_CHESTPLATE || stack.getType() == Material.LEATHER_HELMET || stack.getType() == Material.LEATHER_LEGGINGS)) {
            final String[] color = split[1].split("(\\||,)");
            if (color.length == 3) {
                final int red = NumberUtil.isInt(color[0]) ? Integer.parseInt(color[0]) : 0;
                final int green = NumberUtil.isInt(color[1]) ? Integer.parseInt(color[1]) : 0;
                final int blue = NumberUtil.isInt(color[2]) ? Integer.parseInt(color[2]) : 0;
                final LeatherArmorMeta meta = (LeatherArmorMeta) stack.getItemMeta();
                meta.setColor(Color.fromRGB(red, green, blue));
                stack.setItemMeta(meta);
            } else {
                throw new Exception(tl("leatherSyntax"));
            }
        } else {
            parseEnchantmentStrings(sender, allowUnsafe, split, ess);
        }
    }

    public void addFireworkMeta(final CommandSource sender, final boolean allowShortName, final String string, final IEssentials ess) throws Exception {
        if (stack.getType() == Material.FIREWORK) {
            final String[] split = splitPattern.split(string, 2);

            if (split.length < 2) {
                return;
            }

            if (split[0].equalsIgnoreCase("color") || split[0].equalsIgnoreCase("colour") || (allowShortName && split[0].equalsIgnoreCase("c"))) {
                if (validFirework) {
                    if (!hasMetaPermission(sender, "firework", true, true, ess)) {
                        throw new Exception(tl("noMetaFirework"));
                    }
                    FireworkEffect effect = builder.build();
                    FireworkMeta fmeta = (FireworkMeta) stack.getItemMeta();
                    fmeta.addEffect(effect);
                    if (fmeta.getEffects().size() > 1 && !hasMetaPermission(sender, "firework-multiple", true, true, ess)) {
                        throw new Exception(tl("multipleCharges"));
                    }
                    stack.setItemMeta(fmeta);
                    builder = FireworkEffect.builder();
                }

                List<Color> primaryColors = new ArrayList<Color>();
                String[] colors = split[1].split(",");
                for (String color : colors) {
                    if (colorMap.containsKey(color.toUpperCase())) {
                        validFirework = true;
                        primaryColors.add(colorMap.get(color.toUpperCase()).getFireworkColor());
                    } else {
                        throw new Exception(tl("invalidFireworkFormat", split[1], split[0]));
                    }
                }
                builder.withColor(primaryColors);
            } else if (split[0].equalsIgnoreCase("shape") || split[0].equalsIgnoreCase("type") || (allowShortName && (split[0].equalsIgnoreCase("s") || split[0].equalsIgnoreCase("t")))) {
                FireworkEffect.Type finalEffect = null;
                split[1] = (split[1].equalsIgnoreCase("large") ? "BALL_LARGE" : split[1]);
                if (fireworkShape.containsKey(split[1].toUpperCase())) {
                    finalEffect = fireworkShape.get(split[1].toUpperCase());
                } else {
                    throw new Exception(tl("invalidFireworkFormat", split[1], split[0]));
                }
                if (finalEffect != null) {
                    builder.with(finalEffect);
                }
            } else if (split[0].equalsIgnoreCase("fade") || (allowShortName && split[0].equalsIgnoreCase("f"))) {
                List<Color> fadeColors = new ArrayList<Color>();
                String[] colors = split[1].split(",");
                for (String color : colors) {
                    if (colorMap.containsKey(color.toUpperCase())) {
                        fadeColors.add(colorMap.get(color.toUpperCase()).getFireworkColor());
                    } else {
                        throw new Exception(tl("invalidFireworkFormat", split[1], split[0]));
                    }
                }
                if (!fadeColors.isEmpty()) {
                    builder.withFade(fadeColors);
                }
            } else if (split[0].equalsIgnoreCase("effect") || (allowShortName && split[0].equalsIgnoreCase("e"))) {
                String[] effects = split[1].split(",");
                for (String effect : effects) {
                    if (effect.equalsIgnoreCase("twinkle")) {
                        builder.flicker(true);
                    } else if (effect.equalsIgnoreCase("trail")) {
                        builder.trail(true);
                    } else {
                        throw new Exception(tl("invalidFireworkFormat", split[1], split[0]));
                    }
                }
            }
        }
    }

    public void addPotionMeta(final CommandSource sender, final boolean allowShortName, final String string, final IEssentials ess) throws Exception {
        if (stack.getType() == Material.POTION) {
            final String[] split = splitPattern.split(string, 2);

            if (split.length < 2) {
                return;
            }

            if (split[0].equalsIgnoreCase("effect") || (allowShortName && split[0].equalsIgnoreCase("e"))) {
                pEffectType = Potions.getByName(split[1]);
                if (pEffectType != null && pEffectType.getName() != null) {
                    if (hasMetaPermission(sender, "potions." + pEffectType.getName().toLowerCase(Locale.ENGLISH), true, false, ess)) {
                        validPotionEffect = true;
                    } else {
                        throw new Exception(tl("noPotionEffectPerm", pEffectType.getName().toLowerCase(Locale.ENGLISH)));
                    }
                } else {
                    throw new Exception(tl("invalidPotionMeta", split[1]));
                }
            } else if (split[0].equalsIgnoreCase("power") || (allowShortName && split[0].equalsIgnoreCase("p"))) {
                if (NumberUtil.isInt(split[1])) {
                    validPotionPower = true;
                    power = Integer.parseInt(split[1]);
                    if (power > 0 && power < 4) {
                        power -= 1;
                    }
                } else {
                    throw new Exception(tl("invalidPotionMeta", split[1]));
                }
            } else if (split[0].equalsIgnoreCase("duration") || (allowShortName && split[0].equalsIgnoreCase("d"))) {
                if (NumberUtil.isInt(split[1])) {
                    validPotionDuration = true;
                    duration = Integer.parseInt(split[1]) * 20; //Duration is in ticks by default, converted to seconds
                } else {
                    throw new Exception(tl("invalidPotionMeta", split[1]));
                }
            }

            if (isValidPotion()) {
                PotionMeta pmeta = (PotionMeta) stack.getItemMeta();
                pEffect = pEffectType.createEffect(duration, power);
                if (pmeta.getCustomEffects().size() > 1 && !hasMetaPermission(sender, "potions.multiple", true, false, ess)) {
                    throw new Exception(tl("multiplePotionEffects"));
                }
                pmeta.addCustomEffect(pEffect, true);
                stack.setItemMeta(pmeta);
                resetPotionMeta();
            }
        }
    }

    private void parseEnchantmentStrings(final CommandSource sender, final boolean allowUnsafe, final String[] split, final IEssentials ess) throws Exception {
        final Enchantment enchantment = Enchantments.getByName(split[0]);
        if (enchantment == null || !hasMetaPermission(sender, "enchantments." + enchantment.getName().toLowerCase(Locale.ENGLISH), false, false, ess)) {
            return;
        }

        int level = -1;
        if (split.length > 1) {
            try {
                level = Integer.parseInt(split[1]);
            } catch (NumberFormatException ex) {
                level = -1;
            }
        }

        if (level < 0 || (!allowUnsafe && level > enchantment.getMaxLevel())) {
            level = enchantment.getMaxLevel();
        }
        addEnchantment(sender, allowUnsafe, enchantment, level);
    }

    public void addEnchantment(final CommandSource sender, final boolean allowUnsafe, final Enchantment enchantment, final int level) throws Exception {
        if (enchantment == null) {
            throw new Exception(tl("enchantmentNotFound"));
        }
        try {
            if (stack.getType().equals(Material.ENCHANTED_BOOK)) {
                EnchantmentStorageMeta meta = (EnchantmentStorageMeta) stack.getItemMeta();
                if (level == 0) {
                    meta.removeStoredEnchant(enchantment);
                } else {
                    meta.addStoredEnchant(enchantment, level, allowUnsafe);
                }
                stack.setItemMeta(meta);
            } else // all other material types besides ENCHANTED_BOOK
            {
                if (level == 0) {
                    stack.removeEnchantment(enchantment);
                } else {
                    if (allowUnsafe) {
                        stack.addUnsafeEnchantment(enchantment, level);
                    } else {
                        stack.addEnchantment(enchantment, level);
                    }
                }
            }
        } catch (Exception ex) {
            throw new Exception("Enchantment " + enchantment.getName() + ": " + ex.getMessage(), ex);
        }
    }

    public Enchantment getEnchantment(final User user, final String name) throws Exception {
        final Enchantment enchantment = Enchantments.getByName(name);
        if (enchantment == null) {
            return null;
        }

        final String enchantmentName = enchantment.getName().toLowerCase(Locale.ENGLISH);

        if (!hasMetaPermission(user, "enchantments." + enchantmentName, true, false)) {
            throw new Exception(tl("enchantmentPerm", enchantmentName));
        }
        return enchantment;
    }

    private boolean hasMetaPermission(final CommandSource sender, final String metaPerm, final boolean graceful, final boolean includeBase, final IEssentials ess) throws Exception {
        final User user = sender != null && sender.isPlayer() ? ess.getUser(sender.getPlayer()) : null;
        return hasMetaPermission(user, metaPerm, graceful, includeBase);
    }

    private boolean hasMetaPermission(final User user, final String metaPerm, final boolean graceful, final boolean includeBase) throws Exception {
        final String permBase = includeBase ? "essentials.itemspawn.meta-" : "essentials.";
        if (user == null || user.isAuthorized(permBase + metaPerm)) {
            return true;
        }

        if (graceful) {
            return false;
        } else {
            throw new Exception(tl("noMetaPerm", metaPerm));
        }
    }
}