package org.codehaus.mojo.animal_sniffer.maven;

/*
 * The MIT License
 *
 * Copyright (c) 2009, codehaus.org
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 */

import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.ArtifactUtils;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.Component;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.plugins.annotations.ResolutionScope;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.MavenProjectHelper;
import org.apache.maven.shared.artifact.filter.PatternExcludesArtifactFilter;
import org.apache.maven.shared.artifact.filter.PatternIncludesArtifactFilter;
import org.apache.maven.toolchain.MisconfiguredToolchainException;
import org.apache.maven.toolchain.Toolchain;
import org.apache.maven.toolchain.ToolchainManager;
import org.apache.maven.toolchain.ToolchainManagerPrivate;
import org.apache.maven.toolchain.ToolchainPrivate;
import org.codehaus.mojo.animal_sniffer.SignatureBuilder;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.cli.CommandLineException;
import org.codehaus.plexus.util.cli.CommandLineUtils;
import org.codehaus.plexus.util.cli.Commandline;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/**
 * Generates an API Signature from at least one of: the java runtime, the
 * module dependencies and the module classes.
 *
 * @author Stephen Connolly
 */
@Mojo( name = "build", configurator = "override", requiresDependencyResolution = ResolutionScope.COMPILE, threadSafe = true )
public class BuildSignaturesMojo
    extends AbstractMojo
{
    /**
     * Should the signatures from java home be included.
     *
     * @since 1.3
     */
    @Parameter( property = "includeJavaHome", defaultValue = "true" )
    private boolean includeJavaHome;

    /**
     * Should no signatures be generated if no java home is available.
     *
     * @since 1.3
     */
    @Parameter( property = "skipIfNoJavaHome", defaultValue = "false" )
    private boolean skipIfNoJavaHome;

    /**
     * Should the signatures from this module's classes be included..
     *
     * @since 1.3
     */
    @Parameter( property = "includeJavaHome", defaultValue = "true" )
    private boolean includeModuleClasses;

    /**
     * Classes to generate signatures of.
     *
     * @since 1.3
     */
    @Parameter
    private String[] includeClasses = null;

    /**
     * Classes to exclude from generating signatures of.
     *
     * @since 1.3
     */
    @Parameter
    private String[] excludeClasses = null;

    /**
     * A list of artifact patterns to include. Patterns can include <code>*</code> as a wildcard match for any
     * <b>whole</b> segment, valid patterns are:
     * <ul>
     * <li><code>groupId:artifactId</code></li>
     * <li><code>groupId:artifactId:type</code></li>
     * <li><code>groupId:artifactId:type:version</code></li>
     * <li><code>groupId:artifactId:type:classifier</code></li>
     * <li><code>groupId:artifactId:type:classifier:version</code></li>
     * </ul>
     *
     * @since 1.3
     */
    @Parameter
    private String[] includeDependencies = null;

    /**
     * A list of artifact patterns to exclude. Patterns can include <code>*</code> as a wildcard match for any
     * <b>whole</b> segment, valid patterns are:
     * <ul>
     * <li><code>groupId:artifactId</code></li>
     * <li><code>groupId:artifactId:type</code></li>
     * <li><code>groupId:artifactId:type:version</code></li>
     * <li><code>groupId:artifactId:type:classifier</code></li>
     * <li><code>groupId:artifactId:type:classifier:version</code></li>
     * </ul>
     *
     * @since 1.3
     */
    @Parameter
    private String[] excludeDependencies = null;

    /**
     * The java home to generate the signatures of, if not specified only the signatures of dependencies will be
     * included. This parameter is overridden by {@link #javaHomeClassPath}.  This parameter overrides {@link #jdk}
     * and any java home specified by maven-toolchains-plugin.
     *
     * @since 1.3
     */
    @Parameter( property = "javaHome" )
    private String javaHome;

    /**
     * Use this configuration option only if the automatic boot classpath detection does not work for the specific
     * {@link #javaHome} or {@link #jdk}.  For example, the automatic boot classpath detection does not work with
     * Sun Java 1.1. This parameter overrides {@link #javaHome}, {@link #jdk} and the maven-toolchains-plugin.
     *
     * @since 1.3
     */
    @Parameter
    private File[] javaHomeClassPath;

    /**
     * Where to put the generated signatures.
     *
     * @since 1.3
     */
    @Parameter( defaultValue = "${project.build.directory}", required = true )
    private File outputDirectory;

    /**
     * Where to find this modules classes.
     *
     * @since 1.3
     */
    @Parameter( defaultValue = "${project.build.outputDirectory}", required = true )
    private File classesDirectory;

    /**
     * The name of the generated signatures.
     *
     * @since 1.3
     */
    @Parameter( defaultValue = "${project.build.finalName}", required = true )
    private String signaturesName;

    /**
     * The classifier to add to the generated signatures.
     *
     * @since 1.3
     */
    @Parameter
    private String classifier;

    /**
     */
    @Component
    private MavenProjectHelper projectHelper;

    /**
     * The maven project.
     */
    @Parameter( defaultValue = "${project}", required = true, readonly = true )
    private MavenProject project;

    /**
     */
    @Component
    private ToolchainManager toolchainManager;

    /**
     */
    @Component
    private ToolchainManagerPrivate toolchainManagerPrivate;

    /**
     * The current build session instance. This is used for toolchain manager API calls.
     */
    @Parameter( defaultValue = "${session}", required = true, readonly = true )
    private MavenSession session;

    /**
     * The JDK Toolchain to use.  This parameter can be overridden by {@link #javaHome} or {@link #javaHomeClassPath}.
     * This parameter overrides any toolchain specified with maven-toolchains-plugin.
     *
     * @since 1.3
     */
    @Parameter
    private JdkToolchain jdk;

    /**
     */
    @Parameter( defaultValue = "${plugin.artifacts}", required = true, readonly = true )
    private List<Artifact> pluginArtifacts;

    /**
     * The groupId of the Java Boot Classpath Detector to use. The plugin's dependencies will be searched for a
     * dependency of type <code>jar</code> with this groupId and the artifactId specified in {@link #jbcpdArtifactId}.
     * The dependency should be a standalone executable jar file which outputs the java boot classpath as a single
     * line separated using {@link File#pathSeparatorChar} or else exits with a non-zero return code if it cannot determine
     * the java boot classpath.
     *
     * @since 1.3
     */
    @Parameter( defaultValue = "${plugin.groupId}" )
    private String jbcpdGroupId;

    /**
     * The artifactId of the Java Boot Classpath Detector to use. The plugin's dependencies will be searched for a
     * dependency of type <code>jar</code> with this artifactId and the groupId specified in {@link #jbcpdGroupId}.
     * The dependency should be a standalone executable jar file which outputs the java boot classpath as a single
     * line separated using {@link File#pathSeparatorChar} or else exits with a non-zero return code if it cannot determine
     * the java boot classpath.
     *
     * @since 1.3
     */
    @Parameter( defaultValue = "java-boot-classpath-detector" )
    private String jbcpdArtifactId;

    public void execute()
        throws MojoExecutionException, MojoFailureException
    {
        if ( includeJavaHome && ( javaHomeClassPath == null || javaHomeClassPath.length == 0 ) )
        {
            if ( javaHome != null )
            {
                getLog().warn( "Toolchains are ignored, 'javaHome' parameter is set to " + javaHome );

                if ( !new File( javaHome ).isDirectory() )
                {
                    if ( skipIfNoJavaHome )
                    {
                        getLog().warn( "Skipping signature generation as java home (" + javaHome + ") does not exist" );
                        return;
                    }
                    throw new MojoFailureException( "Cannot include java home if specified java home does not exist" );
                }

                if ( !detectJavaBootClasspath( new File( new File( javaHome, "bin" ), "java" ).getAbsolutePath() ) )
                {
                    return;
                }
            }
            else
            {
                Toolchain tc = getJdkToolchain();

                if ( tc == null && jdk == null )
                {
                    String jvm = null;
                    // TODO: how could this give non null result here if tc was null when doing same???
                    tc = toolchainManager.getToolchainFromBuildContext( "jdk", //NOI18N
                                                                        session );
                    getLog().info( "Toolchain from session: " + tc );
                    //assign the path to executable from toolchains
                    if ( tc != null )
                    {
                        jvm = tc.findTool( "java" ); //NOI18N
                    }

                    if ( jvm == null )
                    {
                        if ( skipIfNoJavaHome )
                        {
                            getLog().warn( "Skipping signature generation as could not find java home" );
                            return;
                        }
                        throw new MojoFailureException(
                            "Cannot include java home if java home is not specified (either via javaClassPath, javaHome or jdk)" );
                    }
                    if ( !detectJavaBootClasspath( jvm ) )
                    {
                        return;
                    }
                }
                else if ( tc != null &&  StringUtils.equalsIgnoreCase( "jdk",tc.getType() ) ) //tc instanceof JavaToolChain )
                {
                    getLog().info( "Toolchain in animal-sniffer-maven-plugin: " + tc );

                    //when the executable to use is explicitly set by user in mojo's parameter, ignore toolchains.

                    //assign the path to executable from toolchains
                    String jvm = tc.findTool( "java" ); //NOI18N

                    if ( jvm == null )
                    {
                        if ( skipIfNoJavaHome )
                        {
                            getLog().warn( "Skipping signature generation as could not find java home" );
                            return;
                        }
                        throw new MojoFailureException(
                            "Cannot include java home if java home is not specified (either via javaClassPath, javaHome or jdk)" );
                    }
                    if ( !detectJavaBootClasspath( jvm ) )
                    {
                        return;
                    }
                }
                else if ( tc == null && jdk != null && jdk.getParameters() != null )
                {
                    if ( skipIfNoJavaHome )
                    {
                        getLog().warn( "Skipping signature generation as could not find jdk toolchain to match "
                                           + jdk.getParameters() );
                        return;
                    }
                    throw new MojoFailureException( "Could not find jdk toolchain to match " + jdk.getParameters() );
                }
                else
                {
                    if ( skipIfNoJavaHome )
                    {
                        getLog().warn( "Skipping signature generation as could not find java home" );
                        return;
                    }
                    throw new MojoFailureException(
                        "Cannot include java home if java home is not specified (either via javaClassPath, javaHome, "
                            + "jdk or maven-toolchains-plugin)" );
                }
            }
        }

        displayJavaBootClasspath();

        File sigFile = getTargetFile( outputDirectory, signaturesName, classifier, "signature" );
        try
        {
            outputDirectory.mkdirs();
            SignatureBuilder builder = new SignatureBuilder( getBaseSignatures(), new FileOutputStream( sigFile ),
                                                             new MavenLogger( getLog() ) );

            if ( includeClasses != null )
            {
                getLog().info( "Restricting signatures to include only the following classes:" );
                for ( int i = 0; i < includeClasses.length; i++ )
                {
                    getLog().info( "  " + includeClasses[i] );
                    builder.addInclude( includeClasses[i] );
                }
            }

            if ( excludeClasses != null )
            {
                getLog().info( "Restricting signatures to exclude the following classes:" );
                for ( int i = 0; i < excludeClasses.length; i++ )
                {
                    getLog().info( "  " + excludeClasses[i] );
                    builder.addExclude( excludeClasses[i] );
                }
            }

            processJavaBootClasspath( builder );

            processModuleDependencies( builder );

            processModuleClasses( builder );

            builder.close();

            projectHelper.attachArtifact( project, "signature", classifier, sigFile );

        }
        catch ( IOException e )
        {
            throw new MojoExecutionException( e.getMessage(), e );
        }
    }

    private boolean detectJavaBootClasspath( String javaExecutable )
        throws MojoFailureException, MojoExecutionException
    {
        getLog().info( "Attempting to auto-detect the boot classpath for " + javaExecutable );
        Iterator<Artifact> i = pluginArtifacts.iterator();
        Artifact javaBootClasspathDetector = null;
        while ( i.hasNext() && javaBootClasspathDetector == null )
        {
            Artifact candidate = (Artifact) i.next();

            if ( StringUtils.equals( jbcpdGroupId, candidate.getGroupId() )
                && StringUtils.equals( jbcpdArtifactId, candidate.getArtifactId() ) && candidate.getFile() != null
                && candidate.getFile().isFile() )
            {
                javaBootClasspathDetector = candidate;
            }
        }
        if ( javaBootClasspathDetector == null )
        {
            if ( skipIfNoJavaHome )
            {
                getLog().warn( "Skipping signature generation as could not find boot classpath detector ("
                                   + ArtifactUtils.versionlessKey( jbcpdGroupId, jbcpdArtifactId ) + ")." );
                return false;
            }
            throw new MojoFailureException( "Could not find boot classpath detector ("
                                                + ArtifactUtils.versionlessKey( jbcpdGroupId, jbcpdArtifactId )
                                                + ")." );
        }

        try
        {
            if ( !detectJavaClasspath( javaBootClasspathDetector, javaExecutable ) )
            {
                return false;
            }
        }
        catch ( CommandLineException e )
        {
            throw new MojoExecutionException( e.getLocalizedMessage(), e );
        }
        return true;
    }

    private boolean detectJavaClasspath( Artifact javaBootClasspathDetector, String javaExecutable )
        throws CommandLineException, MojoFailureException
    {
        final Commandline cli = new Commandline();
        cli.setWorkingDirectory( project.getBasedir().getAbsolutePath() );
        cli.setExecutable( javaExecutable );
        cli.addEnvironment( "CLASSPATH", "" );
        cli.addEnvironment( "JAVA_HOME", "" );
        cli.addArguments( new String[]{ "-jar", javaBootClasspathDetector.getFile().getAbsolutePath() } );

        final CommandLineUtils.StringStreamConsumer stdout = new CommandLineUtils.StringStreamConsumer();
        final CommandLineUtils.StringStreamConsumer stderr = new CommandLineUtils.StringStreamConsumer();
        int exitCode = CommandLineUtils.executeCommandLine( cli, stdout, stderr );
        if ( exitCode != 0 )
        {
            getLog().debug( "Stdout: " + stdout.getOutput() );
            getLog().debug( "Stderr: " + stderr.getOutput() );
            getLog().debug( "Exit code = " + exitCode );
            if ( skipIfNoJavaHome )
            {
                getLog().warn( "Skipping signature generation as could not auto-detect java boot classpath for "
                                   + javaExecutable );
                return false;
            }
            throw new MojoFailureException( "Could not auto-detect java boot classpath for " + javaExecutable );
        }
        String[] classpath = StringUtils.split( stdout.getOutput(), File.pathSeparator );
        javaHomeClassPath = new File[classpath.length];
        for ( int j = 0; j < classpath.length; j++ )
        {
            javaHomeClassPath[j] = new File( classpath[j] );
        }
        return true;
    }

    private void displayJavaBootClasspath()
    {
        if ( includeJavaHome )
        {
            getLog().info( "Java Classpath:" );
            if ( javaHomeClassPath == null )
            {
                getLog().info( "    Empty" );
            }
            else
            {
                for ( int j = 0; j < javaHomeClassPath.length; j++ )
                {
                    getLog().info( "    [" + j + "] = " + javaHomeClassPath[j] );
                }
            }
        }
    }

    private void processModuleDependencies( SignatureBuilder builder )
        throws IOException
    {
        PatternIncludesArtifactFilter includesFilter = includeDependencies == null
            ? null
            : new PatternIncludesArtifactFilter( Arrays.asList( includeDependencies ) );
        PatternExcludesArtifactFilter excludesFilter = excludeDependencies == null
            ? null
            : new PatternExcludesArtifactFilter( Arrays.asList( excludeDependencies ) );

        for ( Iterator<Artifact> i = project.getArtifacts().iterator(); i.hasNext(); )
        {
            Artifact artifact = i.next();

            if ( includesFilter != null && !includesFilter.include( artifact ) )
            {
                getLog().debug( "Artifact " + artifactId( artifact ) + " ignored as it does not match include rules." );
                continue;
            }

            if ( excludesFilter != null && !excludesFilter.include( artifact ) )
            {
                getLog().debug( "Artifact " + artifactId( artifact ) + " ignored as it does match exclude rules." );
                continue;
            }

            if ( artifact.getArtifactHandler().isAddedToClasspath() )
            {
                getLog().info( "Parsing signatures from " + artifactId( artifact ) );
                builder.process( artifact.getFile() );
            }

        }
    }

    private void processModuleClasses( SignatureBuilder builder )
        throws IOException
    {
        if ( includeModuleClasses && classesDirectory.isDirectory() )
        {
            getLog().info( "Parsing signatures from " + classesDirectory );
            builder.process( classesDirectory );
        }
    }

    private void processJavaBootClasspath( SignatureBuilder builder )
        throws IOException
    {
        if ( includeJavaHome && javaHomeClassPath != null && javaHomeClassPath.length > 0 )
        {
            getLog().debug( "Parsing signatures java classpath:" );
            for ( int i = 0; i < javaHomeClassPath.length; i++ )
            {
                if ( javaHomeClassPath[i].isFile() || javaHomeClassPath[i].isDirectory() )
                {
                    getLog().debug( "Processing " + javaHomeClassPath[i] );
                    builder.process( javaHomeClassPath[i] );
                }
                else
                {
                    getLog().warn( "Could not add signatures from boot classpath element: " + javaHomeClassPath[i]
                                       + " as it does not exist." );
                }
            }
        }
    }

    private InputStream[] getBaseSignatures()
        throws FileNotFoundException
    {
        List<InputStream> baseSignatures = new ArrayList<InputStream>();
        for ( Iterator<Artifact> i = project.getArtifacts().iterator(); i.hasNext(); )
        {
            Artifact artifact = i.next();
            if ( StringUtils.equals( "signature", artifact.getType() ) )
            {
                getLog().info( "Importing sigantures from " + artifact.getFile() );
                baseSignatures.add( new FileInputStream( artifact.getFile() ) );
            }
        }
        final InputStream[] baseSignatureInputStreams =
            (InputStream[]) baseSignatures.toArray( new InputStream[baseSignatures.size()] );
        return baseSignatureInputStreams;
    }

    /**
     * Gets the <code>jdk</code> toolchain to use.
     *
     * @return the <code>jdk</code> toolchain to use or <code>null</code> if no toolchain is configured or if no toolchain can be found.
     * @throws MojoExecutionException if toolchains are misconfigured.
     */
    private Toolchain getJdkToolchain()
        throws MojoExecutionException
    {
        Toolchain tc = getJdkToolchainFromConfiguration();
        if ( tc == null )
        {
            tc = getJdkToolchainFromContext();
        }
        return tc;
    }

    /**
     * Gets the toolchain specified for the current context, e.g. specified via the maven-toolchain-plugin
     *
     * @return the toolchain from the context or <code>null</code> if there is no such toolchain.
     */
    private Toolchain getJdkToolchainFromContext()
    {
        if ( toolchainManager != null )
        {
            return toolchainManager.getToolchainFromBuildContext( "jdk", //NOI18N
                                                                  session );
        }
        return null;
    }

    /**
     * Gets the <code>jdk</code> toolchain from this plugin's configuration.
     *
     * @return the toolchain from this plugin's configuration, or <code>null</code> if no matching toolchain can be
     *         found.
     * @throws MojoExecutionException if the toolchains are configured incorrectly.
     */
    private Toolchain getJdkToolchainFromConfiguration()
        throws MojoExecutionException
    {
        if ( toolchainManager != null && jdk != null && jdk.getParameters() != null )
        {
            try
            {
                final ToolchainPrivate[] tcp = getToolchains( "jdk" );
                for ( int i = 0; i < tcp.length; i++ )
                {
                    if ( tcp[i].getType().equals( "jdk" ) /* MNG-5716 */
                                    && tcp[i].matchesRequirements( jdk.getParameters() ) )
                    {
                        return tcp[i];
                    }
                }
            }
            catch ( MisconfiguredToolchainException e )
            {
                throw new MojoExecutionException( e.getLocalizedMessage(), e );
            }
        }
        return null;
    }

    /*package*/ static String artifactId( Artifact artifact )
    {
        return artifact.getGroupId() + ":" + artifact.getArtifactId() + ":" + artifact.getType()
                + ( artifact.getClassifier() != null ? ":" + artifact.getClassifier() : "" ) + ":"
                + artifact.getBaseVersion();

    }

    private ToolchainPrivate[] getToolchains( String type )
        throws MojoExecutionException, MisconfiguredToolchainException
    {
        // The toolchain API has moved about quite a bit... this method tries to navigate through to a
        // successful enumeration of all the toolchains of the required type.
        // This method is only ever called in versions of Maven that have toolchain support.

        Class<?> managerClass = toolchainManagerPrivate.getClass();
        try
        {
            try
            {
                // try 3.x style API
                Method newMethod =
                    managerClass.getMethod( "getToolchainsForType", new Class[]{ String.class, MavenSession.class } );

                return (ToolchainPrivate[]) newMethod.invoke( toolchainManagerPrivate, new Object[]{ type, session } );
            }
            catch ( NoSuchMethodException e1 )
            {
                try
                {
                    // try 2.2.1 style API
                    Method oldMethod = managerClass.getMethod( "getToolchainsForType", new Class[]{ String.class } );

                    return (ToolchainPrivate[]) oldMethod.invoke( toolchainManagerPrivate, new Object[]{ type } );
                }
                catch ( NoSuchMethodException e2 )
                {
                    e2.initCause( e1 );
                    throw e2;
                }
            }
        }
        catch ( NoSuchMethodException e )
        {
            StringBuilder buf = new StringBuilder( "Incompatible toolchain API." );
            buf.append( "\n\nCannot find a suitable 'getToolchainsForType' method. Available methods are:\n" );

            Method[] methods = managerClass.getMethods();
            for ( int i = 0; i < methods.length; i++ )
            {
                buf.append( "  " ).append( methods[i] ).append( '\n' );
            }
            throw new MojoExecutionException( buf.toString(), e );
        }
        catch ( IllegalAccessException e )
        {
            throw new MojoExecutionException( "Incompatible toolchain API", e );
        }
        catch ( InvocationTargetException e )
        {
            Throwable cause = e.getCause();

            if ( cause instanceof RuntimeException )
            {
                throw (RuntimeException) cause;
            }
            if ( cause instanceof MisconfiguredToolchainException )
            {
                throw (MisconfiguredToolchainException) cause;
            }

            throw new MojoExecutionException( "Incompatible toolchain API", e );
        }
    }

    private static File getTargetFile( File basedir, String finalName, String classifier, String type )
    {
        if ( classifier == null )
        {
            classifier = "";
        }
        else if ( classifier.trim().length() > 0 && !classifier.startsWith( "-" ) )
        {
            classifier = "-" + classifier;
        }

        return new File( basedir, finalName + classifier + "." + type );
    }

}
