package de.matthias_burbach.deputy.core;
   
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileNotFoundException;
   import java.io.FileOutputStream;
   import java.io.InputStream;
   import java.util.ArrayList;
   import java.util.Date;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Properties;
  import java.util.StringTokenizer;
  
  import de.matthias_burbach.deputy.core.project.Project;
  import de.matthias_burbach.deputy.core.project.ProjectChangeListener;
  import de.matthias_burbach.deputy.core.project.ProjectComparator;
  import de.matthias_burbach.deputy.core.repository.RepositoryConfig;
  import de.matthias_burbach.deputy.core.rule.EnforcementRule;
  import de.matthias_burbach.deputy.core.rule.Rule;
  import de.matthias_burbach.deputy.core.rule.RuleSetChangeListener;
  import de.matthias_burbach.deputy.core.util.LineBufferLog;
  import de.matthias_burbach.deputy.core.util.Log;
  import de.matthias_burbach.deputy.core.util.P4;
  import de.matthias_burbach.deputy.core.util.SimpleLog;
  
  /***
   * Is the main class of the core application.
   *
   * @author Matthias Burbach
   */
  public class Deputy implements RuleSetChangeListener, ProjectChangeListener {
      /***
       * The export format 'GraphML'.
       */
      public static final int FORMAT_GRAPHML = 0;
  
      /***
       * The export format 'Deputy XML'.
       */
      public static final int FORMAT_DEPUTYXML = 1;
  
      /***
       * The path and name of the application properties file.
       */
      private static final String APP_PROPERTIES_FILE =
          "deputy-application.properties";
  
      /***
       * The path and name of the user properties file.
       */
      private static final String USER_PROPERTIES_FILE =
          System.getProperty("user.home")
              + File.separator
              + "deputy.properties";
  
      /***
       * The property key for the repository configs.
       */
      private static final String KEY_REPOSITORY_CONFIGS =
          "repositoryConfigs";
  
      /***
       * The property key of the Maven project file the user opened the last time.
       */
      private static final String KEY_PROJECT_FILE =
          "projectFile";
  
      /***
       * The property key of the Maven project file the user imported
       * as enforcement rules the last time.
       */
      private static final String KEY_IMPORT_FILE =
          "importFile";
  
      /***
       * The property key of the dependency graph file the user exported the last
       * time.
       */
      private static final String KEY_DEPENDENCY_GRAPH_FILE =
          "dependencyGraphFile";
  
      /***
       * The user properties plus the application properties as defaults.
       */
      private Properties properties;
  
      /***
       * The top level Maven project currently being opened.
       */
      private Project rootProject;
  
      /***
       * The registered change listeners to be notified.
       */
      private List changeListeners = new ArrayList();
  
      /***
       * The log.
      */
     private Log log;
 
     /***
      * Whether the current state of the currently opened top project is saved on
      * disk or not.
      */
     private boolean isSaved = true;
 
     /***
      * Flags that the last change action is unknown.
      */
     public static final int CHANGE_ACTION_UNKNOWN = 0;
 
     /***
      * Flags that the last change action was 'Apply Rules'.
      */
     public static final int CHANGE_ACTION_APPLY_RULES = 1;
 
     /***
      * Flags that the last change action was 'Add Dependency' or
      * 'Remove Dependency'.
      */
     public static final int CHANGE_ACTION_CHANGE_DEPENDENCIES = 2;
 
     /***
      * Flags that the last change action was 'Change Default Rule',
      * 'Add Enforcement Rule', 'Add Deprecation Rule', 'Add Replacement Rule'
      * or 'Remove Rule'.
      */
     public static final int CHANGE_ACTION_CHANGE_RULES = 3;
 
     /***
      * The last change action the user executed on the currently opened project.
      */
     private int lastChangeAction = CHANGE_ACTION_UNKNOWN;
 
     /***
      * Constructs and starts the application.
      *
      * @param log The log for messages.
      * @throws Exception if anything goes unexpectedly wrong
      */
     public Deputy(final Log log) throws Exception {
         this.log = log;
         startApplication();
     }
 
     /***
      * Initializes the application on start up.
      */
     private void startApplication() {
         /*
          * Create application properties
          */
         Properties applicationProperties = new Properties();
 
         /*
          * Now load application properties from file
          */
         try {
             InputStream in =
                 getClass().getResourceAsStream(APP_PROPERTIES_FILE);
             applicationProperties.load(in);
             in.close();
         } catch (Exception e) {
             e.printStackTrace();
         }
 
         /*
          * Create user properties with application properties as defaults
          */
         properties = new Properties(applicationProperties);
 
         /*
          * Now load user properties from file
          */
         try {
             log.log(Log.SEVERITY_INFO, "About to load " + USER_PROPERTIES_FILE);
             FileInputStream in = new FileInputStream(USER_PROPERTIES_FILE);
             properties.load(in);
             in.close();
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 
     /***
      * Cleans up the application on exit.
      */
     public void exitApplication() {
         FileOutputStream out;
         try {
             out = new FileOutputStream(USER_PROPERTIES_FILE);
             properties.store(out, "---user properties---");
             out.close();
         } catch (Exception e) {
             e.printStackTrace();
         }
         System.exit(0);
     }
 
     /***
      * @return The Deputy application version.
      */
     public String getVersion() {
         return properties.getProperty("version");
     }
 
     /***
      * @return The absolute file path and name of the project that is currently
      *         loaded into Deputy or which is to be loaded next into Deputy.
      */
     public String getProjectFile() {
         return properties.getProperty(KEY_PROJECT_FILE);
     }
 
     /***
      * @param projectFile The absolute file path and name of the project that is
      *                    currently loaded into Deputy or which is to be loaded
      *                    next into Deputy.
      */
     public void setProjectFile(final String projectFile) {
         properties.setProperty(KEY_PROJECT_FILE, projectFile);
         fireProjectHasChanged();
     }
 
     /***
      * @return The absolute file path and name of the project that was last
      *         imported from.
      */
     public String getImportFile() {
         return properties.getProperty(KEY_IMPORT_FILE);
     }
 
     /***
      * @param importProjectFile The absolute file path and name of the project
      *                          that was last imported from.
      */
     public void setImportFile(final String importProjectFile) {
         properties.setProperty(KEY_IMPORT_FILE, importProjectFile);
     }
 
     /***
      * @return Returns the virtualRepositoryActive.
      */
     public boolean isVirtualRepositoryActive() {
         boolean result = false;
         String value = getProperty("deputy.virtualRepositoryActive");
         if (value != null) {
             try {
                 result = Boolean.valueOf(value).booleanValue();
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
         return result;
     }
 
     /***
      * @param virtualRepositoryActive The virtualRepositoryActive to set.
      */
     public void setVirtualRepositoryActive(
             final boolean virtualRepositoryActive) {
         setProperty(
                 "deputy.virtualRepositoryActive",
                 Boolean.valueOf(virtualRepositoryActive).toString());
     }
 
     /***
      * Loads the currently set project file 'as is' into Deputy. 'As is' means
      * that no rules are applied yet.
      *
      * @return The project opened.
      * @throws Exception if anything goes unexpectedly wrong.
      */
     public Project openProjectAsIs() throws Exception {
         ProjectRecursor parser =
             new ProjectRecursor(getRepositoryConfigs(), log);
         rootProject = parser.openProjectAsIs(
                 getProjectFile(),
                 isVirtualRepositoryActive());
         rootProject.addChangeListener(this);
         rootProject.getRuleSet().addChangeListener(this);
         setSaved(true);
         lastChangeAction = CHANGE_ACTION_UNKNOWN;
         return rootProject;
     }
 
     /***
      * Adds an enforcement rule for each dependency in the given project.
      *
      * @param aProjectFile Absolute path of the project whose dependencies to
      *                     derive the enforcement rules from.
      * @throws Exception if anything goes unexpectedly wrong.
      */
     public void deriveEnforcementsFromProject(
             final String aProjectFile) throws Exception {
         log.log(Log.SEVERITY_INFO,
                 "Removing all previously derived enforcement rules...");
         rootProject.getRuleSet().removeAllDerivedEnforcementRules();
 
         log.log(Log.SEVERITY_INFO,
                 "Adding an enforcement rule for each dependency of project '"
                 + aProjectFile
                 + "'...");
         setImportFile(aProjectFile);
         ProjectRecursor parser =
             new ProjectRecursor(getRepositoryConfigs(), null);
         Project aProject = parser.openProjectAsIs(
                 aProjectFile,
                 isVirtualRepositoryActive());
         /*
          * Create an enforcement rule for each dependency in the project just
          * opened and add this rule to the current root project.
          */
         Iterator dependencies = aProject.getAllDependencies().iterator();
         int numberOfRules = 0;
         while (dependencies.hasNext()) {
             Project dependency = (Project) dependencies.next();
             EnforcementRule rule = new EnforcementRule();
             rule.setGroupId(dependency.getGroupId());
             rule.setArtifactId(dependency.getArtifactId());
             rule.setVersion(dependency.getVersion());
             rule.setDerived(true);
             rootProject.getRuleSet().add(rule);
             numberOfRules++;
         }
         String message = "Added " + numberOfRules + " derived enforcement rule";
         if (numberOfRules == 1) {
             message += ".";
         } else {
             message += "s.";
         }
         log.log(Log.SEVERITY_INFO, message);
         setSaved(false);
         lastChangeAction = CHANGE_ACTION_UNKNOWN;
     }
 
     /***
      * Loads the currently set project file into Deputy and applies rules on the
      * fly.
      *
      * @return The project after applying the rules to it.
      * @throws Exception if anything goes unexpectedly wrong.
      */
     public Project applyRulesToProject() throws Exception {
         ProjectRecursor parser =
             new ProjectRecursor(getRepositoryConfigs(), log);
         Project oldTopProject = rootProject;
         rootProject =
             parser.applyRulesToProject(
                     getProjectFile(),
                     oldTopProject,
                     isVirtualRepositoryActive());
         rootProject.addChangeListener(this);
         rootProject.getRuleSet().addChangeListener(this);
         setSaved(false);
         computeDiffReports(oldTopProject, rootProject);
         lastChangeAction = CHANGE_ACTION_APPLY_RULES;
         return rootProject;
     }
 
     /***
      * Retrieves all direct and indirect SNAPSHOT dependencies of the current
      * root project and prints them to the log in topological order such that
      * leaves in the topological order occur first.
      */
     public void sortSnapshotsTopologically() {
         /*
          * Create the list of SNAPSHOTs to be sorted
          */
         List snapshotDependencies = new ArrayList();
         Iterator dependencyIter = rootProject.getAllDependencies().iterator();
         while (dependencyIter.hasNext()) {
             Project dependency = (Project) dependencyIter.next();
             if (dependency.getVersion().indexOf("SNAPSHOT") != -1) {
                 snapshotDependencies.add(dependency);
             }
         }
         /*
          * Do the sorting
          */
         List sortedList = new ArrayList();
         List cycles = new ArrayList();
         doSortSnapshotsTopologically(sortedList, snapshotDependencies, cycles);
         /*
          * Print results to the log
          */
         log.log(Log.SEVERITY_INFO, "");
         if (sortedList.size() == 0 && cycles.size() == 0) {
             log.log(Log.SEVERITY_INFO, "There are no SNAPSHOTs to be sorted.");
         } else if (cycles.size() != 0) {
             log.log(Log.SEVERITY_WARNING, "Detected one or more cycles:");
             log.log(Log.SEVERITY_WARNING, "----------------------------");
             for (int i = 0; i < cycles.size(); i++) {
                 List cycle = (List) cycles.get(i);
                 String cycleMessage = "";
                 for (Iterator iter = cycle.iterator(); iter.hasNext();) {
                     Project project = (Project) iter.next();
                     cycleMessage += project + " --> ";
                 }
                 cycleMessage += cycle.get(0);
                 log.log(Log.SEVERITY_WARNING,
                         "Cycle " + i + ": " + cycleMessage);
             }
             if (sortedList.size() > 0) {
                 log.log(Log.SEVERITY_WARNING,
                         "A topological order of unaffected SNAPSHOTs is:");
                 log.log(Log.SEVERITY_WARNING,
                         "-----------------------------------------------");
                 for (Iterator iter = sortedList.iterator(); iter.hasNext();) {
                     Project snapshot = (Project) iter.next();
                     log.log(Log.SEVERITY_WARNING, snapshot.toString());
                 }
             }
         } else {
             log.log(Log.SEVERITY_INFO,
                     "A topological order of all SNAPSHOTs is:");
             log.log(Log.SEVERITY_INFO,
                     "------------------------------------");
             for (Iterator iter = sortedList.iterator(); iter.hasNext();) {
                 Project snapshot = (Project) iter.next();
                 log.log(Log.SEVERITY_INFO, snapshot.toString());
             }
         }
     }
 
     /***
      * Moves all projects from <code>unsortedList</code> to
      * <code>sortedList</code> or fails to sort completely.
      * The <code>sortedList</code> will be sorted topologically whereas the
      * <code>unsortedList</code> will be empty if sorting succeeds.
      * If there are cyclic dependencies detected cycles will be moved to
      * <code>cycles</code>.
      *
      * @param sortedList The list of already sorted projects.
      * @param unsortedList The list of not yet sorted projects.
      * @param cycles The list of lists of projects where each list of projects
      *               is a cycle.
      */
     private void doSortSnapshotsTopologically(
             final List sortedList, final List unsortedList, final List cycles) {
         if (unsortedList.size() != 0) {
             Project nextInLine = findLeftOnlyDependee(sortedList, unsortedList);
             if (nextInLine != null) {
                 // move project from unsorted to sorted list
                 sortedList.add(nextInLine);
                 unsortedList.remove(nextInLine);
                 // recurse
                 doSortSnapshotsTopologically(sortedList, unsortedList, cycles);
             } else {
                 //there is a cycle, go find it, move it out and continue
                 List cycle = findCycle(unsortedList);
                 unsortedList.removeAll(cycle);
                 cycles.add(cycle);
                 doSortSnapshotsTopologically(sortedList, unsortedList, cycles);
             }
         } // else we are successfully done
     }
     /***
      * Returns a project from the <code>rightDependencies</code> which has at
      * most SNAPSHOT dependencies to projects in the
      * <code>leftDependencies</code> but no SNAPSHOT dependencies to projects
      * in the <code>rightDependencies</code>.
      *
      * @param leftDependencies The list of 'left' dependencies of type Project.
      * @param rightDependencies The list of 'right' dependencies of type
      *                          Project.
      * @return A left dependee or <code>null</code>.
      */
     private Project findLeftOnlyDependee(
             final List leftDependencies, final List rightDependencies) {
         Project result = null;
         for (Iterator iter = rightDependencies.iterator(); iter.hasNext();) {
             Project candidate = (Project) iter.next();
             Iterator prjDepIter = candidate.getDependencies();
             boolean candidateRejected = false;
             while (prjDepIter.hasNext()) {
                 Project prjDep = (Project) prjDepIter.next();
                 String artifactId = prjDep.getArtifactId();
                 if (getProjectForArtifactId(
                         rightDependencies, artifactId) != null) {
                     candidateRejected = true;
                     break;
                 }
             }
             if (!candidateRejected) {
                 result = candidate;
                 break;
             }
         }
         return result;
     }
 
     /***
      * Scans the list of projects for one whose artifact id matches the artifact
      * id passed in.
      *
      * @param projects The projects to scan.
      * @param artifactId The artifact id to match with.
      * @return The project found or <code>null</code> if none was found.
      */
     private Project getProjectForArtifactId(
             final List projects, final String artifactId) {
         Project result = null;
         for (Iterator iter = projects.iterator(); iter.hasNext();) {
             Project candidate = (Project) iter.next();
             if (candidate.getArtifactId().equals(artifactId)) {
                 result = candidate;
             }
         }
         return result;
     }
 
     /***
      * Finds a cyclic dependency chain in a list of projects that is assured to
      * contain at least one cycle and where each project is guaranteed to be
      * involved in one cycle at least.
      *
      * @param projects The projects with cyclic dependencies.
      *                 Must contain at least two elements of type
      *                 {@link Project}.
      * @return A list of projects of type {@link Project}
      *         where list.get(i) depends on
      *         project list.get((i + 1) % list.size()).
      */
     private List findCycle(final List projects) {
         List result = null;
         List chain = new ArrayList();
         chain.add(projects.get(0));
         List successorCandidates =
             new ArrayList(projects.subList(1, projects.size()));
         int maxIterations = successorCandidates.size();
         for (int i = 0; i < maxIterations; i++) {
             Project tail = (Project) chain.get(chain.size() - 1);
             for (Iterator iter = successorCandidates.iterator();
                     iter.hasNext();) {
                 Project candidate = (Project) iter.next();
                 if (tail.hasDependencyToSameArtifact(candidate)) {
                     chain.add(candidate);
                     successorCandidates.remove(candidate);
                     for (int from = chain.size() - 2; from >= 0; from--) {
                         if (candidate.hasDependencyToSameArtifact(
                                 (Project) chain.get(from))) {
                            result = chain.subList(from, chain.size());
                            break;
                         }
                     }
                     break;
                 }
             }
             if (result != null) {
                 break;
             }
         }
         return result;
     }
 
     /***
      * Computes and logs diff reports that state the differences in their
      * dependencies and the differences in their indirect dependencies.
      *
      * @param oldProject The project in the state before.
      * @param newProject The project in the state after.
      * @return <code>true</code> if there are differences in the direct or
      *         indirect dependencies
      */
     private boolean computeDiffReports(
             final Project oldProject,
             final Project newProject) {
         boolean directDifferences = false;
         boolean indirectDifferences = false;
         log.log(Log.SEVERITY_INFO, "Applied the rules");
         log.log(Log.SEVERITY_INFO, "Changes in the dependencies:");
         log.log(Log.SEVERITY_INFO, "----------------------------");
         directDifferences = computeDiffReport(
             oldProject.getDependencies(),
             newProject.getDependencies());
         if (rootProject.isAssembly()) {
             log.log(Log.SEVERITY_INFO, "Changes in the indirect dependencies:");
             log.log(Log.SEVERITY_INFO, "-------------------------------------");
             indirectDifferences =
                 computeDiffReport(
                     oldProject.getIndirectDependencies(),
                     newProject.getIndirectDependencies());
         }
         return directDifferences || indirectDifferences;
     }
 
     /***
      * Computes and logs a diff report that state the differences in the two
      * dependency iterations.
      *
      * @param oldDependencies The dependencies in the state before.
      * @param newDependencies The dependencies in the state after.
      * @return <code>true</code> if there are differences
      */
     private boolean computeDiffReport(
             final Iterator oldDependencies,
             final Iterator newDependencies) {
         /*
          * Compute diff report
          */
         List unchangedDependencies = new ArrayList();
         List changedDependencies = new ArrayList();
         List addedDependencies = new ArrayList();
         List removedDependencies = new ArrayList();
         ProjectComparator comparator = new ProjectComparator();
 
         Project oldDependency = advance(oldDependencies);
         Project newDependency = advance(newDependencies);
         while (oldDependency != null && newDependency != null) {
             int comparison =
                 comparator.compare(oldDependency, newDependency);
             if (comparison == 0) {
                 unchangedDependencies.add(getQualifier(oldDependency));
                 oldDependency = advance(oldDependencies);
                 newDependency = advance(newDependencies);
             } else if (equalArtifacts(oldDependency, newDependency)) {
                 changedDependencies.add(
                     getQualifier(oldDependency)
                         + " to "
                         + newDependency.getVersion());
                 oldDependency = advance(oldDependencies);
                 newDependency = advance(newDependencies);
             } else if (comparison < 0) {
                 removedDependencies.add(getQualifier(oldDependency));
                 oldDependency = advance(oldDependencies);
             } else {
                 addedDependencies.add(getQualifier(newDependency));
                 newDependency = advance(newDependencies);
             }
         }
         while (oldDependency != null) {
             removedDependencies.add(getQualifier(oldDependency));
             oldDependency = advance(oldDependencies);
         }
         while (newDependency != null) {
             addedDependencies.add(getQualifier(newDependency));
             newDependency = advance(newDependencies);
         }
 
         /*
          * Print diff report to the log
          */
         boolean noChanges = true;
         if (changedDependencies.size() > 0) {
             noChanges = false;
             Iterator iter = changedDependencies.iterator();
             while (iter.hasNext()) {
                 String changeInfo = "Changed " + (String) iter.next();
                 log.log(Log.SEVERITY_INFO, changeInfo);
             }
             log.log(Log.SEVERITY_INFO, "");
         }
         if (addedDependencies.size() > 0) {
             noChanges = false;
             Iterator iter = addedDependencies.iterator();
             while (iter.hasNext()) {
                 String changeInfo = "Added " + (String) iter.next();
                 log.log(Log.SEVERITY_INFO, changeInfo);
             }
             log.log(Log.SEVERITY_INFO, "");
         }
         if (removedDependencies.size() > 0) {
             noChanges = false;
             Iterator iter = removedDependencies.iterator();
             while (iter.hasNext()) {
                 String changeInfo = "Removed " + (String) iter.next();
                 log.log(Log.SEVERITY_INFO, changeInfo);
             }
             log.log(Log.SEVERITY_INFO, "");
         }
         if (noChanges) {
             log.log(
                 Log.SEVERITY_INFO,
                 "No changes!");
             log.log(Log.SEVERITY_INFO, "");
         }
         return !noChanges;
     }
 
     /***
      * Convenience helper to advance the project iterator to the next project of
      * type {@link Project}.
      *
      * @param projectIterator The iterator to advance.
      * @return The next project or <code>null</code> if the iterator is
      *         exhausted.
      */
     private Project advance(final Iterator projectIterator) {
         Project result = null;
         if (projectIterator.hasNext()) {
             result = (Project) projectIterator.next();
         }
         return result;
     }
 
     /***
      * Determines if the two projects have equal artifact ids.
      * @param project1 The project 1 whose artifact id to compare with the other
      *                 one's.
      * @param project2 The project 2 whose artifact id to compare with the other
      *                 one's.
      * @return <code>true</code> if both project's artifact ids are equal.
      */
     private boolean equalArtifacts(
             final Project project1,
             final Project project2) {
         boolean result = false;
         if (project1.getArtifactId().equals(project2.getArtifactId())) {
             result = true;
         }
         return result;
     }
 
     /***
      * @param project The project to create a qualifier string for.
      * @return The fully qualified name of the project version.
      */
     private String getQualifier(final Project project) {
         String result =
             project.getGroupId()
                 + "/"
                 + project.getArtifactId()
                 + "-"
                 + project.getVersion();
         return result;
     }
 
     /***
      * @return The currently active root project loaded into Deputy.
      *         Can be <code>null.</code>
      */
     public Project getRootProject() {
         return rootProject;
     }
 
     /***
      * Saves the currently loaded project under the new project file name.
      * @param newProjectFileName The absolute path and name to save the project
      *                           under.
      * @throws Exception if anything goes unexpectedly wrong
      */
     public void saveProjectAs(
             final String newProjectFileName)
             throws Exception {
         ProjectGenerator generator =
             new ProjectGenerator(getVersion());
         generator.createAndSaveUpdatedDocument(
             rootProject,
             getProjectFile(),
             newProjectFileName);
         setProjectFile(newProjectFileName);
         log.log(Log.SEVERITY_INFO, "Saved " + newProjectFileName);
         setSaved(true);
     }
 
     /***
      * @return <code>true</code> if the current state of the project is saved.
      */
     public boolean isSaved() {
         return isSaved;
     }
 
     /***
      * @param saved <code>true</code> if the current state of the project is
      *              saved.
      */
     private void setSaved(final boolean saved) {
         if (this.isSaved != saved) {
             this.isSaved = saved;
             fireProjectHasChanged();
         }
     }
 
     /***
      * @return The absolute path and name of the file to export the dependency
      *         graph under.
      */
     public String getDependencyGraphFile() {
         String result = properties.getProperty(KEY_DEPENDENCY_GRAPH_FILE);
         if (result == null) {
             result =
                 System.getProperty("user.home")
                     + File.separator
                     + "dependency-graph.xml";
         }
         return result;
     }
 
     /***
      * @param dependencyGraphFile The absolute path and name of the file to
      *                            export the dependency graph under.
      */
     public void setDependencyGraphFile(final String dependencyGraphFile) {
         properties.setProperty(
             KEY_DEPENDENCY_GRAPH_FILE,
             dependencyGraphFile);
     }
 
     /***
      * Exports the currently loaded project as a dependency graph XML that can
      * be imported into Rational Rose or yEd for diagramming purposes.
      * @param format The export format. Can be {@link #FORMAT_GRAPHML}
      *               or {@link #FORMAT_DEPUTYXML}.
      * @throws Exception if anything goes unexpectedly wrong
      */
     public void exportDependencyGraph(final int format) throws Exception {
         AbstractDependencyGraphGenerator generator = null;
         if (format == FORMAT_GRAPHML) {
             generator = new DependencyGraphMLGenerator();
         } else {
             generator = new DependencyGraphXmlGenerator();
         }
         generator.generateDependencyGraph(
             rootProject,
             getDependencyGraphFile());
     }
 
     /***
      * @return The list of configs of type {@link RepositoryConfig}.
      * @throws Exception if anything goes unexpectedly wrong
      */
     public List getRepositoryConfigs() throws Exception {
         List result =
             parseRepositoryConfigs(
                 properties.getProperty(KEY_REPOSITORY_CONFIGS));
         return result;
     }
 
     /***
      * @param repositoryConfigs A list of configs of type
      *                          {@link RepositoryConfig}.
      * @throws Exception if anything goes unexpectedly wrong
      */
     public void setRepositoryConfigs(
             final List repositoryConfigs)
             throws Exception {
         String repositoryConfigsAsString =
             convertRepositoryConfigsToString(repositoryConfigs);
         properties.setProperty(
             KEY_REPOSITORY_CONFIGS,
             repositoryConfigsAsString);
     }
 
     /***
      * Adds a listener to be notified on changes in the current project.
      * @param listener The listener to be added.
      */
     public void addChangeListener(final DeputyChangeListener listener) {
         if (!changeListeners.contains(listener)) {
             changeListeners.add(listener);
         }
     }
 
     /***
      * Removes a listener to be notified on changes in the current project.
      *
      * @param listener The listener to be removed.
      */
     public void removeChangeListener(final DeputyChangeListener listener) {
         changeListeners.remove(listener);
     }
 
     /***
      * Notifies listeners that the project has changed somehow.
      */
     private void fireProjectHasChanged() {
         for (Iterator iter = changeListeners.iterator(); iter.hasNext();) {
             DeputyChangeListener listener =
                 (DeputyChangeListener) iter.next();
             listener.projectHasChanged();
         }
     }
 
     /***
      * @param repositoryConfigsAsString A semicolon separated string of config
      *                        triples each consisting of an absolute path to a
      *                        Maven repository, a display name for the
      *                        repository and a boolean value indicating
      *                        whether to scan this repository for versions of
      *                        artifacts when applying rules.
      * @return The list of parsed configs of type {@link RepositoryConfig}.
      * @throws Exception if the string cannot be parsed properly
      */
     private List parseRepositoryConfigs(
             final String repositoryConfigsAsString)
             throws Exception {
         List result = new ArrayList();
         StringTokenizer tokenizer =
             new StringTokenizer(repositoryConfigsAsString, ";");
         while (tokenizer.hasMoreTokens()) {
             RepositoryConfig config =
                 new RepositoryConfig(tokenizer.nextToken());
             if (tokenizer.hasMoreTokens()) {
                 config.setDisplayName(tokenizer.nextToken());
             } else {
                 throw new Exception(
                     "Repository path "
                         + "'"
                         + config.getPath()
                         + "'"
                         + " is not properly followed by a semicolon separated "
                         + "display name");
             }
             if (tokenizer.hasMoreTokens()) {
                 config.setToBeScannedForVersions(
                     Boolean.valueOf(tokenizer.nextToken()).booleanValue());
             } else {
                 throw new Exception(
                     "Display name "
                         + "'"
                         + config.getDisplayName()
                         + "'"
                         + " is not properly followed by a semicolon separated "
                         + "boolean value 'true' or 'false'");
             }
             result.add(config);
         }
         if (result.size() == 0) {
             throw new FileNotFoundException("No configs specified");
         }
         return result;
     }
 
     /***
      * @param repositoryConfigs The list of configs of type
      *                          {@link RepositoryConfig} to be converted.
      * @return The result of the conversion.
      */
     private String convertRepositoryConfigsToString(
             final List repositoryConfigs) {
         StringBuffer result = new StringBuffer("");
         for (Iterator iter = repositoryConfigs.iterator(); iter.hasNext();) {
             RepositoryConfig config = (RepositoryConfig) iter.next();
             result.append(config.getPath());
             result.append(";");
             result.append(config.getDisplayName());
             result.append(";");
             result.append(config.isToBeScannedForVersions());
             if (iter.hasNext()) {
                 result.append(";");
             }
         }
         return result.toString();
     }
 
     /*(non-Javadoc)
      * @see de.matthias_burbach.deputy.core.RuleSetChangeListener
      *          #changedDefaultRule()
      */
     /***
      * {@inheritDoc}
      */
     public void changedDefaultRule() {
         setSaved(false);
         lastChangeAction = CHANGE_ACTION_CHANGE_RULES;
         String defaultRule = rootProject.getRuleSet().getDefaultRule();
         log.log(Log.SEVERITY_INFO,
                 "Changed the default rule to " + defaultRule);
     }
 
     /*(non-Javadoc)
      * @see de.matthias_burbach.deputy.core.RuleSetChangeListener
      *          #addedRule(de.matthias_burbach.deputy.core.Rule, int)
      */
     /***
      * {@inheritDoc}
      */
     public void addedRule(final Rule addedRule, final int index) {
         setSaved(false);
         lastChangeAction = CHANGE_ACTION_CHANGE_RULES;
         log.log(Log.SEVERITY_INFO, "Added rule '" + addedRule + "'");
     }
 
     /*(non-Javadoc)
      * @see de.matthias_burbach.deputy.core.RuleSetChangeListener
      *          #removedRule(de.matthias_burbach.deputy.core.Rule)
      */
     /***
      * {@inheritDoc}
      */
     public void removedRule(final Rule removedRule) {
         setSaved(false);
         lastChangeAction = CHANGE_ACTION_CHANGE_RULES;
         log.log(Log.SEVERITY_INFO, "Removed rule '" + removedRule + "'");
     }
 
     /***
      * @return The log Deputy currently writes messages to.
      *         Can be <code>null</code>. Can change, don't cache a reference.
      */
     public Log getLog() {
         return log;
     }
 
     /***
      * @param log The log to write messages to. Can be set by the creator of
      *            this class to define where to log to.
      */
     public void setLog(final Log log) {
         this.log = log;
     }
 
     /***
      * @return One of {@link #CHANGE_ACTION_UNKNOWN},
      *         {@link #CHANGE_ACTION_APPLY_RULES},
      *         {@link #CHANGE_ACTION_CHANGE_DEPENDENCIES},
      */
     public int getLastChangeAction() {
         return lastChangeAction;
     }
 
     /*(non-Javadoc)
      * @see de.matthias_burbach.deputy.core.ProjectChangeListener
      *          #addedDependency(de.matthias_burbach.deputy.core.Project, int)
      */
     /***
      * {@inheritDoc}
      */
     public void addedDependency(
             final Project addedDependency,
             final int index) {
         setSaved(false);
         lastChangeAction = CHANGE_ACTION_CHANGE_DEPENDENCIES;
         log.log(
             Log.SEVERITY_INFO,
             "Added dependency '" + addedDependency + "'");
     }
 
     /*(non-Javadoc)
      * @see de.matthias_burbach.deputy.core.ProjectChangeListener
      *          #removedDependency(de.matthias_burbach.deputy.core.Project)
      */
     /***
      * {@inheritDoc}
      */
     public void removedDependency(final Project removedDependency) {
         setSaved(false);
         lastChangeAction = CHANGE_ACTION_CHANGE_DEPENDENCIES;
         log.log(
             Log.SEVERITY_INFO,
             "Removed dependency '" + removedDependency + "'");
     }
 
     /*(non-Javadoc)
      * @see de.matthias_burbach.deputy.core.ProjectChangeListener
      *          #removedIndirectDependency(
      *              de.matthias_burbach.deputy.core.Project)
      */
     /***
      * {@inheritDoc}
      */
     public void removedIndirectDependency(final Project removedDependency) {
         setSaved(false);
         lastChangeAction = CHANGE_ACTION_CHANGE_DEPENDENCIES;
         log.log(
             Log.SEVERITY_INFO,
             "Removed indirect dependency '" + removedDependency + "'");
     }
 
     /***
      * @param key The property's key.
      * @return The property value or <code>null</code> if the property does not
      *         exist.
      */
     public String getProperty(final String key) {
         String result = properties.getProperty(key);
         return result;
     }
 
     /***
      * @param key The property's key. Must not be <code>null</code>.
      * @param value The property's value. Must not be <code>null</code>.
      */
     public void setProperty(final String key, final String value) {
         properties.setProperty(key, value);
     }
 
     /***
      * Applies the rules on a POM. Optionally, saves the diff report and/or the
      * resulting POM.
      *
      * @param projectFile The absolute path of the POM to process.
      * @param diffFile The absolute path of the file to write the diff report
      *                 to. Can be <code>null</code> if no report is desired.
      * @param saveAsFile The absolute path of the file to save the updated
      *                   POM under. Can be <code>null</code> if results are not
      *                   to be saved.
      * @throws Exception if anything goes unexpectedly wrong
      */
     private void applyRulesInBatchMode(
             final String projectFile,
             final String diffFile,
             final String saveAsFile)
             throws Exception {
         setProjectFile(projectFile);
         openProjectAsIs();
         Project oldProject = getRootProject();
         applyRulesToProject();
         Project newProject = getRootProject();
         if (diffFile != null) {
             LineBufferLog sbLog = new LineBufferLog();
             setLog(sbLog);
             File file = new File(projectFile);
             Date lastModified = new Date(file.lastModified());
             String path = file.getAbsolutePath();
             int revision = -1;
             try {
                 P4 p4 = new P4();
                 revision = p4.getSynchedRevision(projectFile);
             } catch (Exception e) {
                 e.printStackTrace();
             }
             sbLog.log(Log.SEVERITY_INFO, "Project: " + newProject);
             sbLog.log(Log.SEVERITY_INFO, "File: " + path);
             sbLog.log(Log.SEVERITY_INFO, "Last Modified: " + lastModified);
             if (revision != -1) {
                 sbLog.log(Log.SEVERITY_INFO, "Revision: " + revision);
             }
             sbLog.log(Log.SEVERITY_INFO, "");
             boolean differences = computeDiffReports(oldProject, newProject);
             if (differences) {
                 sbLog.writeToFile(diffFile);
             }
         }
         if (saveAsFile != null) {
             saveProjectAs(saveAsFile);
         }
     }
 
     /***
      * Executes Deputy in batch mode. Opens the project file specified, applies
      * the rules on it, and optionally saves the diff report and/or the
      * processed project file.
      * <p/>
      * Exits with return code 0 if processing was successful,
      * exits with return code -1 if an error occurred.
      *
      * @param args The command line arguments:
      * <ul>
      * <li>
      *      -projectFile=absolute path of the project file to process
      *      <br/>
      *      is mandatory
      * </li>
      * <li>
      *      -diffFile=absolute path to save the diff report under
      *      <br/>
      *      is optional, defaults to not saving the diff report after processing
      * </li>
      * <li>
      *      -saveAsFile=absolute path to save the processed project file under
      *      <br/>
      *      is optional, defaults to not saving the file after processing
      * </li>
      * </ul>
      */
     public static void main(final String[] args) {
         try {
             /*
              * Parse arguments
              */
             String projectFile = null;
             String diffFile = null;
             String saveAsFile = null;
             for (int i = 0; i < args.length; i++) {
                 if (args[i].startsWith("-projectFile=")) {
                     projectFile =
                         args[i].substring("-projectFile=".length());
                 } else if (args[i].startsWith("-diffFile=")) {
                     diffFile =
                         args[i].substring("-diffFile=".length());
                 } else if (args[i].startsWith("-saveAsFile=")) {
                     saveAsFile =
                         args[i].substring("-saveAsFile=".length());
                 }
             }
             /*
              * Validate arguments
              */
             if (projectFile == null) {
                 throw new IllegalArgumentException(
                         "project file not specified correctly");
             }
             if (!(new File(projectFile).exists())) {
                 throw new IllegalArgumentException(
                     "project file specified does not exist");
             }
             if (diffFile == null) {
                 System.out.println(
                         "diff report file not specified, will not be written");
             }
             if (saveAsFile == null) {
                 System.out.println(
                         "save as file not specified, will not be written");
             }
             /*
              * Do the actual processing
              */
             Deputy deputy = new Deputy(new SimpleLog());
             deputy.applyRulesInBatchMode(projectFile, diffFile, saveAsFile);
             System.exit(0);
         } catch (IllegalArgumentException e) {
             System.err.println(
                 "Invalid arguments, usage is: "
                 + Deputy.class.getName()
                 + " -projectFile=<absolute path of project input file>"
                 + " [-diffFile=<absolute path of diff report output file>]"
                 + " [-saveAsFile=<absolute path of project output file>]");
             System.err.println(e.getMessage());
             System.exit(-1);
         } catch (Exception e) {
             e.printStackTrace();
             System.exit(-1);
         }
     }
 }