package net.sf.logdistiller.reports;
   
   /*
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  import java.io.IOException;
  import java.io.Writer;
  import java.util.Iterator;
  
  import org.jdom.*;
  import org.jdom.output.Format;
  import org.jdom.output.XMLOutputter;
  
  import net.sf.logdistiller.LogDistillation;
  import net.sf.logdistiller.LogDistiller;
  import net.sf.logdistiller.ReportFormat;
  
  /**
   * XML report format.
   *
   * @since 0.8
   */
  public class XmlReport
      extends ReportFormat
  {
      public XmlReport()
      {
          super( "xml" );
      }
  
      public String getContentType()
      {
          return "text/xml";
      }
  
      public String getFileExtension()
      {
          return "xml";
      }
  
      public void report( LogDistillation ld, Writer output )
          throws IOException
      {
          LogDistiller definition = ld.getDefinition();
  
          Element report = new Element( "logdistiller-report" );
          Element elmt = new Element( "logdistiller" );
          elmt.setAttribute( "id", definition.getOutput().getId() );
          elmt.setAttribute( "description", definition.getDescription() );
          elmt.setAttribute( "logtype", definition.getLogType().getId() );
          elmt.setAttribute( "version", ld.getVersion() );
          report.addContent( elmt );
  
          elmt = new Element( "logdistillation" );
          if ( ld.getContent() != null )
          {
              elmt.setAttribute( "content", ld.getContent() );
          }
          String logsUrl = definition.getOutput().getUrl();
          if ( logsUrl != null )
          {
              elmt.setAttribute( "logsUrl", logsUrl );
          }
          elmt.setAttribute( "beginTime", String.valueOf( ld.getBeginTime() ) );
          elmt.setAttribute( "endTime", String.valueOf( ld.getEndTime() ) );
          elmt.setAttribute( "eventCount", String.valueOf( ld.getEventCount() ) );
          elmt.setAttribute( "eventBytes", String.valueOf( ld.getEventBytes() ) );
          elmt.setAttribute( "skippedEventCount", String.valueOf( ld.getSkippedEventCount() ) );
          elmt.setAttribute( "skippedEventBytes", String.valueOf( ld.getSkippedEventBytes() ) );
          Iterator iter = definition.getWarnings().iterator();
          while ( iter.hasNext() )
          {
              elmt.addContent( new Element( "warning" ).setText( (String) iter.next() ) );
          }
          report.addContent( elmt );
  
          // report for categories, and corresponding groups
          Iterator categoriesIterator = ld.listCategoriesToReport().iterator();
          while ( categoriesIterator.hasNext() )
          {
              LogDistillation.Category category = (LogDistillation.Category) categoriesIterator.next();
              elmt.addContent( newCategory( category ) );
          }
  
          // report for groups without category
          Iterator groupsIterator = ld.listGroupsToReport().iterator();
          while ( groupsIterator.hasNext() )
          {
             LogDistillation.Group group = (LogDistillation.Group) groupsIterator.next();
             elmt.addContent( newGroup( group ) );
         }
 
         new XMLOutputter( Format.getPrettyFormat() ).output( new Document( report ), output );
     }
 
     private Element newCategory( LogDistillation.Category category )
     {
         Element elmt = new Element( "category" );
         LogDistiller.Category definition = category.getDefinition();
         elmt.setAttribute( "id", definition.getId() );
         elmt.setAttribute( "description", definition.getDescription() );
         elmt.setAttribute( "eventCount", String.valueOf( category.sumEventCount() ) );
         elmt.setAttribute( "eventBytes", String.valueOf( category.sumBytes() ) );
         Iterator iter = category.listGroupsToReport().iterator();
         while ( iter.hasNext() )
         {
             LogDistillation.Group group = (LogDistillation.Group) iter.next();
             elmt.addContent( newGroup( group ) );
         }
         return elmt;
     }
 
     private Element newGroup( LogDistillation.Group group )
     {
         Element elmt = new Element( "group" );
         LogDistiller.Group definition = group.getDefinition();
         elmt.setAttribute( "id", definition.getId() );
         elmt.setAttribute( "description", definition.getDescription() );
         elmt.setAttribute( "eventCount", String.valueOf( group.getEventCount() ) );
         elmt.setAttribute( "eventBytes", String.valueOf( group.getBytes() ) );
         if ( definition.continueProcessing() )
         {
             elmt.setAttribute( "continueProcessing", "true" );
         }
         addPluginsGlobalReport( group, new XmlPluginReport( elmt ) );
         return elmt;
     }
 
     public void report( LogDistillation.Group group, Writer output )
         throws IOException
     {
         LogDistillation ld = group.getLogdistillation();
         LogDistiller.Group definition = group.getDefinition();
         Element elmt;
 
         Element report = new Element( "logdistiller-group-report" );
         report.addContent( elmt = new Element( "group" ) );
         elmt.setAttribute( "id", definition.getId() );
         elmt.setAttribute( "description", definition.getDescription() );
         elmt.setAttribute( "continueProcessing", definition.continueProcessing() ? "true" : "false" );
         definition.dumpConditions( elmt );
 
         report.addContent( elmt = new Element( "logdistillation" ) );
         if ( ld.getContent() != null )
         {
             elmt.setAttribute( "content", ld.getContent() );
         }
         String logsUrl = ld.getDefinition().getOutput().getUrl();
         if ( logsUrl != null )
         {
             elmt.setAttribute( "logsUrl", logsUrl );
         }
         elmt.setAttribute( "eventCount", String.valueOf( ld.getEventCount() ) );
         elmt.setAttribute( "eventBytes", String.valueOf( ld.getEventBytes() ) );
 
         if ( definition.getSave() )
         {
             Element save = new Element( "save" );
             save.setAttribute( "logFile", group.getLogFile().getAbsolutePath() );
             save.setAttribute( "savedEventCount", String.valueOf( group.getSavedEventCount() ) );
             save.setAttribute( "maxSaveCount", String.valueOf( group.getMaxSaveCount() ) );
             save.setAttribute( "maxSaveBytes", String.valueOf( group.getMaxSaveBytes() ) );
             if ( logsUrl != null )
             {
                 save.setAttribute( "logsUrl", ld.getDefinition().getOutput().getUrl( group.getLogFile().getName() ) );
             }
             elmt.addContent( save );
         }
         addPluginsGroupReport( group, new XmlPluginReport( elmt ) );
 
         new XMLOutputter( Format.getPrettyFormat() ).output( new Document( report ), output );
     }
 
     private static class XmlPluginReport
         extends PluginReport
     {
         private final Element elmt;
 
         private Element pluginElmt;
 
         public XmlPluginReport( Element elmt )
         {
             this.elmt = elmt;
             pluginElmt = null;
         }
 
         public void beginPluginReport( LogDistillation.Plugin plugin, String description )
         {
             pluginElmt = new Element( "plugin" ).setAttribute( "type", plugin.getDefinition().getType() );
             pluginElmt.addContent( new Element( "description" ).setText( description ) );
         }
 
         public void addLink( String filename, String description )
         {
             pluginElmt.addContent( new Element( "link" ).setAttribute( "filename", filename ).setText( description ) );
         }
 
         public void addParam( String param, String value )
         {
             pluginElmt.addContent( new Element( "param" ).setAttribute( "name", param ).setText( value ) );
         }
 
         public void addItem( int count, String description )
         {
             pluginElmt.addContent( new Element( "item" ).setAttribute( "count", String.valueOf( count ) ).setText(
                                                                                                                    description ) );
         }
 
         public void endPluginReport()
         {
             elmt.addContent( pluginElmt );
             pluginElmt = null;
         }
     }
 }