/*
    * 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.comm.hudson.command;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.Map.Entry;
  import java.util.Properties;
  import java.util.regex.Pattern;
  
  import org.apache.commons.httpclient.methods.PostMethod;
  import org.apache.commons.io.IOUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import de.smartics.ci.comm.LogHelper;
  import de.smartics.ci.comm.command.AbstractGenericJobCommand;
  import de.smartics.ci.comm.command.Command;
  import de.smartics.ci.comm.command.CommandException;
  import de.smartics.ci.comm.command.CommandResult;
  import de.smartics.ci.comm.command.InvalidRequestException;
  
  /**
   * This abstract class contains the functionality to handle jobs calling an api.
   * It handles the replacement of variables in the api call and handles methods
   * to handle the response.
   *
   * @param <T> the concrete type of the command.
   */
  public abstract class AbstractHudsonApiJob<T extends Command<T>> extends
      AbstractGenericJobCommand<T>
  {
  
    /**
     * Reference to the logger for this class.
     */
    private static final Logger LOG = LoggerFactory
        .getLogger(AbstractHudsonApiJob.class);
  
    /**
     * Delimiter, used for logging.
     */
    private static final String BOCKDELIMITER = "-------------------------------";
  
    /**
     * The xmlQuery string to execute against the xml api.
     */
    protected String xmlQueryString;
  
    /**
     * Key value pairs / properties used to replace variables (the keys) in the
     * xml query string with the values.
     */
    protected Properties properties;
  
    /**
     * The result of this command.
     */
    protected CommandResult<T> commandResult;
  
    /**
     * Default constructor.
     *
     * @param jobName the name of the job.
     */
    public AbstractHudsonApiJob(final String jobName)
    {
      super(jobName);
    }
  
    /**
     * Sets the xmlQuery string to execute against the xml api.
     *
     * @param xmlQueryString the xmlQuery string to execute against the xml api.
     */
    public final void setXmlQueryString(final String xmlQueryString)
    {
      this.xmlQueryString = xmlQueryString;
    }
  
    /**
     * Sets the value for keyValuePairs.
     * <p>
     * Key value pairs used to replace variables (the keys) in the xml query
     * string with the values.
     *
    * @param properties the value for keyValuePairs.
    */
   public final void setKeyValuePairs(final Properties properties)
   {
     this.properties = properties;
     if (this.properties == null)
     {
       this.properties = new Properties();
     }
   }
 
   /**
    * Create the command result and provide the result object in this command
    * object.
    *
    * @param statusCode the status code of the response.
    * @param method the method used to execute the command.
    * @throws IOException when the communication fails and the response could not
    *           be retrieved.
    * @throws CommandException when command fails.
    */
   protected final void createResult(final int statusCode,
       final PostMethod method) throws IOException, CommandException
   {
 
     final String response = getResponseAsString(method);
     final CommandResult<T> result =
         new CommandResult<T>(statusCode, new CommandResult.HttpStatus(
             statusCode, method.getStatusText()), response);
     this.commandResult = result;
     logResult(statusCode, response);
   }
 
   private void logResult(final int statusCode, final String response)
     throws CommandException, InvalidRequestException
   {
     if (statusCode / ERROR_CATEGORY_DESTINGUISHER == 2)
     {
       LogHelper.logInfo(LOG, logLevel,
           "HTTP status 'OK' has been returned from server.");
       checkResponseString(response);
     }
     else
     {
       if (response.contains("lieferte keinen Treffer")
           || response.contains("didn't match"))
       {
         LogHelper.logError(LOG, logLevel,
             "Server returned that query did not match.");
       }
       else
       {
         checkResultRegardingRedirect(statusCode);
       }
     }
   }
 
   private String getResponseAsString(final PostMethod method)
     throws IOException
   {
     final InputStream responseStream = method.getResponseBodyAsStream();
     final String response = IOUtils.toString(responseStream);
     return response;
   }
 
   /**
    * Check the response.
    *
    * @param response the response.
    * @throws CommandException when check fails.
    */
   protected void checkResponseString(final String response)
     throws CommandException
   {
   }
 
   /**
    * Log the response of this command.
    *
    * @param response the response as String.
    * @throws IOException when the response can not be retrieved from the method.
    */
   protected final void logResponse(final String response) throws IOException
   {
     LogHelper.logInfo(LOG, logLevel, BOCKDELIMITER);
     LogHelper.logInfo(LOG, logLevel, "\n\r");
     LogHelper.logInfo(LOG, logLevel, response);
     LogHelper.logInfo(LOG, logLevel, "\n\r");
     LogHelper.logInfo(LOG, logLevel, BOCKDELIMITER);
   }
 
   /**
    * Resolve the query string, resolve all variables in the query string with
    * the given values.
    *
    * @param queryString the query string containing variables.
    * @return a query string with replaced variables.
    */
   protected final String resolve(final String queryString)
   {
     String result = queryString;
 
     for (@SuppressWarnings("rawtypes")
     final Entry entry : properties.entrySet())
     {
       result =
           replace(result, entry.getKey().toString(), entry.getValue()
               .toString());
     }
 
     if (!checkKeyValuesContainJobName())
     {
       result = replace(result, "jobName", jobName);
     }
     return result;
   }
 
   @Override
   public final CommandResult<T> getResult()
   {
     return this.commandResult;
   }
 
   private String replace(final String input, final String key,
       final String value)
   {
     return input.replaceAll(Pattern.quote("${" + key + "}"), value).replaceAll(
         Pattern.quote("@{" + key + "}"), value);
   }
 
   private boolean checkKeyValuesContainJobName()
   {
     return properties.containsKey("jobName");
   }
 
 }