/*
    * 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.nexus;
  
  import java.io.IOException;
  
  import org.apache.commons.httpclient.HttpClient;
  import org.apache.commons.httpclient.HttpException;
  import org.apache.commons.httpclient.HttpMethod;
  import org.apache.commons.httpclient.NameValuePair;
  import org.apache.commons.httpclient.methods.GetMethod;
  import org.apache.maven.plugin.logging.Log;
  import org.jdom.Document;
  import org.jdom.Text;
  import org.jdom.input.SAXBuilder;
  import org.jdom.xpath.XPath;
  import org.xml.sax.InputSource;
  
  import de.smartics.maven.issue.command.CommandException;
  import de.smartics.maven.issue.command.CommandResult.HttpStatus;
  import de.smartics.maven.issue.util.HttpClientUtils;
  import de.smartics.maven.issue.util.LogLevel;
  import de.smartics.util.lang.Arg;
  
  /**
   * Runs a REST command against a Nexus server to fetch artifact resolution
   * information.
   */
  public final class NexusClient
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * The minimum HTTP code signaling a successful request.
     */
    private static final int MIN_OK = 200;
  
    /**
     * The maximum HTTP code signaling a successful request.
     */
    private static final int MAX_OK = 299;
  
    /**
     * The status code for a HTTP 404.
     */
    private static final int NOT_FOUND = 404;
  
    // --- members --------------------------------------------------------------
  
    /**
     * The client to issue requests to the Nexus server.
     */
    private final HttpClient client;
  
    /**
     * The logger to log to.
     */
    private final Log log;
  
    /**
     * Defines the verboseness of the output.
     */
    private final LogLevel logLevel;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     *
     * @param client the client to issue requests to the Nexus server.
     * @param log the logger to log to.
     * @param logLevel the value for logLevel.
     * @throws NullPointerException if {@code client} is <code>null</code>.
     * @throws IllegalArgumentException if {@code client} is blank.
     */
    public NexusClient(final HttpClient client, final Log log,
        final LogLevel logLevel) throws NullPointerException,
      IllegalArgumentException
    {
      this.client = Arg.checkNotNull("client", client);
      this.log = log;
      this.logLevel = logLevel;
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * Retrieves the latest version from the Nexus server.
    *
    * @param request the request parameters.
    * @return the latest version as reported by Nexus.
    * @throws CommandException on any problem requesting Nexus.
    */
   public String getLatestReleaseVersion(final NexusRequest request)
     throws CommandException
   {
     if (logLevel.isVerbose())
     {
       log.info("Fetching latest version from Nexus: " + request);
     }
 
     final HttpMethod method = createMethod(request);
     if (logLevel.isVerbose())
     {
       log.info("Executing method: " + toString(method));
     }
     execute(method);
 
     final HttpStatus httpStatus = createStatus(method);
 
     final int httpStatusCode = httpStatus.getCode();
     if (httpStatusCode < MIN_OK || httpStatusCode > MAX_OK)
     {
       final String message =
           "Failed to execute command '" + toString(method) + "': " + httpStatus;
       if (httpStatusCode == NOT_FOUND)
       {
         log.info("Cannot find artifact '" + request.getArtifactString()
                  + "' to resolve latest release version on nexus.");
       }
       else
       {
         if (logLevel.isVerbose())
         {
           log.info(message);
         }
       }
 
       throw new CommandException(message);
     }
 
     final String version = readVersion(method);
     return version;
   }
 
   private static String toString(final HttpMethod method)
   {
     return method.getPath() + '?' + method.getQueryString();
   }
 
   private String readVersion(final HttpMethod method)
   {
     final InputSource bodyContent =
         HttpClientUtils.readBodyContentAsStream(method);
 
     final SAXBuilder builder = new SAXBuilder();
     try
     {
       final Document responseXml = builder.build(bodyContent);
       final String xPathString = "artifact-resolution/data/version/text()";
       final Text versionNode =
           (Text) XPath.selectSingleNode(responseXml, xPathString);
       if (versionNode != null)
       {
         return versionNode.getTextNormalize();
       }
       else
       {
         throw new CommandException("No version found in Nexus response.");
       }
     }
     catch (final Exception e)
     {
       throw new CommandException("Failed to parse Nexus response.", e);
     }
   }
 
   private int execute(final HttpMethod method) throws CommandException
   {
     try
     {
       method.getParams().setContentCharset("UTF-8");
       final int code = client.executeMethod(method);
       return code;
     }
     catch (final HttpException e)
     {
       throw new CommandException("Cannot execute command '" + method + "'.", e);
     }
     catch (final IOException e)
     {
       throw new CommandException("Cannot execute command '" + method + "'.", e);
     }
   }
 
   private HttpStatus createStatus(final HttpMethod method)
   {
     final int code = method.getStatusCode();
     final String text = method.getStatusText();
     final HttpStatus httpStatus = new HttpStatus(code, text);
     return httpStatus;
   }
 
   private HttpMethod createMethod(final NexusRequest request)
   {
     final String url = createUrl(request);
     final GetMethod method = new GetMethod(url);
 
     final NameValuePair[] params =
         new NameValuePair[] {
                              new NameValuePair("r", request.getRepositoryId()),
                              new NameValuePair("g", request.getGroupId()),
                              new NameValuePair("a", request.getArtifactId()),
                              new NameValuePair("e", request.getExtension()),
                              new NameValuePair("v", "RELEASE") };
     method.setQueryString(params);
 
     return method;
   }
 
   private String createUrl(final NexusRequest request)
   {
     final StringBuilder buffer = new StringBuilder(64);
     buffer.append(request.getNexusServer()).append(
         "/service/local/artifact/maven/resolve");
     return buffer.toString();
   }
 
   // --- object basics --------------------------------------------------------
 
 }