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.lang.ArrayUtils;
import org.jdom.Element;

import net.sf.logdistiller.util.FormatUtil;

/**
 * A LogDistiller configuration.
 *
 * @see LogDistillation
 * @see net.sf.logdistiller.xml.DOMConfigurator
 */
public class LogDistiller
    implements Serializable
{
    private static final long serialVersionUID = 1730313287821721822L;

    private final String id;

    private final String description;

    private LogType logtype;

    /** @since 0.7 */
    private final Output output;

    private final Category[] categories;

    private final Group[] groups;

    /** @since 0.7 */
    private final List<String> warnings = new ArrayList<String>();

    private final boolean old;

    public LogDistiller( String id, String description, LogType logtype, Output output, Category[] categories,
                         Group[] groups, boolean old )
    {
        this.id = id;
        this.description = description;
        this.logtype = logtype;
        this.output = output;
        this.categories = (Category[]) ArrayUtils.clone( categories );
        this.groups = (Group[]) ArrayUtils.clone( groups );
        this.old = old;
        updateRef();
    }

    public LogDistiller( String id, String description, LogType logtype, Output output, Category[] categories,
                         Group[] groups )
    {
        this( id, description, logtype, output, categories, groups, false );
    }

    /**
     * Update the references from internal objects to their parent LogDistiller instance and other referenced object not
     * initialized at creation time.
     */
    public void updateRef()
    {
        output.updateRef( this );
        int len = categories.length;
        for ( int i = 0; i < len; i++ )
        {
            categories[i].updateRef( this );
        }
        len = groups.length;
        for ( int i = 0; i < len; i++ )
        {
            groups[i].updateRef( this );
        }
    }

    private void readObject( ObjectInputStream in )
        throws IOException, ClassNotFoundException
    {
        in.defaultReadObject();
        if ( output != null )
        {
            // TODO: do better with deserialization of an old instance
            updateRef();
        }
    }

    public String getId()
    {
        return id;
    }

    public String getDescription()
    {
        return description;
    }

    public LogType getLogType()
    {
        return logtype;
    }

    /**
     * is this LogDistiller read from an old configuration file (DTD older than 1.3)?
     */
    public boolean isOld()
    {
        return old;
    }

    /**
     * To keep old rules configuration files running (without logtype element), create a LogType instance from the type
     * provided. Parameters from the logtype are extracted from global parameters: every <code>logevent.myParam</code>
     * global parameter is inserted as <code>myParam</code>.
     *
     * @param type String the log type to consider
     */
    public void buildCompatibilityLogType( String type )
    {
        Map<String, String> logtypeParams = new HashMap<String, String>();
        Map<String, String> params = output.getParams();
        for ( Map.Entry<String, String> entry : params.entrySet() )
        {
            String key = entry.getKey();
            if ( key.startsWith( "logevent." ) )
            {
                logtypeParams.put( key.substring( 9 ), entry.getValue() );
            }
        }
        String paramAttributes = (String)logtypeParams.get( "attributes" );
        logtype = new LogDistiller.LogType( type, logtypeParams, new Attributes( paramAttributes, new Attributes.Extension[0] ) );
    }

    public Output getOutput()
    {
        return output;
    }

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

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

    public List<String> getWarnings()
    {
        return Collections.unmodifiableList( warnings );
    }

    public void addWarning( String msg )
    {
        warnings.add( msg );
    }

    public void checkLogtypeAttributes( net.sf.logdistiller.LogType.Description description )
    {
        String attributes = ( logtype.getAttributes() == null ) ? null : logtype.getAttributes().getAttributes();
        String attributesReference = FormatUtil.join( ",", description.getAttributeNames() );

        if ( attributes == null )
        {
            addWarning( "<logtype><attributes> element should contain <provided>" + attributesReference
                + "</provided>" );
        }
        else if ( !attributesReference.equals( attributes ) )
        {
            addWarning( "bad value for <logtype><attributes><provided> element, should be " + attributesReference );
        }
    }

    public static String getVersion()
    {
        Package pkg = LogDistiller.class.getPackage();
        String version = ( pkg == null ) ? null : pkg.getSpecificationVersion();
        return ( version == null ) ? "SNAPSHOT" : version;
    }

    /**
     * Definition of the log type used for this logdistiller configuration, with its parameters.
     */
    public static class LogType
        implements Serializable
    {
        private static final long serialVersionUID = 1486393526172179950L;

        private final String id;

        private final Map<String, String> params;

        /**
         * @since 1.1
         */
        private final Attributes attributes;

        public LogType( String id, Map<String, String> params, Attributes attributes )
        {
            this.id = id;
            this.params = params;
            this.attributes = attributes;
        }

        public String getId()
        {
            return id;
        }

        public Map<String, String> getParams()
        {
            return params;
        }

        public String getParam( String name )
        {
            return params.get( name );
        }

        public String getParam( String name, String defaultValue )
        {
            String value = getParam( name );
            return ( value == null ) ? defaultValue : value;
        }

        /**
         * @return extensions (not <code>null</code>)
         *  @since 1.1
         */
        public Attributes.Extension[] getExtensions()
        {
            return ( attributes == null ) ? Attributes.NO_EXTENSIONS : attributes.getExtensions();
        }

        /** @since 1.1 */
        public int getExtensionsCount()
        {
            return ( attributes == null ) ? 0 : attributes.getExtensionsCount();
        }

        /** @since 1.1 */
        public Attributes getAttributes()
        {
            return attributes;
        }
    }

    /**
     * Definition of the global output.
     *
     * @since 0.7
     */
    public static class Output
        implements Serializable
    {
        private static final long serialVersionUID = 1707510377356801400L;

        private String directory;

        private String content;

        private final String url;

        private String skip;

        private final Map<String, String> params;

        private final Report[] reports;

        private transient LogDistiller logdistiller;

        public Output( String directory, String url, String content, String skip, Map<String, String> params,
                       Report[] reports )
        {
            this.directory = directory;
            this.url = url;
            this.content = content;
            this.skip = skip;
            this.params = params;
            this.reports = (Report[]) ArrayUtils.clone( reports );
        }

        public LogDistiller getLogdistiller()
        {
            return logdistiller;
        }

        private void updateRef( LogDistiller logdistiller )
        {
            this.logdistiller = logdistiller;
            int len = reports.length;
            for ( int i = 0; i < len; i++ )
            {
                reports[i].updateRef( this );
            }
        }

        /**
         * Gets the <code>id</code> that will identify the output reports.
         *
         * @return the <code>id</code> param if set, or global logdistiller id.
         */
        public String getId()
        {
            return getParam( "id", logdistiller.getId() );
        }

        public Map<String, String> getParams()
        {
            return params;
        }

        public String getParam( String name )
        {
            return params.get( name );
        }

        public String getParam( String name, String defaultValue )
        {
            String value = getParam( name );
            return ( value == null ) ? defaultValue : value;
        }

        public Report[] getReports()
        {
            return (Report[]) ArrayUtils.clone( reports );
        }

        public void setDirectory( String directory )
        {
            this.directory = directory;
        }

        public String getDirectory()
        {
            return directory;
        }

        public void setContent( String content )
        {
            this.content = content;
        }

        public String getContent()
        {
            return content;
        }

        public String getSkip()
        {
            return skip;
        }

        public void updateCompatibility( File directory, String content, String skip )
        {
            this.directory = directory.getAbsolutePath();
            this.content = content;
            this.skip = skip;
        }

        public String getUrl()
        {
            return url;
        }

        public String getUrl( String file )
        {
            return ( url == null ) ? null : ( url + '/' + file );
        }
    }

    /**
     * Definition of a report, with its publisher, formant and other params.
     */
    public static class Report
        implements Serializable
    {
        private static final long serialVersionUID = 1669156992489095268L;

        private final String publisher;

        private final String format;

        private final Map<String, String> params;

        private transient Output output;

        private transient Group group;

        public Report( String publisher, String format, Map<String, String> params )
        {
            this.publisher = publisher;
            this.format = format;
            this.params = params;
        }

        private void updateRef( Output output )
        {
            this.output = output;
            this.group = null;
        }

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

        public Output getOutput()
        {
            return output;
        }

        public Group getGroup()
        {
            return group;
        }

        public Map<String, String> getParams()
        {
            return params;
        }

        public String getFormat()
        {
            return format;
        }

        public String getParam( String name )
        {
            return params.get( name );
        }

        public String getParam( String name, String defaultValue )
        {
            String value = getParam( name );
            return ( value != null ) ? value : output.getParam( publisher + '.' + name, defaultValue );
        }

        public String getPublisher()
        {
            return publisher;
        }
    }

    /**
     * Definition of a group of events: events corresponding to its conditions will be collected in it.
     */
    public static class Group
        implements Serializable
    {
        private static final long serialVersionUID = 6647633346412959286L;

        private final String id;

        private final String description;

        private final boolean continueProcessing;

        private final boolean save;

        private final Map<String, String> params;

        private final Condition[] conditions;

        private final Report[] reports;

        private final Category category;

        private final Plugin[] plugins;

        private transient LogDistiller logdistiller;

        public Group( String id, String description, boolean continueProcessing, boolean save,
                      Map<String, String> params, Condition[] conditions, Report[] reports, Plugin[] plugins,
                      Category category )
        {
            this.id = id;
            this.description = description;
            this.continueProcessing = continueProcessing;
            this.save = save;
            this.params = params;
            this.conditions = (Condition[]) ArrayUtils.clone( conditions );
            this.reports = (Report[]) ArrayUtils.clone( reports );
            this.plugins = (Plugin[]) ArrayUtils.clone( plugins );
            this.category = category;
        }

        private void updateRef( LogDistiller logdistiller )
        {
            this.logdistiller = logdistiller;
            if ( id == null )
            {
                // for unknown reason, deserialization of a LogDistillation instance does not fully deserialize
                // LogDistiller's
                // instance
                return;
            }
            if ( category != null )
            {
                this.category.addGroup( this );
            }
            int len = reports.length;
            for ( int i = 0; i < len; i++ )
            {
                reports[i].updateRef( this );
            }
            len = plugins.length;
            for ( int i = 0; i < len; i++ )
            {
                plugins[i].updateRef( this );
            }
        }

        public LogDistiller getLogdistiller()
        {
            return logdistiller;
        }

        public Map<String, String> getParams()
        {
            return params;
        }

        public String getParam( String name )
        {
            return (String) params.get( name );
        }

        public String getParam( String name, String defaultValue )
        {
            String value = getParam( name );
            return ( value != null ) ? value : logdistiller.getOutput().getParam( name, defaultValue );
        }

        /**
         * Check if given LogEvent meet one of the conditions defined.
         *
         * @param le LogEvent the LogEvent to check
         * @return Condition the condition which matched the log event, or <code>null</code>
         */
        public Condition accept( LogEvent le )
        {
            int count = conditions.length;
            if ( count == 0 )
            {
                // no condition => accepts all log events
                return Condition.ACCEPT_ALL;
            }
            for ( int i = 0; i < count; i++ )
            {
                if ( conditions[i].match( le ) )
                {
                    return conditions[i];
                }
            }
            return null;
        }

        public String getId()
        {
            return id;
        }

        public Element dumpConditions( Element parent )
        {
            int count = conditions.length;
            for ( int i = 0; i < count; i++ )
            {
                parent.addContent( conditions[i].dump() );
            }
            return parent;
        }

        public String getDescription()
        {
            return description;
        }

        /**
         * @return boolean in case a LogEvent is added to the current group, must classification be continued further to
         *         match other groups?
         */
        public boolean continueProcessing()
        {
            return continueProcessing;
        }

        public boolean getSave()
        {
            return save;
        }

        public Category getCategory()
        {
            return category;
        }

        public Report[] getReports()
        {
            return (Report[]) ArrayUtils.clone( reports );
        }

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

    /**
     * Definition of a category, which will contain groups.
     */
    public static class Category
        implements Serializable
    {
        private static final long serialVersionUID = 3036838205912907804L;

        private final String id;

        private final String description;

        private transient LogDistiller logdistiller;

        private transient List<Group> groups;

        public Category( String id, String description )
        {
            this.id = id;
            this.description = description;
        }

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

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

        public LogDistiller getLogdistiller()
        {
            return logdistiller;
        }

        public String getId()
        {
            return id;
        }

        public String getDescription()
        {
            return description;
        }

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

    public static class Plugin
        implements Serializable
    {
        private static final long serialVersionUID = 7948111042518186219L;

        private final String type;

        private final Map<String, String> params;

        private final boolean globalReport;

        private final boolean groupReport;

        private transient Group group;

        public Plugin( String type, boolean globalReport, boolean groupReport, Map<String, String> params )
        {
            this.type = type;
            this.params = params;
            this.globalReport = globalReport;
            this.groupReport = groupReport;
        }

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

        public Group getGroup()
        {
            return group;
        }

        public String getType()
        {
            return type;
        }

        public boolean isGlobalReportEnabled()
        {
            return globalReport;
        }

        public boolean isGroupReportEnabled()
        {
            return groupReport;
        }

        public Map<String, String> getParams()
        {
            return params;
        }

        public String getParam( String name )
        {
            return params.get( name );
        }

        public String getParam( String name, String defaultValue )
        {
            String value = getParam( name );
            return ( value == null ) ? defaultValue : value;
        }
    }
}