package org.andromda.maven.plugin.andromdapp;
   
   import java.io.BufferedReader;
   import java.io.File;
   import java.io.IOException;
   import java.io.InputStreamReader;
   import java.lang.reflect.Method;
   import java.util.ArrayList;
   import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Properties;
  import org.andromda.maven.plugin.andromdapp.utils.ProjectUtils;
  import org.andromda.maven.plugin.andromdapp.utils.Projects;
  import org.apache.commons.lang.ObjectUtils;
  import org.apache.commons.lang.StringUtils;
  import org.apache.maven.BuildFailureException;
  import org.apache.maven.execution.MavenSession;
  import org.apache.maven.execution.ReactorManager;
  import org.apache.maven.lifecycle.LifecycleExecutionException;
  import org.apache.maven.lifecycle.LifecycleExecutor;
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.project.MavenProjectBuilder;
  import org.apache.maven.project.ProjectBuildingException;
  import org.codehaus.plexus.util.dag.CycleDetectedException;
  
  /**
   * A Mojo used for executing the build goals from the top level project.
   *
   * @goal build
   * @author Chad Brandon
   */
  public class BuildMojo
      extends AbstractMojo
  {
      /**
       * @component role="org.apache.maven.lifecycle.LifecycleExecutor"
       */
      private LifecycleExecutor lifecycleExecutor;
  
      /**
       * @parameter expression="${session}"
       */
      private MavenSession session;
  
      /**
       * @parameter expression="${project.basedir}"
       */
      private File baseDirectory;
  
      /**
       * A comma separated list of modules to execute in the form:
       * <em>-Dmodules=mda,core,common</em> or if you want to specify the goals
       * to execute as well:
       * <em>-Dmodules=mda:[goal1+goal2+goal3],core:[goal1]<em>.
       *
       * @parameter expression="${modules}"
       */
      private String modules;
  
      /**
       * @parameter expression="${project}"
       * @required
       * @readonly
       */
      private MavenProject project;
  
      /**
       * If defined starts the build console (i.e. keeps maven loaded and running)
       *
       * @parameter expression="${console}"
       */
      private String startConsole;
  
      /**
       * The default module goals to execute.
       *
       * @parameter
       */
      private List<String> goals = new ArrayList<String>(Arrays.asList("install"));
  
      /**
       * The string used to quite the console;
       */
      private static final String EXIT = "exit";
  
      /**
       * Used to construct Maven project instances from POMs.
       *
       * @component
       */
      private MavenProjectBuilder projectBuilder;
 
     /**
      * Any execution properties.
      *
      * @parameter
      */
     private Properties executionProperties = new Properties();
 
     /**
      * Identifies system properties when running in console mode.
      */
     private static final String EXECUTION_PROPERTY_TOKEN = "-D";
 
     /**
      * Lists all execution properties when running in console mode.
      */
     private static final String LIST_PROPERTIES = "-list";
 
     /**
      * Clears all execution properties.
      */
     private static final String CLEAR_PROPERTIES = "-clear";
 
     /**
      * Explicitly calls the garbage collector.
      */
     private static final String GARBAGE_COLLECT = "-gc";
 
     /**
      * The prefix environment variables must have.
      *
      * @parameter expression="env."
      */
     private String environmentVariablePrefix;
 
     /**
      * @see org.apache.maven.plugin.Mojo#execute()
      */
     public void execute()
         throws MojoExecutionException
     {
         try
         {
             final Map environment = this.getEnvironment();
             if (this.startConsole != null && !this.startConsole.equals(Boolean.FALSE.toString()))
             {
                 boolean executed = false;
                 this.printLine();
                 while (true)
                 {
                     this.printConsolePrompt();
                     String input = StringUtils.trimToEmpty(this.readLine());
                     if (EXIT.equals(input))
                     {
                         break;
                     }
                     if (input.startsWith(EXECUTION_PROPERTY_TOKEN))
                     {
                         input = input.replaceFirst(
                                 EXECUTION_PROPERTY_TOKEN,
                                 "");
                         int index = input.indexOf('=');
                         String name;
                         String value;
                         if (index <= 0)
                         {
                             name = input.trim();
                             value = "true";
                         }
                         else
                         {
                             name = input.substring(
                                     0,
                                     index).trim();
                             value = input.substring(index + 1).trim();
                         }
                         if (value.startsWith(this.environmentVariablePrefix))
                         {
                             value = StringUtils.replace(
                                     value,
                                     this.environmentVariablePrefix,
                                     "");
                             if (environment.containsKey(value))
                             {
                                 value = ObjectUtils.toString(environment.get(value)).trim();
                             }
                         }
                         this.executionProperties.put(
                             name,
                             value);
                         System.setProperty(
                             name,
                             value);
                         this.printExecutionProperties();
                     }
                     else if (LIST_PROPERTIES.equals(input))
                     {
                         this.printExecutionProperties();
                     }
                     else if (CLEAR_PROPERTIES.equals(input))
                     {
                         this.executionProperties.clear();
                         this.printExecutionProperties();
                     }
                     else if (GARBAGE_COLLECT.equals(input))
                     {
                         // TODO FindBugs: Except for specific use in benchmarking, this is very dubious.
                         System.gc();
                     }
                     else
                     {
                         try
                         {
                             executed = this.executeModules(input);
 
                             // - if nothing was executed, try a goal in the current project
                             if (this.project != null && !executed && input.trim().length() > 0)
                             {
                                 executed = true;
                                 final List<String> goals = Arrays.asList(input.split("\\s+"));
                                 this.executeModules(
                                     StringUtils.join(
                                         this.project.getModules().iterator(),
                                         ","),
                                     goals,
                                     true);
                             }
                         }
                         catch (final Throwable throwable)
                         {
                             throwable.printStackTrace();
                         }
                         if (executed)
                         {
                             this.printLine();
                         }
                         Projects.instance().clear();
                     }
                 }
             }
             else
             {
                 this.executionProperties.putAll(this.session.getExecutionProperties());
                 this.executeModules(this.modules);
             }
         }
         catch (final Throwable throwable)
         {
             throw new MojoExecutionException("Error executing modules", throwable);
         }
     }
 
     private static final String GET_ENVIRONMENT_METHOD = "getenv";
 
     /**
      * Retrieves the environment variables (will only work when running jdk5 or above).
      *
      * @return the environment variables.
      */
     private Map<String, String> getEnvironment()
     {
         final Map<String, String> variables = new HashMap<String, String>();
         try
         {
             final Method method = System.class.getMethod(
                     GET_ENVIRONMENT_METHOD);
             final Object result = method.invoke(
                     System.class);
             if (result instanceof Map)
             {
                 variables.putAll((Map<String, String>)result);
             }
         }
         catch (Exception exception)
         {
             // - ignore (means we can't retrieve the environment with the current JDK).
         }
         return variables;
     }
 
     private void printExecutionProperties()
     {
         this.printLine();
         this.printTextWithLine("| ------------- execution properties ------------- |");
         for (final Iterator<Object> iterator = this.executionProperties.keySet().iterator(); iterator.hasNext();)
         {
             final String name = (String)iterator.next();
             System.out.println("    " + name + " = " + this.executionProperties.getProperty(name));
         }
         this.printTextWithLine("| ------------------------------------------------ |");
         this.printLine();
     }
 
     /**
      * Prints the prompt for the console
      */
     private void printConsolePrompt()
     {
         if (this.project != null)
         {
             this.printText("");
             this.printText(this.project.getArtifactId() + ' ' + this.project.getVersion() + '>');
         }
     }
 
     /**
      * Prints text to the console.
      *
      * @param text the text to print to the console;
      */
     private void printText(final String text)
     {
         System.out.print(text);
         System.out.flush();
     }
 
     /**
      * Prints text with a new line to the console.
      *
      * @param text the text to print to the console.
      */
     private void printTextWithLine(final String text)
     {
         System.out.println(text);
         System.out.flush();
     }
 
     /**
      * Prints a line to standard output.
      */
     private void printLine()
     {
         System.out.println();
         System.out.flush();
     }
 
     /**
      * Reads a line from standard input and returns the value.
      *
      * @return the value read from standard input.
      */
     @SuppressWarnings("null")
     private String readLine()
     {
         final BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
         String inputString = null;
         try
         {
             inputString = input.readLine();
         }
         catch (final IOException exception)
         {
             inputString = null;
         }
         return StringUtils.trimToNull(inputString);
     }
 
     /**
      * Creates all project modules and executes them.
      *
      * @param modules the comma separated list of modules to execute.
      * @return true if any modules were executed, false otherwise.
      * @throws MojoExecutionException
      * @throws CycleDetectedException
      * @throws LifecycleExecutionException
      * @throws BuildFailureException
      */
     private boolean executeModules(final String modules)
         throws MojoExecutionException
     {
         return this.executeModules(
             modules,
             null,
             false);
     }
 
     /**
      * Creates all project modules and executes them.
      *
      * @param modules The list of modules to execute.
      * @param goals the list of goals to execute (if null, the, goals will be retrieved from project map).
      * @param sortProjects whether or not projects should be sorted and then executed or whether they should be executed in the
      *                     order they're in.
      * @throws CycleDetectedException
      * @throws LifecycleExecutionException
      * @throws MojoExecutionException
      * @throws BuildFailureException
      * @return true/false on whether or not any modules were executed
      */
     private boolean executeModules(
         final String modules,
         final List<String> goals,
         boolean sortProjects)
         throws MojoExecutionException
     {
         final Map<MavenProject, List<String>> projects = this.collectProjects(modules);
         boolean executed = !projects.isEmpty();
 
         // - only execute if we have some projects
         if (executed)
         {
             if (!sortProjects)
             {
                 for (final MavenProject project : projects.keySet())
                 {
                     List<String> projectGoals;
                     if (goals == null)
                     {
                         projectGoals = projects.get(project);
                         if (projectGoals.isEmpty())
                         {
                             projectGoals.addAll(this.goals);
                         }
                     }
                     else
                     {
                         projectGoals = goals;
                     }
                     this.executeProjects(
                         Collections.singletonList(project),
                         projectGoals);
                 }
             }
             else
             {
                 this.executeProjects(
                     projects.keySet(),
                     goals);
             }
         }
         return executed;
     }
 
     /**
      * Executes the given maven <code>project</code>.
      *
      * @param projects the projects to execute.
      * @param goals the goals to execute on the project.
      * @throws MojoExecutionException
      * @throws CycleDetectedException
      * @throws LifecycleExecutionException
      * @throws BuildFailureException
      */
     private void executeProjects(
         final Collection<MavenProject> projects,
         final List<String> goals)
         throws MojoExecutionException
     {
         try
         {
             if (goals.isEmpty())
             {
                 goals.addAll(this.goals);
             }
             if (projects.size() > 1)
             {
                 this.getLog().info("Reactor build order:");
             }
             final ReactorManager reactorManager = new ReactorManager(new ArrayList<MavenProject>(projects));
             for (final MavenProject project : reactorManager.getSortedProjects())
             {
                 this.getLog().info("  " + project.getName());
             }
 
             final MavenSession projectSession =
                 new MavenSession(
                     this.session.getContainer(),
                     this.session.getSettings(),
                     this.session.getLocalRepository(),
                     this.session.getEventDispatcher(),
                     reactorManager,
                     goals,
                     this.baseDirectory.toString(),
                     this.executionProperties,
                     this.session.getStartTime());
 
             projectSession.setUsingPOMsFromFilesystem(true);
             this.lifecycleExecutor.execute(
                 projectSession,
                 reactorManager,
                 projectSession.getEventDispatcher());
         }
         catch (final Throwable throwable)
         {
             throw new MojoExecutionException("An error occurred while attempting to execute projects", throwable);
         }
     }
 
     /**
      * Collects all project modules to execute.
      *
      * @param modules The list of modules to execute.
      * @return the Map of collected projects (the key is the project, the value
      *         the goals).
      * @throws MojoExecutionException
      */
     private Map<MavenProject, List<String>> collectProjects(final String modules)
         throws MojoExecutionException
     {
         final Map<MavenProject, List<String>> projects = new LinkedHashMap<MavenProject, List<String>>();
         final Map<File, List<String>> poms = getModulePoms(modules);
 
         if (!poms.isEmpty())
         {
             for (final File pom : poms.keySet())
             {
                 try
                 {
                     final MavenProject project = ProjectUtils.getProject(
                             this.projectBuilder,
                             this.session,
                             pom,
                             this.getLog());
                     if (project != null)
                     {
                         if (this.getLog().isDebugEnabled())
                         {
                             this.getLog().debug("Adding project " + project.getId());
                         }
                         projects.put(
                             project,
                             poms.get(pom));
                     }
                     else
                     {
                         if (this.getLog().isWarnEnabled())
                         {
                             this.getLog().warn("Could not load project from pom: " + pom + " - ignoring");
                         }
                     }
                 }
                 catch (ProjectBuildingException exception)
                 {
                     throw new MojoExecutionException("Error loading POM --> '" + pom + '\'', exception);
                 }
             }
         }
         return projects;
     }
 
     /**
      * Gets all POMs for the modules specified.
      *
      * @param moduleList the list of modules to execute.
      * @return the list of module poms
      */
     private Map<File, List<String>> getModulePoms(final String moduleList)
     {
         final Map<File, List<String>> poms = new LinkedHashMap<File, List<String>>();
         final String[] modules = moduleList != null ? moduleList.split(",") : null;
 
         final String goalPrefix = ":";
         if (modules != null)
         {
             final int numberOfModules = modules.length;
             for (int ctr = 0; ctr < numberOfModules; ctr++)
             {
                 String module = modules[ctr].trim();
                 final List<String> goalsList = new ArrayList<String>();
                 if (module.contains(goalPrefix))
                 {
                     final String[] goals = module.replaceAll(
                             ".*(:\\[)|(\\])",
                             "").split("\\+");
                     if (goals != null)
                     {
                         final int numberOfGoals = goals.length;
                         for (int ctr2 = 0; ctr2 < numberOfGoals; ctr2++)
                         {
                             final String goal = goals[ctr2].trim();
                             goalsList.add(goal);
                         }
                     }
                 }
                 module = module.replaceAll(
                         goalPrefix + "\\[.*\\]",
                         "");
                 final File pom = new File(this.baseDirectory, module + "/pom.xml");
                 if (pom.isFile())
                 {
                     poms.put(
                         pom,
                         goalsList);
                 }
             }
         }
         return poms;
     }
 }