package net.sf.environments;
   
   import java.io.File;
   import java.io.IOException;
   import java.util.Arrays;
   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.LifecyclePhase;
  import org.apache.maven.plugins.annotations.Mojo;
  import org.apache.maven.plugins.annotations.Parameter;
  import org.codehaus.plexus.archiver.Archiver;
  import org.codehaus.plexus.archiver.jar.JarArchiver;
  import org.codehaus.plexus.archiver.manager.ArchiverManager;
  import org.codehaus.plexus.archiver.manager.NoSuchArchiverException;
  import org.codehaus.plexus.util.StringUtils;
  
  /**
   * This goal will create separate packages out of the given environment
   * directory.
   *
   * @author Karl-Heinz Marbaise
   * <a href="mailto:khmarbaise@soebes.de">khmarbaise@soebes.de</a>
   */
  @Mojo(name = "configuration", defaultPhase = LifecyclePhase.PACKAGE, requiresProject = true, threadSafe = true)
  public class ConfigurationMojo extends AbstractEnvironmentsMojo {
  
  	/**
  	 * The JAR archiver needed for archiving the environments.
  	 */
  	@Component(role = Archiver.class, hint = "jar")
  	private JarArchiver jarArchiver;
  
  	@Component
  	private ArchiverManager manager;
  
  	/**
  	 * The kind of archive we should produce {@code zip}, {code jar} etc.
  	 */
  	@Parameter(defaultValue = "jar")
  	private String archiveType;
  
  	@Override
  	public void execute() throws MojoExecutionException, MojoFailureException {
  		String[] identifiedEnvironments = getTheEnvironments(getSourceDirectory());
  
  		if (identifiedEnvironments.length == 0) {
  			getLog().warn("No Environment directories found.");
  			return;
  		}
  
  		validateEnvironments(identifiedEnvironments);
  
  		createLoggingOutput(identifiedEnvironments);
  
  		File resourceResult = createPluginResourceOutput();
  
  		String memEnv = getMavenSession().getUserProperties().getProperty("em.env", null);
  
  		if (StringUtils.isNotBlank(memEnv)) {
  			if (Arrays.asList(identifiedEnvironments).contains(memEnv)) {
  				processEnvironment(memEnv, resourceResult);
  			} // Environment doesn't exist message is already logged inside AbstractEnvironmentMojo.filterResourcesToTarget. Not logging here to avoid duplication
  		} else {
  			for (String environment : identifiedEnvironments) {
  				processEnvironment(environment, resourceResult);
  			}
  		}
  
  		filterResourcesToTarget(identifiedEnvironments);
                  filterResourcesToAdditionalDirectories(identifiedEnvironments);
  	}
  	
  	protected void processEnvironment(final String environment, final File resourceResult) throws MojoExecutionException {
  		// Check why this can happen?
  		if (environment.isEmpty()) {
  			getLog().warn("The given directory '" + environment + "' is empty.");
  			return;
  		}
  
  		if (shouldSkip(environment)) {
  			return;
  		}
  
  		filterResources(resourceResult, environment, false, false);
  
  		try {
  			File targetDirectory = new File(resourceResult, environment);
  			File createArchiveFile = createArchiveFile(null, targetDirectory, environment, archiveType);
  			getProjectHelper().attachArtifact(getMavenProject(), archiveType, environment,
  					createArchiveFile);
  		} catch (NoSuchArchiverException e) {
  			getLog().error("Archive creation failed.", e);
  		} catch (IOException e) {
  			getLog().error("IO Exception.", e);
  		}
  	}
  
  	@Override
 	protected JarArchiver getJarArchiver() {
 		return jarArchiver;
 	}
 }