package net.logAnalyzer.reports;
   
   import java.text.SimpleDateFormat;
   import java.util.Date;
   
   import javax.xml.parsers.DocumentBuilder;
   import javax.xml.parsers.DocumentBuilderFactory;
   import javax.xml.parsers.ParserConfigurationException;
   
  import net.logAnalyzer.analysis.AnalyzerException;
  import net.logAnalyzer.analysis.LAAnalysis;
  import net.logAnalyzer.analysis.LAAnalyzer;
  import net.logAnalyzer.analysis.MultiValuesAnalysis;
  import net.logAnalyzer.analysis.SingleValueAnalysis;
  import net.logAnalyzer.utils.XMLUtils;
  
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  
  /***
   * This renderer generates an XML report from analyzers results. Each analysis
   * is serialized in XML format according to the class of its result.
   * <p>
   * The report returned by {@link #render()} is an XML document of class
   * {@link org.w3c.dom.Document} wrapped in a
   * {@link net.logAnalyzer.reports.XMLReport}.
   * </p>
   * 
   * @author Karim REFEYTON
   * @version 0.1
   */
  public class XMLReportRenderer implements LAReportRenderer {
      /***
       * LAReportRenderer definition.
       */
      private RendererDefinition definition = null;
  
      /***
       * Analyzers to include in the report.
       */
      private LAAnalyzer[] analyzers = null;
  
      /***
       * Creates a new report for specified analyzers.
       * 
       * @param definition
       *            Renderer definition.
       * @param analyzers
       *            Analyzers to include in the report.
       */
      public XMLReportRenderer(RendererDefinition definition,
              LAAnalyzer[] analyzers) {
          this.definition = definition;
          this.analyzers = analyzers;
      }
  
      /***
       * Creates a new XML document.
       * <p>
       * The new XML document has a root node as :<br>
       * <br>
       * <tt>&lt;analyzer:report class="<i>analyzerClassName</i>"/&gt;</tt>.<br>
       * and children as :
       * <tt>&lt;analyzer:report class="<i>analyzerClassName</i>"/&gt;</tt>.
       * </p>
       * <p>
       * The children of each analyzer node are specific to the analyzer result
       * class (see {@link LAAnalysis}).
       * </p>
       * 
       * @return New XML document.
       * @throws AnalyzerException
       *             If anay parsing error.
       */
      protected Document createNewXMLDocument() throws ReportException {
          // Creates a new document
          DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
          factory.setCoalescing(false);
          factory.setExpandEntityReferences(false);
          factory.setIgnoringComments(true);
          factory.setIgnoringElementContentWhitespace(true);
          factory.setNamespaceAware(true);
          factory.setValidating(false);
          Document document = null;
          try {
              DocumentBuilder builder = factory.newDocumentBuilder();
  
              document = builder.newDocument();
              Element root = (Element) document.createElement("report");
              document.appendChild(root);
              XMLUtils.addAttribute(document, root, "created",
                      (new SimpleDateFormat("dd/MM/yyyy HH:mm:ss"))
                              .format(new Date()));
              document.getDocumentElement().normalize();
          } catch (ParserConfigurationException pce) {
              throw new ReportException(pce.getMessage(), pce);
          }
          return document;
      }
 
     /***
      * Returns the name of the analyzer.
      * 
      * @return LAAnalyzer name.
      * @see LAReportRenderer#getName()
      */
     public String getName() {
         return definition.getName();
     }
 
     /***
      * Render the report. The report is a {@link XMLReport} wrapping a XML
      * {@link Document} representation of all anlyzers results.
      * 
      * @return Generated report.
      * @throws ReportException
      * @see LAReportRenderer#render()
      */
     public LAReport[] render() throws ReportException {
         Document report = createNewXMLDocument();
         if (analyzers != null && analyzers.length > 0) {
             for (int i = 0; i < analyzers.length; i++) {
                 renderAnalysis(report, analyzers[i].getAnalysis());
             }
         }
         // Puts reports in the Hashtable
         LAReport[] reports = new LAReport[1];
         reports[0] = new XMLReport("FullReport", report);
         return reports;
     }
 
     /***
      * Empty method to avoid loops on unsupported analysis.
      * 
      * @param report
      *            Report.
      * @param analysis
      *            Analyze to render.
      */
     protected void renderAnalysis(Document report, LAAnalysis analysis) {
         if (analysis instanceof SingleValueAnalysis) {
             renderAnalysis(report, (SingleValueAnalysis) analysis);
         } else if (analysis instanceof MultiValuesAnalysis) {
             renderAnalysis(report, (MultiValuesAnalysis) analysis);
         }
     }
 
     /***
      * Renders a key values result. Element format:
      * 
      * <pre>
      * &lt;analyzerName label=&quot;analyzer.getLabel()&quot;&gt;
      *   &lt;item valueName=&quot;value[1]&quot;&gt;key[1]&lt;/item&gt;
      *   &lt;item valueName=&quot;value[2]&quot;&gt;key[2]&lt;/item&gt;
      *   ...
      * &lt;/analyzerName&gt;
      * </pre>
      * 
      * @param report
      *            Report.
      * @param analysis
      *            Analyze to render.
      */
     protected void renderAnalysis(Document report, SingleValueAnalysis analysis) {
         // Adds the renderAnalysis to the report
         Element newElement = XMLUtils.addElement(report, analysis.getAnalyzer()
                 .getName());
         // Adds the label
         XMLUtils.addAttribute(report, newElement, "label", analysis
                 .getAnalyzer().getLabel());
         // Adds each values and keys
         for (int i = 0; i < analysis.size(); i++) {
             // Adds the key
             Element newItem = XMLUtils.addElement(report, newElement, "item",
                     analysis.getStringKey(i), false);
             // Adds the value
             XMLUtils.addAttribute(report, newItem, analysis.getName(), analysis
                     .getString(i));
         }
     }
 
     /***
      * Renders a multi values result. Element format:
      * 
      * <pre>
      * &lt;analyzerName label=&quot;analyzer.getLabel()&quot;&gt;
      *   &lt;item valueName1=&quot;value1[1]&quot; valueName2=&quot;value2[1]&quot; ...&gt;key[1]&lt;/item&gt;
      *   &lt;item valueName1=&quot;value1[2]&quot; valueName2=&quot;value2[2]&quot; ...&gt;key[2]&lt;/item&gt;
      *   ...
      * &lt;/analyzerName&gt;
      * </pre>
      * 
      * @param report
      *            Report.
      * @param analysis
      *            Analyze to render.
      */
     protected void renderAnalysis(Document report, MultiValuesAnalysis analysis) {
         // Adds the result to the report
         Element newElement = XMLUtils.addElement(report, analysis.getAnalyzer()
                 .getName());
         // Adds the label
         XMLUtils.addAttribute(report, newElement, "label", analysis
                 .getAnalyzer().getLabel());
         // Adds the values and keys
         String[] valuesNames = analysis.getNames();
         for (int i = 0; i < analysis.size(); i++) {
             // Adds the key
             Comparable key = analysis.getKey(i);
             Element newItem = XMLUtils.addElement(report, newElement, "item",
                     analysis.getStringKey(i), false);
             // Adds the values
             for (int j = 0; j < valuesNames.length; j++) {
                 String valueName = valuesNames[j];
                 valueName = valueName.replace(' ', '_');
                 XMLUtils.addAttribute(report, newItem, valueName, analysis
                         .getString(key, j));
             }
         }
     }
 }