/*
    * Copyright 2012 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.ci.maven.mojo;
  
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.io.InputStream;
  import java.net.MalformedURLException;
  import java.net.URL;
  
  import org.apache.commons.io.FileUtils;
  import org.apache.maven.execution.MavenSession;
  import org.apache.maven.model.CiManagement;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.settings.Server;
  import org.apache.maven.settings.Settings;
  import org.codehaus.plexus.util.StringUtils;
  import org.xml.sax.InputSource;
  
  import de.smartics.ci.comm.LogHelper;
  import de.smartics.ci.config.load.HudsonJobConfig;
  import de.smartics.ci.config.load.LocationManager;
  import de.smartics.ci.config.maven.MavenConfig;
  import de.smartics.ci.config.maven.MavenPom;
  import de.smartics.ci.config.maven.MavenSettings;
  import de.smartics.ci.maven.CiServer;
  import de.smartics.ci.maven.Logger;
  
  /**
   * Base implementation for all CI build mojos.
   */
  public abstract class AbstractCiMojo extends AbstractLoggingMojo
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    // ... Mojo infrastructure ..................................................
  
    /**
     * The Maven project.
     *
     * @parameter expression="${project}"
     * @required
     * @readonly
     * @since 1.0
     */
    protected MavenProject project;
  
    /**
     * The user's settings.
     *
     * @parameter expression="${settings}"
     * @required
     * @readonly
     * @since 1.0
     */
    protected Settings settings;
  
    /**
     * The Maven session instance.
     *
     * @parameter expression="${session}"
     * @required
     * @readonly
     */
    protected MavenSession session;
  
    /**
     * The path to the project local configuration files for CI. If
     * <code>${basedir}/src/etc/ci</code> exists, it is automatically added.
     *
     * @parameter
     * @since 1.0
     */
    protected String[] hudsonConfigSourceLocations;
  
    /**
     * The name of the server configuration in the <code>settings.xml</code> that
     * provides credentials to access the Hudson server. Only used if no server
     * matches the POM's <code>ciManagement/url</code> and
     * <code>ciManagement/system</code>.
    *
    * @parameter default-value="hudson"
    * @since 1.0
    */
   protected String ciServerId;
 
   /**
    * The path to the configuration file for CI. Defaults to
    * <code>${basedir}/src/etc/ci/ci-config.xml</code>.
    *
    * @parameter default-value= "${basedir}/src/etc/ci/ci-config.xml"
    * @since 1.0
    */
   protected File ciConfigurationFile;
 
   /**
    * The path to the destination folder to write the Hudson configurations to.
    * Defaults to <code>${project.build.directory}/hudson</code>.
    *
    * @parameter default-value= "${project.build.directory}/hudson"
    * @since 1.0
    */
   protected File hudsonTargetLocation;
 
   // ****************************** Initializer *******************************
 
   // ****************************** Constructors ******************************
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   /**
    * Returns the Maven project.
    *
    * @return the Maven project.
    */
   public final MavenProject getProject()
   {
     return project;
   }
 
   /**
    * Sets the Maven project.
    *
    * @param project the Maven project.
    */
   public final void setProject(final MavenProject project)
   {
     this.project = project;
   }
 
   /**
    * Sets the Maven session instance.
    *
    * @param session the Maven session instance.
    */
   public final void setSession(final MavenSession session)
   {
     this.session = session;
   }
 
   // --- business -------------------------------------------------------------
 
   /**
    * Creates a configured location manager to fetch Hudson configuration files.
    *
    * @return a configured location manager to fetch Hudson configuration files.
    */
   protected final LocationManager createLocationManager()
   {
     final ClassLoader classLoader =
         Thread.currentThread().getContextClassLoader();
     final LocationManager locationManager = new LocationManager(classLoader);
 
     provideDefaultLocation(locationManager);
 
     if (hudsonConfigSourceLocations != null)
     {
       for (final String location : hudsonConfigSourceLocations)
       {
         final File dir = new File(location);
         if (dir.exists())
         {
           locationManager.addLocation(dir);
         }
         else
         {
           final File relativeDir = new File(project.getBasedir(), location);
           if (relativeDir.exists())
           {
             locationManager.addLocation(relativeDir);
           }
           else
           {
             try
             {
               final URL url = new URL(location);
               locationManager.addLocation(url);
             }
             catch (final MalformedURLException e)
             {
               final Logger logger = getLog();
               LogHelper.logWarn(logger, logLevel, "Cannot add location '"
                                                   + location + "'. Skipping.");
             }
           }
         }
       }
     }
 
     return locationManager;
   }
 
   private void provideDefaultLocation(final LocationManager locationManager)
   {
     final File defaultDir = new File(project.getBasedir(), "/src/etc/ci");
     if (defaultDir.exists())
     {
       locationManager.addLocation(defaultDir);
     }
   }
 
   /**
    * Creates a Maven configuration that contains the relevant information for
    * the Hudson configuration files.
    *
    * @return a Maven configuration that contains the relevant information for
    *         the Hudson configuration files.
    */
   protected final MavenConfig createMavenConfig()
   {
     final MavenPom pom = new MavenPom();
     pom.setGroupId(project.getGroupId());
     pom.setArtifactId(project.getArtifactId());
     pom.setDescription(project.getDescription());
     pom.setScmConnectionString(project.getScm().getDeveloperConnection());
 
     final MavenSettings settings = new MavenSettings();
 
     final MavenConfig mavenConfig = new MavenConfig(settings, pom);
     return mavenConfig;
   }
 
   /**
    * Opens a stream to the {@link #ciConfigurationFile}.
    * <p>
    * The client is responsible to close the stream.
    * </p>
    *
    * @return the stream inside an input source.
    * @throws MojoExecutionException on any problem opening the stream.
    */
   protected final InputSource createInputSource() throws MojoExecutionException
   {
     final File ciConfigXml = ciConfigurationFile;
     try
     {
       final InputSource is;
       if (checkCiConfigXml(ciConfigXml))
       {
         is = fetchLocal(ciConfigXml);
       }
       else
       {
         is = fetchClassloader();
       }
       return is;
     }
     catch (final IOException e)
     {
       throw new MojoExecutionException("Cannot open file 'ci-config.xml'.", e);
     }
 
   }
 
   private boolean checkCiConfigXml(final File ciConfigXml)
   {
     return ciConfigXml != null && ciConfigXml.exists();
   }
 
   private InputSource fetchClassloader() throws FileNotFoundException
   {
     final InputSource is;
     final ClassLoader classLoader =
         Thread.currentThread().getContextClassLoader();
     final LocationManager lm = new LocationManager(classLoader);
     is = lm.open("ci-config.xml");
     return is;
   }
 
   private InputSource fetchLocal(final File ciConfigXml) throws IOException
   {
     final InputSource is;
     is = new InputSource(ciConfigXml.getAbsolutePath());
     final InputStream in = FileUtils.openInputStream(ciConfigXml);
     is.setByteStream(in);
     return is;
   }
 
   /**
    * Writes the Hudson job configuration XML file to its destination folder.
    *
    * @param hudsonJobConfig the Hudson job XML document.
    * @throws MojoExecutionException on any problem writing the file.
    */
   protected final void writeHudsonConfigXml(
       final HudsonJobConfig hudsonJobConfig) throws MojoExecutionException
   {
     ensureDirectoryExists(hudsonTargetLocation);
 
     final File file =
         new File(hudsonTargetLocation, hudsonJobConfig.getId() + ".xml");
     try
     {
       FileUtils.writeStringToFile(file, hudsonJobConfig.getConfigXml());
     }
     catch (final IOException e)
     {
       throw new MojoExecutionException(
           "Cannot write Hudson configuration file to '" + file.getPath() + "'",
           e);
     }
   }
 
   private static void ensureDirectoryExists(final File dir)
     throws MojoExecutionException
   {
     if (!dir.exists())
     {
       if (!dir.mkdirs()) // NOPMD
       {
         throw new MojoExecutionException("Cannot generate directory '"
                                          + dir.getPath() + "'");
       }
     }
   }
 
   /**
    * Returns the Hudson server configuration to run a remote access.
    *
    * @return the server information. If no access information is found, only the
    *         URL to the CI server is returned.
    * @throws MojoExecutionException if no CI URL is specified.
    */
   protected final CiServer getCiServer() throws MojoExecutionException
   {
     final CiManagement ciManagement = project.getCiManagement();
     final Server server = getCiServerFromSettings(ciManagement);
     final String ciUrl = ciManagement.getUrl();
     return new CiServer(logger, server, ciUrl);
   }
 
   private Server getCiServerFromSettings(final CiManagement ciManagement)
     throws MojoExecutionException
   {
     Server server;
 
     if (StringUtils.isNotBlank(ciServerId))
     {
       server = settings.getServer(ciServerId);
     }
     else
     {
       final String ciUrl = ciManagement.getUrl();
       server = settings.getServer(ciUrl);
       if (server != null)
       {
         return server;
       }
 
       final String ciName = ciManagement.getSystem();
       if (StringUtils.isNotBlank(ciName))
       {
         server = settings.getServer(ciName);
       }
     }
 
     return server;
   }
 
   // CHECKSTYLE:OFF
   /**
    * Provides a check for conditions to be met to run this plugin successfully.
    * <p>
    * Subclasses may add additional checks by overriding this method and calling
    * this it in their implementation.
    * </p>
    *
    * @throws MojoExecutionException if the preconditions are not met.
    */
   protected void checkPreconditions() throws MojoExecutionException
   {
     // CHECKSTYLE:ON
     if (project == null)
     {
       throw new MojoExecutionException(
           "No project information provided. Please run this plugin on"
               + " a project that provides a POM.");
     }
 
     final CiManagement ciManagement = project.getCiManagement();
     if (ciManagement == null)
     {
       throw new MojoExecutionException(
           "No CI management specified. Please provide CI information"
               + " within the 'ciManagement' block of your POM.");
     }
 
     final String ciUrl = ciManagement.getUrl();
     if (StringUtils.isBlank(ciUrl))
     {
       throw new MojoExecutionException(
           "No CI URL specified. Please provide CI information within the"
               + " 'ciManagement/url' block of your POM.");
     }
   }
 
 }