TotalFreedomMod/commons/src/main/java/me/totalfreedom/totalfreedommod/command/Command_enchant.java

package me.totalfreedom.totalfreedommod.command;

import me.totalfreedom.totalfreedommod.command.handling.CommandParameters;
import me.totalfreedom.totalfreedommod.command.handling.CommandPermissions;
import me.totalfreedom.totalfreedommod.command.handling.FreedomCommand;
import me.totalfreedom.totalfreedommod.command.handling.SourceType;
import me.totalfreedom.totalfreedommod.config.ConfigEntry;
import me.totalfreedom.totalfreedommod.util.FUtil;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import org.bukkit.Material;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;

import java.util.*;
import java.util.stream.IntStream;

@CommandPermissions(permission = "enchant", source = SourceType.ONLY_IN_GAME)
@CommandParameters(description = "Enchant items.", usage = "/<command> <list | addall | reset | add <name> [level] | remove <name>>")
public class Command_enchant extends FreedomCommand
{
    @SuppressWarnings("deprecation")
    @Override
    public boolean run(CommandSender sender, Player playerSender, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
    {
        if (args.length < 1)
        {
            return false;
        }

        ItemStack item = Objects.requireNonNull(playerSender.getEquipment()).getItemInMainHand();

        if (item.getType() == Material.AIR)
        {
            msgNew("<red>You have to hold an item to enchant it.");
            return true;
        }

        if (args[0].equalsIgnoreCase("list"))
        {
            List<String> enchants = Arrays.stream(Enchantment.values()).filter(enchantment -> enchantment.canEnchantItem(item)).map(enchantment -> enchantment.getName()).toList();

            if (enchants.isEmpty())
            {
                msgNew("<red>There are no enchantments that work with this item.");
            } else
            {
                msgNew("Possible enchantments for this item: <enchants>", Placeholder.unparsed("enchants", FUtil.listToString(enchants)));
            }
        } else if (args[0].equalsIgnoreCase("addall"))
        {
            Arrays.stream(Enchantment.values()).filter(enchantment -> enchantment.canEnchantItem(item)).forEach(ench ->
            {
                try
                {
                    item.addEnchantment(ench, ench.getMaxLevel());
                } catch (Exception ignored)
                {
                }
            });

            msgNew("<green>Added all possible enchantments for this item.");
        } else if (args[0].equalsIgnoreCase("reset"))
        {
            item.getEnchantments().keySet().forEach(item::removeEnchantment);
            msgNew("<green>Removed all enchantments.");
        } else
        {
            if (args.length < 2)
            {
                return false;
            }

            Enchantment ench = Enchantment.getByName(args[1].toUpperCase());

            if (ench == null)
            {
                msgNew("<red><enchant> is an invalid enchantment for the held item. Type \"/enchant list\" for valid enchantments for this item.", Placeholder.unparsed("enchant", args[1]));
                return true;
            }

            if (args[0].equalsIgnoreCase("add"))
            {
                if (!ench.canEnchantItem(item) && !ConfigEntry.ALLOW_UNSAFE_ENCHANTMENTS.getBoolean())
                {
                    msgNew("<red>Can't use this enchantment on that item.");
                    return true;
                }
                int level = ench.getMaxLevel();
                if (args.length > 2)
                {
                    try
                    {
                        if (ConfigEntry.ALLOW_UNSAFE_ENCHANTMENTS.getBoolean())
                        {
                            level = Integer.parseInt(args[2]);
                        } else
                        {
                            level = Math.max(1, Math.min(ench.getMaxLevel(), Integer.parseInt(args[2])));
                        }
                    } catch (NumberFormatException ex)
                    {
                        msgNew("Invalid number: <number>", Placeholder.unparsed("number", args[2]));
                        return true;
                    }
                }
                if (!ConfigEntry.ALLOW_UNSAFE_ENCHANTMENTS.getBoolean())
                {
                    item.addEnchantment(ench, level);
                } else
                {
                    item.addUnsafeEnchantment(ench, level);
                }

                msgNew("<green>Added enchantment: <enchantment>", Placeholder.unparsed("enchantment", ench.getName()));
            } else if (args[0].equals("remove"))
            {
                item.removeEnchantment(ench);

                msgNew("<green>Removed enchantment: <enchantment>", Placeholder.unparsed("enchantment", ench.getName()));
            }
        }

        return true;
    }

    @SuppressWarnings("deprecation")
    public List<String> getAllEnchantments()
    {
        List<String> enchantments = new ArrayList<>();
        for (Enchantment enchantment : Enchantment.values())
        {
            enchantments.add(enchantment.getName());
        }
        return enchantments;
    }

    @SuppressWarnings("deprecation")
    public List<String> getAllEnchantments(ItemStack item)
    {
        List<String> enchantments = new ArrayList<>();
        for (Enchantment enchantment : Enchantment.values())
        {
            if (enchantment.canEnchantItem(item))
            {
                enchantments.add(enchantment.getName());
            }
        }
        return enchantments;
    }

    @SuppressWarnings("deprecation")
    public List<String> getEnchantments(ItemStack item)
    {
        List<String> enchantments = new ArrayList<>();
        for (Enchantment enchantment : item.getEnchantments().keySet())
        {
            enchantments.add(enchantment.getName());
        }
        return enchantments;
    }

    @SuppressWarnings("deprecation")
    @Override
    public List<String> getTabCompleteOptions(CommandSender sender, Command command, String alias, String[] args)
    {
        Player player;
        if (sender instanceof Player)
        {
            player = (Player) sender;
        } else
        {
            return Collections.emptyList();
        }
        ItemStack item = Objects.requireNonNull(player.getEquipment()).getItemInMainHand();

        if (item.getType() == Material.AIR)
        {
            return Collections.emptyList();
        }

        boolean unsafe = ConfigEntry.ALLOW_UNSAFE_ENCHANTMENTS.getBoolean();

        if (args.length == 1)
        {
            return Arrays.asList("list", "addall", "reset", "add", "remove");
        } else if (args.length == 2)
        {
            if (args[0].equals("add"))
            {
                if (unsafe)
                {
                    return getAllEnchantments();
                } else
                {
                    return getAllEnchantments(item);
                }
            } else if (args[0].equals("remove"))
            {
                return getEnchantments(item);
            }
        } else if (args.length == 3 && args[0].equals("add"))
        {
            Enchantment enchantment = Enchantment.getByName(args[1].toUpperCase());
            if (enchantment != null)
            {
                if (!unsafe)
                {
                    return IntStream.rangeClosed(1, enchantment.getMaxLevel()).mapToObj(String::valueOf).toList();
                } else
                {
                    return Collections.singletonList("[level]");
                }
            }
        }

        return Collections.emptyList();
    }
}