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.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.text.ParseException;
import java.util.regex.Matcher;

import net.sf.logdistiller.LogType.AttributeInfo;

import org.apache.commons.lang.ArrayUtils;

/**
 * Log events base class. Every new log type must implement an inherited class, with appropriate:
 * <ul>
 * <li>{@link Factory} to create events from the log stream</li>
 * <li>{@link LogType} to declare the log type and eventually available parameters to customize its format</li>
 * </ul>
 *
 * @see LogType
 * @see LogTypes
 */
public abstract class LogEvent
{
    private final Factory factory;

    private final String rawLog;

    /** provided attributes */
    private String[] attributes;

    /** extended attributes */
    private Extension[] extensions;

    protected LogEvent( Factory factory, String rawLog )
    {
        this.factory = factory;
        this.rawLog = rawLog;
        this.extensions = new Extension[factory.getDescription().getExtensions().length];
    }

    /**
     * Set the provided attributes values.
     *
     * @param attributes attributes values
     */
    protected void setAttributes( String[] attributes )
    {
        int count = factory.getDescription().getAttributesCount();
        if ( attributes.length != count )
        {
            throw new IllegalArgumentException( "expected " + count + " attributes, got " + attributes.length );
        }
        this.attributes = attributes;
    }

    protected void checkInitialized()
    {
        if ( attributes == null )
        {
            throw new IllegalStateException( "log event not initialized: call setAttributes() to initialize it" );
        }
    }

    /**
     * Get the raw log text from which this event was parsed.
     *
     * @return String
     */
    public String getRawLog()
    {
        return rawLog;
    }

    /**
     * Get a provided attribute value by its position index.
     *
     * @param pos the position index of the attribute.
     * @return the value of the attribute.
     */
    public String getAttribute( int pos )
    {
        checkInitialized();
        return attributes[pos];
    }

    /**
     * Get a clone copy of the provided attributes. Note the this method clones the values array.
     *
     * @return (a copy of) provided attributes
     */
    public String[] getAttributes()
    {
        checkInitialized();
        return (String[]) ArrayUtils.clone( attributes );
    }

    /**
     * Get provided attributes count.
     *
     * @return the count of provided attributes
     */
    public int getAttributesCount()
    {
        checkInitialized();
        return attributes.length;
    }

    /**
     * Extracts an attribute's provided value of the log event.
     *
     * @param attributeName the name of the attribute (provided only)
     * @return the value
     */
    public String getAttribute( String attributeName )
    {
        int index = factory.getDescription().getAttributeIndex( attributeName );
        if ( index < 0 )
        {
            throw new IllegalArgumentException( "unknown provided attribute '" + attributeName + "'" );
        }
        return getAttribute( index );
    }

    public String getValue( AttributeInfo info )
    {
        if ( info.extended )
        {
            Extension extension = extensions[info.index];
            if ( extension == null )
            {
                extension = new Extension( factory.getDescription().getExtensions()[info.index] );
                extensions[info.index] = extension;
            }
            return extension.getValue( info.regexpGroup );
        }
        return getAttribute( info.index );
    }

    public Factory getFactory()
    {
        return factory;
    }

    public void dump( PrintWriter out )
    {
        out.println( "- raw log: " + getRawLog() );
        for ( int i = 0; i < getAttributesCount(); i++ )
        {
            out.println( "- " + getFactory().getDescription().getAttributeName( i ) + ": " + getAttribute( i ) );
        }
    }

    public String dump()
    {
        StringWriter sw = new StringWriter();
        PrintWriter out = new PrintWriter( sw, false );
        dump( out );
        out.close();
        return sw.toString();
    }

    /**
     * Get the timestamp.
     *
     * @return the timestamp or "-" if no this log type does not have a timestamp
     * @see LogType.Description#getTimestampAttribute()
     */
    public String getTimestamp()
    {
        int index = factory.getDescription().getTimestampAttribute();
        return ( index > 0 ) ? getAttribute( index ) : "-";
    }

    /**
     * The base class for LogEvent factories, responsible for parsing an input stream into <code>LogEvent</code>s.
     */
    public static abstract class Factory
    {
        public final static String NEWLINE = System.getProperty( "line.separator" );

        protected final LogType.Description description;

        protected final String logSource;

        private LogEvent lastEvent;

        private LogEvent pushedbackEvent;

        protected Factory( LogType.Description description, String logSource )
        {
            this.description = description;
            this.logSource = logSource;
        }

        /**
         * gets the next LogEvent.
         *
         * @throws IOException
         * @throws ParseException
         * @return LogEvent the new LogEvent read, or <code>null</code> if none available any more
         */
        public LogEvent nextEvent()
            throws IOException, ParseException
        {
            LogEvent nextEvent = null;
            if ( pushedbackEvent != null )
            {
                nextEvent = pushedbackEvent;
                pushedbackEvent = null;
            }
            else
            {
                try
                {
                    nextEvent = readNextEvent();
                }
                catch ( ParseException pe )
                {
                    ParseException pe2 = new ParseException( "error in '" + logSource + "' " + pe.getMessage(),
                                                             pe.getErrorOffset() );
                    pe2.initCause( pe );
                    throw pe2;
                }
                catch ( RuntimeException re )
                {
                    throw new RuntimeException( "error in '" + logSource + "' " + re.getMessage(), re );
                }
            }
            lastEvent = nextEvent;
            return nextEvent;
        }

        public void pushbackLastEvent()
            throws IllegalStateException
        {
            if ( pushedbackEvent != null )
            {
                throw new IllegalStateException( "The last event has already been pushed back" );
            }
            if ( lastEvent == null )
            {
                throw new IllegalStateException( "There is no last event to push back" );
            }
            pushedbackEvent = lastEvent;
        }

        public LogType.Description getDescription()
        {
            return description;
        }

        public String getLogSource()
        {
            return logSource;
        }

        protected abstract LogEvent readNextEvent()
            throws IOException, ParseException;
    }

    /**
     * Extended attributes calculated for a log event.
     *
     * @since 1.1
     */
    private class Extension
    {
        /**
         * Values of regexp match groups
         */
        private final String[] values;

        public Extension( Attributes.Extension definition )
        {
            values = new String[definition.getProvides().size()];
            Matcher matcher = definition.getRegexp().matcher( getAttribute( definition.getSource() ) );
            if ( matcher.find() )
            {
                int count = matcher.groupCount();
                for ( int i = 0; i < values.length; i++ )
                {
                    String value = ( i < count ) ? matcher.group( i + 1 ) : "";
                    values[i] = ( value == null ) ? "" : value;
                }
            }
            else
            {
                for ( int i = 0; i < values.length; i++ )
                {
                    values[i] = "";
                }
            }
        }

        public String getValue( int index )
        {
            return values[index];
        }
    }
}