/*
    * 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;
  
  import static de.smartics.ci.maven.HudsonUtils.determineJobName;
  
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.List;
  
  import org.apache.commons.io.IOUtils;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.jdom.JDOMException;
  import org.xml.sax.InputSource;
  
  import de.smartics.ci.comm.CiController;
  import de.smartics.ci.comm.LogLevel;
  import de.smartics.ci.config.load.HudsonJobConfig;
  import de.smartics.ci.config.load.HudsonJobConfigLoader;
  import de.smartics.ci.config.load.HudsonJobConfigurationLoaderConfig;
  import de.smartics.ci.config.load.LoaderPlan;
  import de.smartics.ci.config.load.LoaderPlanLoader;
  import de.smartics.ci.config.load.LocationManager;
  import de.smartics.ci.config.maven.MavenConfig;
  
  /**
   * Hudson CI mojo.
   */
  public abstract class AbstractConfigChoiceHudsonCiMojo extends
      AbstractHudsonCiMojo
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * Use this file as is and do not use the ci-config mechanism.
     *
     * @parameter expression="${hudson-maven-plugin.jobConfigFile}"
     * @since 1.0
     */
    private String jobConfigFile;
  
    /**
     * Use this name as the job name and do not use the ci-config mechanism.
     *
     * @parameter expression="${hudson-maven-plugin.jobName}"
     * @since 1.0
     */
    private String jobName;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    /**
     * {@inheritDoc}
     *
     * @see org.apache.maven.plugin.Mojo#execute()
     */
    public final void execute() throws MojoExecutionException,
      MojoFailureException
    {
      checkPreconditions();
      if (HudsonUtils.checkForManualConfiguration(this.jobName,
          this.jobConfigFile))
      {
        executeManualConfiguration();
      }
      else
      {
        executeConfigurationUsingCiConfigFile();
     }
   }
 
   private void executeConfigurationUsingCiConfigFile()
     throws MojoExecutionException
   {
     final HudsonJobConfigLoader configLoader = createJobConfigLoader();
     final MavenConfig mavenConfig = createMavenConfig();
     final LoaderPlanLoader loader =
         HudsonUtils.createLoaderPlanLoader(mavenConfig);
 
     final InputSource ciConfigurationInputSource = createInputSource();
 
     final List<LoaderPlan> plans = loader.load(ciConfigurationInputSource);
     for (final LoaderPlan plan : plans)
     {
       try
       {
         final String configString = readConfig(configLoader, plan);
         final CiController controller = loginToCiServer(new LogLevel(verbose));
         final String jobName = determineJobName(plan);
         final String formattedConfigString =
             HudsonUtils.prettyFormat(configString, 2);
         executeCommand(jobName, formattedConfigString, controller);
       }
       catch (final Exception e)
       {
         logError("Terminated handling jobs. Rollback not possile. Please check status manually at: "
                  + getCiServer().getUrl());
         throw new MojoExecutionException("Cannot load plan: " + plan, e);
       }
       logInfo("All Jobs successfully handled.");
     }
   }
 
   private void executeManualConfiguration() throws MojoExecutionException
   {
     final LogLevel logLevel = new LogLevel(verbose);
     try
     {
       if (HudsonUtils.checkIfHudsonJobConfigFileIsSpecified(this.jobConfigFile))
       {
         final String configString = readPlainUnparsedConfig();
         final CiController controller = loginToCiServer(logLevel);
         executeCommand(jobName, configString, controller);
       }
       else
       {
         final CiController controller = loginToCiServer(logLevel);
         executeCommand(jobName, null, controller);
       }
     }
     catch (final Exception e)
     {
       logError("Terminated handling jobs. Rollback not possile. Please check status manually at: "
                + getCiServer().getUrl());
       throw new MojoExecutionException("Cannot handle jobName " + jobName, e);
     }
   }
 
   private HudsonJobConfigLoader createJobConfigLoader()
   {
     final HudsonJobConfigurationLoaderConfig loaderConfig =
         createLoaderConfig();
     final LocationManager locationManager = createLocationManager();
     final HudsonJobConfigLoader configLoader =
         new HudsonJobConfigLoader(locationManager, loaderConfig);
     return configLoader;
   }
 
   private String readConfig(final HudsonJobConfigLoader configLoader,
       final LoaderPlan plan) throws JDOMException, MojoExecutionException
   {
     final HudsonJobConfig hudsonConfig = configLoader.loadHudsonConfig(plan);
     final String configString = hudsonConfig.getConfigXml();
     writeHudsonConfigXml(hudsonConfig);
     return configString;
   }
 
   private String readPlainUnparsedConfig() throws FileNotFoundException
   {
     final LocationManager locationManager = createLocationManager();
     final InputSource source = locationManager.open(this.jobConfigFile);
     final InputStream is = source.getByteStream();
 
     String hudsonConfig = null;
     try
     {
       hudsonConfig = IOUtils.toString(is);
     }
     catch (final IOException e)
     {
       // do nothin
     }
     return hudsonConfig;
   }
 
   private HudsonJobConfigurationLoaderConfig createLoaderConfig()
   {
     final HudsonJobConfigurationLoaderConfig.Builder builder =
         new HudsonJobConfigurationLoaderConfig.Builder();
     builder
         .withAddScmElementWithFullContent(addScmElementWithFullContent)
         .withRemoveCascadingChildrenNamesElement(
             removeCascadingChildrenNamesElement)
         .withRemoveCascadingJobPropertiesElement(
             removeCascadingJobPropertiesElement);
     final HudsonJobConfigurationLoaderConfig config = builder.build();
     return config;
   }
 
   // --- object basics --------------------------------------------------------
 
 }