package net.sf.logdistiller.logtypes;
   
   /*
    * 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.text.SimpleDateFormat;
  import java.text.DateFormat;
  import java.text.ParseException;
  import java.util.Date;
  
  import org.apache.commons.lang.StringUtils;
  
  import net.sf.logdistiller.LogEvent;
  import net.sf.logdistiller.LogType;
  import net.sf.logdistiller.util.LogEventBuilder;
  import net.sf.logdistiller.util.StringCutter;
  
  /**
   * Log event for log4j XMLLayout (<code>log4j-XML</code>). By default, the classification rules generated by the GUI for
   * this type of logs will sort events based on the following attributes: <code>level</code>, then <code>logger</code>.
   */
  public class Log4jXmlLogEvent
      extends LogEvent
      implements Comparable<Log4jXmlLogEvent>
  {
      public final static String ID = "log4j-XML";
  
      public final String logger;
  
      public final String timestamp;
  
      public final String datetime;
  
      public final long timestampValue;
  
      public final String level;
  
      public final String thread;
  
      public final String message;
  
      public final String ndc;
  
      public final String throwable;
  
      public final String locationInfoClass;
  
      public final String locationInfoMethod;
  
      public final String locationInfoFile;
  
      public final String locationInfoLine;
  
      public final static LogType LOGTYPE = new LogType.Basic( ID );
  
      private final static DateFormat DATE_FORMAT = new SimpleDateFormat( "dd/MM/yyyy HH:mm:ss" );
  
      private final static String LOGEVENT_START = "<log4j:event logger=\"";
  
      private final static String[] ATTRIBUTE_NAMES =
          { "logSource", "datetime", "timestamp", "level", "logger", "thread", "message", "NDC", "throwable",
              "locationInfo.class", "locationInfo.method", "locationInfo.file", "locationInfo.line" };
  
      public final static LogType.Description DESCRIPTION = new Description( (LogType.Basic) LOGTYPE, ATTRIBUTE_NAMES );
  
      public Log4jXmlLogEvent( LogEvent.Factory factory, String rawLog )
          throws ParseException
      {
          super( factory, rawLog );
          StringCutter cutter = new StringCutter( rawLog );
          cutter.parseTo( LOGEVENT_START );
          logger = cutter.parseTo( "\" timestamp=\"" );
          timestamp = cutter.parseTo( "\" level=\"" );
          timestampValue = Long.parseLong( timestamp );
          datetime = DATE_FORMAT.format( new Date( timestampValue ) );
          level = cutter.parseTo( "\" thread=\"" );
          thread = cutter.parseTo( "\">" );
          cutter.parseTo( "<log4j:message><![CDATA[" );
          message = unescapeCDATA( cutter.parseTo( "]]></log4j:message>" ) );
  
          String remaining = cutter.getRemaining();
          if ( remaining.indexOf( "<log4j:NDC>" ) < 0 )
          {
              ndc = "";
          }
          else
          {
             cutter.parseTo( "<log4j:NDC><![CDATA[" );
             ndc = unescapeCDATA( cutter.parseTo( "]]></log4j:NDC>" ) );
             remaining = cutter.getRemaining();
         }
         if ( remaining.indexOf( "<log4j:throwable>" ) < 0 )
         {
             throwable = "";
         }
         else
         {
             cutter.parseTo( "<log4j:throwable><![CDATA[" );
             throwable = unescapeCDATA( cutter.parseTo( "]]></log4j:throwable>" ) );
             remaining = cutter.getRemaining();
         }
         if ( remaining.indexOf( "<log4j:locationInfo" ) < 0 )
         {
             locationInfoClass = "";
             locationInfoMethod = "";
             locationInfoFile = "";
             locationInfoLine = "";
         }
         else
         {
             cutter.parseTo( "<log4j:locationInfo class=\"" );
             locationInfoClass = cutter.parseTo( "\" method=\"" );
             locationInfoMethod = cutter.parseTo( "\" file=\"" );
             locationInfoFile = cutter.parseTo( "\" line=\"" );
             locationInfoLine = cutter.parseTo( "\"/>" );
         }
         setAttributes( new String[] { factory.getLogSource(), datetime, timestamp, level, logger, thread, message, ndc,
             throwable, locationInfoClass, locationInfoMethod, locationInfoFile, locationInfoLine } );
     }
 
     public static String unescapeCDATA( String cdata )
     {
         return StringUtils.replace( cdata, "]]>]]&gt;<![CDATA[", "]]>" );
     }
 
     public int compareTo( Log4jXmlLogEvent o )
     {
         long diff = timestampValue - o.timestampValue;
         return ( diff < 0 ) ? -1 : ( diff > 0 ) ? 1 : 0;
     }
 
     private static class Description
         extends LogType.Description
     {
         public Description( LogType.Basic logtype, String[] attributeNames )
         {
             super( logtype, attributeNames );
             logtype.setDescription( this );
         }
 
         public LogEvent.Factory newFactory( Reader reader, String logSource )
             throws IOException
         {
             return new Factory( this, reader, logSource );
         }
 
         public String getDefaultSpecificGroups()
         {
             return "  <group id=\"warn\">\n"
                 + "    <description>WARN events</description>\n"
                 + "    <condition>\n"
                 + "      <match attribute=\"level\" type=\"equals\">WARN</match>\n"
                 + "    </condition>\n"
                 + "    <report publisher=\"file\"/>\n"
                 + "    <plugin type=\"sampling\">\n"
                 + "      <param name=\"attributes\">logger</param>\n"
                 + "    </plugin>\n"
                 + "  </group>\n"
                 + "\n"
                 + "  <group id=\"error\">\n"
                 + "    <description>ERROR events</description>\n"
                 + "    <condition>\n"
                 + "      <match attribute=\"level\" type=\"equals\">ERROR</match>\n"
                 + "    </condition>\n"
                 + "    <report publisher=\"file\"/>\n"
                 + "    <plugin type=\"sampling\">\n"
                 + "      <param name=\"attributes\">logger</param>\n"
                 + "    </plugin>\n"
                 + "  </group>";
         }
 
         public String getDefaultSamplingAttributes()
         {
             return "level,logger";
         }
     }
 
     private static class Factory
         extends LogEvent.Factory
     {
         private final LineNumberReader reader;
 
         private String curLine;
 
         public Factory( Description description, Reader reader, String logSource )
             throws FileNotFoundException
         {
             super( description, logSource );
             this.reader = new LineNumberReader( reader );
         }
 
         protected boolean detectLogEventStart( String line )
         {
             return line.startsWith( LOGEVENT_START );
         }
 
         protected LogEvent readNextEvent()
             throws IOException, ParseException
         {
             if ( curLine == null )
             {
                 curLine = reader.readLine();
                 if ( curLine == null )
                 {
                     // EOF
                     return null;
                 }
             }
             if ( !detectLogEventStart( curLine ) )
             {
                 throw new ParseException(
                                           "bad log format, beginnig of line " + reader.getLineNumber() + ": " + curLine,
                                           0 );
             }
             StringBuffer buffer = new StringBuffer( curLine );
             int lineNumber = reader.getLineNumber();
 
             while ( ( ( curLine = reader.readLine() ) != null ) && ( !detectLogEventStart( curLine ) ) )
             {
                 buffer.append( "\r\n" ); // fixed newline, as log4j
                 buffer.append( curLine );
             }
             return BUILDER.buildLogEvent( this, lineNumber, buffer.toString() );
         }
 
         private final static LogEventBuilder BUILDER = new LogEventBuilder()
         {
             protected LogEvent newEvent( LogEvent.Factory factory, String curLine, Object... objects )
                 throws ParseException
             {
                 return new Log4jXmlLogEvent( factory, curLine );
             }
         };
     }
 }