package org.apache.maven.plugin.patch;

/*
 * 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.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.cli.CommandLineException;
import org.codehaus.plexus.util.cli.CommandLineUtils;
import org.codehaus.plexus.util.cli.Commandline;
import org.codehaus.plexus.util.cli.StreamConsumer;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

/**
 * Apply one or more patches to project sources.
 */
@Mojo( name = "apply", defaultPhase = LifecyclePhase.PROCESS_SOURCES )
public class ApplyMojo
    extends AbstractMojo
{

    public static final List PATCH_FAILURE_WATCH_PHRASES;

    public static final List DEFAULT_IGNORED_PATCHES;

    public static final List DEFAULT_IGNORED_PATCH_PATTERNS;

    static
    {
        List watches = new ArrayList();

        watches.add( "fail" );
        watches.add( "skip" );
        watches.add( "reject" );

        PATCH_FAILURE_WATCH_PHRASES = watches;

        List ignored = new ArrayList();

        ignored.add( ".svn" );
        ignored.add( "CVS" );

        DEFAULT_IGNORED_PATCHES = ignored;

        List ignoredPatterns = new ArrayList();

        ignoredPatterns.add( ".svn/**" );
        ignoredPatterns.add( "CVS/**" );

        DEFAULT_IGNORED_PATCH_PATTERNS = ignoredPatterns;
    }

    /**
     * Whether to exclude default ignored patch items, such as <code>.svn</code> or <code>CVS</code> directories.
     */
    @Parameter( defaultValue = "true" )
    private boolean useDefaultIgnores;

    /**
     * The list of patch file names, supplying the order in which patches should be applied. The path names in this list
     * must be relative to the base directory specified by the parameter <code>patchDirectory</code>. This parameter
     * is mutually exclusive with the <code>patchfile</code> parameter.
     */
    @Parameter
    protected List patches;

    /**
     * Whether to skip this goal's execution.
     */
    @Parameter( alias = "patch.apply.skip", defaultValue = "false" )
    private boolean skipApplication;

    /**
     * Flag to enable/disable optimization file from being written. This file tracks the patches that were applied the
     * last time this goal actually executed. It is required for cases where project-sources optimizations are enabled,
     * since project-sources will not be re-unpacked if they are at least as fresh as the source archive. If we avoid
     * re-unpacking project sources, we need to make sure we don't reapply patches.<br/> <strong>Note:</strong> If the
     * list of patches changes and this flag is enabled, a "<code>mvn clean</code>" must be executed before the next
     * build, to remove the tracking file.
     */
    @Parameter( defaultValue = "true" )
    private boolean optimizations;

    /**
     * This is the tracking file used to maintain a list of the patches applied to the unpacked project sources which
     * are currently in the target directory. If this file is present, and project-source unpacking is optimized
     * (meaning it won't re-unpack unless the project-sources archive is newer), this goal will not execute and no
     * patches will be applied in the current build.
     */
    @Parameter( defaultValue = "${project.build.directory}/optimization-files/patches-applied.txt" )
    private File patchTrackingFile;

    /**
     * The target directory for applying patches. Files in this directory will be modified.
     */
    @Parameter( alias = "patchTargetDir", defaultValue = "${project.build.sourceDirectory}" )
    private File targetDirectory;

    /**
     * Flag being <code>true</code> if the desired behavior is to fail the build on the first failed patch detected.
     */
    @Parameter( defaultValue = "true" )
    private boolean failFast;

    /**
     * Setting natural order processing to <code>true</code> will cause all patches in a directory to be processed in
     * a natural order alleviating the need to declare patches directly in the project file.
     */
    @Parameter( defaultValue = "false" )
    private boolean naturalOrderProcessing;

    /**
     * When the <code>strictPatching</code> flag is set, this parameter is useful to mark certain contents of the
     * patch-source directory that should be ignored without causing the build to fail.
     */
    @Parameter
    private List ignoredPatches;

    /**
     * Flag that, when set to <code>true</code>, will make sure that all patches included in the <code>patches</code>
     * list must be present and describe the full contents of the patch directory. If <code>strictPatching</code> is
     * set to <code>true</code>, and the <code>patches</code> list has a value that does not correspond to a file
     * in the patch directory, the build will fail. If <code>strictPatching</code> is set to <code>true</code>, and
     * the patch directory contains files not listed in the <code>patches</code> parameter, the build will fail. If
     * set to <code>false</code>, only the patches listed in the <code>patches</code> parameter that have
     * corresponding files will be applied; the rest will be ignored.
     */
    @Parameter( defaultValue = "false" )
    private boolean strictPatching;

    /**
     * The number of directories to be stripped from patch file paths, before applying, starting from the leftmost, or
     * root-est.
     */
    @Parameter( defaultValue = "0" )
    private int strip;

    /**
     * Whether to ignore whitespaces when applying the patches.
     */
    @Parameter( defaultValue = "true" )
    private boolean ignoreWhitespace;

    /**
     * Whether to treat these patches as having reversed source and dest in the patch syntax.
     */
    @Parameter( defaultValue = "false" )
    private boolean reverse;

    /**
     * Whether to make backups of the original files before modding them.
     */
    @Parameter( defaultValue = "false" )
    private boolean backups;

    /**
     * List of phrases to watch for in the command output from the patch tool. If one is found, it will cause the build
     * to fail. All phrases should be lower-case <em>only</em>. By default, the phrases <code>fail</code>,
     * <code>skip</code> and <code>reject</code> are used.
     */
    @Parameter
    private List failurePhrases = PATCH_FAILURE_WATCH_PHRASES;

    /**
     * The original file which will be modified by the patch. By default, the patch tool will automatically derive the
     * original file from the header of the patch file.
     */
    @Parameter
    private File originalFile;

    /**
     * The output file which is the original file, plus modifications from the patch. By default, the file(s) will be
     * patched inplace.
     */
    @Parameter
    private File destFile;

    /**
     * The single patch file to apply. This parameter is mutually exclusive with the <code>patches</code> parameter.
     */
    @Parameter
    private File patchFile;

    /**
     * The base directory for the file names specified by the parameter <code>patches</code>.
     */
    @Parameter( defaultValue = "src/main/patches" )
    private File patchDirectory;

    /**
     * When set to <code>true</code>, the empty files resulting from the patching process are removed. Empty ancestor
     * directories are removed as well.
     *
     * @since 1.1
     */
    @Parameter( defaultValue = "false" )
    private boolean removeEmptyFiles;

    /**
     * apply --binary option to patch command line
     * @since 1.2
     */
    @Parameter( defaultValue = "false" )
    private boolean binary;

    /**
     * Apply the patches. Give preference to patchFile over patchSourceDir/patches, and preference to originalFile over
     * workDir.
     */
    public void execute()
        throws MojoExecutionException, MojoFailureException
    {
        boolean patchDirEnabled = ( ( patches != null ) && !patches.isEmpty() ) || naturalOrderProcessing;
        boolean patchFileEnabled = patchFile != null;

        // if patches is null or empty, and naturalOrderProcessing is not true then disable patching
        if ( !patchFileEnabled && !patchDirEnabled )
        {
            getLog().info( "Patching is disabled for this project." );
            return;
        }

        if ( skipApplication )
        {
            getLog().info( "Skipping patch file application (per configuration)." );
            return;
        }

        patchTrackingFile.getParentFile().mkdirs();

        Map patchesToApply;

        try
        {
            if ( patchFileEnabled )
            {
                patchesToApply = Collections.singletonMap( patchFile.getName(), createPatchCommand( patchFile ) );
            }
            else
            {
                if ( !patchDirectory.isDirectory() )
                {
                    throw new FileNotFoundException( "The base directory for patch files does not exist: "
                        + patchDirectory );
                }

                List foundPatchFiles = FileUtils.getFileNames( patchDirectory, "*", null, false );

                patchesToApply = findPatchesToApply( foundPatchFiles, patchDirectory );

                checkStrictPatchCompliance( foundPatchFiles );
            }

            String output = applyPatches( patchesToApply );

            checkForWatchPhrases( output );

            writeTrackingFile( patchesToApply );
        }
        catch ( IOException ioe )
        {
            throw new MojoExecutionException( "Unable to obtain list of patch files", ioe );
        }
    }

    private Map findPatchesToApply( List foundPatchFiles, File patchSourceDir )
        throws MojoFailureException
    {
        Map patchesApplied = new LinkedHashMap();

        if ( naturalOrderProcessing )
        {
            patches = new ArrayList( foundPatchFiles );
            Collections.sort( patches );
        }

        String alreadyAppliedPatches = "";

        try
        {
            if ( optimizations && patchTrackingFile.exists() )
            {
                alreadyAppliedPatches = FileUtils.fileRead( patchTrackingFile );
            }
        }
        catch ( IOException ioe )
        {
            throw new MojoFailureException( "unable to read patch tracking file: " + ioe.getMessage() );
        }

        for (Object patche : patches) {
            String patch = (String) patche;

            if (!alreadyAppliedPatches.contains(patch)) {
                File patchFile = new File(patchSourceDir, patch);

                getLog().debug("Looking for patch: " + patch + " in: " + patchFile);

                if (!patchFile.exists()) {
                    if (strictPatching) {
                        throw new MojoFailureException(this, "Patch operation cannot proceed.",
                                "Cannot find specified patch: \'" + patch
                                        + "\' in patch-source directory: \'" + patchSourceDir
                                        + "\'.\n\nEither fix this error, "
                                        + "or relax strictPatching.");
                    } else {
                        getLog().info(
                                "Skipping patch: " + patch + " listed in the parameter \"patches\"; "
                                        + "it is missing.");
                    }
                } else {
                    foundPatchFiles.remove(patch);

                    patchesApplied.put(patch, createPatchCommand(patchFile));
                }
            }
        }

        return patchesApplied;
    }

    private void checkStrictPatchCompliance( List foundPatchFiles )
        throws MojoExecutionException
    {
        if ( strictPatching )
        {
            List ignored = new ArrayList();

            if ( ignoredPatches != null )
            {
                ignored.addAll( ignoredPatches );
            }

            if ( useDefaultIgnores )
            {
                ignored.addAll( DEFAULT_IGNORED_PATCHES );
            }

            List limbo = new ArrayList( foundPatchFiles );

            for (Object anIgnored : ignored) {
                String ignoredFile = (String) anIgnored;

                limbo.remove(ignoredFile);
            }

            if ( !limbo.isEmpty() )
            {
                StringBuilder extraFileBuffer = new StringBuilder();

                extraFileBuffer.append("Found ").append(limbo.size()).append(" unlisted patch files:");

                for (Object foundPatchFile : foundPatchFiles) {
                    String patch = (String) foundPatchFile;

                    extraFileBuffer.append("\n  \'").append(patch).append('\'');
                }

                extraFileBuffer.append( "\n\nEither remove these files, "
                    + "add them to the patches configuration list, " + "or relax strictPatching." );

                throw new MojoExecutionException( extraFileBuffer.toString() );
            }
        }
    }

    private String applyPatches( Map patchesApplied )
        throws MojoExecutionException
    {
        final StringWriter outputWriter = new StringWriter();

        StreamConsumer consumer = new StreamConsumer()
        {
            public void consumeLine( String line )
            {
                if ( getLog().isDebugEnabled() )
                {
                    getLog().debug( line );
                }

                outputWriter.write( line + "\n" );
            }
        };

        // used if failFast is false
        List failedPatches = new ArrayList();

        for (Object o : patchesApplied.entrySet()) {
            Entry entry = (Entry) o;
            String patchName = (String) entry.getKey();
            Commandline cli = (Commandline) entry.getValue();

            try {
                getLog().info("Applying patch: " + patchName);

                int result = executeCommandLine(cli, consumer, consumer);

                if (result != 0) {
                    if (failFast) {
                        throw new MojoExecutionException("Patch command failed with exit code " + result + " for "
                                + patchName + ". Please see console and debug output for more information.");
                    } else {
                        failedPatches.add(patchName);
                    }
                }
            } catch (CommandLineException e) {
                throw new MojoExecutionException("Failed to apply patch: " + patchName
                        + ". See debug output for more information.", e);
            }
        }

        if ( !failedPatches.isEmpty() )
        {
            getLog().error( "Failed applying one or more patches:" );
            for (Object failedPatche : failedPatches) {
                getLog().error("* " + failedPatche);
            }
            throw new MojoExecutionException( "Patch command failed for one or more patches."
                + " Please see console and debug output for more information." );
        }

        return outputWriter.toString();
    }

    private int executeCommandLine( Commandline cli, StreamConsumer out, StreamConsumer err )
        throws CommandLineException
    {
        if ( getLog().isDebugEnabled() )
        {
            getLog().debug( "Executing: " + cli );
        }

        int result = CommandLineUtils.executeCommandLine( cli, out, err );

        if ( getLog().isDebugEnabled() )
        {
            getLog().debug( "Exit code: " + result );
        }

        return result;
    }

    private void writeTrackingFile( Map patchesApplied )
        throws MojoExecutionException
    {
        FileWriter writer = null;
        try
        {
            boolean appending = patchTrackingFile.exists();

            writer = new FileWriter( patchTrackingFile, appending );

            for ( Iterator it = patchesApplied.keySet().iterator(); it.hasNext(); )
            {
                if ( appending )
                {
                    writer.write( System.getProperty( "line.separator" ) );
                }

                String patch = (String) it.next();
                writer.write( patch );

                if ( it.hasNext() )
                {
                    writer.write( System.getProperty( "line.separator" ) );
                }
            }

            writer.flush();
        }
        catch ( IOException e )
        {
            throw new MojoExecutionException( "Failed to write patch-tracking file: " + patchTrackingFile, e );
        }
        finally
        {
            IOUtil.close( writer );
        }
    }

    private void checkForWatchPhrases( String output )
        throws MojoExecutionException
    {
        for (Object failurePhrase : failurePhrases) {
            String phrase = (String) failurePhrase;

            if (output.contains(phrase)) {
                throw new MojoExecutionException("Failed to apply patches (detected watch-phrase: \'" + phrase
                        + "\' in output). " + "If this is in error, configure the patchFailureWatchPhrases parameter.");
            }
        }
    }

    /**
     * Add a new Patch task to the Ant calling mechanism. Give preference to originalFile/destFile, then workDir, and
     * finally ${basedir}.
     */
    private Commandline createPatchCommand( File patchFile )
    {
        Commandline cli = new Commandline();

        cli.setExecutable( "patch" );

        cli.setWorkingDirectory( targetDirectory.getAbsolutePath() );

        cli.createArg().setValue( "-p" + strip );

        if ( binary )
        {
            cli.createArg().setValue( "--binary" );
        }

        if ( ignoreWhitespace )
        {
            cli.createArg().setValue( "-l" );
        }

        if ( reverse )
        {
            cli.createArg().setValue( "-R" );
        }

        if ( backups )
        {
            cli.createArg().setValue( "-b" );
        }

        if ( removeEmptyFiles )
        {
            cli.createArg().setValue( "-E" );
        }

        cli.createArg().setValue( "-i" );
        cli.createArg().setFile( patchFile );

        if ( destFile != null )
        {
            cli.createArg().setValue( "-o" );
            cli.createArg().setFile( destFile );
        }

        if ( originalFile != null )
        {
            cli.createArg().setFile( originalFile );
        }

        return cli;
    }

}