package de.thedevstack.conversationsplus.utils;


import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

/**
 *
 */
public final class SimpleCryptoUtil {

    public static String encrypt(String seed, String cleartext) {
        String result = null;
        if (null != seed && null != cleartext) {
            try {
                byte[] rawKey = getRawKey(seed.getBytes());
                byte[] encryptedBytes = encrypt(rawKey, cleartext.getBytes());
                result = toHex(encryptedBytes);
            } catch (NoSuchAlgorithmException | InvalidKeyException | IllegalBlockSizeException | BadPaddingException | NoSuchPaddingException e) {
                // FIXME
            }
        }

        return result;
    }

    public static String decrypt(String seed, String encrypted) {
        String result = null;
        if (null != seed && null != encrypted) {
            try {
                byte[] rawKey = getRawKey(seed.getBytes());
                byte[] enc = toByte(encrypted);
                byte[] decryptedBytes = decrypt(rawKey, enc);
                result = new String(decryptedBytes);
            } catch (NoSuchAlgorithmException | InvalidKeyException | IllegalBlockSizeException | BadPaddingException | NoSuchPaddingException e) {
                // FIXME
            }
        }

        return result;
    }

    private static byte[] encrypt(byte[] raw, byte[] clear) throws IllegalBlockSizeException, BadPaddingException, InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException {
        byte[] encrypted = doCipherOperation(raw, clear, Cipher.ENCRYPT_MODE);
        return encrypted;
    }

    private static byte[] decrypt(byte[] raw, byte[] encrypted) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
        byte[] decrypted = doCipherOperation(raw, encrypted, Cipher.DECRYPT_MODE);
        return decrypted;
    }

    private static byte[] doCipherOperation(byte[] raw, byte[] input, int mode) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(mode, skeySpec);

        return cipher.doFinal(input);
    }

    private static byte[] getRawKey(byte[] seed) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] md5Bytes = md.digest(seed); // 128 Bit = 16 byte
        SecretKey skey = new SecretKeySpec(md5Bytes, "AES");
        byte[] raw = skey.getEncoded();
        return raw;
    }

    public static byte[] toByte(String hexString) {
        int len = hexString.length() / 2;
        byte[] result = new byte[len];
        for (int i = 0; i < len; i++) {
            result[i] = Integer.valueOf(hexString.substring(2 * i, 2 * i + 2), 16).byteValue();
        }
        return result;
    }

    public static String toHex(byte[] buf) {
        if (buf == null) {
            return null;
        }
        StringBuffer result = new StringBuffer(2 * buf.length);
        for (int i = 0; i < buf.length; i++) {
            appendHex(result, buf[i]);
        }
        return result.toString();
    }

    private final static String HEX = "0123456789ABCDEF";

    private static void appendHex(StringBuffer sb, byte b) {
        sb.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0x0f));
    }

    /**
     * private constructor to avoid instantiation
     */
    private SimpleCryptoUtil() {
        // private constructor to avoid instantiation
    }
}