package com.ywt.outpatient.core.utils;

/**
 * @author daiyihua
 * @create 2023-04-28 17:58
 * @program ywt-wapapi
 * @description AES对称加密算法
 **/

import com.ywt.biz.common.util.Checker;
import org.apache.commons.codec.binary.Hex;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.Key;
import java.security.SecureRandom;


public class AESUtil {

    private static final String KEY_ALGORITHM = "AES";
    private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";
    private static final String PASSWORD = "ywta123456.";     //加解密的密码

    /**
     * 指定随机字符串（密码）生成密钥
     *
     * @param randomKey 加解密的密码
     * @throws Exception
     */
    public static byte[] getSecretKey(String randomKey) throws Exception {
        KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_ALGORITHM); //秘钥生成器，指定秘钥算法

        //初始化此密钥生成器，指定AES的秘钥长度为128
        if (Checker.isNone(randomKey)) {   //不指定密码
            keyGenerator.init(128);
        } else {    //指定密码
            SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
            random.setSeed(randomKey.getBytes());
            keyGenerator.init(128, random);
        }

        SecretKey secretKey = keyGenerator.generateKey();   //生成密钥
        return secretKey.getEncoded();
    }

    /**
     * 加密
     *
     * @param data 待加密数据
     * @param key  密钥
     * @return byte[]   加密数据
     * @throws Exception
     */
    public static byte[] encrypt(byte[] data, Key key) throws Exception {
        return encrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
    }

    /**
     * 加密
     *
     * @param data 待加密数据
     * @param key  二进制密钥
     * @return byte[]   加密数据
     * @throws Exception
     */
    public static byte[] encrypt(byte[] data, byte[] key) throws Exception {
        return encrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
    }

    /**
     * 加密
     *
     * @param data            待加密数据
     * @param key             二进制密钥
     * @param cipherAlgorithm 加密算法/工作模式/填充方式
     * @return byte[]   加密数据
     * @throws Exception
     */
    public static byte[] encrypt(byte[] data, byte[] key, String cipherAlgorithm) throws Exception {
        Key k = toKey(key);
        return encrypt(data, k, cipherAlgorithm);
    }

    /**
     * 加密
     *
     * @param data            待加密数据
     * @param key             密钥
     * @param cipherAlgorithm 加密算法/工作模式/填充方式
     * @return byte[]   加密数据
     * @throws Exception
     */
    public static byte[] encrypt(byte[] data, Key key, String cipherAlgorithm) throws Exception {
        Cipher cipher = Cipher.getInstance(cipherAlgorithm);    //获取算法
        cipher.init(Cipher.ENCRYPT_MODE, key);                  //设置加密模式，并指定秘钥
        return cipher.doFinal(data);                            //加密数据
    }

    /**
     * 解密
     *
     * @param data 待解密数据
     * @param key  二进制密钥
     * @return byte[]   解密数据
     * @throws Exception
     */
    public static byte[] decrypt(byte[] data, byte[] key) throws Exception {
        return decrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
    }

    /**
     * 解密
     *
     * @param data 待解密数据
     * @param key  密钥
     * @return byte[]   解密数据
     * @throws Exception
     */
    public static byte[] decrypt(byte[] data, Key key) throws Exception {
        return decrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
    }

    /**
     * 解密
     *
     * @param data            待解密数据
     * @param key             二进制密钥
     * @param cipherAlgorithm 加密算法/工作模式/填充方式
     * @return byte[]   解密数据
     * @throws Exception
     */
    public static byte[] decrypt(byte[] data, byte[] key, String cipherAlgorithm) throws Exception {
        Key k = toKey(key);
        return decrypt(data, k, cipherAlgorithm);
    }

    /**
     * 解密
     *
     * @param data            待解密数据
     * @param key             密钥
     * @param cipherAlgorithm 加密算法/工作模式/填充方式
     * @return byte[]   解密数据
     * @throws Exception
     */
    public static byte[] decrypt(byte[] data, Key key, String cipherAlgorithm) throws Exception {
        Cipher cipher = Cipher.getInstance(cipherAlgorithm);     //获取算法
        cipher.init(Cipher.DECRYPT_MODE, key);                   //设置解密模式，并指定秘钥
        return cipher.doFinal(data);                             //解密数据
    }


    /**
     * 转换密钥
     *
     * @param secretKey 二进制密钥
     * @return 密钥
     */
    public static Key toKey(byte[] secretKey) {
        return new SecretKeySpec(secretKey, KEY_ALGORITHM);   //生成密钥
    }

    /**
     * 加密
     *
     * @param data 需要加密的数据
     * @return
     * @throws Exception
     */
    public static String encrypt(String data) {
        try {
            if (Checker.isNone(data)) {
                return "";
            }
            byte[] secretKey = getSecretKey(PASSWORD);
            Key key = toKey(secretKey);
            byte[] encryptData = encrypt(data.getBytes(), key);
            String encryptDataHex = Hex.encodeHexString(encryptData);   //把密文转为16进制
            return encryptDataHex;
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("加密失败" + e.getMessage());
            System.out.println(e);
            return "";
        }
    }

    /**
     * 解密
     *
     * @param encryptDataHex 需要解密的数据，十六进制
     * @return
     * @throws Exception
     */
    public static String decrypt(String encryptDataHex) {
        try {
            if (Checker.isNone(encryptDataHex)) {
                return "";
            }
            byte[] secretKey = getSecretKey(PASSWORD);
            Key key = toKey(secretKey);
            byte[] decryptData = decrypt(Hex.decodeHex(encryptDataHex.toCharArray()), key);
            return new String(decryptData);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("解密失败" + e.getMessage());
            System.out.println(e);
            return "";
        }
    }
/*
    public static void main(String[] args) throws Exception {
        // 方式一：
        String data = "AES 对称加密算法-----";
        String encryptDataHex = encrypt(data);
        System.out.println("加密 : " + encryptDataHex);
        String decryptData = decrypt(encryptDataHex);
        System.out.println("解密 : " + decryptData);

        // 方式二：
        String password = "123456";     //加解密的密码
        byte[] secretKey = getSecretKey(password);
        Key key = toKey(secretKey);

        String data = "AES 对称加密算法";
        System.out.println("明文 ：" + data);

        byte[] encryptData = encrypt(data.getBytes(), key);
        String encryptDataHex = Hex.encodeHexString(encryptData);   //把密文转为16进制
        System.out.println("加密 : " + encryptDataHex);

        byte[] decryptData = decrypt(Hex.decodeHex(encryptDataHex.toCharArray()), key);
        System.out.println("解密 : " + new String(decryptData));
    }
 */
}


