package net.sf.logdistiller.ant;

/*
 * 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.*;
import java.util.*;
import java.util.zip.*;
import javax.xml.parsers.*;

import org.apache.tools.ant.*;
import org.apache.tools.ant.types.*;
import org.xml.sax.*;

import net.sf.logdistiller.*;
import net.sf.logdistiller.util.*;
import net.sf.logdistiller.xml.*;

/**
 * Ant task to configure and launch a log distillation.
 *
 * <pre>
 * &lt;logdistiller conf=&quot;&lt;i&gt;[xml configuration file]&lt;/i&gt;&quot; publish=&quot;&lt;i&gt;[all|file,mail,...]&lt;/i&gt;&quot; compressed=&quot;&lt;i&gt;[no|gzip|zip]&lt;/i&gt;&quot;&gt;
 *  [&lt;&lt;a href=&quot;AntProperty.html&quot;&gt;property&lt;/a&gt; .../&gt;]*
 *  &lt;fileset ...&gt;
 * lt;/logdistiller&gt;
 * </pre>
 */
public class LogDistillerTask
    extends Task
{
    private File conf;

    private boolean mail = true;

    private boolean mailConfigured = false;

    private List<String> publish;

    private boolean publishConfigured = false;

    private Map<String, String> properties = new HashMap<String, String>();

    private AntLogEvent logevent;

    private AntLogDistillation logdistillation;

    private List<FileSet> filesets = new ArrayList<FileSet>();

    /** @since 0.8 */
    private String compressed = "no";

    public LogDistillerTask()
    {
    }

    public void setConf( File conf )
    {
        this.conf = conf;
    }

    public void setMail( boolean mail )
    {
        this.mail = mail;
        mailConfigured = true;
    }

    public void setPublish( String publish )
    {
        publishConfigured = true;
        publish = publish.trim();
        if ( publish.equals( "all" ) )
        {
            this.publish = null;
        }
        else
        {
            this.publish = new ArrayList<String>();
            while ( publish.length() > 0 )
            {
                int index = publish.indexOf( ',' );
                if ( index > -1 )
                {
                    this.publish.add( publish.substring( 0, index ).trim() );
                    publish = publish.substring( index + 1 );
                }
                else
                {
                    this.publish.add( publish );
                    publish = "";
                }
            }
        }
    }

    public void addConfiguredProperty( AntProperty property )
    {
        properties.put( property.getName(), property.getValue() );
    }

    public void setCompressed( Compressed attr )
    {
        this.compressed = attr.getValue();
    }

    /**
     * @deprecated since LogDistiller 0.7, replaced by logtype element in rules configuration
     */
    public AntLogEvent createLogevent()
    {
        logevent = new AntLogEvent( getProject() );
        return logevent;
    }

    /**
     * @deprecated since LogDistiller 0.7, replaced by output element in rules configuration
     */
    public AntLogDistillation createLogdistillation()
    {
        logdistillation = new AntLogDistillation();
        return logdistillation;
    }

    public void addFileSet( FileSet fs )
    {
        filesets.add( fs );
    }

    public void execute()
        throws BuildException
    {
        log( "LogDistiller " + LogDistiller.getVersion() );
        LogDistiller ld = readLogDistiller();
        compatibilityUpdate( ld );

        if ( LogTypes.getLogType( ld.getLogType().getId() ) == null )
        {
            throw new BuildException( "Could not find logtype '" + ld.getLogType().getId() + "': available values are "
                + LogTypes.listAllLogTypeIds() );
        }

        LogDistillation distillation = new LogDistillation( ld );

        LogEvent.Factory factory = initLogEventFactory( distillation.getLogTypeDescription() );

        log( "content: " + ld.getOutput().getContent() + ", output directory: " + ld.getOutput().getDirectory() );

        String step = null;
        try
        {
            step = "beginning logdistillation";
            distillation.begin();

            step = "reading a log event";
            int count = 0;
            LogEvent le;
            while ( ( le = factory.nextEvent() ) != null )
            {
                count++;
                distillation.processLogEvent( le );
            }

            step = "ending logdistillation";
            distillation.end();
            log( "logevents distilled: " + count + ", time elapsed: "
                + FormatUtil.formatPeriod( distillation.getEndTime() - distillation.getBeginTime() ) );

            step = "publishing logdistillation reports";
            int reports = new PublishHelper( distillation, publish ).publish();
            log( "reports published: " + reports );
        }
        catch ( IOException ioe )
        {
            throw new BuildException( "I/O error when " + step + ": " + ioe.getMessage(), ioe );
        }
        catch ( Publisher.PublishException ppe )
        {
            throw new BuildException( "Error when " + step + ": " + ppe.getMessage(), ppe );
        }
        catch ( ParseException pe )
        {
            throw new BuildException( "Parsing error when " + step + ": " + pe.getMessage(), pe );
        }
    }

    /**
     * Make all that's possible to update latest LogDistiller model to maintain compatibility with older versions, since
     * some elements have moved from Ant task to LogDistiller model.
     *
     * @param ld LogDistiller
     */
    private void compatibilityUpdate( LogDistiller ld )
    {
        if ( logevent != null )
        {
            if ( ld.isOld() )
            {
                String warning =
                    "element 'logevent' is deprecated in Ant logdistiller task, please use element 'logtype' "
                        + "from " + LogDistillerEntityResolver.LATEST_DTD + " in your rules file";
                log( "WARNING: " + warning, Project.MSG_WARN );
                ld.addWarning( warning );
                ld.buildCompatibilityLogType( logevent.getLogtype() );
            }
            else
            {
                String warning =
                    "element 'logevent' is deprecated in Ant logdistiller task now that you use element "
                        + "'logtype' from " + LogDistillerEntityResolver.LATEST_DTD
                        + " in your rules file: ignored (please remove)";
                log( "WARNING : " + warning, Project.MSG_WARN );
                ld.addWarning( warning );
            }
        }

        if ( logdistillation != null )
        {
            if ( ld.isOld() )
            {
                String warning =
                    "element 'logdistillation' is deprecated in Ant logdistiller task, please use element "
                        + "'output' from " + LogDistillerEntityResolver.LATEST_DTD + " in your rules file";
                log( "WARNING: " + warning, Project.MSG_WARN );
                ld.addWarning( warning );
                String skipgroups = logdistillation.getSkipgroups();
                int pos = skipgroups.indexOf( ',' );
                if ( pos >= 0 )
                {
                    skipgroups = skipgroups.substring( 0, pos ).trim();
                    warning =
                        "attribute skipgroups in logdistillation element cannot refer any more to multiple groups: "
                            + "please create a category. Only group '" + skipgroups + "' has been kept.";
                }
                ld.getOutput().updateCompatibility( logdistillation.getDestdir(), logdistillation.getContent(),
                                                    skipgroups );
            }
            else
            {
                String warning =
                    "element 'logdistillation' is deprecated in Ant logdistiller task now that you use element "
                        + "'output' from " + LogDistillerEntityResolver.LATEST_DTD
                        + " in your rules file: ignored (please remove)";
                log( "WARNING: " + warning, Project.MSG_WARN );
                ld.addWarning( warning );
            }
        }

        if ( mailConfigured )
        {
            if ( !publishConfigured )
            {
                setPublish( mail ? "file,mail" : "file" );
            }
            else
            {
                String warning =
                    "attribute 'mail' is deprecated in Ant logdistiller task now that you use attribute "
                        + "'publish': attribute ignored (please remove)";
                log( "WARNING: " + warning, Project.MSG_WARN );
                ld.addWarning( warning );
            }
        }
    }

    private LogDistiller readLogDistiller()
    {
        DOMConfigurator domConfigurator = new DOMConfigurator( properties );
        try
        {
            log( "reading configuration " + conf );
            return domConfigurator.read( conf );
        }
        catch ( IllegalArgumentException iae )
        {
            throw new BuildException( "error in configuration: " + iae.getMessage(), iae );
        }
        catch ( SAXException saxe )
        {
            throw new BuildException( "parsing error in logdistiller XML configuration file " + conf + ": "
                + saxe.getMessage(), saxe );
        }
        catch ( IOException ioe )
        {
            throw new BuildException( "error while reading file " + conf + ": " + ioe.getMessage(), ioe );
        }
        catch ( ParserConfigurationException pce )
        {
            throw new BuildException( "error with XML parser configuration:" + pce.getMessage(), pce );
        }
    }

    private FactoryMultiplexer initLogEventFactory( LogType.Description description )
    {
        // construct a log event multiplexer with each file added in the fileset
        FactoryMultiplexer multiplexer = new FactoryMultiplexer( description );
        try
        {
            int count = 0;
            for ( FileSet fs : filesets )
            {
                DirectoryScanner ds = fs.getDirectoryScanner( getProject() );
                String[] srcFiles = ds.getIncludedFiles();
                int len = srcFiles.length;
                for ( int i = 0; i < len; i++ )
                {
                    count += addFile( new File( ds.getBasedir(), srcFiles[i] ), description, multiplexer );
                }
            }
            log( "parsing " + count + " log files" );
        }
        catch ( IOException ioe )
        {
            throw new BuildException( "error while opening log file: " + ioe.getMessage(), ioe );
        }
        return multiplexer;
    }

    private int addFile( File file, LogType.Description description, FactoryMultiplexer multiplexer )
        throws IOException
    {
        int count = 0;
        log( "parsing " + file.getPath() );
        if ( "no".equals( compressed ) )
        {
            Reader reader = new InputStreamReader( new FileInputStream( file ) );
            String logSource = file.toURL().toString();
            multiplexer.addFactory( description.newFactory( reader, logSource ) );
            count++;
        }
        else if ( "gzip".equals( compressed ) )
        {
            Reader reader = new InputStreamReader( new GZIPInputStream( new FileInputStream( file ) ) );
            String logSource = "gzip:" + file.toURL().toString();
            multiplexer.addFactory( description.newFactory( reader, logSource ) );
            count++;
        }
        else if ( "compress".equals( compressed ) )
        {
            Reader reader = new InputStreamReader( new UncompressInputStream( new FileInputStream( file ) ) );
            String logSource = "compress:" + file.toURL().toString();
            multiplexer.addFactory( description.newFactory( reader, logSource ) );
            count++;
        }
        else
        { // zip
            ZipFile zip = new ZipFile( file );
            Enumeration<? extends ZipEntry> iter = zip.entries();
            while ( iter.hasMoreElements() )
            {
                ZipEntry entry = iter.nextElement();
                if ( !entry.isDirectory() )
                {
                    log( "   " + entry.getName() );
                    Reader reader = new InputStreamReader( zip.getInputStream( entry ) );
                    String logSource = "zip:" + file.toURL() + "!" + entry.getName();
                    multiplexer.addFactory( description.newFactory( reader, logSource ) );
                    count++;
                }
            }
        }
        return count;
    }

    public static class Compressed
        extends EnumeratedAttribute
    {
        public String[] getValues()
        {
            return new String[] { "no", "gzip", "zip", "compress" };
        }
    }
}