package utils;


import java.io.Serializable;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import java.util.Base64;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SealedObject;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;

public class CryptUtil {

	public static final int AES_128 = 128;
	public static final int AES_256 = 256; 
	public static final int AES_512 = 512;
	
	public static final String ECB_MODE = "AES/ECB/PKCS5Padding";
	public static final String CBC_MODE = "AES/CBC/PKCS5Padding";
	
	/**
	 * 			 (PKBDF2)
	 * 
	 * num of iterations 	time(ms)
	 *
	 *		100				2
	 *		1000			16
	 *		10.000			196
	 *		50.000			807
	 *		100.000			1474
   	 *		200.000			2892
	 *		500.000			7172
	 *
	 */
	
	
	
	
	
	// n --> (128, 192, and 256)
	public static SecretKey genSecretKeyAES(int n) {
	
		SecretKey key = null;
		
		try {
			KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
			keyGenerator.init(n);
			key = keyGenerator.generateKey();
			
		}catch(Exception e) {utils.MessageUtil.showErrorMessage("ERROR",
																"Error creating secret key for AES",
																utils.MessageUtil.ROUNDED_DENIED,
																e);}
		
	    return key;
	}
	
	public static byte[] genSalt() {
		
		byte[] salt = null;
		
		try {
			SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
			salt = new byte[16];
			sr.nextBytes(salt);

		}catch(Exception e) {utils.MessageUtil.showErrorMessage("ERROR",
																"Error generating salt",
																utils.MessageUtil.ROUNDED_DENIED,
																e);}
		
		return salt;
	}
	

	public static IvParameterSpec genIVSpec() {
		
		byte[] iv = null;
		
		try {
			iv = new byte[16];
			new SecureRandom().nextBytes(iv);

		}catch(Exception e) {utils.MessageUtil.showErrorMessage("ERROR",
																"Error generating IV",
																utils.MessageUtil.ROUNDED_DENIED,
																e);}
		
		return new IvParameterSpec(iv);
	}
	
	public static byte[] genIVBuffer() {
		
		byte[] iv = null;
		
		try {
			iv = new byte[16];
			new SecureRandom().nextBytes(iv);

		}catch(Exception e) {utils.MessageUtil.showErrorMessage("ERROR",
																"Error generating IV",
																utils.MessageUtil.ROUNDED_DENIED,
																e);}
		
		return iv;
	}
	
	public static SecretKey hashKeyWithPKBDF2(char[] password, byte[] salt) {
		    
		SecretKey hashedKey = null;
		
		try {
			SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
			KeySpec spec = new PBEKeySpec(password, salt, 66000, 256);
			hashedKey = new SecretKeySpec(factory.generateSecret(spec).getEncoded(), "AES");
		
		}catch(Exception e) {utils.MessageUtil.showErrorMessage("ERROR",
															"Error hashing the password",
															utils.MessageUtil.ROUNDED_DENIED,
															e);}
			
		return hashedKey;
	}
	
	public static SecretKey hashKeyWithPKBDF2(char[] password, int iterations, byte[] salt) {
		SecretKey hashedKey = null;
		
		try {
			SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
			KeySpec spec = new PBEKeySpec(password, salt, iterations, 256);
			hashedKey = new SecretKeySpec(factory.generateSecret(spec).getEncoded(), "AES");
		
		}catch(Exception e) {utils.MessageUtil.showErrorMessage("ERROR",
																"Error hashing the password",
																utils.MessageUtil.ROUNDED_DENIED,
																e);}
		
		return hashedKey;
	}
	
	
	
	public static SecretKey hashKeyWithPKBDF2(char[] password,
												   byte[] salt,
												   int iterations,
												   int shaAlgo) throws NoSuchAlgorithmException, InvalidKeySpecException {
		SecretKey hashedKey = null;
		
		try {
			SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
			KeySpec spec = new PBEKeySpec(password, salt, iterations, shaAlgo);
			hashedKey = new SecretKeySpec(factory.generateSecret(spec).getEncoded(), "AES");
		
		}catch(Exception e) {utils.MessageUtil.showErrorMessage("ERROR",
																"Error hashing the password",
																utils.MessageUtil.ROUNDED_DENIED,
																e);}
		
		return hashedKey;
	}
	
	
	public static String encodeToBase64String(byte[] cipherText) {
		return Base64.getEncoder().encodeToString(cipherText);
		
	}
	
	public static byte[] encodeToBase64Buffer(byte[] cipherText) {
		return Base64.getEncoder().encode(cipherText);
		
	}
	
	
	public static byte[] decodeFromBase64String(String cipherText) {
		return Base64.getDecoder().decode(cipherText);
		
	}
	
