/**
      This file is part of GoldenGate Project (named also GoldenGate or GG).
   
      Copyright 2009, Frederic Bregier, and individual contributors by the @author
      tags. See the COPYRIGHT.txt in the distribution for a full listing of
      individual contributors.
   
      All GoldenGate Project is free software: you can redistribute it and/or 
      modify it under the terms of the GNU General Public License as published 
     by the Free Software Foundation, either version 3 of the License, or
     (at your option) any later version.
  
     GoldenGate 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 GoldenGate .  If not, see <http://www.gnu.org/licenses/>.
   */
  package goldengate.common.crypto;
  
  import goldengate.common.exception.CryptoException;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.security.NoSuchAlgorithmException;
  import java.util.Enumeration;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.atomic.AtomicBoolean;
  
  /**
   * This class implements a simple Key Manager from name
   *
   * @author frederic bregier
   *
   */
  public abstract class KeyManager {
      ConcurrentHashMap<String, KeyObject> keysConcurrentHashMap =
          new ConcurrentHashMap<String, KeyObject>();
      volatile AtomicBoolean isInitialized = new AtomicBoolean(false);
  
      public abstract KeyObject createKeyObject();
      /**
       * Init the Manager from a list of filename Key, the key name is the basename minus the extension
       * @param keys
       * @param extension
       * @return the list of wrong keys
       */
      public List<String> initFromList(List<String> keys, String extension) {
          LinkedList<String> wrong = new LinkedList<String>();
          for (String filename: keys) {
              File file = new File(filename);
              if (file.canRead()) {
                  String basename = file.getName();
                  int lastpos = basename.lastIndexOf(extension);
                  if (lastpos <= 0) {
                      wrong.add(filename);
                      continue;
                  }
                  String firstname = basename.substring(0, lastpos-1);
                  int len = (int)file.length();
                  byte []key = new byte[len];
                  FileInputStream inputStream = null;
                  try {
                      inputStream = new FileInputStream(file);
                  } catch (FileNotFoundException e) {
                      // should not be
                      wrong.add(filename);
                      continue;
                  }
                  int read = 0;
                  int offset = 0;
                  while (read > 0) {
                      try {
                          read = inputStream.read(key, offset, len);
                      } catch (IOException e) {
                          wrong.add(filename);
                          read = -2;
                          break;
                      }
                      offset += read;
                      if (offset < len) {
                          len -= read;
                      } else {
                          break;
                      }
                  }
                  if (read < -1) {
                      // wrong
                      continue;
                  }
                  KeyObject keyObject = createKeyObject();
                  keyObject.setSecretKey(key);
                  this.setKey(firstname, keyObject);
             } else {
                 wrong.add(filename);
             }
         }
         this.isInitialized.set(true);
         return wrong;
     }
 
     public void saveToFiles(String extension) throws CryptoException, IOException {
         Enumeration<String> names = keysConcurrentHashMap.keys();
         while (names.hasMoreElements()) {
             String name = names.nextElement();
             KeyObject key = keysConcurrentHashMap.get(name);
             key.saveSecretKey(new File(name+"."+extension));
         }
     }
     /**
      * Add or set a new key associated to the given name
      *
      * @param name
      * @param keyObject
      */
     public void setKey(String name, KeyObject keyObject) {
         this.keysConcurrentHashMap.put(name, keyObject);
     }
 
     /**
      * @param name
      * @return the key associated to the given name
      */
     public KeyObject getKey(String name) {
         return this.keysConcurrentHashMap.get(name);
     }
     /**
      * One method to get the crypted String from the given string and key
      * @param keyName
      * @param toBeCrypted
      * @return the crypted String
      * @throws Exception
      */
     public String crypt(String keyName, String toBeCrypted) throws Exception {
         KeyObject keyObject = this.getKey(keyName);
         if (keyName == null) {
             throw new NoSuchAlgorithmException("Key does not exist: "+keyName);
         }
         return keyObject.cryptToHex(toBeCrypted);
     }
     /**
      * One method to get the uncrypted String from the given crypted string and key
      * @param keyName
      * @param toBeDecrypted
      * @return the uncrypted String
      * @throws Exception
      */
     public String decrypt(String keyName, String toBeDecrypted) throws Exception {
         KeyObject keyObject = this.getKey(keyName);
         if (keyName == null) {
             throw new NoSuchAlgorithmException("Key does not exist: "+keyName);
         }
         return keyObject.decryptHexInString(toBeDecrypted);
     }
 
 }