/* 
    * Copyright (c) 2007, Fraunhofer-Gesellschaft
    * All rights reserved.
    * 
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are
    * met:
    * 
    * (1) Redistributions of source code must retain the above copyright
   *     notice, this list of conditions and the disclaimer at the end.
   *     Redistributions in binary form must reproduce the above copyright
   *     notice, this list of conditions and the following disclaimer in
   *     the documentation and/or other materials provided with the
   *     distribution.
   * 
   * (2) Neither the name of Fraunhofer nor the names of its
   *     contributors may be used to endorse or promote products derived
   *     from this software without specific prior written permission.
   * 
   * DISCLAIMER
   * 
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *  
   */
  package org.ogf.graap.wsag.wsrf.security;
  
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.net.URL;
  import java.security.KeyStore;
  import java.security.PrivateKey;
  import java.security.cert.X509Certificate;
  import java.text.MessageFormat;
  import java.util.Properties;
  
  import org.apache.log4j.Logger;
  import org.apache.ws.security.WSSecurityException;
  import org.apache.ws.security.components.crypto.CredentialException;
  import org.apache.ws.security.util.Loader;
  import org.ogf.graap.wsag.api.WsagConstants;
  import org.ogf.graap.wsag.api.security.SecurityConstants;
  import org.ogf.graap.wsag.wsrf.WsrfEngine;
  import org.ogf.graap.wsag4j.types.configuration.ConfigurationType;
  import org.ogf.graap.wsag4j.types.configuration.WSRFEngineConfigurationType;
  
  /**
   * Merlin
   * 
   * @author Oliver Waeldrich
   * 
   */
  public class Merlin extends org.apache.ws.security.components.crypto.Merlin
  {
  
      private static final Logger LOG = Logger.getLogger( Merlin.class );
  
      String truststoreFile = null;
  
      String truststoreType = null;
  
      String truststorePassword = null;
  
      // KeyStore truststore = null;
  
      /**
       * Creates a new {@link org.apache.ws.security.components.crypto.Merlin} instance using the specified
       * properties.
       * 
       * @param properties
       *            the properties to use
       * 
       * @throws CredentialException
       *             error processing the keystore credentials
       * @throws IOException
       *             error accessing the keystore
       */
      public Merlin( Properties properties )
          throws CredentialException, IOException
      {
          this( loadProperties( properties ), new MerlinClassLoader( Merlin.class.getClassLoader() ) );
      }
  
      /**
       * Creates a new {@link org.apache.ws.security.components.crypto.Merlin} instance using the specified
       * properties and class loader.
       * 
       * @param properties
       *            the properties to use
      * 
      * @param loader
      *            the class loader to use
      * 
      * @throws CredentialException
      *             error processing the keystore credentials
      * @throws IOException
      *             error accessing the keystore
      */
     public Merlin( Properties properties, ClassLoader loader )
         throws CredentialException, IOException
     {
         super( loadProperties( properties ), loader );
 
         this.truststoreFile = this.properties.getProperty( SecurityConstants.PROP_TRUSTSTORE_FILE );
         this.truststoreType = this.properties.getProperty( SecurityConstants.PROP_TRUSTSTORE_TYPE );
         this.truststorePassword = this.properties.getProperty( SecurityConstants.PROP_TRUSTSTORE_PASS );
 
         loadTrustStore( loader );
     }
 
     private static Properties loadProperties( Properties properties ) throws WSSecurityException
     {
 
         //
         // if properties are provided, we use them
         //
         if ( properties != null )
         {
             String value = (String) properties.get( "org.ogf.graap.wsag.security.configuration" );
             if ( !"useWSRFConfigFile".equalsIgnoreCase( value ) )
             {
                 return properties;
             }
         }
 
         //
         // if no properties are provided, we read them from the wsrf-configuration file
         //
         properties = new Properties();
 
         try
         {
             ConfigurationType config =
                 WsrfEngine.findWsrfConfiguration( WsagConstants.WSAG4J_WSRF_ENGINE_CONFIG_FILE );
             WSRFEngineConfigurationType wsrfConfig = config.getWSRFEngineConfiguration();
 
             String alias = wsrfConfig.getKeystore().getAlias();
             String aliasPassword = wsrfConfig.getKeystore().getAliasPassword();
             String keystoreFile = wsrfConfig.getKeystore().getKeystoreFile();
             String keystorePassword = wsrfConfig.getKeystore().getKeystorePassword();
             String keystoreType = wsrfConfig.getKeystore().getKeystoreType();
 
             String truststoreFile = wsrfConfig.getTruststore().getTruststoreFile();
             String truststorePassword = wsrfConfig.getTruststore().getTruststorePassword();
             String truststoreType = wsrfConfig.getTruststore().getTruststoreType();
 
             setProperty( SecurityConstants.PROP_CRYPTO_PROVIDER, Merlin.class.getName(), properties );
             setProperty( SecurityConstants.PROP_KEYSTORE_TYPE, keystoreType, properties );
             setProperty( SecurityConstants.PROP_KEYSTORE_PASS, keystorePassword, properties );
             setProperty( SecurityConstants.PROP_KEYSTORE_ALIAS, alias, properties );
             setProperty( SecurityConstants.PROP_KEYSTORE_ALIAS_PASS, aliasPassword, properties );
             setProperty( SecurityConstants.PROP_KEYSTORE_FILE, keystoreFile, properties );
 
             setProperty( SecurityConstants.PROP_TRUSTSTORE_FILE, truststoreFile, properties );
             setProperty( SecurityConstants.PROP_TRUSTSTORE_PASS, truststorePassword, properties );
             setProperty( SecurityConstants.PROP_TRUSTSTORE_TYPE, truststoreType, properties );
 
             return properties;
         }
         catch ( Exception e )
         {
             String message = "Merlin: Could not load WSAG4J keystore properties from configuration file.";
             throw new WSSecurityException( message, e );
         }
     }
 
     private static void setProperty( String name, String value, Properties properties )
     {
         if ( ( name != null ) && ( value != null ) )
         {
             properties.setProperty( name, value );
         }
     }
 
     private void loadTrustStore( ClassLoader loader )
     {
 
         try
         {
             KeyStore truststore = null;
 
             if ( ( truststoreFile != null ) && ( truststorePassword != null ) )
             {
                 try
                 {
                     InputStream is = null;
                     URL url = Loader.getResource( loader, truststoreFile );
 
                     if ( url != null )
                     {
                         is = url.openStream();
                     }
                     else
                     {
                         is = new java.io.FileInputStream( truststoreFile );
                     }
 
                     //
                     // If we don't find it, then look on the file system.
                     //
                     if ( is == null )
                     {
                         try
                         {
                             is = new FileInputStream( truststoreFile );
                         }
                         catch ( Exception e )
                         {
                             throw new CredentialException( 3, "proxyNotFound",
                                 new Object[] { truststoreFile } );
                         }
                     }
 
                     try
                     {
                         truststore = load( is, truststorePassword, null, truststoreType );
                     }
                     finally
                     {
                         is.close();
                     }
                 }
                 catch ( Exception e )
                 {
                     Object[] filler = new Object[] { e.getMessage() };
                     String message =
                         MessageFormat.format(
                             "Truststore was not specified or could not be loaded. Message: {0}", filler );
 
                     LOG.info( message );
                     LOG.info( "Use JVM cacerts as truststore." );
                 }
             }
 
             if ( truststore == null )
             {
                 // use default behavior with JVM ca-certs file as truststore
                 if ( LOG.isDebugEnabled() )
                 {
                     LOG.debug( "No truststore specified. Using default JVM ca-certs as truststore." );
                 }
             }
             else
             {
                 cacerts = truststore;
             }
 
         }
         catch ( Exception e )
         {
             Object[] filler = new Object[] { e.getMessage() };
             String message = MessageFormat.format( "truststore was not loaded. Reason: {0}", filler );
             LOG.error( message );
         }
 
     }
 
     /**
      * {@inheritDoc}
      * 
      * @see org.apache.ws.security.components.crypto.Crypto#getPrivateKey(java.lang.String, java.lang.String)
      * 
      *      Change the alias name provided in the AXIS2 service configuration to the defaultAlias if necessary
      *      and change the password accordingly.
      */
     @Override
     public PrivateKey getPrivateKey( String alias, String password ) throws Exception
     {
         if ( alias.equals( SecurityConstants.DEFAULT_ALIAS )
             && password.equals( SecurityConstants.DEFAULT_ALIAS_PASSWORD ) )
         {
             alias = getDefaultX509Alias();
             password = properties.getProperty( "org.apache.ws.security.crypto.merlin.alias.password" );
         }
         return super.getPrivateKey( alias, password );
     }
 
     /**
      * Change the alias name provided in the AXIS2 service configuration to the defaultAlias if necessary.
      * 
      * {@inheritDoc}
      * 
      * @see org.apache.ws.security.components.crypto.Crypto#getCertificates(java.lang.String)
      */
     @Override
     public X509Certificate[] getCertificates( String alias ) throws WSSecurityException
     {
         alias = ( alias.equals( SecurityConstants.DEFAULT_ALIAS ) ) ? getDefaultX509Alias() : alias;
         return super.getCertificates( alias );
     }
 
 }