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.Reader;
import java.util.*;

import net.sf.logdistiller.Attributes.Extension;
import net.sf.logdistiller.util.FormatUtil;

/**
 * Base class for log type implementation. A log type identifies the log format, which can be customized depending on
 * parameter's values. When defining a new log type, {@link #newDescription newDescription(Map params)} method has to be
 * implemented to define and handle log type's parameters.
 *
 * @see LogType.Basic
 * @see LogType.Description
 * @see LogTypes
 */
public abstract class LogType
{
    private final String id;

    protected LogType( String id )
    {
        this.id = id;
    }

    /**
     * Create a new log description customized with parameters.
     *
     * @param params the parameters to customize the log type definition
     */
    public abstract Description newDescription( Map<String, String> params );

    public String getId()
    {
        return id;
    }

    /**
     * Basic logtype definition that does not provide any parameters for customization. It always returns the same
     * Description instance, which must have been set by calling {@link #setDescription}.
     */
    public static class Basic
        extends LogType
    {
        private Description description;

        public Basic( String id )
        {
            super( id );
        }

        public void setDescription( Description description )
        {
            this.description = description;
        }

        public Description newDescription( Map<String, String> params )
        {
            if ( description == null )
            {
                throw new IllegalStateException( "description must be set before basic logtype use" );
            }
            return description;
        }
    }

    /**
     * Description of a log format corresponding to a log type. It must be subclassed for every log type to implement
     * specialized {@link #newFactory(Reader, String)} method.
     */
    public static abstract class Description
    {
        private final LogType logtype;

        private final List<String> attributeNames;

        /**
         * Extensions of the log type attributes. Each extension can define multiple extension attributes.
         * @since 1.1
         */
        private Attributes.Extension[] extensions = Attributes.NO_EXTENSIONS;

        /**
         * Attributes defined by extensions, with corresponding extension index position.
         * @since 1.1
         */
        private Map<String, Integer> extendedAttributes = new HashMap<String, Integer>();

        /**
         * Create a new LogType description. By convention, the first attribute should be <code>logSource</code> and the
         * second should be the timestamp (if this notion is relevant for the log type).
         *
         * @param logtype
         * @param attributeNames
         * @see #getTimestampAttribute()
         * @see LogEvent#getTimestamp()
         */
        public Description( LogType logtype, String[] attributeNames )
        {
            this.logtype = logtype;
            this.attributeNames = Collections.unmodifiableList( Arrays.asList( attributeNames ) );
        }

        public LogType getLogType()
        {
            return logtype;
        }

        public List<String> getAttributeNames()
        {
            return attributeNames;
        }

        public int getAttributesCount()
        {
            return attributeNames.size();
        }

        public String getAttributeName( int pos )
        {
            return attributeNames.get( pos );
        }

        /** @since 1.1 */
        public void setExtensions( Attributes.Extension[] extensions )
        {
            this.extensions = extensions;
            for ( int i = extensions.length - 1; i >= 0; i-- )
            {
                Attributes.Extension extension = extensions[i];
                for ( String attribute : extension.getProvides() )
                {
                    extendedAttributes.put( attribute, new Integer( i ) );
                }
            }
        }

        /** @since 1.1 */
        public Attributes.Extension[] getExtensions()
        {
            return extensions;
        }

        /**
         * Gets the extension index position which defines corresponding attribute.
         *
         * @return the extension index, or -1 if not found
         * @since 1.1
         */
        public int getExtensionIndex( String attribute )
        {
            Integer index = extendedAttributes.get( attribute );
            return ( index == null ) ? -1 : index.intValue();
        }

        /**
         * Get the attribute that represents the timestamp.
         *
         * @return the attribute count, or <code>-1</code> if this logtype does not have a timestamp
         */
        public int getTimestampAttribute()
        {
            return 1;
        }

        /**
         * Get the group definitions specific to this log type that will be added to the generated rules configuration
         * generated by the GUI.
         *
         * @return an XML fragment containing group definitions
         */
        public String getDefaultSpecificGroups()
        {
            return "";
        }

        /**
         * Get the attributes that can be used as a sorting key to get useful event sampling in the last "unknown" group
         * (separated with a quote when multiple attributes). They will be used as a default sampling rule
         * configuration.
         *
         * @return "attr1[,attr2[,...]]"
         */
        public String getDefaultSamplingAttributes()
        {
            return "";
        }

        /**
         * Find the attribute index corresponding to an attribute name (provided attributes only).
         *
         * @param name String the attribute name to search for
         * @return int the index of the attribute, or -1 if not found
         * @see #getExtensionIndex(String) to find an extension attribute index
         */
        public int getAttributeIndex( String name )
        {
            return attributeNames.indexOf( name );
        }

        public AttributeInfo getAttributeInfo( String name )
        {
            int index = getAttributeIndex( name );
            if ( index > -1 )
            {
                return new AttributeInfo( index );
            }
            index = getExtensionIndex( name );
            if ( index < 0 )
            {
                throw new IllegalArgumentException( "unknown attribute '" + name + "'. "
                    + "Provided attributes are: " + FormatUtil.join( ", ", getAttributeNames() )
                    + ", extended attributes are: " + FormatUtil.join( ", ", extendedAttributes.keySet() ) + "." );
            }
            Extension extension = extensions[index];
            return new AttributeInfo( index, extension.getProvides().indexOf( name ) );
        }

        /**
         * Create a new LogEvent factory for a log stream corresponding to this log description.
         *
         * @param reader the stream containing to parse
         * @param logSource a textual description of the stream's source (useful when LogDistiller works on multiple
         *            simultaneous log sources)
         */
        public abstract LogEvent.Factory newFactory( Reader reader, String logSource )
            throws IOException;
    }

    public static class AttributeInfo
    {
        public final boolean extended;

        public final int index;

        public final int regexpGroup;

        AttributeInfo( int index )
        {
            extended = false;
            this.index = index;
            regexpGroup = -1;
        }

        AttributeInfo( int index, int regexpGroup )
        {
            extended = true;
            this.index = index;
            this.regexpGroup = regexpGroup;
        }
    }
}