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.lang.ArrayUtils;
  import org.jdom.Element;
  
  import net.sf.logdistiller.util.FormatUtil;
  
  /**
   * A LogDistiller configuration.
   *
   * @see LogDistillation
   * @see net.sf.logdistiller.xml.DOMConfigurator
   */
  public class LogDistiller
      implements Serializable
  {
      private static final long serialVersionUID = 1730313287821721822L;
  
      private final String id;
  
      private final String description;
  
      private LogType logtype;
  
      /** @since 0.7 */
      private final Output output;
  
      private final Category[] categories;
  
      private final Group[] groups;
  
      /** @since 0.7 */
      private final List<String> warnings = new ArrayList<String>();
  
      private final boolean old;
  
      public LogDistiller( String id, String description, LogType logtype, Output output, Category[] categories,
                           Group[] groups, boolean old )
      {
          this.id = id;
          this.description = description;
          this.logtype = logtype;
          this.output = output;
          this.categories = (Category[]) ArrayUtils.clone( categories );
          this.groups = (Group[]) ArrayUtils.clone( groups );
          this.old = old;
          updateRef();
      }
  
      public LogDistiller( String id, String description, LogType logtype, Output output, Category[] categories,
                           Group[] groups )
      {
          this( id, description, logtype, output, categories, groups, false );
      }
  
      /**
       * Update the references from internal objects to their parent LogDistiller instance and other referenced object not
       * initialized at creation time.
       */
      public void updateRef()
      {
          output.updateRef( this );
          int len = categories.length;
          for ( int i = 0; i < len; i++ )
          {
              categories[i].updateRef( this );
          }
          len = groups.length;
          for ( int i = 0; i < len; i++ )
          {
              groups[i].updateRef( this );
          }
      }
  
      private void readObject( ObjectInputStream in )
          throws IOException, ClassNotFoundException
      {
          in.defaultReadObject();
          if ( output != null )
          {
              // TODO: do better with deserialization of an old instance
              updateRef();
         }
     }
 
     public String getId()
     {
         return id;
     }
 
     public String getDescription()
     {
         return description;
     }
 
     public LogType getLogType()
     {
         return logtype;
     }
 
     /**
      * is this LogDistiller read from an old configuration file (DTD older than 1.3)?
      */
     public boolean isOld()
     {
         return old;
     }
 
     /**
      * To keep old rules configuration files running (without logtype element), create a LogType instance from the type
      * provided. Parameters from the logtype are extracted from global parameters: every <code>logevent.myParam</code>
      * global parameter is inserted as <code>myParam</code>.
      *
      * @param type String the log type to consider
      */
     public void buildCompatibilityLogType( String type )
     {
         Map<String, String> logtypeParams = new HashMap<String, String>();
         Map<String, String> params = output.getParams();
         for ( Map.Entry<String, String> entry : params.entrySet() )
         {
             String key = entry.getKey();
             if ( key.startsWith( "logevent." ) )
             {
                 logtypeParams.put( key.substring( 9 ), entry.getValue() );
             }
         }
         String paramAttributes = (String)logtypeParams.get( "attributes" );
         logtype = new LogDistiller.LogType( type, logtypeParams, new Attributes( paramAttributes, new Attributes.Extension[0] ) );
     }
 
     public Output getOutput()
     {
         return output;
     }
 
     public Category[] getCategories()
     {
         return (Category[]) ArrayUtils.clone( categories );
     }
 
     public Group[] getGroups()
     {
         return (Group[]) ArrayUtils.clone( groups );
     }
 
     public List<String> getWarnings()
     {
         return Collections.unmodifiableList( warnings );
     }
 
     public void addWarning( String msg )
     {
         warnings.add( msg );
     }
 
     public void checkLogtypeAttributes( net.sf.logdistiller.LogType.Description description )
     {
         String attributes = ( logtype.getAttributes() == null ) ? null : logtype.getAttributes().getAttributes();
         String attributesReference = FormatUtil.join( ",", description.getAttributeNames() );
 
         if ( attributes == null )
         {
             addWarning( "<logtype><attributes> element should contain <provided>" + attributesReference
                 + "</provided>" );
         }
         else if ( !attributesReference.equals( attributes ) )
         {
             addWarning( "bad value for <logtype><attributes><provided> element, should be " + attributesReference );
         }
     }
 
     public static String getVersion()
     {
         Package pkg = LogDistiller.class.getPackage();
         String version = ( pkg == null ) ? null : pkg.getSpecificationVersion();
         return ( version == null ) ? "SNAPSHOT" : version;
     }
 
     /**
      * Definition of the log type used for this logdistiller configuration, with its parameters.
      */
     public static class LogType
         implements Serializable
     {
         private static final long serialVersionUID = 1486393526172179950L;
 
         private final String id;
 
         private final Map<String, String> params;
 
         /**
          * @since 1.1
          */
         private final Attributes attributes;
 
         public LogType( String id, Map<String, String> params, Attributes attributes )
         {
             this.id = id;
             this.params = params;
             this.attributes = attributes;
         }
 
         public String getId()
         {
             return id;
         }
 
         public Map<String, String> getParams()
         {
             return params;
         }
 
         public String getParam( String name )
         {
             return params.get( name );
         }
 
         public String getParam( String name, String defaultValue )
         {
             String value = getParam( name );
             return ( value == null ) ? defaultValue : value;
         }
 
         /**
          * @return extensions (not <code>null</code>)
          *  @since 1.1
          */
         public Attributes.Extension[] getExtensions()
         {
             return ( attributes == null ) ? Attributes.NO_EXTENSIONS : attributes.getExtensions();
         }
 
         /** @since 1.1 */
         public int getExtensionsCount()
         {
             return ( attributes == null ) ? 0 : attributes.getExtensionsCount();
         }
 
         /** @since 1.1 */
         public Attributes getAttributes()
         {
             return attributes;
         }
     }
 
     /**
      * Definition of the global output.
      *
      * @since 0.7
      */
     public static class Output
         implements Serializable
     {
         private static final long serialVersionUID = 1707510377356801400L;
 
         private String directory;
 
         private String content;
 
         private final String url;
 
         private String skip;
 
         private final Map<String, String> params;
 
         private final Report[] reports;
 
         private transient LogDistiller logdistiller;
 
         public Output( String directory, String url, String content, String skip, Map<String, String> params,
                        Report[] reports )
         {
             this.directory = directory;
             this.url = url;
             this.content = content;
             this.skip = skip;
             this.params = params;
             this.reports = (Report[]) ArrayUtils.clone( reports );
         }
 
         public LogDistiller getLogdistiller()
         {
             return logdistiller;
         }
 
         private void updateRef( LogDistiller logdistiller )
         {
             this.logdistiller = logdistiller;
             int len = reports.length;
             for ( int i = 0; i < len; i++ )
             {
                 reports[i].updateRef( this );
             }
         }
 
         /**
          * Gets the <code>id</code> that will identify the output reports.
          *
          * @return the <code>id</code> param if set, or global logdistiller id.
          */
         public String getId()
         {
             return getParam( "id", logdistiller.getId() );
         }
 
         public Map<String, String> getParams()
         {
             return params;
         }
 
         public String getParam( String name )
         {
             return params.get( name );
         }
 
         public String getParam( String name, String defaultValue )
         {
             String value = getParam( name );
             return ( value == null ) ? defaultValue : value;
         }
 
         public Report[] getReports()
         {
             return (Report[]) ArrayUtils.clone( reports );
         }
 
         public void setDirectory( String directory )
         {
             this.directory = directory;
         }
 
         public String getDirectory()
         {
             return directory;
         }
 
         public void setContent( String content )
         {
             this.content = content;
         }
 
         public String getContent()
         {
             return content;
         }
 
         public String getSkip()
         {
             return skip;
         }
 
         public void updateCompatibility( File directory, String content, String skip )
         {
             this.directory = directory.getAbsolutePath();
             this.content = content;
             this.skip = skip;
         }
 
         public String getUrl()
         {
             return url;
         }
 
         public String getUrl( String file )
         {
             return ( url == null ) ? null : ( url + '/' + file );
         }
     }
 
     /**
      * Definition of a report, with its publisher, formant and other params.
      */
     public static class Report
         implements Serializable
     {
         private static final long serialVersionUID = 1669156992489095268L;
 
         private final String publisher;
 
         private final String format;
 
         private final Map<String, String> params;
 
         private transient Output output;
 
         private transient Group group;
 
         public Report( String publisher, String format, Map<String, String> params )
         {
             this.publisher = publisher;
             this.format = format;
             this.params = params;
         }
 
         private void updateRef( Output output )
         {
             this.output = output;
             this.group = null;
         }
 
         private void updateRef( Group group )
         {
             this.group = group;
             this.output = group.getLogdistiller().getOutput();
         }
 
         public Output getOutput()
         {
             return output;
         }
 
         public Group getGroup()
         {
             return group;
         }
 
         public Map<String, String> getParams()
         {
             return params;
         }
 
         public String getFormat()
         {
             return format;
         }
 
         public String getParam( String name )
         {
             return params.get( name );
         }
 
         public String getParam( String name, String defaultValue )
         {
             String value = getParam( name );
             return ( value != null ) ? value : output.getParam( publisher + '.' + name, defaultValue );
         }
 
         public String getPublisher()
         {
             return publisher;
         }
     }
 
     /**
      * Definition of a group of events: events corresponding to its conditions will be collected in it.
      */
     public static class Group
         implements Serializable
     {
         private static final long serialVersionUID = 6647633346412959286L;
 
         private final String id;
 
         private final String description;
 
         private final boolean continueProcessing;
 
         private final boolean save;
 
         private final Map<String, String> params;
 
         private final Condition[] conditions;
 
         private final Report[] reports;
 
         private final Category category;
 
         private final Plugin[] plugins;
 
         private transient LogDistiller logdistiller;
 
         public Group( String id, String description, boolean continueProcessing, boolean save,
                       Map<String, String> params, Condition[] conditions, Report[] reports, Plugin[] plugins,
                       Category category )
         {
             this.id = id;
             this.description = description;
             this.continueProcessing = continueProcessing;
             this.save = save;
             this.params = params;
             this.conditions = (Condition[]) ArrayUtils.clone( conditions );
             this.reports = (Report[]) ArrayUtils.clone( reports );
             this.plugins = (Plugin[]) ArrayUtils.clone( plugins );
             this.category = category;
         }
 
         private void updateRef( LogDistiller logdistiller )
         {
             this.logdistiller = logdistiller;
             if ( id == null )
             {
                 // for unknown reason, deserialization of a LogDistillation instance does not fully deserialize
                 // LogDistiller's
                 // instance
                 return;
             }
             if ( category != null )
             {
                 this.category.addGroup( this );
             }
             int len = reports.length;
             for ( int i = 0; i < len; i++ )
             {
                 reports[i].updateRef( this );
             }
             len = plugins.length;
             for ( int i = 0; i < len; i++ )
             {
                 plugins[i].updateRef( this );
             }
         }
 
         public LogDistiller getLogdistiller()
         {
             return logdistiller;
         }
 
         public Map<String, String> getParams()
         {
             return params;
         }
 
         public String getParam( String name )
         {
             return (String) params.get( name );
         }
 
         public String getParam( String name, String defaultValue )
         {
             String value = getParam( name );
             return ( value != null ) ? value : logdistiller.getOutput().getParam( name, defaultValue );
         }
 
         /**
          * Check if given LogEvent meet one of the conditions defined.
          *
          * @param le LogEvent the LogEvent to check
          * @return Condition the condition which matched the log event, or <code>null</code>
          */
         public Condition accept( LogEvent le )
         {
             int count = conditions.length;
             if ( count == 0 )
             {
                 // no condition => accepts all log events
                 return Condition.ACCEPT_ALL;
             }
             for ( int i = 0; i < count; i++ )
             {
                 if ( conditions[i].match( le ) )
                 {
                     return conditions[i];
                 }
             }
             return null;
         }
 
         public String getId()
         {
             return id;
         }
 
         public Element dumpConditions( Element parent )
         {
             int count = conditions.length;
             for ( int i = 0; i < count; i++ )
             {
                 parent.addContent( conditions[i].dump() );
             }
             return parent;
         }
 
         public String getDescription()
         {
             return description;
         }
 
         /**
          * @return boolean in case a LogEvent is added to the current group, must classification be continued further to
          *         match other groups?
          */
         public boolean continueProcessing()
         {
             return continueProcessing;
         }
 
         public boolean getSave()
         {
             return save;
         }
 
         public Category getCategory()
         {
             return category;
         }
 
         public Report[] getReports()
         {
             return (Report[]) ArrayUtils.clone( reports );
         }
 
         public Plugin[] getPlugins()
         {
             return (Plugin[]) ArrayUtils.clone( plugins );
         }
     }
 
     /**
      * Definition of a category, which will contain groups.
      */
     public static class Category
         implements Serializable
     {
         private static final long serialVersionUID = 3036838205912907804L;
 
         private final String id;
 
         private final String description;
 
         private transient LogDistiller logdistiller;
 
         private transient List<Group> groups;
 
         public Category( String id, String description )
         {
             this.id = id;
             this.description = description;
         }
 
         private void updateRef( LogDistiller logdistiller )
         {
             this.logdistiller = logdistiller;
             this.groups = new ArrayList<Group>();
         }
 
         private void addGroup( Group group )
         {
             this.groups.add( group );
         }
 
         public LogDistiller getLogdistiller()
         {
             return logdistiller;
         }
 
         public String getId()
         {
             return id;
         }
 
         public String getDescription()
         {
             return description;
         }
 
         public List<Group> getGroups()
         {
             return groups;
         }
     }
 
     public static class Plugin
         implements Serializable
     {
         private static final long serialVersionUID = 7948111042518186219L;
 
         private final String type;
 
         private final Map<String, String> params;
 
         private final boolean globalReport;
 
         private final boolean groupReport;
 
         private transient Group group;
 
         public Plugin( String type, boolean globalReport, boolean groupReport, Map<String, String> params )
         {
             this.type = type;
             this.params = params;
             this.globalReport = globalReport;
             this.groupReport = groupReport;
         }
 
         private void updateRef( Group group )
         {
             this.group = group;
         }
 
         public Group getGroup()
         {
             return group;
         }
 
         public String getType()
         {
             return type;
         }
 
         public boolean isGlobalReportEnabled()
         {
             return globalReport;
         }
 
         public boolean isGroupReportEnabled()
         {
             return groupReport;
         }
 
         public Map<String, String> getParams()
         {
             return params;
         }
 
         public String getParam( String name )
         {
             return params.get( name );
         }
 
         public String getParam( String name, String defaultValue )
         {
             String value = getParam( name );
             return ( value == null ) ? defaultValue : value;
         }
     }
 }