Commands.java

package ch.njol.skript.command;

import ch.njol.skript.ScriptLoader;
import ch.njol.skript.Skript;
import ch.njol.skript.SkriptConfig;
import ch.njol.skript.lang.Effect;
import ch.njol.skript.lang.TriggerItem;
import ch.njol.skript.lang.parser.ParserInstance;
import ch.njol.skript.localization.ArgsMessage;
import ch.njol.skript.localization.Message;
import ch.njol.skript.log.RetainingLogHandler;
import ch.njol.skript.log.SkriptLogger;
import ch.njol.skript.variables.Variables;
import com.google.common.base.Preconditions;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.ConsoleCommandSender;
import org.bukkit.command.SimpleCommandMap;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.AsyncPlayerChatEvent;
import org.bukkit.help.HelpMap;
import org.bukkit.help.HelpTopic;
import org.bukkit.plugin.SimplePluginManager;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.NotNull;
import org.skriptlang.skript.bukkit.text.TextComponentParser;
import org.skriptlang.skript.lang.script.Script;

import java.io.File;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.regex.Pattern;

//TODO option to disable replacement of <color>s in command arguments?

/**
 * @author Peter Güttinger
 */
@SuppressWarnings("deprecation")
public abstract class Commands {

	public final static ArgsMessage m_too_many_arguments = new ArgsMessage("commands.too many arguments");
	public final static Message m_internal_error = new Message("commands.internal error");
	public final static Message m_correct_usage = new Message("commands.correct usage");

	/**
	 * A Converter flag declaring that a Converter cannot be used for parsing command arguments.
	 */
	public static final int CONVERTER_NO_COMMAND_ARGUMENTS = 8;

	private final static Map<String, ScriptCommand> commands = new HashMap<>();

	@Nullable
	private static SimpleCommandMap commandMap = null;
	@Nullable
	private static Map<String, Command> cmKnownCommands;
	@Nullable
	private static Set<String> cmAliases;

	static {
		init(); // separate method for the annotation
	}
	public static Set<String> getScriptCommands(){
		return commands.keySet();
	}

	@Nullable
	public static SimpleCommandMap getCommandMap(){
		return commandMap;
	}

	@SuppressWarnings({"unchecked", "removal"})
	private static void init() {
		try {
			if (Bukkit.getPluginManager() instanceof SimplePluginManager) {
				Field commandMapField = SimplePluginManager.class.getDeclaredField("commandMap");
				commandMapField.setAccessible(true);
				commandMap = (SimpleCommandMap) commandMapField.get(Bukkit.getPluginManager());

				Field knownCommandsField = SimpleCommandMap.class.getDeclaredField("knownCommands");
				knownCommandsField.setAccessible(true);
				cmKnownCommands = (Map<String, Command>) knownCommandsField.get(commandMap);

				try {
					Field aliasesField = SimpleCommandMap.class.getDeclaredField("aliases");
					aliasesField.setAccessible(true);
					cmAliases = (Set<String>) aliasesField.get(commandMap);
				} catch (NoSuchFieldException ignored) {}
			}
		} catch (SecurityException e) {
			Skript.error("Please disable the security manager");
			commandMap = null;
		} catch (Exception e) {
			Skript.outdatedError(e);
			commandMap = null;
		}
	}

	@Nullable
	public static List<Argument<?>> currentArguments = null;

	@SuppressWarnings("null")
	private final static Pattern escape = Pattern.compile("[" + Pattern.quote("(|)<>%\\") + "]");
	@SuppressWarnings("null")
	private final static Pattern unescape = Pattern.compile("\\\\[" + Pattern.quote("(|)<>%\\") + "]");

	public static String escape(String string) {
		return "" + escape.matcher(string).replaceAll("\\\\$0");
	}

	public static String unescape(String string) {
		return "" + unescape.matcher(string).replaceAll("$0");
	}

	static boolean handleEffectCommand(CommandSender sender, String command) {
		if (!(Skript.testing() || sender instanceof ConsoleCommandSender || sender.hasPermission("skript.effectcommands") || SkriptConfig.allowOpsToUseEffectCommands.value() && sender.isOp()))
			return false;
		try {
			command = "" + command.substring(SkriptConfig.effectCommandToken.value().length()).trim();
			RetainingLogHandler log = SkriptLogger.startRetainingLog();
			try {
				// Call the event on the Bukkit API for addon developers.
				EffectCommandEvent effectCommand = new EffectCommandEvent(sender, command);
				Bukkit.getPluginManager().callEvent(effectCommand);
				command = effectCommand.getCommand();
				ParserInstance parserInstance = ParserInstance.get();
				parserInstance.setCurrentEvent("effect command", EffectCommandEvent.class);
				Effect effect = Effect.parse(command, null);
				parserInstance.deleteCurrentEvent();

				TextComponentParser textParser = TextComponentParser.instance();
				if (effect != null) {
					log.clear(); // ignore warnings and stuff
					log.printLog();
					if (!effectCommand.isCancelled()) {
						sender.sendMessage(textParser.parse("<gray>Executing '" + textParser.escape(command) + "'"));
						if (SkriptConfig.logEffectCommands.value() && !(sender instanceof ConsoleCommandSender))
							Skript.info(sender.getName() + " issued effect command: " + textParser.escape(command));
						TriggerItem.walk(effect, effectCommand);
						Variables.removeLocals(effectCommand);
					} else {
						sender.sendMessage(textParser.parse("<red>Your effect command '" + textParser.escape(command) + "' was cancelled."));
					}
				} else {
					if (sender == Bukkit.getConsoleSender()) // log as SEVERE instead of INFO like printErrors below
						// No need to escape command here, logger will do it
						SkriptLogger.LOGGER.severe("Error in: " + command);
					else
						sender.sendMessage(textParser.parse("<red>Error in: <gray>" + textParser.escape(command)));
					// TODO errors likely need to be escaped too
					log.printErrors(sender, "(No specific information is available)");
				}
			} finally {
				log.stop();
			}
			return true;
		} catch (Exception e) {
			Skript.exception(e, "Unexpected error while executing effect command '" + TextComponentParser.instance().escape(command) + "' by '" + sender.getName() + "'");
			sender.sendRichMessage("<red>An internal error occurred while executing this effect. Please refer to the server log for details.");
			return true;
		}
	}

