/*
    * Copyright 2012-2013 smartics, Kronseder & Reiner GmbH
    *
    * 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.
   */
  package de.smartics.maven.bugzilla;
  
  import static de.smartics.maven.issue.util.PackagingUtils.mapToExtension;
  
  import org.apache.commons.httpclient.HttpClient;
  import org.apache.maven.model.DeploymentRepository;
  import org.apache.maven.model.DistributionManagement;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.plugin.logging.Log;
  import org.apache.maven.project.MavenProject;
  import org.codehaus.plexus.util.StringUtils;
  
  import de.smartics.maven.issue.command.CommandException;
  import de.smartics.maven.issue.util.LogLevel;
  import de.smartics.maven.issue.util.VersionHelper;
  import de.smartics.maven.nexus.NexusClient;
  import de.smartics.maven.nexus.NexusRequest;
  import de.smartics.maven.nexus.NexusUtils;
  
  /**
   * Used after a release: Updates a product on the issue management server with
   * information from this project and initializes the version information for
   * that project.
   *
   * @goal sync
   * @requiresProject
   * @threadSafe
   * @since 1.0
   * @description Synchronizes the product information after a release according
   *              to best practices.
   */
  public class SyncProductMojo extends UpdateProductMojo
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The released version to add. Also the major, minor and micro increment
     * milestones are added. If for e.g. the released version is
     * <code>1.2.3</code>, this version and the milestones <code>1.2.4</code>,
     * <code>1.3.0</code> and <code>2.0.0</code> are initialized.
     * <p>
     * If the released version cannot be recognized by Maven's standard
     * implementation of a version parser, increment versions will not be added.
     * </p>
     * <p>
     * It is allowed to use the tokens MICRO, MINOR, MAJOR to let the plugin
     * calculate the previous version by the current version in the POM. For
     * instance:
     * </p>
     * <ul>
     * <li>1.2.3-SNAPSHOT MICRO -> 1.2.2</li>
     * <li>1.2.0-SNAPSHOT MINOR -> 1.1.0</li>
     * <li>1.2.1-SNAPSHOT MINOR -> 1.2.0</li>
     * <li>2.0.0-SNAPSHOT MAJOR -> 1.0.0</li>
     * <li>2.0.1-SNAPSHOT MAJOR -> 2.0.0</li>
     * </ul>
     * <p>
     * The following example contexts raise an exception:
     * </p>
     * <ul>
     * <li>1.2.0-SNAPSHOT MICRO -> Failure</li>
     * <li>1.0.0-SNAPSHOT MINOR -> Failure</li>
     * <li>0.0.0-SNAPSHOT MAJOR -> Failure</li>
     * <li>0.1.2-SNAPSHOT MAJOR -> Failure</li>
     * </ul>
     * <p>
     * If the version is not provided, the nexus server will be queried for the
     * released version.
     * </p>
     *
     * @parameter expression="${releasedVersion}" default-value="NEXUS"
     * @since 1.0
     */
    private String releasedVersion;
  
    /**
     * If <code>releasedVersion</code> is set to <code>NEXUS</code> and the
     * default searching for the release repository's HTTP URL ending with
     * <code>/</code> or <code>/nexus</code> would not determine the correct URL,
    * override it here. This value will take precedence.
    *
    * @parameter expression="${nexusServer}"
    * @since 1.0
    */
   private String nexusServer;
 
   /**
    * The extension to use for querying the Nexus server for the latest released
    * version, if <code>releasedVersion</code> is set to <code>NEXUS</code>. Per
    * default the extension will be derived from the POM's packaging information.
    *
    * @parameter
    * @since 1.0
    */
   private String extension;
 
   /**
    * The repository ID to use to query the Nexus server for the latest released
    * version, if <code>releasedVersion</code> is set to <code>NEXUS</code>. Per
    * default the plugin will use the identifier of the release repository found
    * in the <code>distributionManagement</code>. This value overrides the
    * default behavior.
    *
    * @parameter expression="${repositoryId}"
    * @since 1.0
    */
   private String repositoryId;
 
   /**
    * If set to <code>true</code> the Bugzilla product will not be updated.
    * Usually there are no changes to the components, so that skipping is the
    * default.
    *
    * @parameter expression="${skipProductUpdate}" default-value="true"
    * @since 1.0
    */
   private boolean skipProductUpdate;
 
   // ****************************** Initializer *******************************
 
   // ****************************** Constructors ******************************
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * {@inheritDoc}
    */
   @Override
   public final void run() throws MojoExecutionException, MojoFailureException
   {
     if (!skipProductUpdate)
     {
       super.run();
     }
 
     final MavenProject project = getProject();
     final MojoHelperSync helper =
         new MojoHelperSync(project, commandFactory, console);
 
     final String previousVersion = calculatePreviousVersion(project);
     helper.execute(previousVersion);
   }
 
   // --- object basics --------------------------------------------------------
 
   private String calculatePreviousVersion(final MavenProject project)
     throws MojoExecutionException, MojoFailureException
   {
     final Log log = getLog();
     final LogLevel logLevel = new LogLevel(verbose);
 
     final String previousVersion;
     if ("NEXUS".equals(releasedVersion))
     {
       final NexusClient client =
           new NexusClient(new HttpClient(), log, logLevel);
       final NexusRequest request = createNexusRequest(project);
       try
       {
         previousVersion = client.getLatestReleaseVersion(request);
       }
       catch (final CommandException e)
       {
         throw new MojoFailureException(
             "Cannot determine latest release version on Nexus.", e);
       }
     }
     else
     {
       final VersionHelper versionHelper = new VersionHelper(project);
       try
       {
         previousVersion =
             versionHelper.calculatePreviousVersion(releasedVersion);
 
       }
       catch (final IllegalArgumentException e)
       {
         throw new MojoExecutionException("Cannot calculate previous version: "
                                          + e.getMessage(), e);
       }
     }
 
     return previousVersion;
   }
 
   private NexusRequest createNexusRequest(final MavenProject project)
     throws MojoExecutionException
   {
     final DeploymentRepository repository =
         getDeploymentRepository(project.getDistributionManagement());
     final String nexusServerUrl = getNexusServerUrl(repository);
     final String repositoryId = getRepositoryId(repository);
     final String groupId = project.getGroupId();
     final String artifactId = project.getArtifactId();
     final String extension = map(project.getPackaging(), this.extension);
     return new NexusRequest(nexusServerUrl, repositoryId, groupId, artifactId,
         extension);
   }
 
   private static String map(final String packaging, final String extension)
   {
     if (StringUtils.isNotBlank(extension))
     {
       return extension;
     }
     return mapToExtension(packaging);
   }
 
   private static DeploymentRepository getDeploymentRepository(
       final DistributionManagement distributionManagement)
   {
     if (distributionManagement != null)
     {
       final DeploymentRepository repository =
           distributionManagement.getRepository();
       return repository;
     }
     return null;
   }
 
   private String getNexusServerUrl(final DeploymentRepository repository)
     throws MojoExecutionException
   {
     if (StringUtils.isNotBlank(nexusServer))
     {
       return nexusServer;
     }
 
     if (repository != null)
     {
       final String url = repository.getUrl();
 
       if (StringUtils.isBlank(url))
       {
         throw new MojoExecutionException(
             "No valid Nexus server URL can be determined. Neiter deployment"
                 + " repository in the POM specified an URL nor is it specified"
                 + " via nexusServer.");
       }
 
       final String nexusServer = NexusUtils.calcNexusServerUrl(url);
       if (StringUtils.isNotBlank(nexusServer))
       {
         return nexusServer;
       }
     }
 
     throw new MojoExecutionException(
         "No valid Nexus server URL can be determined.  Neither a deployment"
             + " repository specified in the POM nor specified via nexusServer.");
   }
 
   private String getRepositoryId(final DeploymentRepository repository)
     throws MojoExecutionException
   {
     final String id;
 
     if (StringUtils.isNotBlank(repositoryId))
     {
       id = repositoryId;
     }
     else if (repository != null)
     {
       id = repository.getId();
       if (StringUtils.isBlank(id))
       {
         throw new MojoExecutionException(
             "No valid repository ID can be determined. Not found in the"
                 + " release repository's element nor specified via repositoryId.");
       }
     }
     else
     {
       throw new MojoExecutionException(
           "No valid repository ID can be determined. Neither a deployment"
               + " repository specified in the POM nor specified via repositoryId.");
     }
 
     return id;
   }
 
 }