/*
    * Copyright 2001-2008 The Apache Software Foundation.
    * 
    * 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 org.apache.juddi.v3.client.cryptor;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileReader;
  import java.util.HashMap;
  import java.util.Map;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.juddi.v3.client.ClassUtil;
  import org.apache.juddi.v3.client.config.Property;
  
  /**
   * Used to create the org.apache.juddi.cryptor.Cryptor implementation as
   * specified by the 'juddi.cryptor' property. Defaults to
   * org.apache.juddi.cryptor.DefaultCryptor if an implementation is not
   * specified.
   *
   * @author Steve Viens (sviens@apache.org)
   * @author <a href="mailto:jfaath@apache.org">Jeff Faath</a>
   */
  public abstract class CryptorFactory {
  
          private static final Log log = LogFactory.getLog(CryptorFactory.class);
          // the shared Cryptor instance
          private static Cryptor cryptor = null;
          private static Map<String, Cryptor> cache = new HashMap<String, Cryptor>();
  
          /**
           * Returns a crypto provider with the matching classname, throws if not
           * possible
           *
           * @param className
           * @return a Cryptor instance
           * @throws Exception
           */
          public static Cryptor getCryptor(String className) throws Exception {
                  if (cache.containsKey(className)) {
                          return cache.get(className);
                  }
                  Class<?> cryptorClass = null;
                  try {
                          // Use Loader to locate & load the Cryptor implementation
                          cryptorClass = ClassUtil.forName(className, CryptorFactory.class);
                  } catch (ClassNotFoundException e) {
                          log.error("The specified Cryptor class '" + className + "' was not found in classpath.");
                          log.error(e);
                          throw e;
                  }
  
                  try {
                          // try to instantiate the Cryptor implementation
                          cryptor = (Cryptor) cryptorClass.newInstance();
                          cache.put(className, cryptor);
                  } catch (Exception e) {
                          log.error("Exception while attempting to instantiate the implementation of Cryptor: " + cryptorClass.getName() + "\n" + e.getMessage());
                          log.error(e);
                          throw e;
                  }
  
                  return cryptor;
          }
  
          /**
           * Returns a new instance of a CryptorFactory.
           *
           * @return Cryptor
           */
          public static synchronized Cryptor getCryptor() {
                  if (cryptor == null) {
                          cryptor = createCryptor();
                  }
                  return cryptor;
          }
  
          /*
           * Returns a new instance of a Cryptor.
           * 
           * @return Cryptor
           */
          private static synchronized Cryptor createCryptor() {
                  if (cryptor != null) {
                          return cryptor;
                 }
 
                 // grab class name of the Cryptor implementation to create
                 String className = Property.DEFAULT_CRYPTOR;
 
                 // write the Cryptor implementation name to the log
                 log.debug("Cryptor Implementation = " + className);
 
                 Class<?> cryptorClass = null;
                 try {
                         // Use Loader to locate & load the Cryptor implementation
                         cryptorClass = ClassUtil.forName(className, CryptorFactory.class);
                 } catch (ClassNotFoundException e) {
                         log.error("The specified Cryptor class '" + className + "' was not found in classpath.");
                         log.error(e);
                 }
 
                 if (cryptorClass != null) {
                         try {
                                 // try to instantiate the Cryptor implementation
                                 cryptor = (Cryptor) cryptorClass.newInstance();
                         } catch (Exception e) {
                                 log.error("Exception while attempting to instantiate the implementation of Cryptor: " + cryptorClass.getName() + "\n" + e.getMessage());
                                 log.error(e);
                         }
                 }
 
                 return cryptor;
         }
 
         protected static String loadKeyFromFile(String provider) {
                 String fs = System.getProperty("juddi.encryptionKeyFile." + provider);
                 if (fs == null || fs.length() == 0) {
                         return null;
                 }
                 File cwd = new File(".");
                 log.debug("CWD="+cwd.getAbsolutePath());
                 File f = new File(fs);
                 if (f.exists() && f.isFile()) {
                         BufferedReader reader = null;
                         try {
                                 reader = new BufferedReader(new FileReader(f));
                                 String line = null;
                                 StringBuilder stringBuilder = new StringBuilder();
                                 String ls = System.getProperty("line.separator");
 
                                 while ((line = reader.readLine()) != null) {
                                         stringBuilder.append(line);
                                         stringBuilder.append(ls);
                                 }
                                 reader.close();
 
                                 return stringBuilder.toString().trim();
                         } catch (Exception ex) {
                                 log.warn("the system property juddi.encryptionKeyFile."  + provider+" is defined, however there was an error reading the file!", ex);
                         } finally {
                                 if (reader != null) {
                                         try {
                                                 reader.close();
                                         } catch (Exception ex) {
 
                                         }
                                 }
                         }
                 } else {
                         log.warn("the system property juddi.encryptionKeyFile."  + provider+" is defined, however that file either couldn't be found or isn't a file");
                 }
                 return null;
         }
 }