package org.kuali.mobility.security.util;
   import java.security.InvalidKeyException;
   import java.security.NoSuchAlgorithmException;
   import java.util.List;
   import java.util.Properties;
   
   import javax.crypto.BadPaddingException;
   import javax.crypto.Cipher;
   import javax.crypto.IllegalBlockSizeException;
  import javax.crypto.NoSuchPaddingException;
  import javax.crypto.spec.SecretKeySpec;
  
  import org.apache.commons.codec.binary.Base64;
  import org.apache.log4j.Logger;
  
  public class EncryptionUtil implements EncryptionConstants{
  	
  	private static final Logger LOGGER = Logger.getLogger(EncryptionUtil.class);
  	
  	private SecretKeySpec keySpec;
  	private Cipher encryptionCipher, decryptionCipher;
  
  	private String encodedKey;
  	private String algorithm;
  	
  	Properties kmeProperties;
  	
  	/**
  	 * 
  	 * 
  	 * @param propertiesFile - the file which contains entry for key, algorithm and its sub type.
  	 * @throws NoSuchAlgorithmException 
  	 * @throws NoSuchPaddingException 
  	 * @throws InvalidKeyException 
  	 */
  	public EncryptionUtil(Properties properties) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException {		
  		algorithm = properties.getProperty(ENCRYPTION_ALGORITHM);
  		if(algorithm == null){
  			throw new RuntimeException("No encryption algorithm provided");
  		}
  		
  		encodedKey = properties.getProperty(ENCRYPTION_KEY);
  		
  		this.kmeProperties = properties;
  		
  		keySpec = new SecretKeySpec(Base64.decodeBase64(encodedKey),algorithm);
  		
  		encryptionCipher = Cipher.getInstance(algorithm);
  		decryptionCipher = Cipher.getInstance(algorithm);
  		
  		encryptionCipher.init(Cipher.ENCRYPT_MODE, keySpec);
  		decryptionCipher.init(Cipher.DECRYPT_MODE, keySpec);		
  
  	}
  	
  	public synchronized String encrypt(String value) throws IllegalBlockSizeException, BadPaddingException{
  		byte[] encryptedBytes = encryptionCipher.doFinal(value.getBytes());
  		return Base64.encodeBase64String(encryptedBytes);
  	}
  	
  	public synchronized String decrypt(String value) throws IllegalBlockSizeException, BadPaddingException{
  		byte[] decodedBytes = Base64.decodeBase64(value);
  		byte[] decryptedBytes = decryptionCipher.doFinal(decodedBytes);
  		return new String(decryptedBytes);
  	}
  	
  	public Properties encryptProperties(List<String> propertyNames) throws IllegalBlockSizeException, BadPaddingException{
  		Properties encryptedProperties = new Properties();
  				
  		for(String property : propertyNames){
  			String encryptedValue =  encrypt(kmeProperties.getProperty(property));
  			encryptedProperties.put(property,encryptedValue);
  			LOGGER.info(property + "=" + encryptedValue);
  		}
  		
  		return encryptedProperties;		
  	}	
  }