package de.matthias_burbach.deputy.core;
   
   import java.util.Date;
   import java.util.Iterator;
   import java.util.List;
   
   import org.jdom.Comment;
   import org.jdom.Document;
   import org.jdom.Element;
  import org.jdom.xpath.XPath;
  
  import de.matthias_burbach.deputy.core.project.Project;
  import de.matthias_burbach.deputy.core.rule.DeprecationRule;
  import de.matthias_burbach.deputy.core.rule.EnforcementRule;
  import de.matthias_burbach.deputy.core.rule.RemovalRule;
  import de.matthias_burbach.deputy.core.rule.ReplacementRule;
  import de.matthias_burbach.deputy.core.rule.RetentionRule;
  import de.matthias_burbach.deputy.core.util.FileUtils;
  import de.matthias_burbach.deputy.core.util.XmlUtils;
  
  /***
   * Generates a new XML document for a Maven project from its current XML file
   * and the changes made in the application.
   *
   * @author Matthias Burbach
   */
  public class ProjectGenerator {
      /***
       * The version of the Deputy application.
       * To be printed in the generator comment.
       */
      private String deputyVersion = "";
  
      /***
       * @param deputyVersion The version of the Deputy application.
       *                      To be printed in the generator comment.
       */
      public ProjectGenerator(final String deputyVersion) {
          this.deputyVersion = deputyVersion;
      }
  
      /***
       * Generates a new XML document for a Maven project from its current XML
       * file and the changes made in the application.
       *
       * @param project The project to generate the document for.
       * @param projectFileName The full path of the current project file.
       * @return The generated document.
       * @throws Exception if anything goes unexpectedly wrong
       */
      public Document createUpdatedDocument(
              final Project project,
              final String projectFileName)
              throws Exception {
          Document newDocument = XmlUtils.loadXmlDocument(projectFileName);
          generateDependencies(project, newDocument);
          generateRules(project, newDocument);
          return newDocument;
      }
  
      /***
       * Generates a new XML document for a Maven project from its current XML
       * file and the changes made in the application.
       * <p/>
       * Saves a backup of the previous version of the XML file under the path and
       * name of the original file plus the suffix '.bak' if the original file
       * is overridden.
       *
       * @param project The project to generate the document for.
       * @param oldProjectFileName The full path of the current project file.
       * @param newProjectFileName The full path to save the generated document
       *                           under.
       * @throws Exception if anything goes unexpectedly wrong
       */
      public void createAndSaveUpdatedDocument(
              final Project project,
              final String oldProjectFileName,
              final String newProjectFileName)
              throws Exception {
          if (newProjectFileName.equals(oldProjectFileName)) {
              backupFile(oldProjectFileName);
          }
          Document updatedDocument =
              createUpdatedDocument(project, oldProjectFileName);
          XmlUtils.saveXmlDocument(newProjectFileName, updatedDocument);
      }
  
      /***
       * @param project The project to generate dependencies for.
       * @param document The document to generate into.
       * @throws Exception if anything goes unexpectedly wrong
       */
      private void generateDependencies(
              final Project project,
              final Document document)
              throws Exception {
          //get the dependency mappings element from the document
          Element dependenciesElement = getDependenciesElement(document);
  
         //remove the contents of the dependencies element
         //because it may contain old dependency elements
         dependenciesElement.getContent().clear();
 
         //add comment to output
         dependenciesElement.addContent(getGeneratorComment());
 
         //generate the direct (=top level) dependency elements
         Iterator iter = project.getDependencies();
         while (iter.hasNext()) {
             Project dependency = (Project) iter.next();
             generateDependency(
                 dependenciesElement,
                 dependency,
                 true,
                 project.isAssembly(),
                 project.getDependencyPropertyList(dependency.getArtifactId()));
         }
 
         if (project.isAssembly()) {
             //generate the indirect dependency elements
             //add comment to output
             dependenciesElement.addContent(getIndirectDependenciesComment());
             iter = project.getIndirectDependencies();
             while (iter.hasNext()) {
                 Project dependency = (Project) iter.next();
                 generateDependency(
                     dependenciesElement,
                     dependency,
                     false,
                     project.isAssembly(),
                     project.getDependencyPropertyList(
                         dependency.getArtifactId()));
             }
         }
     }
 
     /***
      * @param dependenciesElement The parent Element to add the generated
      *                            dependency element to.
      * @param dependency The dependency to generate an XML element for.
      * @param isTop Whether this is a direct (or: top level) dependency.
      * @param isAssembly Whether we generate an assembly or a component project.
      * @param preservableProperties The dependency properties to be nested into
      *                              the dependency.
      */
     private void generateDependency(
             final Element dependenciesElement,
             final Project dependency,
             final boolean isTop,
             final boolean isAssembly,
             final List preservableProperties) {
         Element dependencyElement = new Element("dependency");
         addChildElement(
             dependencyElement, "groupId", dependency.getGroupId());
         addChildElement(
             dependencyElement, "artifactId", dependency.getArtifactId());
         addChildElement(
             dependencyElement, "version", dependency.getVersion());
         addChildElement(
             dependencyElement, "jar", dependency.getJar());
 
         String type = dependency.getType();
         if ("war".equals(type) && !isAssembly) {
             /*
              * WAR files must be referenced as JAR files by components.
              */
             type = null;
         }
         addChildElement(
             dependencyElement, "type", type);
 
         addChildElement(
             dependencyElement, "url", dependency.getUrl());
 
         Element propertiesElement = new Element("properties");
         Element topElement = new Element("top");
         topElement.setText((Boolean.valueOf(isTop)).toString());
         propertiesElement.addContent(topElement);
         /*
          * Add additional foreign properties which must be preserved
          */
         if (preservableProperties != null) {
             Iterator iter = preservableProperties.iterator();
             while (iter.hasNext()) {
                 Element element = (Element) iter.next();
                 propertiesElement.addContent((Element) element.clone());
             }
         }
         dependencyElement.addContent(propertiesElement);
 
         //add generated dependency to parent
         dependenciesElement.addContent(dependencyElement);
     }
 
     /***
      * @param project The project to generate the rules for.
      * @param document The document to generate into.
      * @throws Exception if anything goes unexpectedly wrong
      */
     private void generateRules(
             final Project project, final Document document) throws Exception {
         //get the rules element from the document
         Element rulesElement = getRulesElement(project, document);
 
         //remove the contents of the rules element
         //because it may contain old rule elements
         rulesElement.getContent().clear();
 
         //generate the default element
         Element defaultElement = new Element("default");
         String value = project.getRuleSet().getDefaultRule();
         defaultElement.setAttribute("value", value);
         rulesElement.addContent(defaultElement);
 
         //generate the enforcement elements
         Element enforcementsElement = new Element("enforcements");
         Iterator iter = project.getRuleSet().getEnforcementRules().iterator();
         while (iter.hasNext()) {
             EnforcementRule rule = (EnforcementRule) iter.next();
             generateRule(enforcementsElement, rule);
         }
         rulesElement.addContent(enforcementsElement);
 
         //generate the deprecation elements
         Element deprecationsElement = new Element("deprecations");
         iter = project.getRuleSet().getDeprecationRules().iterator();
         while (iter.hasNext()) {
             DeprecationRule rule = (DeprecationRule) iter.next();
             generateRule(deprecationsElement, rule);
         }
         rulesElement.addContent(deprecationsElement);
 
         //generate the replacement elements
         Element replacementsElement = new Element("replacements");
         iter = project.getRuleSet().getReplacementRules().iterator();
         while (iter.hasNext()) {
             ReplacementRule rule = (ReplacementRule) iter.next();
             generateRule(replacementsElement, rule);
         }
         rulesElement.addContent(replacementsElement);
 
         //generate the removal elements
         Element removalsElement = new Element("removals");
         iter = project.getRuleSet().getRemovalRules().iterator();
         while (iter.hasNext()) {
             RemovalRule rule = (RemovalRule) iter.next();
             generateRule(removalsElement, rule);
         }
         rulesElement.addContent(removalsElement);
 
         //generate the retention elements
         Element retentionsElement = new Element("retentions");
         iter = project.getRuleSet().getRetentionRules().iterator();
         while (iter.hasNext()) {
             RetentionRule rule = (RetentionRule) iter.next();
             generateRule(retentionsElement, rule);
         }
         rulesElement.addContent(retentionsElement);
     }
 
     /***
      * @param enforcementsElement The parent to add the generated element to.
      * @param rule The rule to generate an XML element for.
      */
     private void generateRule(
             final Element enforcementsElement,
             final EnforcementRule rule) {
         Element element = new Element("enforcement");
         addChildElement(element, "groupId", rule.getGroupId());
         addChildElement(element, "artifactId", rule.getArtifactId());
         addChildElement(element, "version", rule.getVersion());
         if (rule.isDerived()) {
             addChildElement(
                     element, "derived", Boolean.toString(rule.isDerived()));
         }
 
         //add generated element to parent
         enforcementsElement.addContent(element);
     }
 
     /***
      * @param deprecationsElement The parent to add the generated element to.
      * @param rule The rule to generate an XML element for.
      */
     private void generateRule(
             final Element deprecationsElement,
             final DeprecationRule rule) {
         Element element = new Element("deprecation");
         addChildElement(element, "groupId", rule.getGroupId());
         addChildElement(element, "artifactId", rule.getArtifactId());
         addChildElement(element, "version", rule.getVersion());
 
         //add generated element to parent
         deprecationsElement.addContent(element);
     }
 
     /***
      * @param replacementsElement The parent to add the generated element to.
      * @param rule The rule to generate an XML element for.
      */
     private void generateRule(
             final Element replacementsElement,
             final ReplacementRule rule) {
         Element element = new Element("replacement");
 
         Element displacementElement = new Element("displacement");
         addChildElement(
             displacementElement,
             "groupId",
             rule.getDisplacedGroupId());
         addChildElement(
             displacementElement,
             "artifactId",
             rule.getDisplacedArtifactId());
         if (rule.getDisplacedVersion() != null) {
             addChildElement(
                 displacementElement,
                 "version",
                 rule.getDisplacedVersion());
         }
 
         Element placementElement = new Element("placement");
         addChildElement(
             placementElement,
             "groupId",
             rule.getGroupId());
         addChildElement(
             placementElement,
             "artifactId",
             rule.getArtifactId());
         if (rule.getVersion() != null) {
             addChildElement(
                 placementElement,
                 "version",
                 rule.getVersion());
         }
 
         element.addContent(displacementElement);
         element.addContent(placementElement);
         //add generated element to parent
         replacementsElement.addContent(element);
     }
 
     /***
      * @param removalsElement The parent to add the generated element to.
      * @param rule The rule to generate an XML element for.
      */
     private void generateRule(
             final Element removalsElement,
             final RemovalRule rule) {
         Element element = new Element("removal");
         addChildElement(element, "groupId", rule.getGroupId());
         addChildElement(element, "artifactId", rule.getArtifactId());
         if (rule.getVersion() != null) {
             addChildElement(element, "version", rule.getVersion());
         }
         //add generated element to parent
         removalsElement.addContent(element);
     }
 
     /***
      * @param retentionsElement The parent to add the generated element to.
      * @param rule The rule to generate an XML element for.
      */
     private void generateRule(
             final Element retentionsElement,
             final RetentionRule rule) {
         Element element = new Element("retention");
         addChildElement(element, "groupId", rule.getGroupId());
         addChildElement(element, "artifactId", rule.getArtifactId());
         if (rule.getVersion() != null) {
             addChildElement(element, "version", rule.getVersion());
         }
         //add generated element to parent
         retentionsElement.addContent(element);
     }
 
     /***
      * Adds an element to the parent if the text is not <code>null</code>.
      *
      * @param parentElement The parent to add to.
      * @param childName The name of the child element to add.
      * @param childText The contents of the child element to add. Can be
      *                  <code>null</code> which will make this operation a noop.
      */
     private void addChildElement(
             final Element parentElement,
             final String childName,
             final String childText) {
         if (childText != null) {
             Element childElement = new Element(childName);
             childElement.setText(childText);
             parentElement.addContent(childElement);
         }
     }
 
     /***
      * Finds or creates the dependencies element in the document.
      *
      * @param document The document to parse for a potentially already existing
      *                 dependencies element.
      * @return The dependencies element.
      * @throws Exception if anything goes unexpectedly wrong
      */
     private Element getDependenciesElement(
             final Document document) throws Exception {
         Element dependenciesElement = null;
         if (document != null) {
             dependenciesElement =
                 (Element) XPath.newInstance("//project/dependencies")
                                .selectSingleNode(document);
         }
         if (dependenciesElement == null) {
             dependenciesElement = new Element("dependencies");
             Element projectElement =
                 (Element) XPath.newInstance("//project")
                                .selectSingleNode(document);
             if (projectElement != null) {
                 projectElement.addContent(dependenciesElement);
             }
         }
         return dependenciesElement;
     }
 
     /***
      * Finds or creates the rules element in the document.
      *
      * @param project The current project.
      * @param document The document to parse for a potentially already existing
      *                 rules element.
      * @return The rules element.
      * @throws Exception if anything goes unexpectedly wrong
      */
     private Element getRulesElement(
             final Project project,
             final Document document) throws Exception {
         Element resultElement = null;
         Element deputyElement = getDeputyElement(project, document);
         if (deputyElement != null) {
             resultElement =
                 (Element) XPath.newInstance("rules").selectSingleNode(
                     deputyElement);
             if (resultElement == null) {
                 resultElement = new Element("rules");
                 deputyElement.addContent(resultElement);
             }
         }
         return resultElement;
     }
 
     /***
      * Finds or creates the deputy element in the document.
      *
      * @param project The current project.
      * @param document The document to parse for a potentially already existing
      *                 deputy element.
      *
      * @return The deputy element from the project's properties.
      * @throws Exception if anything goes unexpectedly wrong
      */
     private Element getDeputyElement(
             final Project project,
             final Document document) throws Exception {
         Element resultElement = null;
         Element propertiesElement = getPropertiesElement(document);
         if (propertiesElement != null) {
             resultElement =
                 (Element) XPath.newInstance("deputy").selectSingleNode(
                     propertiesElement);
             if (resultElement == null) {
                 resultElement = new Element("deputy");
                 propertiesElement.addContent(resultElement);
             }
         }
         //set the isAssembly attribute
         resultElement.setAttribute(
             "isAssembly",
             Boolean.valueOf(project.isAssembly()).toString());
         return resultElement;
     }
 
     /***
      * Finds or creates the project's properties element.
      *
      * @param document The document to parse for the potentially already
      *                 existing properties element.
      * @return The properties element.
      * @throws Exception if anything goes unexpectedly wrong
      */
     private Element getPropertiesElement(
             final Document document) throws Exception {
         Element resultElement = null;
         Element projectElement = getProjectElement(document);
         if (projectElement != null) {
             resultElement =
                 (Element) XPath.newInstance("properties").selectSingleNode(
                     projectElement);
             if (resultElement == null) {
                 resultElement = new Element("properties");
                 projectElement.addContent(resultElement);
             }
         }
         return resultElement;
     }
 
     /***
      * Finds or creates the project element.
      *
      * @param document The document to parse for the potentially already
      *                 existing project element.
      * @return The project element.
      * @throws Exception if anything goes unexpectedly wrong
      */
     private Element getProjectElement(
             final Document document) throws Exception {
         Element resultElement = null;
         if (document != null) {
             resultElement =
                 (Element) XPath.newInstance("//project").selectSingleNode(
                     document);
         }
         return resultElement;
     }
 
     /***
      * @return The comment stating the name of the generator tool and the time
      *         of the generation.
      */
     private Comment getGeneratorComment() {
         return new Comment(
                 "Generated by Deputy " + deputyVersion + " at " + new Date());
     }
 
     /***
      * @return The comment heading the indirect dependencies in assemblies.
      */
     private Comment getIndirectDependenciesComment() {
         return new Comment("Indirect Dependencies");
     }
 
     /***
      * Backs up the file passed in.
      * <p/>
      * The backup is copied to the same directory the original is in. It is
      * named '&lt;original-file-name&gt;.bak'.
      *
      * @param pathAndFile The file to be backed up.
      * @throws Exception if anything goes unexpectedly wrong
      */
     private void backupFile(final String pathAndFile) throws Exception {
         FileUtils.copy(pathAndFile, pathAndFile + ".bak");
     }
 }