package org.apache.maven.plugins.repository;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.artifact.resolver.ArtifactResolver;
import org.apache.maven.model.License;
import org.apache.maven.model.Model;
import org.apache.maven.model.Scm;
import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
import org.apache.maven.model.io.xpp3.MavenXpp3Writer;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
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.settings.Settings;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.archiver.jar.JarArchiver;
import org.codehaus.plexus.components.interactivity.InputHandler;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.ReaderFactory;
import org.codehaus.plexus.util.WriterFactory;
import org.codehaus.plexus.util.xml.XmlStreamReader;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Collections;
import java.util.List;

/**
 * Packs artifacts already available in a local repository in a bundle for an
 * upload requests. It requires that the artifact has a POM in the local
 * repository. It will check for mandatory elements, asking interactively for
 * missing values. Can be used to generate bundles for third parties artifacts
 * that have been manually added to the local repository.
 *
 * @since 2.1
 */
@Mojo( name = "bundle-pack", requiresProject = false )
public class BundlePackMojo
    extends AbstractMojo
{
    public static final String POM = "pom.xml";

    /**
     * Jar archiver.
     */
    @Component( role = Archiver.class, hint = "jar" )
    protected JarArchiver jarArchiver;

    /**
     * Artifact resolver.
     */
    @Component
    protected ArtifactResolver artifactResolver;

    /**
     * Artifact factory.
     */
    @Component
    protected ArtifactFactory artifactFactory;

    /**
     * Local maven repository.
     */
    @Parameter( defaultValue = "${localRepository}", required = true, readonly = true )
    protected ArtifactRepository localRepository;

    /**
     */
    @Component
    protected InputHandler inputHandler;

    /**
     * Directory where the upload-bundle will be created.
     */
    @Parameter( defaultValue = "${basedir}", readonly = true )
    protected String basedir;

    /**
     * GroupId for the artifact to create an upload bundle for.
     */
    @Parameter( property = "groupId" )
    protected String groupId;

    /**
     * ArtifactId for the artifact to create an upload bundle for.
     */
    @Parameter( property = "artifactId" )
    protected String artifactId;

    /**
     * Version for the artifact to create an upload bundle for.
     */
    @Parameter( property = "version" )
    protected String version;

    /**
     * Viewable URL for SCM connections, in cases where this isn't provided by the POM.
     */
    @Parameter( property = "scmUrl" )
    protected String scmUrl;

    /**
     * Read-only URL for SCM tool connections, in cases where this isn't provided by the POM.
     * <br/>
     * <b>NOTE:</b> This should be a standard maven-scm URL. See the
     * <a href="http://maven.apache.org/scm/scm-url-format.html">format guidelines</a> for more
     * information.
     */
    @Parameter( property = "scmConnection" )
    protected String scmConnection;

    /**
     */
    @Parameter( defaultValue = "${settings}", readonly = true, required = true )
    protected Settings settings;

    /**
     * Disable validations to make sure bundle supports project materialization.
     * <br/>
     * <b>WARNING: This means your project will be MUCH harder to use.</b>
     */
    @Parameter( property = "bundle.disableMaterialization", defaultValue = "false" )
    private boolean disableMaterialization;

    @SuppressWarnings( "unchecked" )
    public void execute()
        throws MojoExecutionException
    {
        readArtifactDataFromUser();

        Artifact artifact = artifactFactory.createProjectArtifact( groupId, artifactId, version );

        try
        {
            artifactResolver.resolve( artifact, Collections.EMPTY_LIST, localRepository );
        }
        catch ( ArtifactResolutionException e )
        {
            throw new MojoExecutionException( "Unable to resolve artifact " + artifact.getId(), e );
        }
        catch ( ArtifactNotFoundException e )
        {
            throw new MojoExecutionException( "Artifact " + artifact.getId() + " not found in local repository", e );
        }

        File pom = artifact.getFile();

        File dir = pom.getParentFile();

        Model model = readPom( pom );

        boolean rewrite = false;
        try
        {

            if ( model.getPackaging() == null )
            {
                model.setPackaging( "jar" );
                rewrite = true;
            }
            if ( model.getName() == null )
            {
                getLog().info( "Project name is missing, please type the project name [" + artifactId + "]:" );
                model.setName( inputHandler.readLine() );
                if ( model.getName() == null )
                {
                    model.setName( artifactId );
                }
                rewrite = true;
            }
            if ( model.getDescription() == null )
            {
                getLog().info( "Project description is missing, please type the project description:" );
                model.setDescription( inputHandler.readLine() );
                rewrite = true;
            }
            if ( model.getUrl() == null )
            {
                getLog().info( "Project URL is missing, please type the project URL:" );
                model.setUrl( inputHandler.readLine() );
                rewrite = true;
            }

            List<License> licenses = model.getLicenses();
            if ( licenses.isEmpty() )
            {
                License license = new License();

                getLog().info( "License name is missing, please type the license name:" );
                license.setName( inputHandler.readLine() );
                getLog().info( "License URL is missing, please type the license URL:" );
                license.setUrl( inputHandler.readLine() );
                licenses.add( license );
                rewrite = true;
            }

            if ( disableMaterialization )
            {
                getLog().warn( "Validations to confirm support for project materialization have been DISABLED."
                                   + "\n\nYour project may not provide the POM elements necessary to allow "
                                   + "users to retrieve sources on-demand,"
                                   + "\nor to easily checkout your project in an IDE. "
                                   + "THIS CAN SERIOUSLY INCONVENIENCE YOUR USERS.\n\nContinue? [y/N]" );

                try
                {
                    if ( 'y' != inputHandler.readLine()
                                            .toLowerCase()
                                            .charAt( 0 ) )
                    {
                        disableMaterialization = false;
                    }
                }
                catch ( IOException e )
                {
                    getLog().debug( "Error reading confirmation: " + e.getMessage(), e );
                }

            }

            if ( !disableMaterialization )
            {
                Scm scm = model.getScm();
                if ( scm == null )
                {
                    scm = new Scm();
                    model.setScm( scm );
                }

                if ( scm.getUrl() == null )
                {
                    if ( scmUrl != null )
                    {
                        scm.setUrl( scmUrl );
                    }
                    else
                    {
                        getLog().info( "SCM view URL is missing, please type the URL for the viewable SCM interface:" );
                        scm.setUrl( inputHandler.readLine() );
                        rewrite = true;
                    }
                }

                if ( scm.getConnection() == null )
                {
                    if ( scmConnection != null )
                    {
                        scm.setConnection( scmConnection );
                    }
                    else
                    {
                        getLog().info( "SCM read-only connection URL is missing, please type the read-only SCM URL:" );
                        scm.setConnection( inputHandler.readLine() );
                        rewrite = true;
                    }
                }
            }
        }
        catch ( IOException e )
        {
            throw new MojoExecutionException( e.getMessage(), e );
        }

        try
        {
            if ( rewrite )
            {
                new MavenXpp3Writer().write( WriterFactory.newXmlWriter( pom ), model );
            }

            String finalName = null;

            if ( model.getBuild() != null )
            {
                finalName = model.getBuild()
                                 .getFinalName();
            }
            if ( finalName == null )
            {
                finalName = model.getArtifactId() + "-" + model.getVersion();
            }

            boolean batchMode = settings == null ? false : !settings.isInteractiveMode();
            List<File> files = BundleUtils.selectProjectFiles( dir, inputHandler, finalName, pom, getLog(), batchMode );

            File bundle = new File( basedir, finalName + "-bundle.jar" );

            jarArchiver.addFile( pom, POM );

            boolean artifactChecks = !"pom".equals( model.getPackaging() );
            boolean sourcesFound = false;
            boolean javadocsFound = false;

            for ( File f : files )
            {
                if ( artifactChecks && f.getName()
                                        .endsWith( finalName + "-sources.jar" ) )
                {
                    sourcesFound = true;
                }
                else if ( artifactChecks && f.getName()
                                             .equals( finalName + "-javadoc.jar" ) )
                {
                    javadocsFound = true;
                }

                jarArchiver.addFile( f, f.getName() );
            }

            if ( artifactChecks && !sourcesFound )
            {
                getLog().warn( "Sources not included in upload bundle." );
            }

            if ( artifactChecks && !javadocsFound )
            {
                getLog().warn( "Javadoc not included in upload bundle." );
            }

            jarArchiver.setDestFile( bundle );

            jarArchiver.createArchive();

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

    }

    /**
     * Read groupId, artifactId and version from the user on the command line,
     * if they were not provided as parameters.
     *
     * @throws MojoExecutionException If the values can't be read
     */
    private void readArtifactDataFromUser()
        throws MojoExecutionException
    {
        try
        {
            if ( groupId == null )
            {
                getLog().info( "groupId? " );

                groupId = inputHandler.readLine();

            }

            if ( artifactId == null )
            {
                getLog().info( "artifactId? " );
                artifactId = inputHandler.readLine();
            }

            if ( version == null )
            {
                getLog().info( "version? " );
                version = inputHandler.readLine();
            }
        }
        catch ( IOException e )
        {
            throw new MojoExecutionException( e.getMessage(), e );
        }
    }

    /**
     * Read the POM file.
     *
     * @param pom The file to read
     * @return A Maven Model
     * @throws MojoExecutionException if something goes wrong when reading the file
     */
    private Model readPom( File pom )
        throws MojoExecutionException
    {
        Model model;
        XmlStreamReader reader = null;
        try
        {
            reader = ReaderFactory.newXmlReader( pom );
            model = new MavenXpp3Reader().read( reader );
            reader.close();
            reader = null;
        }
        catch ( XmlPullParserException e )
        {
            throw new MojoExecutionException( "Unable to parse POM at " + pom.getAbsolutePath() + ": " + e.getMessage(),
                                              e );
        }
        catch ( FileNotFoundException e )
        {
            throw new MojoExecutionException( "Unable to read POM at " + pom.getAbsolutePath() + ": " + e.getMessage(),
                                              e );
        }
        catch ( IOException e )
        {
            throw new MojoExecutionException( "Unable to read POM at " + pom.getAbsolutePath() + ": " + e.getMessage(),
                                              e );
        }
        finally
        {
            IOUtil.close( reader );
        }
        return model;
    }

}