/FileExtraction/Java_unseen/Wind-Development_WindSpigot/WindSpigot-API/src/main/java/org/bukkit/command/PluginCommand.java
package org.bukkit.command;

import java.util.List;

import org.apache.commons.lang.Validate;
import org.bukkit.Location;
import org.bukkit.plugin.Plugin;

/**
 * Represents a {@link Command} belonging to a plugin
 */
public final class PluginCommand extends Command implements PluginIdentifiableCommand {
	private final Plugin owningPlugin;
	private CommandExecutor executor;
	private TabCompleter completer;

	protected PluginCommand(String name, Plugin owner) {
		super(name);
		this.executor = owner;
		this.owningPlugin = owner;
		this.usageMessage = "";
	}

	/**
	 * Executes the command, returning its success
	 *
	 * @param sender       Source object which is executing this command
	 * @param commandLabel The alias of the command used
	 * @param args         All arguments passed to the command, split via ' '
	 * @return true if the command was successful, otherwise false
	 */
	@Override
	public boolean execute(CommandSender sender, String commandLabel, String[] args) {
		boolean success = false;

		if (!owningPlugin.isEnabled()) {
			return false;
		}

		if (!testPermission(sender)) {
			return true;
		}

		try {
			success = executor.onCommand(sender, this, commandLabel, args);
		} catch (Throwable ex) {
			throw new CommandException("Unhandled exception executing command '" + commandLabel + "' in plugin "
					+ owningPlugin.getDescription().getFullName(), ex);
		}

		if (!success && usageMessage.length() > 0) {
			for (String line : usageMessage.replace("<command>", commandLabel).split("\n")) {
				sender.sendMessage(line);
			}
		}

		return success;
	}

	/**
	 * Sets the {@link CommandExecutor} to run when parsing this command
	 *
	 * @param executor New executor to run
	 */
	public void setExecutor(CommandExecutor executor) {
		this.executor = executor == null ? owningPlugin : executor;
	}

	/**
	 * Gets the {@link CommandExecutor} associated with this command
	 *
	 * @return CommandExecutor object linked to this command
	 */
	public CommandExecutor getExecutor() {
		return executor;
	}

	/**
	 * Sets the {@link TabCompleter} to run when tab-completing this command.
	 * <p>
	 * If no TabCompleter is specified, and the command's executor implements
	 * TabCompleter, then the executor will be used for tab completion.
	 *
	 * @param completer New tab completer
	 */
	public void setTabCompleter(TabCompleter completer) {
		this.completer = completer;
	}

	/**
	 * Gets the {@link TabCompleter} associated with this command.
	 *
	 * @return TabCompleter object linked to this command
	 */
	public TabCompleter getTabCompleter() {
		return completer;
	}

	/**
	 * Gets the owner of this PluginCommand
	 *
	 * @return Plugin that owns this command
	 */
	public Plugin getPlugin() {
		return owningPlugin;
	}

	/**
	 * {@inheritDoc}
	 * <p>
	 * Delegates to the tab completer if present.
	 * <p>
	 * If it is not present or returns null, will delegate to the current command
	 * executor if it implements {@link TabCompleter}. If a non-null list has not
	 * been found, will default to standard player name completion in
	 * {@link Command#tabComplete(CommandSender, String, String[])}.
	 * <p>
	 * This method does not consider permissions.
	 *
	 * @throws CommandException         if the completer or executor throw an
	 *                                  exception during the process of
	 *                                  tab-completing.
	 * @throws IllegalArgumentException if sender, alias, or args is null
	 */
	@Override
	public java.util.List<String> tabComplete(CommandSender sender, String alias, String[] args)
			throws CommandException, IllegalArgumentException {
		return tabComplete(sender, alias, args, null); // PaperSpigot - The code from this method has been (slightly
														// modified) moved to the Location method.
	}

	// PaperSpigot start - location tab-completes
	/**
	 * This code was copied from tabComplete(CommandSender sender, String alias,
	 * String[] args)
	 */
	@Override
	public List<String> tabComplete(CommandSender sender, String alias, String[] args, Location location)
			throws CommandException, IllegalArgumentException {
		Validate.notNull(sender, "Sender cannot be null");
		Validate.notNull(args, "Arguments cannot be null");
		Validate.notNull(alias, "Alias cannot be null");

		List<String> completions = null;
		try {
			if (completer != null) {
				completions = completer.onTabComplete(sender, this, alias, args, location); // PaperSpigot - add
																							// location argument
			}
			if (completions == null && executor instanceof TabCompleter) {
				completions = ((TabCompleter) executor).onTabComplete(sender, this, alias, args, location); // PaperSpigot
																											// - add
																											// location
																											// argument
			}
		} catch (Throwable ex) {
			StringBuilder message = new StringBuilder();
			message.append("Unhandled exception during tab completion for command '/").append(alias).append(' ');
			for (String arg : args) {
				message.append(arg).append(' ');
			}
			message.deleteCharAt(message.length() - 1).append("' in plugin ")
					.append(owningPlugin.getDescription().getFullName());
			throw new CommandException(message.toString(), ex);
		}

		if (completions == null) {
			return super.tabComplete(sender, alias, args);
		}
		return completions;
	}
	// PaperSpigot end

	@Override
	public String toString() {
		StringBuilder stringBuilder = new StringBuilder(super.toString());
		stringBuilder.deleteCharAt(stringBuilder.length() - 1);
		stringBuilder.append(", ").append(owningPlugin.getDescription().getFullName()).append(')');
		return stringBuilder.toString();
	}
}
