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 );
            }
        };
    }
}