/*
   Copyright (C) 2000 - 2007 Grid Systems, S.A.
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
  package com.gridsystems.innergrid.api;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.Reader;
  import java.net.ConnectException;
  import java.net.HttpURLConnection;
  import java.net.MalformedURLException;
  import java.net.SocketException;
  import java.net.URL;
  import java.net.URLConnection;
  import java.util.Formatter;
  import java.util.HashMap;
  import java.util.Map;
  
  import javax.net.ssl.SSLHandshakeException;
  
  import org.apache.axis.AxisProperties;
  import org.apache.commons.io.IOUtils;
  
  import com.gridsystems.innergrid.kernel.KernelException;
  
  /**
   * Connects to a single server.
   *
   * @author Rodrigo Ruiz
   * @author Xmas
   */
  public abstract class AbstractConnection implements Connection {
  
    /**
     * Maps Credentials classes to Base URL templates.
     */
    private static final Map<Class<?>, String> PATH_TEMPLATES;
  
    static {
      PATH_TEMPLATES = new HashMap<Class<?>, String>();
      PATH_TEMPLATES.put(UsernameTokenCredentials.class, "/kernel/api/%s");
      PATH_TEMPLATES.put(X509CertificateCredentials.class, "/kernel/api/%s_cert");
      PATH_TEMPLATES.put(null, "/kernel/api/%s");
    }
  
    /**
     * Default retries.
     */
    public static final int DEFAULT_RETRIES = 5;
  
    /**
     * Host to connect.
     */
    protected String host = null;
  
    /**
     * Port to connect.
     */
    protected int port = -1;
  
    /**
     * Web-application context path base.
     */
    protected String contextPath;
  
    /**
     * Secured connection.
     */
    protected boolean secured = false;
  
    /**
     * SSL Connection Info.
     */
    protected SSLConnectionInfo sslInfo = null;
  
    /**
     * The credentials to use.
     */
    protected Credentials credentials = null;
  
    /**
     * Connection timeout.
     */
    protected int timeout = DEFAULT_TIMEOUT;
  
   /**
    * Chunked Transfer encoding control flag.
    */
   protected boolean chunkedTransferEnabled = true;
 
   /**
    * Keep-Alive control flag.
    */
   protected boolean keepAliveEnabled = false;
 
   /**
    * Attachments format.
    */
   protected String attachmentFormat;
 
   /**
    * Number of retries.
    */
   protected int retries = DEFAULT_RETRIES;
 
   /**
    * Flag that avoid repeating the connection test.
    */
   protected boolean connChecked = false;
 
   /**
    * To synchronise host, port, and secured access.
    */
   protected Object sync = new Object();
 
   static {
     // This makes the client sockets to disable their SO_LINGER option flag
     AxisProperties.setProperty("axis.socketFactory",
       NoLingerSocketFactory.class.getName(), true);
 
     // This makes the client to accept Grid Certificates
     AxisProperties.setProperty("axis.socketSecureFactory",
         InnergridJSSESocketFactory.class.getName(), true);
   }
 
   /**
    * Gets the default Context Path Template for the specified Credentials
    * instance.
    *
    * @param cred Credentials instance
    * @return Context path template
    */
   private static String getDefaultPathFor(Credentials cred) {
     String path = null;
     if (cred != null) {
       path = PATH_TEMPLATES.get(cred.getClass());
     }
 
     if (path == null) {
       path = PATH_TEMPLATES.get(null);
     }
 
     return path;
   }
 
 
   /**
    * Creates an instance of the connector to the specified host:port, and
    * using the specified credentials.
    *
    * @param h           The remote server host name or address
    * @param p           The remote server port
    * @param ctxPath     Context path base
    * @param secure      Whether to use a secure protocol(HTTPS) or not
    * @param sslinfo     Additional info to establish SSL connection
    * @param credentials The user name.
    */
   public AbstractConnection(String h, int p, String ctxPath, boolean secure,
     SSLConnectionInfo sslinfo, Credentials credentials) {
     this.host = h;
     this.port = p;
     this.contextPath = (ctxPath == null) ? getDefaultPathFor(credentials) : ctxPath;
     this.secured = secure;
     if (this.secured) {
       if (sslinfo == null) {
         this.sslInfo = new AcceptAllCertificates();
       } else {
         this.sslInfo = sslinfo;
       }
       InnergridJSSESocketFactory.registrySSLConnectionInfo(h, p, sslInfo);
     }
     this.credentials = credentials;
   }
 
   /**
    * Creates an instance of the connector to the specified host:port, and
    * using the specified credentials.
    *
    * @param h           The remote server host name or address
    * @param p           The remote server port
    * @param secure      Whether to use a secure protocol(HTTPS) or not
    * @param sslinfo     Additional info to establish SSL connection
    * @param credentials The user name.
    */
   public AbstractConnection(String h, int p, boolean secure,
     SSLConnectionInfo sslinfo, Credentials credentials) {
     this(h, p, null, secure, sslinfo, credentials);
   }
 
   /**
    * Gets Host to connect.
    * @return Host to connect.
    */
   public String getHost() {
     synchronized (sync) {
       return this.host;
     }
   }
 
   /**
    * Gets Port to connect.
    * @return Port to connect.
    */
   public int getPort() {
     synchronized (sync) {
       return this.port;
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public String getContextPath() {
     synchronized (sync) {
       return this.contextPath;
     }
   }
 
   /**
    * Sets the context path template.
    *
    * @param ctxPath Template
    */
   public void setContextPath(String ctxPath) {
     if (ctxPath == null) {
       ctxPath = getDefaultPathFor(this.credentials);
     }
     this.contextPath = ctxPath;
   }
 
   /**
    * Use a secured connection.
    * @return true if this connection uses SSL.
    */
   public boolean isSecured() {
     synchronized (sync) {
       return this.secured;
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public int getTimeout() {
     synchronized (sync) {
       return this.timeout;
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void setTimeout(int timeout) {
     synchronized (sync) {
       this.timeout = timeout;
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public boolean isChunkedTransferEnabled() {
     synchronized (sync) {
       return this.chunkedTransferEnabled;
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void setChunkedTransferEnabled(boolean enabled) {
     synchronized (sync) {
       this.chunkedTransferEnabled = enabled;
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public boolean isKeepAliveEnabled() {
     synchronized (sync) {
       return this.keepAliveEnabled;
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void setKeepAliveEnabled(boolean enabled) {
     synchronized (sync) {
       this.keepAliveEnabled = enabled;
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public String getAttachmentFormat() {
     synchronized (sync) {
       return this.attachmentFormat;
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void setAttachmentFormat(String format) {
     synchronized (sync) {
       this.attachmentFormat = format;
     }
   }
 
   /**
    * Gets retries.
    * @return Return retries value.
    */
   public int getRetries() {
     return this.retries;
   }
 
   /**
    * Sets retires.
    * @param retries New value for retries
    */
   public void setRetries(int retries) {
     this.retries = retries;
   }
 
   /**
    * {@inheritDoc}
    *
    */
   public URL getUrl(String apiName) throws KernelException {
     String baseUrl = getBaseUrl();
     try {
       Formatter f = new Formatter();
       f.format(baseUrl, apiName);
       return new URL(f.toString());
     } catch (MalformedURLException e) {
       throw new CKernelException(e, "CLT008", "[ " + baseUrl + ", " + apiName + " ]");
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public Credentials getCredentials() {
     return this.credentials;
   }
 
   /**
    * Obtain additional information to establish SSL connection.
    * @return SLL Connection Info
    */
   public SSLConnectionInfo getSSLConnectionInfo() {
     return sslInfo;
   }
 
   /**
    * Gets the base URL for all API URLs.
    *
    * @return  The base URL
    * @throws KernelException If the URL is not well formed
    */
   public abstract String getBaseUrl() throws KernelException;
 
   /**
    * Manage Exceptions.
    *
    * @param ke KernelException captured
    * @param retry Number of retry
    * @throws KernelException Throws ke exception if do not desire retry.
    *
    */
   public abstract void manageException(KernelException ke, int retry)
     throws KernelException;
 
   /**
    * Avoids checking the connection data.
    * <p>
    * When the connection is used the first time, it performs a test to find out
    * if the data (specially the protocol used) is right. Calling this method
    * avoids calling the tests, improving the connection performance for that
    * first time.
    */
   public final void clearChecks() {
     this.connChecked = true;
   }
 
   /**
    * {@inheritDoc}
    */
   public final void checkConnection() throws KernelException {
     if (!connChecked && !checkPort(secured)) {
       String url = this.host + ":" + this.port;
       String[] protocols = { "http", "https" };
       int i = secured ? 1 : 0;
       throw new CKernelException("CLT061", protocols[i], url, protocols[1 - i]);
     }
     connChecked = true;
   }
 
   /**
    * Checks that the connection port can be reached in a safe/unsafe way.
    *
    * @param secure <code>true</code> if <code>https</code> protocol is to be checked;
    *               <code>false</code> if the protocol to be used is <code>http</code>.
    * @return true if and only if the port was reached and the stream obtained
    *         was formed by "normal" text.
    * @throws KernelException in case of error reaching for the port.
    */
   private boolean checkPort(boolean secure) throws KernelException {
     // Opening an HTTPS connection when the remote port is HTTP would hang the thread
     if (secure && checkPort(false)) {
       return false;
     }
 
     BufferedReader reader = null;
     URLConnection con = null;
     try {
       URL url = new URL(secure ? "https" : "http", this.host, this.port, "");
       con = url.openConnection();
       con.setUseCaches(false);
 
       reader = new BufferedReader(new InputStreamReader(con.getInputStream()));
 
       // A successful connection will return a mix of printable and control characters.
       // The following code controls the case where the connection returned only
       // control characters, which is an indication of a corrupted stream
       return test(reader);
 
     } catch (MalformedURLException e) {
       throw new CKernelException(e, "CLT062", "malformed");
     } catch (ConnectException e) {
       throw new CKernelException(e, "CLT000", host + ":" + port);
     } catch (SocketException e) {
       return false;
     } catch (SSLHandshakeException e) {
       // A Handshake error means there is SSL at both sides
       return this.secured;
     } catch (IOException ioe) {
       if (ioe.getMessage().indexOf("hostname wrong") != -1) {
         return secure;
       }
 
       // Unexpected errors are converted to KernelExceptions
       throw new CKernelException(ioe, "CLT062", ioe.getMessage());
     } catch (Throwable t) {
       // Unexpected errors are converted to KernelExceptions
       throw new CKernelException(t, "CLT062", t.getMessage());
     } finally {
       IOUtils.closeQuietly(reader);
       if (con instanceof HttpURLConnection) {
         ((HttpURLConnection)con).disconnect();
       }
     }
   }
 
   /**
    * Reads the reader contents and searches for non-control characters in its stream.
    *
    * @param reader  The reader to read from
    * @return        <code>true</code> if it contains at least one non-control character
    * @throws IOException If an I/O error occurs
    */
   private boolean test(Reader reader) throws IOException {
     char ch = (char)reader.read();
     while (ch != -1) {
       if (!Character.isISOControl(ch)) {
         return true;
       }
       ch = (char)reader.read();
     }
     return false;
   }
 }