	public static byte[] decodeFromBase64Buffer(byte[] cipherText) {
		return Base64.getDecoder().decode(cipherText);
		
	}
	
	
	
	
	public static String encryptWithCBCMode(byte[] plainText, char[] password) {
		
		byte[] cipherText = null;
		byte[] salt = null;
		byte[] ivBuffer = null;
		

		
		try {
			
			salt = genSalt();
			ivBuffer = genIVBuffer();
			SecretKey key = hashKeyWithPKBDF2(password, salt);

			Cipher cipher = Cipher.getInstance(CBC_MODE);
			cipher.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(ivBuffer));
			cipherText = cipher.doFinal(plainText);
			
		    
			

		}catch(Exception e) {utils.MessageUtil.showErrorMessage("ERROR",
																"Error encrypting the note",
																utils.MessageUtil.ROUNDED_DENIED,
																e);}
		
		password = null;
		
		return encodeToBase64String(salt) + encodeToBase64String(ivBuffer) + encodeToBase64String(cipherText);
		
		}
	
	
	
	public static String decryptWithCBCMode(String encodedCipherText, char[] password, String encodedSalt, String encodedIV) {
		
		byte[] plainText = null;
		
		try {
			
			byte[] decodedCiphertext = decodeFromBase64String(encodedCipherText);
		    byte[] decodedSalt = decodeFromBase64String(encodedSalt);
		    byte[] decodedIV = decodeFromBase64String(encodedIV);
			
			SecretKey key = hashKeyWithPKBDF2(password, decodedSalt);
			
		    Cipher cipher = Cipher.getInstance(CBC_MODE);
		    cipher.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(decodedIV));
		    plainText = cipher.doFinal(decodedCiphertext);
		    
		   
		}catch(Exception e) {utils.MessageUtil.showErrorMessage("ERROR",
																"Error decrypting the note",
																utils.MessageUtil.ROUNDED_DENIED,
																e);}
	
		password = null;
		
	    return new String(plainText);
	}
	
	
	/**		(How a file should be read, into chunks)		
	  * 
	  *		byte[] buff = new byte[BUFFERSIZE];
	  *		for(int readBytes=in.read(buff); readBytes>-1;readBytes=in.read(buff)) {
  	  *			out.write(cipher.update(buff,0, readBytes);
	  *		}
	  *		out.write(cipher.doFinal());
	  *
	  */
	
	
	
	@Deprecated
	public static SealedObject encryptObjectWithECB(Serializable object, SecretKey key) {
		    
		SealedObject sealedObject = null;
		
		try {
		
			Cipher cipher = Cipher.getInstance(ECB_MODE);
			cipher.init(Cipher.ENCRYPT_MODE, key);
			sealedObject = new SealedObject(object, cipher);

		}catch(Exception e) {utils.MessageUtil.showErrorMessage("ERROR",
															"Error decrypting the object " + object.getClass(),
															utils.MessageUtil.ROUNDED_DENIED,
															e);}
			
		return sealedObject;
	}
	
	@Deprecated
	public static Serializable decryptObjectWithECB(SealedObject sealedObject,SecretKey key) {
			
	Serializable unsealObject = null;
	
	try {
			
		Cipher cipher = Cipher.getInstance(ECB_MODE);
		cipher.init(Cipher.DECRYPT_MODE, key);
		unsealObject = (Serializable) sealedObject.getObject(cipher);
		    
	}catch(Exception e) {utils.MessageUtil.showErrorMessage("ERROR",
															"Error decrypting the object " + sealedObject.getClass(),
															utils.MessageUtil.ROUNDED_DENIED,
															e);}
	
	return unsealObject;
	
	}
	
	public static SealedObject encryptObjectWithECB(Serializable object,SecretKey key, IvParameterSpec iv) {
		    
		SealedObject sealedObject = null;
		
		try {
		
			Cipher cipher = Cipher.getInstance(CBC_MODE);
		    cipher.init(Cipher.ENCRYPT_MODE, key, iv);
		    sealedObject = new SealedObject(object, cipher);

		}catch(Exception e) {utils.MessageUtil.showErrorMessage("ERROR",
																"Error decrypting the object " + object.getClass(),
																utils.MessageUtil.ROUNDED_DENIED,
																e);}
		
	    return sealedObject;
	}
	
	public static Serializable decryptObjectWithCBC(SealedObject sealedObject, SecretKey key, IvParameterSpec iv) {
		    
		Serializable unsealObject = null;
		
		try {
		
		    Cipher cipher = Cipher.getInstance(CBC_MODE);
		    cipher.init(Cipher.DECRYPT_MODE, key, iv);
		    unsealObject = (Serializable) sealedObject.getObject(cipher);

		 
		}catch(Exception e) {utils.MessageUtil.showErrorMessage("ERROR",
																"Error decrypting the object " + sealedObject.getClass(),
																utils.MessageUtil.ROUNDED_DENIED,
																e);}
	    return unsealObject;
	}
}