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

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.ArrayUtils;

/**
 * The class executing a log distillation, using a log distiller, and processing every log events. A log distillation
 * can be run either with LogDistiller's {@link net.sf.logdistiller.gui GUI} or with {@link net.sf.logdistiller.ant Ant
 * tasks}.
 *
 * @see LogDistiller
 */
public class LogDistillation
    implements Serializable
{
    private static final long serialVersionUID = -9098523382541148543L;

    public final static String LINE_SEPARATOR = System.getProperty( "line.separator" );

    private final LogDistiller ld;

    private final Group[] groups;

    private final Category[] categories;

    private final String content;

    private final File destinationDirectory;

    private final String version = LogDistiller.getVersion();

    private transient Map<String, Group> mapGroups;

    private transient Map<String, Category> mapCategories;

    private long beginTime;

    private long endTime;

    private int eventCount = -1;

    private long eventBytes = 0;

    private int skippedEventCount = 0;

    private long skippedEventBytes = 0;

    private transient LogType.Description logtypeDescription;

    public LogDistillation( LogDistiller ld )
    {
        this.ld = ld;

        // init categories
        LogDistiller.Category[] categoryDefinitions = ld.getCategories();
        int length = categoryDefinitions.length;
        categories = new Category[length];
        mapCategories = new HashMap<String, Category>();
        for ( int i = 0; i < length; i++ )
        {
            categories[i] = new Category( categoryDefinitions[i] );
            mapCategories.put( categoryDefinitions[i].getId(), categories[i] );
        }

        // init groups
        LogDistiller.Group[] groupDefinitions = ld.getGroups();
        length = groupDefinitions.length;
        groups = new Group[length];
        for ( int i = 0; i < length; i++ )
        {
            LogDistiller.Group groupDefinition = groupDefinitions[i];
            LogDistiller.Category categoryDefinition = groupDefinition.getCategory();
            Category category =
                ( categoryDefinition == null ) ? null : (Category) mapCategories.get( categoryDefinition.getId() );
            groups[i] = new Group( groupDefinition, category );
        }

        // misc.
        content = ld.getOutput().getContent();
        destinationDirectory = new File( ld.getOutput().getDirectory() );
        updateRef();
    }

    /**
     * Create a logtype description with parameters defined in LogDistiller configuration.
     * @return a new logtype description
     */
    private LogType.Description newLogTypeDescription()
    {
        LogDistiller.LogType lt = ld.getLogType();

        LogType logtype = LogTypes.getLogType( lt.getId() );
        LogType.Description logtypeDescription = logtype.newDescription( ld.getLogType().getParams() );
        logtypeDescription.setExtensions( ld.getLogType().getExtensions() );
        ld.checkLogtypeAttributes( logtypeDescription );

        return logtypeDescription;
    }

    /**
     * update internal maps, skip value and references from categories and groups
     */
    private void updateRef()
    {
        String skip = ld.getOutput().getSkip();

        // process categories
        mapCategories = new HashMap<String, Category>();
        Category skipCategory = null;
        int len = categories.length;
        for ( int i = 0; i < len; i++ )
        {
            Category category = categories[i];
            mapCategories.put( category.getDefinition().getId(), category );
            category.updateRef( this );

            if ( category.getDefinition().getId().equals( skip ) )
            {
                skipCategory = category;
            }
        }

        // process groups
        mapGroups = new HashMap<String, Group>();
        len = groups.length;
        for ( int i = 0; i < len; i++ )
        {
            Group group = groups[i];
            mapGroups.put( group.getDefinition().getId(), group );
            group.updateRef( this );

            if ( group.getDefinition().getId().equals( skip ) )
            {
                group.setSkip( true );
            }
        }

        if ( skipCategory != null )
        {
            skipCategory.setSkip( true );
        }

        logtypeDescription = newLogTypeDescription();
    }

    private void readObject( ObjectInputStream in )
        throws IOException, ClassNotFoundException
    {
        in.defaultReadObject();
        if ( ld.getOutput() != null )
        {
            ld.updateRef(); // workaround: a problem with Group deserialization happens
            updateRef();
        }
    }

    /**
     * begin the distillation
     *
     * @throws IOException
     */
    public void begin()
        throws IOException
    {
        destinationDirectory.mkdirs();
        int count = groups.length;
        for ( int i = 0; i < count; i++ )
        {
            groups[i].begin( destinationDirectory );
        }
        eventCount = 0;
        beginTime = System.currentTimeMillis();
    }

    /**
     * Process a log event
     *
     * @param le LogEvent the log event
     * @throws IOException if an error occurs when (eventually) saving the log event
     */
    public void processLogEvent( LogEvent le )
        throws IOException
    {
        if ( eventCount < 0 )
        {
            throw new IllegalStateException( "LogDistiller not initialized: need to call begin() before processing" );
        }
        eventCount++;
        int eventSize = le.getRawLog().length() + LINE_SEPARATOR.length();
        eventBytes += eventSize;
        int count = groups.length;
        for ( int i = 0; i < count; i++ )
        {
            Group group = groups[i];
            if ( group.accept( le ) )
            {
                if ( group.isSkip() )
                {
                    // logevent matched a skipped group => update counters
                    eventCount--;
                    eventBytes -= eventSize;
                    skippedEventCount++;
                    skippedEventBytes += eventSize;
                    break;
                }
                if ( !group.getDefinition().continueProcessing() )
                {
                    break;
                }
            }
        }
    }

    /**
     * end the distillation
     *
     * @throws IOException if an error occurs when closing the files where log events were (eventually) saved
     */
    public void end()
        throws IOException
    {
        endTime = System.currentTimeMillis();
        int count = groups.length;
        for ( int i = 0; i < count; i++ )
        {
            Group group = groups[i];
            group.end();
        }
        saveTo( newDestinationFile( "result.ser" ) );
    }

    /**
     * Saves the distillation to a file, in Java serialized format.
     *
     * @param file File destination file.
     */
    public void saveTo( File file )
        throws IOException
    {
        OutputStream out = null;
        try
        {
            out = new FileOutputStream( file );
            saveTo( out );
        }
        finally
        {
            IOUtils.closeQuietly( out );
        }
    }

    public void saveTo( OutputStream out )
        throws IOException
    {
        ObjectOutputStream obj = new ObjectOutputStream( out );
        obj.writeObject( this );
    }

    public List<Category> listCategoriesToReport()
    {
        List<Category> reportCategories = new ArrayList<Category>();
        int count = categories.length;
        for ( int i = 0; i < count; i++ )
        {
            Category category = categories[i];
            if ( ( !category.isSkip() ) && ( category.sumEventCount() > 0 ) )
            {
                reportCategories.add( category );
            }
        }
        return reportCategories;
    }

    public List<Group> listGroupsToReport()
    {
        List<Group> reportGroups = new ArrayList<Group>();
        int count = groups.length;
        for ( int i = 0; i < count; i++ )
        {
            Group group = groups[i];
            if ( ( !group.isSkip() ) && ( group.getEventCount() > 0 ) && ( group.getCategory() == null ) )
            {
                reportGroups.add( group );
            }
        }
        return reportGroups;
    }

    public LogDistiller getDefinition()
    {
        return ld;
    }

    public Group[] getGroups()
    {
        return (Group[]) ArrayUtils.clone( groups );
    }

    public Group getGroup( String id )
    {
        return mapGroups.get( id );
    }

    public Category[] getCategories()
    {
        return (Category[]) ArrayUtils.clone( categories );
    }

    public Category getCategory( String id )
    {
        return mapCategories.get( id );
    }

    public String getContent()
    {
        return content;
    }

    public int getEventCount()
    {
        return eventCount;
    }

    public long getEventBytes()
    {
        return eventBytes;
    }

    public long getBeginTime()
    {
        return beginTime;
    }

    public long getEndTime()
    {
        return endTime;
    }

    public int getSkippedEventCount()
    {
        return skippedEventCount;
    }

    public long getSkippedEventBytes()
    {
        return skippedEventBytes;
    }

    public File newDestinationFile( String filename )
    {
        return new File( destinationDirectory, filename );
    }

    public LogType.Description getLogTypeDescription()
    {
        return logtypeDescription;
    }

    /**
     * What is the version of <b>LogDistiller</b> that was used to create this instance?
     *
     * @return String the version
     */
    public String getVersion()
    {
        return ( version == null ) ? "unknown" : version;
    }

    public class Group
        implements Serializable
    {
        private static final long serialVersionUID = 5788707827350407084L;

        private final LogDistiller.Group definition;

        private final Category category;

        private transient LogDistillation logdistillation;

        private boolean skip = false;

        /**
         * maximum number of events saved, -1 = no limit
         *
         * @since 0.7
         */
        private final int maxSaveCount;

        /**
         * maximum size sum of events saved in bytes, -1 = no limit
         *
         * @since 0.7
         */
        private final long maxSaveBytes;

        private final Plugin[] plugins;

        private File logFile;

        private transient PrintStream logStream;

        private int eventCount = 0;

        private int savedEventCount = 0;

        private long bytes = 0;

        public Group( LogDistiller.Group definition, Category category )
        {
            this.definition = definition;
            this.category = category;
            maxSaveCount = Integer.parseInt( definition.getParam( "maxSave.count", "-1" ) );
            maxSaveBytes = Long.parseLong( definition.getParam( "maxSave.size", "-1" ) ) * 1024;
            LogDistiller.Plugin[] pluginDefs = definition.getPlugins();
            plugins = new Plugin[pluginDefs.length];
            for ( int i = 0; i < pluginDefs.length; i++ )
            {
                plugins[i] = Plugins.newInstance( pluginDefs[i] );
            }
        }

        private void updateRef( LogDistillation logdistillation )
        {
            this.logdistillation = logdistillation;
            if ( category != null )
            {
                category.addGroup( this );
            }
            int len = plugins.length;
            for ( int i = 0; i < len; i++ )
            {
                plugins[i].updateRef( this );
            }
        }

        public LogDistillation getLogdistillation()
        {
            return logdistillation;
        }

        public Category getCategory()
        {
            return category;
        }

        public void setSkip( boolean skip )
        {
            this.skip = skip;
        }

        public boolean isSkip()
        {
            return skip;
        }

        /**
         * Check if given LogEvent meet one of the conditions defined.
         *
         * @param le LogEvent the LogEvent to check
         * @throws IOException
         * @return boolean <code>true</code> if the LogEvent meets a condition
         */
        public boolean accept( LogEvent le )
            throws IOException
        {
            Condition condition = definition.accept( le );
            if ( condition != null )
            {
                addLogEvent( le, condition );
                return true;
            }
            return false;
        }

        /**
         * Add a LogEvent to the current Group.
         *
         * @param le LogEvent
         * @param condition the condition that matched the LogEvent
         * @throws IOException
         */
        protected void addLogEvent( LogEvent le, Condition condition )
            throws IOException
        {
            eventCount++;
            bytes += le.getRawLog().length() + LINE_SEPARATOR.length();
            if ( definition.getSave() && ( ( maxSaveCount < 0 ) || ( eventCount <= maxSaveCount ) )
                && ( ( maxSaveBytes < 0 ) || ( bytes <= maxSaveBytes ) ) )
            {
                if ( logStream == null )
                {
                    logStream = new PrintStream( new FileOutputStream( logFile ) );
                }
                logStream.println( le.getRawLog() );
                savedEventCount++;
            }
            int len = plugins.length;
            for ( int i = 0; i < len; i++ )
            {
                plugins[i].addLogEvent( le, condition );
            }
        }

        void begin( File destinationDirectory )
            throws IOException
        {
            logFile = newDestinationFile( definition.getId() + ".log" );
            int len = plugins.length;
            for ( int i = 0; i < len; i++ )
            {
                plugins[i].begin( destinationDirectory );
            }
        }

        void end()
            throws IOException
        {
            if ( logStream != null )
            {
                logStream.close();
            }
            int len = plugins.length;
            for ( int i = 0; i < len; i++ )
            {
                plugins[i].end();
            }
        }

        public LogDistiller.Group getDefinition()
        {
            return definition;
        }

        public int getEventCount()
        {
            return eventCount;
        }

        public int getSavedEventCount()
        {
            return savedEventCount;
        }

        public long getBytes()
        {
            return bytes;
        }

        public File getLogFile()
        {
            return logFile;
        }

        public int getMaxSaveCount()
        {
            return maxSaveCount;
        }

        public long getMaxSaveBytes()
        {
            return maxSaveBytes;
        }

        public Plugin[] getPlugins()
        {
            return (Plugin[]) ArrayUtils.clone( plugins );
        }
    }

    public static class Category
        implements Serializable
    {
        private static final long serialVersionUID = 7098883103191641753L;

        private final LogDistiller.Category definition;

        private transient LogDistillation logdistillation;

        private transient List<Group> groups;

        private boolean skip = false;

        public Category( LogDistiller.Category definition )
        {
            this.definition = definition;
        }

        private void updateRef( LogDistillation logdistillation )
        {
            this.logdistillation = logdistillation;
            groups = new ArrayList<Group>();
        }

        public LogDistillation getLogdistillation()
        {
            return logdistillation;
        }

        public LogDistiller.Category getDefinition()
        {
            return definition;
        }

        private void addGroup( Group group )
        {
            groups.add( group );
        }

        public List<Group> getGroups()
        {
            return groups;
        }

        public void setSkip( boolean skip )
        {
            this.skip = skip;
            for ( Group group : groups )
            {
                group.setSkip( skip );
            }
        }

        public boolean isSkip()
        {
            return skip;
        }

        public int sumEventCount()
        {
            int sum = 0;
            for ( Group group : groups )
            {
                sum += group.getEventCount();
            }
            return sum;
        }

        public long sumBytes()
        {
            long sum = 0;
            for ( Group group : groups )
            {
                sum += group.getBytes();
            }
            return sum;
        }

        public List<Group> listGroupsToReport()
        {
            List<Group> reportGroups = new ArrayList<Group>();
            for ( Group group : groups )
            {
                if ( group.getEventCount() > 0 )
                {
                    reportGroups.add( group );
                }
            }
            return reportGroups;
        }
    }

    public static abstract class Plugin
        implements Serializable
    {
        private static final long serialVersionUID = -722318023109374109L;

        protected final LogDistiller.Plugin definition;

        protected transient Group group;

        public Plugin( LogDistiller.Plugin definition )
        {
            this.definition = definition;
        }

        private void updateRef( Group group )
        {
            this.group = group;
        }

        public Group getGroup()
        {
            return group;
        }

        public LogDistiller.Plugin getDefinition()
        {
            return definition;
        }

        public String getId()
        {
            return getDefinition().getType();
        }

        /**
         * Begin the log distillation for this plugin instance.
         *
         * @param destinationDirectory the directory where reports will be stored.
         * @throws IOException
         */
        abstract public void begin( File destinationDirectory )
            throws IOException;

        /**
         * Add a log event to this plugin instance.
         *
         * @param le the log event.
         * @throws IOException
         */
        abstract public void addLogEvent( LogEvent le )
            throws IOException;

        /**
         * Add a log event to this plugin instance, with information on which condition was matched.
         *
         * @param le the log event.
         * @param condition the condition which was matched
         * @since 1.1
         */
        public void addLogEvent( LogEvent le, Condition condition )
            throws IOException
        {
            addLogEvent( le ); // default implementation does ignore condition
        }

        /**
         * End the log distillation for this plugin instance.
         *
         * @throws IOException
         */
        abstract public void end()
            throws IOException;

        /**
         * Append a summary of this plugin instance results to the group report.
         *
         * @param report the plugin report formatter
         */
        abstract public void appendGroupReport( ReportFormat.PluginReport report );

        /**
         * Append a summary of this plugin instance results to the global report.
         *
         * @param report the plugin report formatter
         */
        abstract public void appendGlobalReport( ReportFormat.PluginReport report );
    }
}