CE_Import.java

package com.nicewuerfel.blockown.command;

import com.nicewuerfel.blockown.BlockOwn;
import com.nicewuerfel.blockown.Message;
import com.nicewuerfel.blockown.Setting;
import com.nicewuerfel.blockown.database.Database;
import com.nicewuerfel.blockown.importer.Importer;
import com.nicewuerfel.blockown.importer.ImporterException;
import com.nicewuerfel.blockown.output.Output;
import com.nicewuerfel.blockown.protection.Protection;

import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;

import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;

public class CE_Import extends CommandExecutor {

  private final ClassLoader externalImportClassLoader;
  private final boolean folderAccess;

  public CE_Import(Setting setting, Database database, Protection protection, File importerFolder) {
    super(setting, database, protection);
    URL url = null;
    try {
      url = importerFolder.toURI().toURL();
    } catch (MalformedURLException e) {
      getOutput().printException("Error accessing Importer folder, import command unavailable", e);
      folderAccess = false;
      externalImportClassLoader = null;
      return;
    }
    externalImportClassLoader =
        URLClassLoader.newInstance(new URL[]{url}, BlockOwn.class.getClassLoader());
    folderAccess = true;
  }

  @Override
  public boolean onCommand(final CommandSender sender, Command cmd, String cmdName, String[] args) {
    if (!folderAccess) {
      sender.sendMessage(Message.COMMAND_IMPORT_UNAVAILABLE.getMessage());
      return false;
    }

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

    if (args.length != 1) {
      return false;
    }

    Class<? extends Importer> importerClass;
    try {
      importerClass = findClass(args[0]);
    } catch (ClassNotFoundException e) {
      getOutput().printException("No matching importer found", e);
      return false;
    }
    try {
      Importer importer =
          importerClass.getConstructor(Output.class, Database.class, File.class, Runnable.class)
              .newInstance(getOutput(), database, new File("plugins"), new Runnable() {
                @Override
                public void run() {
                  sender.sendMessage(Message.COMMAND_IMPORT_SUCCESS.getMessage());
                }
              });
      Thread importThread = new Thread(importer, "Import Thread");
      sender.sendMessage(Message.COMMAND_IMPORT_START.getMessage());
      importThread.start();
      return true;
    } catch (InstantiationException | IllegalAccessException | InvocationTargetException
        | NoSuchMethodException | SecurityException e) {
      getOutput().printException("There probably was an error in the requested importer class", e);
      return false;
    } catch (ImporterException e) {
      getOutput().printException(e.getMessage(), e);
      return false;
    }
  }

  @SuppressWarnings("unchecked")
  private Class<? extends Importer> findClass(String name) throws ClassNotFoundException {
    Class<? extends Importer> result = null;
    try {
      Class<?> found = Class.forName("de.pheasn.blockown.importer." + name);
      if (Importer.class.isAssignableFrom(found) && !found.isInterface()) {
        result = (Class<? extends Importer>) found;
      }
    } catch (ClassNotFoundException e) {
      if (externalImportClassLoader != null) {
        Class<?> found = externalImportClassLoader.loadClass(name);
        if (Importer.class.isAssignableFrom(found) && !found.isInterface()) {
          result = (Class<? extends Importer>) found;
        }
      }
    }
    if (result == null) {
      throw new ClassNotFoundException();
    }
    return result;
  }

}