	@Nullable
	public static ScriptCommand getScriptCommand(String key) {
		return commands.get(key);
	}

	/**
	 * @deprecated Use {@link #scriptCommandExists(String)} instead.
	 */
	@Deprecated(since = "2.8.0", forRemoval = true)
	public static boolean skriptCommandExists(String command) {
		return scriptCommandExists(command);
	}

	public static boolean scriptCommandExists(String command) {
		ScriptCommand scriptCommand = commands.get(command);
		return scriptCommand != null && scriptCommand.getName().equals(command);
	}

	public static void registerCommand(ScriptCommand command) {
		// Validate that there are no duplicates
		ScriptCommand existingCommand = commands.get(command.getLabel());
		if (existingCommand != null && existingCommand.getLabel().equals(command.getLabel())) {
			Script script = existingCommand.getScript();
			Skript.error("A command with the name /" + existingCommand.getName() + " is already defined"
				+ (script != null ? (" in " + script.getConfig().getFileName()) : "")
			);
			return;
		}

		if (commandMap != null) {
			assert cmKnownCommands != null;// && cmAliases != null;
			command.register(commandMap, cmKnownCommands, cmAliases);
		}
		commands.put(command.getLabel(), command);
		for (String alias : command.getActiveAliases()) {
			commands.put(alias.toLowerCase(Locale.ENGLISH), command);
		}
		command.registerHelp();
	}

	@Deprecated(since = "2.7.0", forRemoval = true)
	public static int unregisterCommands(File script) {
		int numCommands = 0;
		for (ScriptCommand c : new ArrayList<>(commands.values())) {
			if (c.getScript() != null && c.getScript().equals(ScriptLoader.getScript(script))) {
				numCommands++;
				unregisterCommand(c);
			}
		}
		return numCommands;
	}

	public static void unregisterCommand(ScriptCommand scriptCommand) {
		scriptCommand.unregisterHelp();
		if (commandMap != null) {
			assert cmKnownCommands != null;// && cmAliases != null;
			scriptCommand.unregister(commandMap, cmKnownCommands, cmAliases);
		}
		commands.values().removeIf(command -> command == scriptCommand);
	}

	private static boolean registeredListeners = false;

	public static void registerListeners() {
		if (!registeredListeners) {
			Bukkit.getPluginManager().registerEvents(new Listener() {
				@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
				public void onPlayerChat(AsyncPlayerChatEvent event) {
					if ((!SkriptConfig.enableEffectCommands.value() && !Skript.testing()) || !event.getMessage().startsWith(SkriptConfig.effectCommandToken.value()))
						return;
					if (!event.isAsynchronous()) {
						if (handleEffectCommand(event.getPlayer(), event.getMessage()))
							event.setCancelled(true);
					} else {
						Future<Boolean> f = Bukkit.getScheduler().callSyncMethod(Skript.getInstance(), () -> handleEffectCommand(event.getPlayer(), event.getMessage()));
						try {
							while (true) {
								try {
									if (f.get())
										event.setCancelled(true);
									break;
								} catch (InterruptedException ignored) {
								}
							}
						} catch (ExecutionException e) {
							Skript.exception(e);
						}
					}
				}
			}, Skript.getInstance());

			registeredListeners = true;
		}
	}

	/**
	 * copied from CraftBukkit (org.bukkit.craftbukkit.help.CommandAliasHelpTopic)
	 */
	public static final class CommandAliasHelpTopic extends HelpTopic {

		private final String aliasFor;
		private final HelpMap helpMap;

		public CommandAliasHelpTopic(String alias, String aliasFor, HelpMap helpMap) {
			this.aliasFor = aliasFor.startsWith("/") ? aliasFor : "/" + aliasFor;
			this.helpMap = helpMap;
			name = alias.startsWith("/") ? alias : "/" + alias;
			Preconditions.checkState(!name.equals(this.aliasFor), "Command " + name + " cannot be alias for itself");
			shortText = ChatColor.YELLOW + "Alias for " + ChatColor.WHITE + this.aliasFor;
		}

		@Override
		@NotNull
		public String getFullText(CommandSender forWho) {
			StringBuilder fullText = new StringBuilder(shortText);
			HelpTopic aliasForTopic = helpMap.getHelpTopic(aliasFor);
			if (aliasForTopic != null) {
				fullText.append("\n");
				fullText.append(aliasForTopic.getFullText(forWho));
			}
			return "" + fullText;
		}

		@Override
		public boolean canSee(CommandSender commandSender) {
			if (amendedPermission != null)
				return commandSender.hasPermission(amendedPermission);
			HelpTopic aliasForTopic = helpMap.getHelpTopic(aliasFor);
			return aliasForTopic != null && aliasForTopic.canSee(commandSender);
		}
	}

}