package rydeen.plugins.strenc;
   
   import java.security.InvalidKeyException;
   import java.security.NoSuchAlgorithmException;
   import java.security.Provider;
   import java.security.Security;
   
   import javax.crypto.BadPaddingException;
   import javax.crypto.Cipher;
  import javax.crypto.IllegalBlockSizeException;
  import javax.crypto.KeyGenerator;
  import javax.crypto.NoSuchPaddingException;
  import javax.crypto.SecretKey;
  import javax.crypto.spec.SecretKeySpec;
  
  import rydeen.Arguments;
  import rydeen.ProcessorException;
  import rydeen.ProcessorInitializeException;
  
  /**
   * 暗号化を管理するためのクラスです．
   *
   * @author Haruaki Tamada
   */
  public class EncryptManager{
      private static final int DEFAULT_KEY_LENGTH = 128;
      private String algorithm;
      private Cipher cipher;
      private String decryptClassName;
      private String decryptMethodName;
      private byte[] key;
      private int keyLength;
      private Provider provider;
  
      /**
       * 与えられたパラメータで暗号化を管理するクラスのオブジェクトを作成します．
       * 指定可能なパラメータは{@link StringEncryptObfuscatorService#createDefaultArguments}
       * を参照してください．
       */
      public EncryptManager(Arguments args) throws ProcessorException{
          this.algorithm = args.getValue("algorithm");
  
          String keyLengthString = args.getValue("keyLength");
          if(keyLengthString != null){
              try{
                  keyLength = Integer.parseInt(keyLengthString);
              } catch(NumberFormatException e){
                  keyLength = DEFAULT_KEY_LENGTH;
              }
          }
          String keyString = args.getValue("key");
          if(keyString == null || keyString.trim().equals("")){
              key = generateKey(keyLength);
          }
          else{
              key = normalizeGivenKey(keyString, keyLength);
          }
  
          String providerString = args.getValue("provider");
          if(providerString == null || providerString.trim().equals("")){
              provider = Security.getProvider(providerString);
          }
  
          initCipher();
      }
  
      public Provider getProvider(){
          return provider;
      }
  
      public String getAlgorithm(){
          return algorithm;
      }
  
      public String getKeyFieldName(){
          return "__decryptKey";
      }
  
      public byte[] getKey(){
          byte[] newKey = new byte[key.length];
          System.arraycopy(key, 0, newKey, 0, key.length);
          return newKey;
      }
  
      public String encrypt(String string){
          return encodeHex(string.getBytes());
      }
  
      public byte[] encode(byte[] data){
          try{
              return cipher.doFinal(data);
          } catch(IllegalBlockSizeException e){
          } catch(BadPaddingException e){
          }
          return null;
      }
  
      private String encodeHex(byte[] data){
          byte[] encodedData = encode(data);
         StringBuilder sb = new StringBuilder();
         for(int i = 0; i < encodedData.length; i++){
             int value = encodedData[i] & 0xff;
             if(value < 0x10) sb.append('0');
             sb.append(Integer.toHexString(value));
         }
         return new String(sb);
     }
 
     private byte[] generateKey(int keyLength) throws ProcessorException{
         try{
             KeyGenerator keyGen = KeyGenerator.getInstance(algorithm);
             keyGen.init(keyLength);
             SecretKey skey = keyGen.generateKey();
             return skey.getEncoded();
         } catch(NoSuchAlgorithmException e){
             throw new ProcessorInitializeException(e);
         }
     }
 
     public String getDecryptClassName(){
         return decryptClassName;
     }
 
     public String getDecryptMethodName(){
         return decryptMethodName;
     }
 
     private void initCipher() throws ProcessorException{
         try{
             SecretKeySpec skeySpec = new SecretKeySpec(key, algorithm);
             if(provider != null){
                 cipher = Cipher.getInstance(algorithm, provider);
             }
             else{
                 cipher = Cipher.getInstance(algorithm);
             }
             cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
 
         } catch(NoSuchAlgorithmException e){
             throw new ProcessorInitializeException(e);
         } catch(NoSuchPaddingException e){
             throw new ProcessorInitializeException(e);
         } catch(InvalidKeyException e){
             throw new ProcessorInitializeException(e);
         }
     }
 
     private byte[] normalizeGivenKey(String keyString, int keyLength) throws ProcessorException{
         byte[] key = keyString.getBytes();
         byte[] skey = new byte[keyLength];
         int minLength = skey.length;
         if(skey.length > key.length){
             minLength = key.length;
         }
         System.arraycopy(key, 0, skey, 0, minLength);
         return skey;
     }
 
     public void setDecryptClassName(String decryptClassName){
         this.decryptClassName = decryptClassName;
     }
 
     public void setDecryptMethodName(String decryptMethodName){
         this.decryptMethodName = decryptMethodName;
     }
 }