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 java.util.Locale;
import java.util.regex.Pattern;

import net.sf.logdistiller.LogEvent;
import net.sf.logdistiller.LogType;
import net.sf.logdistiller.util.LogEventBuilder;

/**
 * Oracle Database's <code>alert.log</code> file parser. A typical rule configuration with such log files is:
 *
 * <pre>
 * &lt;group id=&quot;ORA&quot;&gt;
 *  &lt;description&gt;ORA-* messages&lt;/description&gt;
 *  &lt;condition&gt;
 *    &lt;match attribute=&quot;message&quot; type=&quot;contains&quot;&gt;ORA-&lt;/match&gt;
 *  &lt;/condition&gt;
 *  &lt;plugin type=&quot;sampling&quot;&gt;
 *    &lt;param name=&quot;attribute&quot;&gt;message&lt;/param&gt;
 *    &lt;param name=&quot;regexp&quot;&gt;(ORA-\d+)&lt;/param&gt;
 *  &lt;/plugin&gt;
 * lt;/group&gt;
 * </pre>
 *
 * By default, the classification rules generated by the GUI for this type of logs:
 * <ol>
 * <li>will contain a such "ORA" group for events with an ORA- id</li>
 * <li>but won't be able to sort other events, as the log event structure is too generic (the message has no specific
 * format).</li>
 * </ol>
 *
 * @since 0.9
 */
public class OracleAlertLogEvent
    extends LogEvent
    implements Comparable<OracleAlertLogEvent>
{
    public final static String ID = "oracle-alert";

    public final String timestamp;

    public final Date date;

    public final String message;

    public final static LogType LOGTYPE = new LogType.Basic( ID );

    private final static DateFormat DATE_FORMAT = new SimpleDateFormat( "EEE MMM dd HH:mm:ss yyyy", Locale.US );

    private final static String[] ATTRIBUTE_NAMES =
        { "logSource", "timestamp", "timestamp.day", "timestamp.time", "message" };

    public final static LogType.Description DESCRIPTION = new Description( (LogType.Basic) LOGTYPE, ATTRIBUTE_NAMES );

    public OracleAlertLogEvent( LogEvent.Factory factory, String firstLine, String message )
        throws ParseException
    {
        super( factory, firstLine + Factory.NEWLINE + message );
        timestamp = firstLine;
        date = DATE_FORMAT.parse( timestamp );
        this.message = message;
        setAttributes( new String[] { factory.getLogSource(), timestamp,
            timestamp.substring( 0, 10 ) + timestamp.substring( 19, 24 ), timestamp.substring( 11, 19 ), message } );
    }

    public int compareTo( OracleAlertLogEvent o )
    {
        return date.compareTo( o.date );
    }

    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=\"ORA\">\n"
                + "    <description>ORA-* messages</description>\n"
                + "    <condition>\n"
                + "      <match attribute=\"message\" type=\"contains\">ORA-</match>\n"
                + "    </condition>\n"
                + "    <report publisher=\"file\"/>\n"
                + "    <plugin type=\"sampling\">\n"
                + "      <param name=\"attribute\">message</param>\n"
                + "      <param name=\"regexp\">(ORA-\\d+)</param>\n"
                + "    </plugin>\n"
                + "  </group>";
        }
    }

    private static class Factory
        extends LogEvent.Factory
    {
        private final LineNumberReader reader;

        private String curLine;

        private final static Pattern DATE_PATTERN =
            Pattern.compile( "\\w{3} \\w{3} \\d{2} \\d{2}:\\d{2}:\\d{2} \\d{4}" );

        public Factory( Description description, Reader reader, String logSource )
            throws FileNotFoundException
        {
            super( description, logSource );
            this.reader = new LineNumberReader( reader );
        }

        /**
         * Detect the start of a new log event
         */
        protected boolean detectLogEventStart( String line )
        {
            return DATE_PATTERN.matcher( line ).matches();
        }

        protected LogEvent readNextEvent()
            throws IOException, ParseException
        {
            if ( curLine == null )
            {
                curLine = reader.readLine();
                if ( curLine == null )
                {
                    // EOF
                    return null;
                }
                // beginning of log file does not start with a complete log event with timestamp
                while ( !detectLogEventStart( curLine ) )
                {
                    curLine = reader.readLine();
                    if ( curLine == null )
                    {
                        // EOF
                        return null;
                    }
                }
            }

            String firstLine = curLine;
            int lineNumber = reader.getLineNumber();

            StringBuffer buffer = new StringBuffer();
            while ( ( ( curLine = reader.readLine() ) != null ) && ( !detectLogEventStart( curLine ) ) )
            {
                if ( buffer.length() > 0 )
                {
                    buffer.append( NEWLINE );
                }
                buffer.append( curLine );
            }

            return BUILDER.buildLogEvent( this, lineNumber, firstLine, buffer.toString() );
        }

        private final static LogEventBuilder BUILDER = new LogEventBuilder()
        {
            protected LogEvent newEvent( LogEvent.Factory factory, String curLine, Object... objects )
                throws ParseException
            {
                return new OracleAlertLogEvent( factory, curLine, (String) objects[0] );
            }
        };
    }
}