package org.apache.maven.plugins.patchtracker;

 /*

  * 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.commons.lang.StringUtils;

 import org.apache.maven.plugin.AbstractMojo;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugins.patchtracker.patching.PatchRepository;

 import org.apache.maven.plugins.patchtracker.tracking.PatchTracker;

 import org.apache.maven.plugins.patchtracker.tracking.PatchTrackerRequest;

 import org.apache.maven.project.MavenProject;

 import org.apache.maven.scm.ScmException;

 import org.apache.maven.scm.ScmFileSet;

 import org.apache.maven.scm.command.diff.DiffScmResult;

 import org.apache.maven.scm.manager.NoSuchScmProviderException;

 import org.apache.maven.scm.manager.ScmManager;

 import org.apache.maven.scm.provider.ScmProvider;

 import org.apache.maven.scm.repository.ScmRepository;

 import org.apache.maven.scm.repository.ScmRepositoryException;

 import org.apache.maven.settings.Server;

 import org.apache.maven.settings.Settings;

 import org.codehaus.plexus.PlexusConstants;

 import org.codehaus.plexus.PlexusContainer;

 import org.codehaus.plexus.component.repository.exception.ComponentLookupException;

 import org.codehaus.plexus.components.interactivity.Prompter;

 import org.codehaus.plexus.components.interactivity.PrompterException;

 import org.codehaus.plexus.context.Context;

 import org.codehaus.plexus.context.ContextException;

 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Contextualizable;

 import java.io.File;

 import java.util.Arrays;

 import java.util.Collections;

 import java.util.List;

 /**

  * @author Olivier Lamy

  */

 public abstract class AbstractPatchMojo

     extends AbstractMojo

     implements Contextualizable

 {

     /**

      * The Maven Project Object.

      *

      * @parameter default-value="${project}"

      * @required

      * @readonly

      */

     protected MavenProject project;

     /**

      * @parameter default-value="${basedir}"

      * @required

      * @readonly

      */

     protected File baseDir;

     /**

      * @parameter expression="${scm.providerType}" default-value=""

      */

     protected String providerType = "";

     /**

      * @parameter default-value="${settings}"

      * @required

      * @readonly

      */

     protected Settings settings;

     /**

      * if user/password are stored in your settings.xml in a server

      *

      * @parameter expression="${patch.serverId}" default-value=""

      */

     protected String serverId;

     /**

      * if path tracker url is not stored in the pom.

      * <b>For jira, url must include project key!: http://jira.codehaus.org/browse/MNG</b>

      *

      * @parameter expression="${patch.serverUrl}" default-value=""

      */

     protected String serverUrl;

     /**

      * @parameter expression="${patch.user}" default-value=""

      */

     protected String user;

     /**

      * @parameter expression="${patch.password}" default-value=""

      */

     protected String password;

     /**

      * @parameter expression="${patch.issueSystem}" default-value=""

      */

     protected String issueSystem;

     /**

      * @parameter expression="${patch.patchSystem}" default-value="${project.patchManagement.system}"

      */

     protected String patchSystem;

     /**

      * @parameter expression="${patch.summary}" default-value=""

      */

     protected String summary;

     /**

      * @parameter expression="${patch.description}" default-value=""

      */

     protected String description;

     /**

      * the type of the patch tracker entry to load: default 1 for jira bug

      *

      * @parameter expression="${patch.patchType}" default-value="1"

      */

     protected String patchType;

     /**

      * the priority of the patch tracker entry to load: default 3 for jira major

      *

      * @parameter expression="${patch.priority}" default-value="3"

      */

     protected String patchPriority;

     /**

      * Component used to prompt for input.

      *

      * @component

      */

     protected Prompter prompter;

     protected PlexusContainer plexusContainer;

     /**

      * @component

      */

     protected ScmManager scmManager;

     protected String getPatchContent()

         throws MojoExecutionException

     {

         try

         {

             ScmRepository scmRepository = scmManager.makeScmRepository( project.getScm().getConnection() );

             ScmProvider provider = scmManager.getProviderByType( scmRepository.getProvider() );

             getLog().debug( "scm.providerType:" + providerType );

             if ( StringUtils.isNotEmpty( providerType ) )

             {

                 provider = scmManager.getProviderByType( providerType );

             }

             DiffScmResult diffScmResult = provider.diff( scmRepository, new ScmFileSet( baseDir ), "", "" );

             getLog().debug( diffScmResult.getPatch() );

             return diffScmResult.getPatch();

         }

         catch ( ScmRepositoryException e )

         {

             throw new MojoExecutionException( e.getMessage(), e );

         }

         catch ( NoSuchScmProviderException e )

         {

             throw new MojoExecutionException( e.getMessage(), e );

         }

         catch ( ScmException e )

         {

             throw new MojoExecutionException( e.getMessage(), e );

         }

     }

     protected PatchTrackerRequest buidPatchTrackerRequest( boolean creation )

         throws MojoExecutionException

     {

         try

         {

             PatchTrackerRequest patchTrackerRequest =

                 new PatchTrackerRequest().setUrl( getPatchTrackerUrl() ).setUserName(

                     getPatchTrackerUsername() ).setPassword( getPatchTrackerPassword() ).setPatchType(

                     patchType ).setPatchPriority( patchPriority );

             return creation ? patchTrackerRequest.setSummary( getPatchTrackerSummary() ).setDescription(

                 getPatchTrackerDescription() ) : patchTrackerRequest;

         }

         catch ( PrompterException e )

         {

             throw new MojoExecutionException( e.getMessage(), e );

         }

     }

     protected String getPatchTrackerUrl()

         throws PrompterException, MojoExecutionException

     {

         String value = project.getIssueManagement() == null ? "" : project.getIssueManagement().getUrl();

         // cli must win !

         if ( StringUtils.isNotEmpty( serverUrl ) )

         {

             value = serverUrl;

         }

         return getValue( value, "path tracker url ? (http://jira.codehaus.org/browse/MNG)", null, true,

                          "you must configure a patch system or at least use interactive mode", value, false );

     }

     protected String getPatchTrackerSummary()

         throws PrompterException, MojoExecutionException

     {

         String value = summary;

         return getValue( value, "patch summary ? (wonderfull patch to fix ....) ", Collections.<String>emptyList(),

                          true, "you must configure a patch summary or at least use interactive mode", null, false );

     }

     protected String getPatchTrackerDescription()

         throws PrompterException, MojoExecutionException

     {

         String value = description;

         return getValue( value, "patch description ?(this patch fix this very annoying issue ....) ", null, false,

                          "you must configure a patch summary or at least use interactive mode", null, false );

     }

     protected String getServerId()

     {

         String serverIdFromPom = (String) project.getProperties().get( "patch.tracker.serverId" );

         if ( StringUtils.isNotEmpty( serverIdFromPom ) )

         {

             return serverIdFromPom;

         }

         return serverId;

     }

     protected String getPatchTrackerUsername()

         throws PrompterException, MojoExecutionException

     {

         String value = null;

         if ( StringUtils.isNotEmpty( getServerId() ) )

         {

             Server server = getServer( getServerId() );

             if ( server == null )

             {

                 getLog().warn( "no server found in your settings.xml with id:" + getServerId() );

             }

             else

             {

                 value = server.getUsername();

             }

         }

         // cli must win !

         if ( StringUtils.isNotEmpty( user ) )

         {

             value = user;

         }

         return getValue( value, "patch tracker username ?", null, true,

                          "you must configure a user for your patch tracker or at least use interactive mode", value,

                          false );

     }

     protected String getPatchTrackerPassword()

         throws PrompterException, MojoExecutionException

     {

         String value = null;

         if ( StringUtils.isNotEmpty( getServerId() ) )

         {

             Server server = getServer( getServerId() );

             if ( server == null )

             {

                 getLog().warn( "no server found in your settings.xml with id:" + getServerId() );

             }

             else

             {

                 value = server.getPassword();

             }

         }

         // cli must win !

         if ( StringUtils.isNotEmpty( password ) )

         {

             value = password;

         }

         return getValue( value, "patch tracker password ?", null, true,

                          "you must configure a password for your patch tracker or at least use interactive mode", value,

                          true );

     }

     protected String getPatchTrackerSystem()

         throws MojoExecutionException

     {

         String value = project.getIssueManagement() == null ? "" : project.getIssueManagement().getSystem();

         // cli must win !

         if ( StringUtils.isNotEmpty( issueSystem ) )

         {

             value = issueSystem;

         }

         try

         {

             return getValue( value, "path tracker system id ?", Arrays.asList( "jira" ), true,

                              "you must configure a patch system or at least use interactive mode", "jira", false );

         }

         catch ( PrompterException e )

         {

             throw new MojoExecutionException( e.getMessage(), e );

         }

     }

     protected String getPatchRepositorySystem()

         throws MojoExecutionException

     {

         String value = project.getProperties().getProperty( "project.patchManagement.system" );

         // cli must win !

         if ( StringUtils.isNotEmpty( patchSystem ) )

         {

             value = patchSystem;

         }

         try

         {

             return getValue( value, "path repository system id ?", Arrays.asList( "github" ), true,

                              "you must configure a patch system or at least use interactive mode", "github", false );

         }

         catch ( PrompterException e )

         {

             throw new MojoExecutionException( e.getMessage(), e );

         }

     }

     protected String getValue( String currentValue, String message, List<String> possibleValues, boolean mandatory,

                                String errorMessage, String defaultValue, boolean passwordPrompt )

         throws PrompterException, MojoExecutionException

     {

         boolean loadFromPrompt = false;

         String value = currentValue;

         if ( mandatory && StringUtils.isEmpty( value ) )

         {

             if ( settings.isInteractiveMode() )

             {

                 getLog().debug( "1st prompt message " + message + ", defaultValue " + defaultValue + ", possibleValues"

                                     + possibleValues );

                 if ( passwordPrompt )

                 {

                     value = prompter.promptForPassword( message );

                 }

                 else

                 {

                     value = ( possibleValues == null || possibleValues.isEmpty() )

                         ? prompter.prompt( message, defaultValue )

                         : prompter.prompt( message, possibleValues, defaultValue );

                 }

                 loadFromPrompt = StringUtils.isNotBlank( value );

             }

             else

             {

                 getLog().error( errorMessage );

                 throw new MojoExecutionException( errorMessage );

             }

             if ( StringUtils.isEmpty( value ) )

             {

                 getLog().error( errorMessage );

                 throw new MojoExecutionException( errorMessage );

             }

         }

         if ( settings.isInteractiveMode() && !loadFromPrompt )

         {

             getLog().debug( "2nd prompt message " + message + ", defaultValue " + defaultValue + ", possibleValues"

                                 + possibleValues );

             if ( passwordPrompt )

             {

                 value = prompter.promptForPassword( message );

             }

             else

             {

                 value = ( possibleValues == null || possibleValues.isEmpty() ) ? ( StringUtils.isEmpty( defaultValue )

                     ? prompter.prompt( message )

                     : prompter.prompt( message, defaultValue ) )

                     : ( StringUtils.isEmpty( defaultValue )

                         ? prompter.prompt( message, possibleValues )

                         : prompter.prompt( message, possibleValues, defaultValue ) );

             }

             if ( StringUtils.isEmpty( value ) && mandatory )

             {

                 getLog().error( errorMessage );

                 throw new MojoExecutionException( errorMessage );

             }

         }

         return value;

     }

     protected Server getServer( String id )

     {

         if ( StringUtils.isEmpty( id ) )

         {

             return null;

         }

         return settings.getServer( id );

     }

     protected PatchTracker getPatchTracker()

         throws MojoExecutionException, ComponentLookupException

     {

         String system = getPatchTrackerSystem();

         getLog().debug( "patch tracker system:" + system );

         return (PatchTracker) plexusContainer.lookup( PatchTracker.class.getName(), system );

     }

     protected PatchRepository getPatchRepository()

         throws MojoExecutionException, ComponentLookupException

     {

         String system = getPatchRepositorySystem();

         getLog().debug( "patch repository system:" + system );

         return (PatchRepository) plexusContainer.lookup( PatchRepository.class.getName(), system );

     }

     public void contextualize( Context context )

         throws ContextException

     {

         this.plexusContainer = (PlexusContainer) context.get( PlexusConstants.PLEXUS_KEY );

     }

 }