package net.sf.environments;
   
   import java.io.File;
   import java.io.FileFilter;
   import java.io.IOException;
   import java.util.ArrayList;
   import java.util.Arrays;
   import java.util.Collections;
   import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  import static net.sf.environments.EnvironmentArchiveConfiguration.MANIFEST_ENVIRONMENT_KEY;
  
  import org.apache.maven.archiver.MavenArchiveConfiguration;
  import org.apache.maven.archiver.MavenArchiver;
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.artifact.DependencyResolutionRequiredException;
  import org.apache.maven.execution.MavenSession;
  import org.apache.maven.model.Resource;
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.plugins.annotations.Component;
  import org.apache.maven.plugins.annotations.Parameter;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.project.MavenProjectHelper;
  import org.apache.maven.shared.filtering.MavenFilteringException;
  import org.apache.maven.shared.filtering.MavenResourcesExecution;
  import org.apache.maven.shared.filtering.MavenResourcesFiltering;
  import org.codehaus.plexus.archiver.ArchiverException;
  import org.codehaus.plexus.archiver.jar.JarArchiver;
  import org.codehaus.plexus.archiver.jar.ManifestException;
  import org.codehaus.plexus.archiver.manager.NoSuchArchiverException;
  import org.codehaus.plexus.archiver.util.DefaultFileSet;
  import org.codehaus.plexus.util.FileUtils;
  import org.codehaus.plexus.util.StringUtils;
  
  /**
   * @author Karl-Heinz Marbaise
   * <a href="mailto:khmarbaise@soebes.de">khmarbaise@soebes.de</a>
   */
  public abstract class AbstractEnvironmentsMojo
  		extends AbstractMojo {
  
  	private static final String TARGET_PATHS_COMMAND_LINE_KEY = "mem.env-target-path";
  	private static final String INDIVIDUAL_ENVIRONMENT_COMMAND_LINE_KEY = "em.env";
  	
  	/**
  	 * The project currently being build.
  	 */
  	@Parameter(defaultValue = "${project}", required = true, readonly = true)
  	private MavenProject mavenProject;
  
  	/**
  	 * The current Maven session.
  	 */
  	@Parameter(defaultValue = "${session}", required = true, readonly = true)
  	private MavenSession mavenSession;
  
  	/**
  	 * The directory for the generated configuration packages.
  	 */
  	@Parameter(defaultValue = "${project.build.directory}", required = true, readonly = true)
  	private File outputDirectory;
  
  	/**
  	 * directory which contains the different environments
  	 */
  	// TODO: src/main ? property?
  	@Parameter(defaultValue = "${basedir}/src/main/environments")
  	private File sourceDirectory;
  
  	/**
  	 * The character encoding scheme to be applied when filtering resources.
  	 */
  	@Parameter(defaultValue = "${project.build.sourceEncoding}")
  	private String encoding;
  
  	/**
  	 * Name of the generated JAR.
  	 */
  	@Parameter(defaultValue = "${project.build.finalName}", readonly = true)
  	private String finalName;
  
  	@Component
  	private MavenProjectHelper projectHelper;
  
  	/**
  	 * The archive configuration to use. See
  	 * <a href="http://maven.apache.org/shared/maven-archiver/index.html">Maven
  	 * Archiver Reference</a>.
  	 */	
  	@Parameter
  	private List<EnvironmentArchiveConfiguration> archives;
  
  	/**
  	 * Expression preceded with the String won't be interpolated \${foo} will be
  	 * replaced with ${foo}
 	 */
 	@Parameter
 	private String escapeString;
 
 	/**
 	 * Whether to escape backslashes and colons in windows-style paths.
 	 */
 	@Parameter(defaultValue = "true")
 	private boolean escapeWindowsPaths;
 
 	/**
 	 * Filter files.
 	 *
 	 * List of files which will be used to filter files in the directory defined
 	 * in commonDir tag of the plugin configuration.
 	 */
 	@Parameter
 	private List<String> filters;
 
 	/**
 	 * Support filtering of filenames directories etc.
 	 */
 	@Parameter(defaultValue = "false")
 	private boolean fileNameFiltering;
 
 	/**
 	 * <p>
 	 * Set of delimiters for expressions to filter within the resources. These
 	 * delimiters are specified in the form 'beginToken*endToken'. If no '*' is
 	 * given, the delimiter is assumed to be the same for start and end.
 	 * </p>
 	 * <p>
 	 * So, the default filtering delimiters might be specified as:
 	 * </p>
 	 *
 	 * <pre>
 	 * &lt;delimiters&gt;
 	 *   &lt;delimiter&gt;${*}&lt;/delimiter&gt;
 	 *   &lt;delimiter&gt;@&lt;/delimiter&gt;
 	 * &lt;/delimiters&gt;
 	 * </pre>
 	 * <p>
 	 * Since the '@' delimiter is the same on both ends, we don't need to
 	 * specify '@*@' (though we can).
 	 * </p>
 	 */
 	@Parameter
 	private LinkedHashSet<String> delimiters;
 
 	/**
 	 * Use default delimiters in addition to custom delimiters, if any.
 	 */
 	@Parameter(defaultValue = "true")
 	private boolean useDefaultDelimiters;
 
 	/**
 	 * Include empty directories or not.
 	 */
 	@Parameter(defaultValue = "true")
 	private boolean includeEmptyDirs;
 
 	/**
 	 * Additional file extensions to not apply filtering (already defined are :
 	 * jpg, jpeg, gif, bmp, png)
 	 */
 	@Parameter
 	private List<String> nonFilteredFileExtensions;
 
 	/**
 	 * Comma separated list of names of environments.
 	 */
 	@Parameter(defaultValue = "", name = "excludeEnvironments", required = false)
 	protected String excludeEnvironments;
 
 	/**
 	 * stop searching endToken at the end of line
 	 */
 	@Parameter(defaultValue = "false")
 	private boolean supportMultiLineFiltering;
 
 	/**
 	 * Name of the directory where files common to all environments are stored.
 	 * Any and all files listed in this directory are included in all
 	 * environment wars.
 	 *
 	 * The files are filtered using the filter files defined in filters tag of
 	 * the plugin configuration.
 	 *
 	 * If commonDir isn't configured then it is assumed that there is no common
 	 * directory. i.e. there is no default value for commonDir.
 	 *
 	 */
 	@Parameter
 	private String commonDir;
 
 	/**
 	 * Set describe the resource target path. The path is relative to the
 	 * target/classes directory (i.e.
 	 * <code>${project.build.outputDirectory}</code>). For example, if you want
 	 * that resource to appear in a specific package
 	 * (<code>org.apache.maven.messages</code>), you must specify this element
 	 * with this value: <code>org/apache/maven/messages</code>. This is not
 	 * required if you simply put the resources in that directory structure at
 	 * the source, however.
 	 *
 	 * @param targetPath
 	 */
 	@Parameter
 	private String targetPath;
 
 	/**
 	 * 
 	 */	
 	@Parameter
 	private List<String> dirs;
         
 	@Component(role = MavenResourcesFiltering.class, hint = "default")
 	protected MavenResourcesFiltering mavenResourcesFiltering;
 	
 	/**
 	 * A booleans which help in avoiding the repetition of logging warning and error messages for common director feature.
 	 */
 	private boolean showCommonDirWarningMsg = true;
 	private boolean showCommonDirErrorMsg = true;
 	
 	public List<EnvironmentArchiveConfiguration> getArchives() {
 		return archives;
 	}
 	
 	public MavenArchiveConfiguration getArchive(final String environment) {
 		if (StringUtils.isBlank(environment) || getArchives() == null) {
 			return new MavenArchiveConfiguration();
 		}
 		
 		for (final EnvironmentArchiveConfiguration  archiveWrapper: getArchives()) {
 			if (StringUtils.isNotBlank(archiveWrapper.getEnvironment()) 
 					&& environment.trim().equals(archiveWrapper.getEnvironment())) {
 				return archiveWrapper.getArchive();
 			}
 		}
 		
 		return new MavenArchiveConfiguration();
 	}
 	
 	protected MavenArchiveConfiguration addEnvironmentToManifest(final MavenArchiveConfiguration archive, final String environment) {
 		if (archive == null) return archive;
 		String env = environment;
 		if (StringUtils.isBlank(env)) env = "";
 		
 		if (!archive.getManifestEntries().containsKey(MANIFEST_ENVIRONMENT_KEY)) {
 			archive.addManifestEntry(MANIFEST_ENVIRONMENT_KEY, env);
 		}
 		
 		return archive;
 	}
 
 	public MavenProject getMavenProject() {
 		return mavenProject;
 	}
 
 	public MavenSession getMavenSession() {
 		return mavenSession;
 	}
 
 	public File getOutputDirectory() {
 		return outputDirectory;
 	}
 
 	public MavenProjectHelper getProjectHelper() {
 		return projectHelper;
 	}
 
 	public File getSourceDirectory() {
 		return sourceDirectory;
 	}
 
 	public String getFinalName() {
 		return finalName;
 	}
 
 	public String getEncoding() {
 		return encoding;
 	}
 
 	/**
 	 * @param resourceResult The directory where to search for different
 	 * environments.
 	 * @return The list of identified environments. This list is converted to
 	 * lower case.
 	 */
 	protected String[] getTheEnvironments(File resourceResult) {
 		File[] theResultingFolders = resourceResult.listFiles(new FileFilter() {
 			@Override
 			public boolean accept(File pathname) {
 				return pathname.isDirectory() && pathname.exists();
 			}
 		});
 
 		String[] result = new String[theResultingFolders.length];
 		for (int i = 0; i < theResultingFolders.length; i++) {
 			getLog().debug("Folders: " + theResultingFolders[i].getName());
 			result[i] = theResultingFolders[i].getName().toLowerCase();
 		}
 		return result;
 	}
 
 	/**
 	 * This will check if an environment (directory) contains a space cause the
 	 * environment will later being used as a classifier which does not allow a
 	 * space.
 	 *
 	 * @param environmens The environments which should be checked.
 	 * @return The list contains the invalid environments. If the list is
 	 * {@code empty} all environments are ok.
 	 */
 	protected List<String> environmentNamesAreValid(String[] environmens) {
 		List<String> result = new ArrayList<>();
 		for (String item : environmens) {
 			if (item.contains(" ")) {
 				result.add(item);
 			}
 		}
 		return result;
 	}
 
 	/**
 	 * Returns the archive file to generate, based on an optional classifier.
 	 *
 	 * @param basedir the output directory
 	 * @param finalName the name of the ear file
 	 * @param classifier an optional classifier
 	 * @param archiveExt Archive Extension
 	 * @return the file to generate
 	 */
 	protected File getArchiveFile(File basedir, String finalName, String classifier, String archiveExt) {
 		if (basedir == null) {
 			throw new IllegalArgumentException("basedir is not allowed to be null");
 		}
 		if (finalName == null) {
 			throw new IllegalArgumentException("finalName is not allowed to be null");
 		}
 		if (archiveExt == null) {
 			throw new IllegalArgumentException("archiveExt is not allowed to be null");
 		}
 
 		if (finalName.isEmpty()) {
 			throw new IllegalArgumentException("finalName is not allowed to be empty.");
 		}
 		if (archiveExt.isEmpty()) {
 			throw new IllegalArgumentException("archiveExt is not allowed to be empty.");
 		}
 
 		StringBuilder fileName = new StringBuilder(finalName);
 
 		if (hasClassifier(classifier)) {
 			fileName.append("-").append(classifier);
 		}
 
 		fileName.append('.');
 		fileName.append(archiveExt);
 
 		return new File(basedir, fileName.toString());
 	}
 
 	public String getEscapeString() {
 		return escapeString;
 	}
 
 	public boolean isEscapeWindowsPaths() {
 		return escapeWindowsPaths;
 	}
 
 	public List<String> getFilters() {
 		return filters;
 	}
 
 	public boolean isFileNameFiltering() {
 		return fileNameFiltering;
 	}
 
 	public LinkedHashSet<String> getDelimiters() {
 		return delimiters;
 	}
 
 	public boolean isUseDefaultDelimiters() {
 		return useDefaultDelimiters;
 	}
 
 	public List<String> getNonFilteredFileExtensions() {
 		return nonFilteredFileExtensions;
 	}
 
 	public boolean isSupportMultiLineFiltering() {
 		return supportMultiLineFiltering;
 	}
 
 	public String getExcludeEnvironments() {
 		return excludeEnvironments;
 	}
 
 	public void setExcludeEnvironments(String excludeEnvironments) {
 		this.excludeEnvironments = excludeEnvironments;
 	}
 
 	private boolean hasClassifier(String classifier) {
 		boolean result = false;
 		if (classifier != null && classifier.trim().length() > 0) {
 			result = true;
 		}
 
 		return result;
 	}
 
 	protected void deleteDirectoryOfPreviousRunIfExist(File directoryOfPreviousRun)
 			throws MojoExecutionException {
 
 		if (directoryOfPreviousRun.exists()) {
 			try {
 				FileUtils.deleteDirectory(directoryOfPreviousRun);
 			} catch (IOException e) {
 				throw new MojoExecutionException("Failure while deleting " + directoryOfPreviousRun.getAbsolutePath(),
 						e);
 			}
 		}
 	}
 
 	/**
 	 * Create the unpack directory for later unpacking of the main artifact.
 	 *
 	 * @return The directory which has been created.
 	 * @throws org.apache.maven.plugin.MojoFailureException in case of failures.
 	 * @throws MojoExecutionException in case of failures.
 	 */
 	protected File createUnpackDirectory() throws MojoFailureException, MojoExecutionException {
 		// TODO: Should we use a different name or temp file? File.createTempFile( prefix, suffix );
 		File unpackDirectory = new File(getOutputDirectory(), "multienv-maven-plugin-unpack");
 
 		deleteDirectoryOfPreviousRunIfExist(unpackDirectory);
 
 		if (!unpackDirectory.mkdirs()) {
 			throw new MojoExecutionException("The unpack directory " + unpackDirectory.getAbsolutePath()
 					+ " couldn't generated!");
 		}
 		return unpackDirectory;
 	}
 
 	protected String getArchiveExtensionOfTheProjectMainArtifact()
 			throws MojoExecutionException {
 		if (getMavenProject().getArtifact() == null) {
 			throw new MojoExecutionException("No main artifact has been set yet.");
 		}
 
 		if (getMavenProject().getArtifact().getFile() == null) {
 			throw new MojoExecutionException("No main artifact file has been set yet.");
 		}
 
 		return FileUtils.getExtension(getMavenProject().getArtifact().getFile().getAbsolutePath()).toLowerCase();
 
 	}
 
 	protected String getArchiveExtensionOfTheArtifact(Artifact artifact)
 			throws MojoExecutionException {
 		if (artifact == null) {
 			throw new MojoExecutionException("No artifact has been set yet.");
 		}
 
 		if (artifact.getFile() == null) {
 			throw new MojoExecutionException("No artifact file has been set yet.");
 		}
 
 		return FileUtils.getExtension(artifact.getFile().getAbsolutePath()).toLowerCase();
 
 	}
 
 	protected File createPluginResourceOutput()
 			throws MojoExecutionException {
 		// TODO: Should we use a different name? Or temp File?
 		File resourceResult = new File(getOutputDirectory(), "multienv-maven-plugin-resource-output");
 
 		deleteDirectoryOfPreviousRunIfExist(resourceResult);
 
 		if (!resourceResult.mkdirs()) {
 			throw new MojoExecutionException("Failure while trying to create " + resourceResult.getAbsolutePath());
 		}
 
 		return resourceResult;
 	}
 
 	public boolean isIncludeEmptyDirs() {
 		return includeEmptyDirs;
 	}
 
 	public void setIncludeEmptyDirs(boolean includeEmptyDirs) {
 		this.includeEmptyDirs = includeEmptyDirs;
 	}
 
 	/**
 	 * @param outputDir Output Directory where the resources need to be copied.
 	 * @param environment absolute path of the environment directory.
 	 * @param singleEnvironment boolean that specifies the user specified em.env command line switch.
 	 * @throws org.apache.maven.plugin.MojoExecutionException in case of failures.
 	 */
 	protected void filterResources(File outputDir, final String environment, boolean singleEnvironment, final boolean ignoreTargetPath)
 			throws MojoExecutionException {
 		List<Resource> resources = new ArrayList<>();
 		Resource res = new Resource();
 		// TODO: Check how to prevent hard coding here?
 		String baseEnvironmentResourcePath = StringUtils.join(new String[]{getSourceDirectory().getAbsolutePath(), environment}, "/");
 		res.setDirectory(baseEnvironmentResourcePath);
 		res.setFiltering(true);
 		// TODO: Check if it makes sense to make this list configurable?
 		res.setIncludes(Collections.singletonList("**/*"));
 
                 if (!ignoreTargetPath) {
                     res.setTargetPath(getTargetPath(singleEnvironment, environment));
                 }
 
 		resources.add(res);
 
 		List<String> filtersFile = new ArrayList<>();
 
 		addCommonDirResource(environment, filtersFile, resources, singleEnvironment, outputDir, ignoreTargetPath);
 
 		MavenResourcesExecution execution
 				= new MavenResourcesExecution(resources, outputDir, getMavenProject(),
 						getEncoding(), filtersFile, getNonFilteredFileExtensions(),
 						getMavenSession());
 
 		execution.setEscapeString(getEscapeString());
 		execution.setSupportMultiLineFiltering(isSupportMultiLineFiltering());
 		execution.setIncludeEmptyDirs(isIncludeEmptyDirs());
 		execution.setEscapeWindowsPaths(isEscapeWindowsPaths());
 		execution.setFilterFilenames(isFileNameFiltering());
 
 		//// execution.setFilters( filters );
 		//
 		// // TODO: Check if we need a parameter?
 		execution.setOverwrite(true);
 		execution.setDelimiters(getDelimiters(), isUseDefaultDelimiters());
 		execution.setEncoding(getEncoding());
 		//
 		// execution.setUseDefaultFilterWrappers( true );
 
 		if (getNonFilteredFileExtensions() != null) {
 			execution.setNonFilteredFileExtensions(getNonFilteredFileExtensions());
 		}
 
 		try {
 			mavenResourcesFiltering.filterResources(execution);
 		} catch (MavenFilteringException e) {
 			getLog().error("Failure during filtering.", e);
 			throw new MojoExecutionException("Failure during filtering", e);
 		}
 
 	}
 	
 	protected void filterResourcesToTarget(String[] identifiedEnvironments) throws MojoExecutionException {
 		File classes = new File(getOutputDirectory(), "classes");
                 filterResourcesToDirectory(identifiedEnvironments, classes, true);
 	}
         
         protected void filterResourcesToAdditionalDirectories(String[] identifiedEnvironments) throws MojoExecutionException {
             if (dirs != null && !dirs.isEmpty()) {
                 for (final String dir: dirs) {
                     File d = new File(StringUtils.join(new String[]{mavenProject.getFile().getParentFile().getAbsolutePath(), dir }, "/"));
                     if (!d.exists()) {
                         d.mkdirs();
                     }
                     filterResourcesToDirectory(identifiedEnvironments, d, true);
                 }
             }
         }
         
         private void filterResourcesToDirectory(final String[] identifiedEnvironments, final File dir, final boolean ignoreTargetPath) throws MojoExecutionException {
             String memEnv = getMavenSession().getUserProperties().getProperty("em.env", null);
 
             if (StringUtils.isNotBlank(memEnv)) {
                     if (Arrays.asList(identifiedEnvironments).contains(memEnv)) {
                             filterResources(dir, memEnv, true, ignoreTargetPath);
                     } else {
                             getLog().error(String.format("Environment '%s' doesn't exist", memEnv));
                     }
             }
         }
         
         protected String getTargetPath(final boolean singleEnvironment, final String environment) {
             String tp = "";
             if (singleEnvironment) {
                 if (StringUtils.isNotBlank(targetPath)) {
                     tp = targetPath;
                 }
             } else {
                 if (StringUtils.isNotBlank(targetPath)) {
                     tp = StringUtils.join(new String[]{environment, targetPath}, "/");
                 } else {
                     tp = environment;
                 }
             }
             
             return tp;
         }
 
 	private void addCommonDirResource(final String environment, final List<String> filtersFile, final List<Resource> resources, 
                 final boolean singleEnvironment, final File outputDir, final boolean ignoreTargetPath) {
 		if (StringUtils.isNotBlank(environment)) {
 			if (getFilters() != null && StringUtils.isNotBlank(commonDir)) {
 				Resource common = new Resource();
 
 				common.setDirectory(StringUtils.join(new String[]{getSourceDirectory().getAbsolutePath(), getCommonDir()}, "/"));
 				
                                 if (!ignoreTargetPath) {
                                     common.setTargetPath(getTargetPath(singleEnvironment, environment));
                                 }
 
 				common.setFiltering(true);
 				common.setIncludes(Collections.singletonList("**/*"));
 				resources.add(common);
 
 				List<String> filtersRelativePaths = getFilters();
 
 				for (final String fileRelativePath : filtersRelativePaths) {
 					String path = StringUtils.join(new String[]{getSourceDirectory().getPath(), environment, fileRelativePath}, "/");
 					filtersFile.add(path);
 				}
 			} else if ((getFilters() == null || getFilters().isEmpty()) && StringUtils.isNotBlank(commonDir) && showCommonDirWarningMsg) {
 				getLog().warn("A common directory is configured but no Filters are configured on MultiEnv maven plugin. Files in common directory will not be filtered but will be included in archives.");
 				showCommonDirWarningMsg = false;
 			} else if ((getFilters() != null && !getFilters().isEmpty()) && StringUtils.isBlank(commonDir) && showCommonDirErrorMsg) {
 				getLog().error("Found filter configuration but no common directory configuration on MultiEnv maven plugin. MultiEnv maven filters configuration will have no effect.");
 				showCommonDirErrorMsg = false;
 			}
 		}
 	}
     
 	/**
 	 * Returns true if this directory in src/main/environments doesn't represent
 	 * an environment.
 	 *
 	 * The following directories are excluded - Comma separated list of
 	 * directory names enclosed within excludeEnvironments tags in plugin
 	 * configuration. - Directory name enclosed in common tag in plugin
 	 * configuration.
 	 *
 	 * @param environment name of the environment.
 	 * @return boolean indicating whether the specified environment should be skipped.
 	 */
 	protected boolean shouldSkip(final String environment) {
 		boolean skip = false;
 
 		List<String> excludedEnvs = new ArrayList<>();
 		if (StringUtils.isNotBlank(excludeEnvironments)) {
 			for (final String excludedEnv : excludeEnvironments.split(",")) {
 				if (StringUtils.isNotBlank(excludedEnv.trim())) {
 					excludedEnvs.add(excludedEnv.trim());
 				}
 			}
 		}
 
 		if (excludedEnvs.contains(environment)) {
 			getLog().info(" - Excluding Environment: '" + environment + "'");
 			skip = true;
 		} else if (StringUtils.isNotBlank(getCommonDir()) && getCommonDir().equals(environment)) {
 			getLog().info(" - Excluding common directory: '" + environment + "'");
 			skip = true;
 		} else {
 			getLog().info("Building Environment: '" + environment + "'");
 		}
 
 		return skip;
 	}
 
 	protected void createLoggingOutput(String[] identifiedEnvironments) {
 		getLog().info("");
 		getLog().info("We have found " + identifiedEnvironments.length + " environments.");
 
 		StringBuilder sb = new StringBuilder();
 		for (String identifiedEnvironment : identifiedEnvironments) {
 			if (sb.length() > 0) {
 				sb.append(',');
 			}
 			sb.append(identifiedEnvironment);
 		}
 
 		getLog().info("We have the following environments: " + sb.toString());
 		getLog().info("");
 	}
 
 	/**
 	 * This will validate the environments and will fail the build in case of
 	 * errors.
 	 *
 	 * @param identifiedEnvironments The environments which will be checked.
 	 * @throws MojoFailureException in case of invalid environments.
 	 */
 	protected void validateEnvironments(String[] identifiedEnvironments)
 			throws MojoFailureException {
 		List<String> environmentNamesAreValid = environmentNamesAreValid(identifiedEnvironments);
 		if (!environmentNamesAreValid.isEmpty()) {
 			for (String invalidEnv : environmentNamesAreValid) {
 				getLog().error("Your environment '" + invalidEnv + "' name contains spaces which is not allowed.");
 
 			}
 			throw new MojoFailureException("Your environment names contain spaces which are not allowed."
 					+ "See previous error messages for details.");
 		}
 	}
 
 
 	protected File createArchiveFile(File unpackDirectory, File targetDirectory, String directory, String archiveExt)
 			throws NoSuchArchiverException, IOException, MojoExecutionException {
 		final MavenArchiver mavenArchiver = new MavenArchiver();
 
 		mavenArchiver.setArchiver(getJarArchiver());
 
 		getJarArchiver().addFileSet(new DefaultFileSet(targetDirectory));
 		
 		if (unpackDirectory != null) {
 			getJarArchiver().addFileSet(new DefaultFileSet(unpackDirectory));
 		}
 		// jarArchiver.setDuplicateBehavior( duplicate );
 
 		File resultArchive = getArchiveFile(getOutputDirectory(), getFinalName(), directory, archiveExt);
 
 		mavenArchiver.setOutputFile(resultArchive);
 		try {
 			MavenArchiveConfiguration archive = getArchive(directory);
 			mavenArchiver.createArchive(getMavenSession(), getMavenProject(), addEnvironmentToManifest(archive, directory));
 			getJarArchiver().reset();													// Reset JarArchiver, otherwise the manifest entries get reused across passes.
 		} catch (ArchiverException | ManifestException | DependencyResolutionRequiredException e) {
 			getLog().error(e.getMessage(), e);
 			throw new MojoExecutionException(e.getMessage(), e);
 		}
 
 		return resultArchive;
 
 	}
 	
 	protected String getCommonDir() {
 		return commonDir;
 	}
 
 	public String getTargetPath() {
 		return targetPath;
 	}
 
 	abstract protected JarArchiver getJarArchiver();
 
 }