package net.sf.logdistiller;
   
   /*
    * 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.*;
  import java.util.*;
  
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.lang.ArrayUtils;
  
  /**
   * The class executing a log distillation, using a log distiller, and processing every log events. A log distillation
   * can be run either with LogDistiller's {@link net.sf.logdistiller.gui GUI} or with {@link net.sf.logdistiller.ant Ant
   * tasks}.
   *
   * @see LogDistiller
   */
  public class LogDistillation
      implements Serializable
  {
      private static final long serialVersionUID = -9098523382541148543L;
  
      public final static String LINE_SEPARATOR = System.getProperty( "line.separator" );
  
      private final LogDistiller ld;
  
      private final Group[] groups;
  
      private final Category[] categories;
  
      private final String content;
  
      private final File destinationDirectory;
  
      private final String version = LogDistiller.getVersion();
  
      private transient Map<String, Group> mapGroups;
  
      private transient Map<String, Category> mapCategories;
  
      private long beginTime;
  
      private long endTime;
  
      private int eventCount = -1;
  
      private long eventBytes = 0;
  
      private int skippedEventCount = 0;
  
      private long skippedEventBytes = 0;
  
      private transient LogType.Description logtypeDescription;
  
      public LogDistillation( LogDistiller ld )
      {
          this.ld = ld;
  
          // init categories
          LogDistiller.Category[] categoryDefinitions = ld.getCategories();
          int length = categoryDefinitions.length;
          categories = new Category[length];
          mapCategories = new HashMap<String, Category>();
          for ( int i = 0; i < length; i++ )
          {
              categories[i] = new Category( categoryDefinitions[i] );
              mapCategories.put( categoryDefinitions[i].getId(), categories[i] );
          }
  
          // init groups
          LogDistiller.Group[] groupDefinitions = ld.getGroups();
          length = groupDefinitions.length;
          groups = new Group[length];
          for ( int i = 0; i < length; i++ )
          {
              LogDistiller.Group groupDefinition = groupDefinitions[i];
              LogDistiller.Category categoryDefinition = groupDefinition.getCategory();
              Category category =
                  ( categoryDefinition == null ) ? null : (Category) mapCategories.get( categoryDefinition.getId() );
              groups[i] = new Group( groupDefinition, category );
          }
  
          // misc.
          content = ld.getOutput().getContent();
          destinationDirectory = new File( ld.getOutput().getDirectory() );
          updateRef();
      }
 
     /**
      * Create a logtype description with parameters defined in LogDistiller configuration.
      * @return a new logtype description
      */
     private LogType.Description newLogTypeDescription()
     {
         LogDistiller.LogType lt = ld.getLogType();
 
         LogType logtype = LogTypes.getLogType( lt.getId() );
         LogType.Description logtypeDescription = logtype.newDescription( ld.getLogType().getParams() );
         logtypeDescription.setExtensions( ld.getLogType().getExtensions() );
         ld.checkLogtypeAttributes( logtypeDescription );
 
         return logtypeDescription;
     }
 
     /**
      * update internal maps, skip value and references from categories and groups
      */
     private void updateRef()
     {
         String skip = ld.getOutput().getSkip();
 
         // process categories
         mapCategories = new HashMap<String, Category>();
         Category skipCategory = null;
         int len = categories.length;
         for ( int i = 0; i < len; i++ )
         {
             Category category = categories[i];
             mapCategories.put( category.getDefinition().getId(), category );
             category.updateRef( this );
 
             if ( category.getDefinition().getId().equals( skip ) )
             {
                 skipCategory = category;
             }
         }
 
         // process groups
         mapGroups = new HashMap<String, Group>();
         len = groups.length;
         for ( int i = 0; i < len; i++ )
         {
             Group group = groups[i];
             mapGroups.put( group.getDefinition().getId(), group );
             group.updateRef( this );
 
             if ( group.getDefinition().getId().equals( skip ) )
             {
                 group.setSkip( true );
             }
         }
 
         if ( skipCategory != null )
         {
             skipCategory.setSkip( true );
         }
 
         logtypeDescription = newLogTypeDescription();
     }
 
     private void readObject( ObjectInputStream in )
         throws IOException, ClassNotFoundException
     {
         in.defaultReadObject();
         if ( ld.getOutput() != null )
         {
             ld.updateRef(); // workaround: a problem with Group deserialization happens
             updateRef();
         }
     }
 
     /**
      * begin the distillation
      *
      * @throws IOException
      */
     public void begin()
         throws IOException
     {
         destinationDirectory.mkdirs();
         int count = groups.length;
         for ( int i = 0; i < count; i++ )
         {
             groups[i].begin( destinationDirectory );
         }
         eventCount = 0;
         beginTime = System.currentTimeMillis();
     }
 
     /**
      * Process a log event
      *
      * @param le LogEvent the log event
      * @throws IOException if an error occurs when (eventually) saving the log event
      */
     public void processLogEvent( LogEvent le )
         throws IOException
     {
         if ( eventCount < 0 )
         {
             throw new IllegalStateException( "LogDistiller not initialized: need to call begin() before processing" );
         }
         eventCount++;
         int eventSize = le.getRawLog().length() + LINE_SEPARATOR.length();
         eventBytes += eventSize;
         int count = groups.length;
         for ( int i = 0; i < count; i++ )
         {
             Group group = groups[i];
             if ( group.accept( le ) )
             {
                 if ( group.isSkip() )
                 {
                     // logevent matched a skipped group => update counters
                     eventCount--;
                     eventBytes -= eventSize;
                     skippedEventCount++;
                     skippedEventBytes += eventSize;
                     break;
                 }
                 if ( !group.getDefinition().continueProcessing() )
                 {
                     break;
                 }
             }
         }
     }
 
     /**
      * end the distillation
      *
      * @throws IOException if an error occurs when closing the files where log events were (eventually) saved
      */
     public void end()
         throws IOException
     {
         endTime = System.currentTimeMillis();
         int count = groups.length;
         for ( int i = 0; i < count; i++ )
         {
             Group group = groups[i];
             group.end();
         }
         saveTo( newDestinationFile( "result.ser" ) );
     }
 
     /**
      * Saves the distillation to a file, in Java serialized format.
      *
      * @param file File destination file.
      */
     public void saveTo( File file )
         throws IOException
     {
         OutputStream out = null;
         try
         {
             out = new FileOutputStream( file );
             saveTo( out );
         }
         finally
         {
             IOUtils.closeQuietly( out );
         }
     }
 
     public void saveTo( OutputStream out )
         throws IOException
     {
         ObjectOutputStream obj = new ObjectOutputStream( out );
         obj.writeObject( this );
     }
 
     public List<Category> listCategoriesToReport()
     {
         List<Category> reportCategories = new ArrayList<Category>();
         int count = categories.length;
         for ( int i = 0; i < count; i++ )
         {
             Category category = categories[i];
             if ( ( !category.isSkip() ) && ( category.sumEventCount() > 0 ) )
             {
                 reportCategories.add( category );
             }
         }
         return reportCategories;
     }
 
     public List<Group> listGroupsToReport()
     {
         List<Group> reportGroups = new ArrayList<Group>();
         int count = groups.length;
         for ( int i = 0; i < count; i++ )
         {
             Group group = groups[i];
             if ( ( !group.isSkip() ) && ( group.getEventCount() > 0 ) && ( group.getCategory() == null ) )
             {
                 reportGroups.add( group );
             }
         }
         return reportGroups;
     }
 
     public LogDistiller getDefinition()
     {
         return ld;
     }
 
     public Group[] getGroups()
     {
         return (Group[]) ArrayUtils.clone( groups );
     }
 
     public Group getGroup( String id )
     {
         return mapGroups.get( id );
     }
 
     public Category[] getCategories()
     {
         return (Category[]) ArrayUtils.clone( categories );
     }
 
     public Category getCategory( String id )
     {
         return mapCategories.get( id );
     }
 
     public String getContent()
     {
         return content;
     }
 
     public int getEventCount()
     {
         return eventCount;
     }
 
     public long getEventBytes()
     {
         return eventBytes;
     }
 
     public long getBeginTime()
     {
         return beginTime;
     }
 
     public long getEndTime()
     {
         return endTime;
     }
 
     public int getSkippedEventCount()
     {
         return skippedEventCount;
     }
 
     public long getSkippedEventBytes()
     {
         return skippedEventBytes;
     }
 
     public File newDestinationFile( String filename )
     {
         return new File( destinationDirectory, filename );
     }
 
     public LogType.Description getLogTypeDescription()
     {
         return logtypeDescription;
     }
 
     /**
      * What is the version of <b>LogDistiller</b> that was used to create this instance?
      *
      * @return String the version
      */
     public String getVersion()
     {
         return ( version == null ) ? "unknown" : version;
     }
 
     public class Group
         implements Serializable
     {
         private static final long serialVersionUID = 5788707827350407084L;
 
         private final LogDistiller.Group definition;
 
         private final Category category;
 
         private transient LogDistillation logdistillation;
 
         private boolean skip = false;
 
         /**
          * maximum number of events saved, -1 = no limit
          *
          * @since 0.7
          */
         private final int maxSaveCount;
 
         /**
          * maximum size sum of events saved in bytes, -1 = no limit
          *
          * @since 0.7
          */
         private final long maxSaveBytes;
 
         private final Plugin[] plugins;
 
         private File logFile;
 
         private transient PrintStream logStream;
 
         private int eventCount = 0;
 
         private int savedEventCount = 0;
 
         private long bytes = 0;
 
         public Group( LogDistiller.Group definition, Category category )
         {
             this.definition = definition;
             this.category = category;
             maxSaveCount = Integer.parseInt( definition.getParam( "maxSave.count", "-1" ) );
             maxSaveBytes = Long.parseLong( definition.getParam( "maxSave.size", "-1" ) ) * 1024;
             LogDistiller.Plugin[] pluginDefs = definition.getPlugins();
             plugins = new Plugin[pluginDefs.length];
             for ( int i = 0; i < pluginDefs.length; i++ )
             {
                 plugins[i] = Plugins.newInstance( pluginDefs[i] );
             }
         }
 
         private void updateRef( LogDistillation logdistillation )
         {
             this.logdistillation = logdistillation;
             if ( category != null )
             {
                 category.addGroup( this );
             }
             int len = plugins.length;
             for ( int i = 0; i < len; i++ )
             {
                 plugins[i].updateRef( this );
             }
         }
 
         public LogDistillation getLogdistillation()
         {
             return logdistillation;
         }
 
         public Category getCategory()
         {
             return category;
         }
 
         public void setSkip( boolean skip )
         {
             this.skip = skip;
         }
 
         public boolean isSkip()
         {
             return skip;
         }
 
         /**
          * Check if given LogEvent meet one of the conditions defined.
          *
          * @param le LogEvent the LogEvent to check
          * @throws IOException
          * @return boolean <code>true</code> if the LogEvent meets a condition
          */
         public boolean accept( LogEvent le )
             throws IOException
         {
             Condition condition = definition.accept( le );
             if ( condition != null )
             {
                 addLogEvent( le, condition );
                 return true;
             }
             return false;
         }
 
         /**
          * Add a LogEvent to the current Group.
          *
          * @param le LogEvent
          * @param condition the condition that matched the LogEvent
          * @throws IOException
          */
         protected void addLogEvent( LogEvent le, Condition condition )
             throws IOException
         {
             eventCount++;
             bytes += le.getRawLog().length() + LINE_SEPARATOR.length();
             if ( definition.getSave() && ( ( maxSaveCount < 0 ) || ( eventCount <= maxSaveCount ) )
                 && ( ( maxSaveBytes < 0 ) || ( bytes <= maxSaveBytes ) ) )
             {
                 if ( logStream == null )
                 {
                     logStream = new PrintStream( new FileOutputStream( logFile ) );
                 }
                 logStream.println( le.getRawLog() );
                 savedEventCount++;
             }
             int len = plugins.length;
             for ( int i = 0; i < len; i++ )
             {
                 plugins[i].addLogEvent( le, condition );
             }
         }
 
         void begin( File destinationDirectory )
             throws IOException
         {
             logFile = newDestinationFile( definition.getId() + ".log" );
             int len = plugins.length;
             for ( int i = 0; i < len; i++ )
             {
                 plugins[i].begin( destinationDirectory );
             }
         }
 
         void end()
             throws IOException
         {
             if ( logStream != null )
             {
                 logStream.close();
             }
             int len = plugins.length;
             for ( int i = 0; i < len; i++ )
             {
                 plugins[i].end();
             }
         }
 
         public LogDistiller.Group getDefinition()
         {
             return definition;
         }
 
         public int getEventCount()
         {
             return eventCount;
         }
 
         public int getSavedEventCount()
         {
             return savedEventCount;
         }
 
         public long getBytes()
         {
             return bytes;
         }
 
         public File getLogFile()
         {
             return logFile;
         }
 
         public int getMaxSaveCount()
         {
             return maxSaveCount;
         }
 
         public long getMaxSaveBytes()
         {
             return maxSaveBytes;
         }
 
         public Plugin[] getPlugins()
         {
             return (Plugin[]) ArrayUtils.clone( plugins );
         }
     }
 
     public static class Category
         implements Serializable
     {
         private static final long serialVersionUID = 7098883103191641753L;
 
         private final LogDistiller.Category definition;
 
         private transient LogDistillation logdistillation;
 
         private transient List<Group> groups;
 
         private boolean skip = false;
 
         public Category( LogDistiller.Category definition )
         {
             this.definition = definition;
         }
 
         private void updateRef( LogDistillation logdistillation )
         {
             this.logdistillation = logdistillation;
             groups = new ArrayList<Group>();
         }
 
         public LogDistillation getLogdistillation()
         {
             return logdistillation;
         }
 
         public LogDistiller.Category getDefinition()
         {
             return definition;
         }
 
         private void addGroup( Group group )
         {
             groups.add( group );
         }
 
         public List<Group> getGroups()
         {
             return groups;
         }
 
         public void setSkip( boolean skip )
         {
             this.skip = skip;
             for ( Group group : groups )
             {
                 group.setSkip( skip );
             }
         }
 
         public boolean isSkip()
         {
             return skip;
         }
 
         public int sumEventCount()
         {
             int sum = 0;
             for ( Group group : groups )
             {
                 sum += group.getEventCount();
             }
             return sum;
         }
 
         public long sumBytes()
         {
             long sum = 0;
             for ( Group group : groups )
             {
                 sum += group.getBytes();
             }
             return sum;
         }
 
         public List<Group> listGroupsToReport()
         {
             List<Group> reportGroups = new ArrayList<Group>();
             for ( Group group : groups )
             {
                 if ( group.getEventCount() > 0 )
                 {
                     reportGroups.add( group );
                 }
             }
             return reportGroups;
         }
     }
 
     public static abstract class Plugin
         implements Serializable
     {
         private static final long serialVersionUID = -722318023109374109L;
 
         protected final LogDistiller.Plugin definition;
 
         protected transient Group group;
 
         public Plugin( LogDistiller.Plugin definition )
         {
             this.definition = definition;
         }
 
         private void updateRef( Group group )
         {
             this.group = group;
         }
 
         public Group getGroup()
         {
             return group;
         }
 
         public LogDistiller.Plugin getDefinition()
         {
             return definition;
         }
 
         public String getId()
         {
             return getDefinition().getType();
         }
 
         /**
          * Begin the log distillation for this plugin instance.
          *
          * @param destinationDirectory the directory where reports will be stored.
          * @throws IOException
          */
         abstract public void begin( File destinationDirectory )
             throws IOException;
 
         /**
          * Add a log event to this plugin instance.
          *
          * @param le the log event.
          * @throws IOException
          */
         abstract public void addLogEvent( LogEvent le )
             throws IOException;
 
         /**
          * Add a log event to this plugin instance, with information on which condition was matched.
          *
          * @param le the log event.
          * @param condition the condition which was matched
          * @since 1.1
          */
         public void addLogEvent( LogEvent le, Condition condition )
             throws IOException
         {
             addLogEvent( le ); // default implementation does ignore condition
         }
 
         /**
          * End the log distillation for this plugin instance.
          *
          * @throws IOException
          */
         abstract public void end()
             throws IOException;
 
         /**
          * Append a summary of this plugin instance results to the group report.
          *
          * @param report the plugin report formatter
          */
         abstract public void appendGroupReport( ReportFormat.PluginReport report );
 
         /**
          * Append a summary of this plugin instance results to the global report.
          *
          * @param report the plugin report formatter
          */
         abstract public void appendGlobalReport( ReportFormat.PluginReport report );
     }
 }