/*
    * 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.issue.util;
  
  import org.apache.maven.artifact.versioning.ArtifactVersion;
  import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
  import org.apache.maven.project.MavenProject;
  
  import de.smartics.util.lang.Arg;
  
  /**
   * Utility class to handle versions.
   */
  public final class VersionHelper
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * Signals to increment the major version number, setting minor and micro to
     * zero.
     * <p>
     * The value of this constant is {@value}.
     * </p>
     */
    public static final String MAJOR = "MAJOR";
  
    /**
     * Signals to increment the minor version number, setting micro to zero.
     * <p>
     * The value of this constant is {@value}.
     * </p>
     */
    public static final String MINOR = "MINOR";
  
    /**
     * Signals to increment the micro version number.
     * <p>
     * The value of this constant is {@value}.
     * </p>
     */
    public static final String MICRO = "MICRO";
  
    /**
     * Signals to use the current version (without SNAPSHOT).
     * <p>
     * The value of this constant is {@value}.
     * </p>
     */
    public static final String CURRENT = "CURRENT";
  
    /**
     * Signals to use the current version (inclusive if present SNAPSHOT).
     * <p>
     * The value of this constant is {@value}.
     * </p>
     */
    public static final String SNAPSHOT = "SNAPSHOT";
  
    // --- members --------------------------------------------------------------
  
    /**
     * The project's version.
     */
    private final String projectVersion;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Convenience constructor.
     *
     * @param project the Maven project.
     */
    public VersionHelper(final MavenProject project)
    {
      this(project.getVersion());
    }
  
    /**
     * Default constructor.
     *
     * @param projectVersion the project's version.
     * @throws NullPointerException if {@code projectVersion} is {@code null}.
    * @throws IllegalArgumentException if {@code projectVersion} is blank.
    */
   public VersionHelper(final String projectVersion)
     throws NullPointerException, IllegalArgumentException
   {
     this.projectVersion = Arg.checkNotBlank("projectVersion", projectVersion);
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * Calculates the previous version.
    *
    * @param version the version to analyze.
    * @return the version if it is neither {@link #MAJOR}, {@link #MINOR}, or
    *         {@link #MICRO}.
    * @throws IllegalArgumentException if the version cannot be decremented.
    */
   public String calculatePreviousVersion(final String version)
     throws IllegalArgumentException
   {
     final String strippedVersion =
         getVersionStrippedFromSnapshotSuffix(projectVersion);
     final String previousVersion;
     if (MAJOR.equals(version))
     {
       previousVersion = calcPreviousMajor(strippedVersion);
     }
     else if (MINOR.equals(version))
     {
       previousVersion = calcPreviousMinor(strippedVersion);
     }
     else if (MICRO.equals(version))
     {
       previousVersion = calcPreviousMicro(strippedVersion);
     }
     else
     {
       previousVersion = version;
     }
 
     return previousVersion;
   }
 
   private String calcPreviousMajor(final String strippedVersion)
   {
     final String nextVersion;
     final ArtifactVersion artifactVersion =
         createArtifactVersion(strippedVersion);
     if (artifactVersion == null)
     {
       throw new IllegalArgumentException("Cannot major decrement '"
                                          + projectVersion + '.');
     }
 
     final int currentVersion = artifactVersion.getMajorVersion();
     if (currentVersion == 0)
     {
       throw new IllegalArgumentException("Cannot major decrement '"
                                          + projectVersion + '.');
     }
 
     final int minorVersion = artifactVersion.getMinorVersion();
     final int microVersion = artifactVersion.getIncrementalVersion();
     if (minorVersion == 0 && microVersion == 0)
     {
       final int previous = currentVersion - 1;
       nextVersion = previous + ".0.0"; // NOPMD
     }
     else
     {
       nextVersion = currentVersion + ".0.0";
     }
     return nextVersion;
   }
 
   private String calcPreviousMinor(final String strippedVersion)
     throws IllegalArgumentException
   {
     final String previousVersion;
     final ArtifactVersion artifactVersion =
         createArtifactVersion(strippedVersion);
     if (artifactVersion == null)
     {
       throw new IllegalArgumentException("Cannot minor decrement '"
                                          + projectVersion + '.');
     }
 
     final int currentVersion = artifactVersion.getMinorVersion();
     if (currentVersion == 0)
     {
       final int currentIncrement = artifactVersion.getIncrementalVersion();
 
       if (currentIncrement == 0)
       {
         throw new IllegalArgumentException("Cannot minor decrement '"
                                            + projectVersion + '.');
       }
 
       final int previous = currentIncrement - 1;
       previousVersion = artifactVersion.getMajorVersion() + ".0." + previous;
     }
     else
     {
       final int previous = currentVersion - 1;
       previousVersion =
           String.valueOf(artifactVersion.getMajorVersion()) + '.' + previous
               + ".0";
     }
     return previousVersion;
   }
 
   private String calcPreviousMicro(final String strippedVersion)
     throws IllegalArgumentException
   {
     final String previousVersion;
     final ArtifactVersion artifactVersion =
         createArtifactVersion(strippedVersion);
     if (artifactVersion == null)
     {
       throw new IllegalArgumentException("Cannot micro decrement '"
                                          + projectVersion + '.');
     }
 
     final int currentVersion = artifactVersion.getIncrementalVersion();
     if (currentVersion == 0)
     {
       throw new IllegalArgumentException("Cannot micro decrement '"
                                          + projectVersion + '.');
     }
 
     final int previous = currentVersion - 1;
     previousVersion =
         String.valueOf(artifactVersion.getMajorVersion()) + '.'
             + artifactVersion.getMinorVersion() + '.' + previous;
     return previousVersion;
   }
 
   /**
    * Calculates the next version.
    *
    * @param version the version to analyze.
    * @return the version if it is neither {@link #SNAPSHOT}, {@link #CURRENT},
    *         {@link #MAJOR}, {@link #MINOR}, or {@link #MICRO}.
    */
   public String calculateNextVersion(final String version)
   {
     final String nextVersion;
     if (MAJOR.equals(version))
     {
       nextVersion = calcNextMajor();
     }
     else if (MINOR.equals(version))
     {
       nextVersion = calcNextMinor();
     }
     else if (MICRO.equals(version))
     {
       nextVersion = calcNextMicro();
     }
     else if (CURRENT.equals(version))
     {
       nextVersion = getVersionStrippedFromSnapshotSuffix(projectVersion);
     }
     else if (SNAPSHOT.equals(version))
     {
       nextVersion = projectVersion;
     }
     else
     {
       nextVersion = version;
     }
 
     return nextVersion;
   }
 
   /**
    * Returns the given version without the <code>-SNAPSHOT</code> suffix.
    *
    * @param version the version to strip.
    * @return the stripped version or (if no suffix was present) the
    *         {@code version}.
    */
   public static String getVersionStrippedFromSnapshotSuffix(final String version)
   {
     if (version.endsWith("-SNAPSHOT"))
     {
       return version.substring(0, version.length() - 9);
     }
     return version;
   }
 
   private String calcNextMajor()
   {
     final String nextVersion;
     final ArtifactVersion artifactVersion = createArtifactVersion();
     if (artifactVersion == null)
     {
       return null;
     }
     final int next = artifactVersion.getMajorVersion() + 1;
     nextVersion = next + ".0.0";
     return nextVersion;
   }
 
   private String calcNextMinor()
   {
     final String nextVersion;
     final ArtifactVersion artifactVersion = createArtifactVersion();
     if (artifactVersion == null)
     {
       return null;
     }
     final int next = artifactVersion.getMinorVersion() + 1;
     nextVersion =
         String.valueOf(artifactVersion.getMajorVersion()) + '.' + next + ".0";
     return nextVersion;
   }
 
   private String calcNextMicro()
   {
     final String nextVersion;
     final ArtifactVersion artifactVersion = createArtifactVersion();
     if (artifactVersion == null)
     {
       return null;
     }
     final int next = artifactVersion.getIncrementalVersion() + 1;
     nextVersion =
         String.valueOf(artifactVersion.getMajorVersion()) + '.'
             + artifactVersion.getMinorVersion() + '.' + next;
     return nextVersion;
   }
 
   private ArtifactVersion createArtifactVersion()
   {
     return createArtifactVersion(projectVersion);
   }
 
   private ArtifactVersion createArtifactVersion(final String version)
   {
     final ArtifactVersion artifactVersion = new DefaultArtifactVersion(version);
     if (notRecognized(artifactVersion))
     {
       return null;
     }
     return artifactVersion;
   }
 
   private static boolean notRecognized(final ArtifactVersion artifactVersion)
   {
     return (artifactVersion.getMajorVersion() == 0
             && artifactVersion.getMinorVersion() == 0 && artifactVersion
         .getIncrementalVersion() == 0);
   }
 
   // --- object basics --------------------------------------------------------
 
 }