package org.andromda.maven.plugin.site;
   
   import java.io.ByteArrayInputStream;
   import java.io.ByteArrayOutputStream;
   import java.io.File;
   import java.io.FileWriter;
   import java.io.IOException;
   import java.io.InputStream;
   import java.net.URL;
  import java.util.List;
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.transform.Result;
  import javax.xml.transform.Source;
  import javax.xml.transform.TransformerFactory;
  import javax.xml.transform.dom.DOMSource;
  import javax.xml.transform.stream.StreamResult;
  import javax.xml.transform.stream.StreamSource;
  import org.apache.commons.lang.StringUtils;
  import org.dom4j.Element;
  import org.dom4j.io.SAXReader;
  import org.dom4j.io.XMLWriter;
  import org.w3c.dom.Document;
  import org.xml.sax.EntityResolver;
  import org.xml.sax.InputSource;
  import org.xml.sax.SAXException;
  
  /**
   * Used to perform the transformation of XSL documents
   * within the site plugin.
   *
   * @author Chad Brandon
   * @author Vance Karimi
   */
  public class XslTransformer
  {
      private String projectName;
  
      /**
       * Default constructor
       *
       */
      public XslTransformer()
      {
          // Default constructor
      }
  
      /**
       * Constructor that sets the project name used to replace variable inside generated
       * xdoc xml.
       *
       * @param projectNameIn
       */
      public XslTransformer(String projectNameIn)
      {
          this.projectName = projectNameIn;
      }
  
      /**
       * Applies the given XSLT files to the model in the order in which they are found.
       *
       * @param xmlDocument The full path of the original XML
       * @param transformation The full path of the XSLT
       * @param outputLocation The full path of the output xdoc XML
       */
      public void transform(
          final String xmlDocument,
          final String transformation,
          final String outputLocation)
      {
          try
          {
              this.transform(xmlDocument, new File(transformation).toURI().toURL(), outputLocation);
          }
          catch (final Exception exception)
          {
              throw new RuntimeException(exception);
          }
      }
  
      /**
       * Applies the given XSLT files to the model in the order in which they are found.
       *
       * @param xmlDocument The full path of the original XML
       * @param xslt The URL of the XSLT
       * @param outputLocation The full path of the output xdoc XML
       */
      public void transform(
          final String xmlDocument,
          final URL xslt,
          final String outputLocation)
      {
          try
          {
              if (StringUtils.isNotBlank(xmlDocument))
              {
                  final Source xmlSource = new DOMSource(this.urlToDocument(xmlDocument));
                  final TransformerFactory factory = TransformerFactory.newInstance();
                 if (xslt != null)
                 {
                     final Source xsltSource = new StreamSource(xslt.openStream());
                     final javax.xml.transform.Transformer transformer = factory.newTransformer(xsltSource);
                     final ByteArrayOutputStream output = new ByteArrayOutputStream();
                     final Result result = new StreamResult(output);
                     transformer.transform(
                         xmlSource,
                         result);
 
                     final byte[] outputResult = output.toByteArray();
                     final org.dom4j.Document document = replaceVariableProperties(outputResult);
 
                     if (StringUtils.isNotBlank(outputLocation))
                     {
                         final File fileOutput = new File(outputLocation);
                         final File parent = fileOutput.getParentFile();
                         if (parent != null)
                         {
                             parent.mkdirs();
                         }
 
                         FileWriter fwriter = new FileWriter(fileOutput);
                         XMLWriter writer = new XMLWriter(fwriter);
                         writer.write(document);
                         writer.flush();
                         writer.close();
                         fwriter.close();
                     }
                 }
             }
         }
         catch (final Exception exception)
         {
             throw new RuntimeException(exception);
         }
     }
 
     /**
      * Parses the XML retrieved from the String URL and returns a Document object.
      * @param url the url of the XML to parse.
      * @return Document newly created Document object.
      * @throws ParserConfigurationException
      * @throws IOException
      * @throws SAXException
      */
     @SuppressWarnings("static-method")
     private Document urlToDocument(String url)
         throws Exception
     {
         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
         DocumentBuilder builder = factory.newDocumentBuilder();
         builder.setEntityResolver(new XslTransformerEntityResolver(url));
         return builder.parse(new InputSource(url));
     }
 
     /**
      * The prefix that the systemId should start with when attempting
      * to resolve it within a jar.
      */
     private static final String SYSTEM_ID_FILE = "file:";
 
     /**
      * Provides the resolution of external entities.
      */
     private static final class XslTransformerEntityResolver
         implements EntityResolver
     {
         private String xmlDocument;
 
         XslTransformerEntityResolver(final String xmlDocument)
         {
             this.xmlDocument = xmlDocument;
         }
 
         /**
          * @see org.xml.sax.EntityResolver#resolveEntity(String, String)
          */
         @SuppressWarnings("resource")
         public InputSource resolveEntity(
             final String publicId,
             final String systemId)
             throws SAXException, IOException
         {
             InputSource source = null;
             String path = systemId;
             if (path != null && path.startsWith(SYSTEM_ID_FILE))
             {
                 final String xmlResource = this.xmlDocument;
                 path = path.replaceFirst(
                         SYSTEM_ID_FILE,
                         "");
 
                 // - remove any extra starting slashes
                 path = path.replaceAll(
                         "\\+",
                         "/").replaceAll(
                         "/+",
                         "/");
 
                 // - if we still have one starting slash, remove it
                 if (path.startsWith("/"))
                 {
                     path = path.substring(
                             1,
                             path.length());
                 }
                 final String xmlResourceName = xmlResource.replaceAll(
                         ".*(\\+|/)",
                         "");
 
                 InputStream inputStream = null;
                 URL uri = new File(StringUtils.replace(
                             xmlResource,
                             xmlResourceName,
                             path)).toURI().toURL();
                 if (uri != null)
                 {
                     inputStream = uri.openStream();
                 }
                 if (inputStream != null)
                 {
                     source = new InputSource(inputStream);
                     source.setPublicId(publicId);
                     if (uri != null)
                     {
                         source.setSystemId(uri.toString());
                     }
                 }
             }
             return source;
         }
     }
 
     /**
      * Replace the variable property defined by %module% in the output generated
      * xdoc file.  Uses dom4j XPath to locate the variable.
      *
      * @param documentBuffer The byte array representing the xdoc XML
      * @return the org.dom4j.Document object of the xdoc XML
      * @throws Exception
      */
     private org.dom4j.Document replaceVariableProperties(byte[] documentBuffer)
         throws Exception
     {
         SAXReader reader = new SAXReader();
         org.dom4j.Document document = reader.read(new ByteArrayInputStream(documentBuffer));
 
         // List elements = document.selectNodes("//*[contains(text(),'%module%')]");
         List<Element> elements = document.selectNodes("//*");
         for (final Element element : elements)
         {
             if (StringUtils.contains(element.getText(), "%module%"))
             {
                 element.setText(
                         StringUtils.replace(
                                 element.getText(),
                                 "%module%",
                                 this.getProjectName()));
             }
         }
         elements.clear();
 
         elements = document.selectNodes("//*[contains(@*,'%module%')]");
         for (final Element element : elements)
         {
             element.addAttribute(
                     "name",
                     StringUtils.replace(
                             element.attributeValue("name"),
                             "%module%",
                             this.getProjectName()));
         }
         return document;
     }
 
     /**
      * @return Returns the projectName.
      */
     public String getProjectName()
     {
         return projectName;
     }
 
     /**
      * @param projectName The projectName to set.
      */
     public void setProjectName(String projectName)
     {
         this.projectName = projectName;
     }
 }