package encryptx

import (
	"testing"
)

func TestGetEncryptTypeName(t *testing.T) {
	// 测试获取加密类型名称
	if name := GetEncryptTypeName(MD5); name != "MD5" {
		t.Errorf("MD5类型名称错误，期望: MD5, 实际: %s", name)
	}

	if name := GetEncryptTypeName(AES_CBC); name != "AES-CBC" {
		t.Errorf("AES-CBC类型名称错误，期望: AES-CBC, 实际: %s", name)
	}

	if name := GetEncryptTypeName(RSA); name != "RSA" {
		t.Errorf("RSA类型名称错误，期望: RSA, 实际: %s", name)
	}
}

func TestGetAllEncryptTypes(t *testing.T) {
	// 测试获取所有加密类型
	types := GetAllEncryptTypes()
	if len(types) != len(encryptTypeNames) {
		t.Errorf("加密类型数量不匹配，期望: %d, 实际: %d", len(encryptTypeNames), len(types))
	}

	// 检查是否包含所有类型
	for _, tt := range types {
		if _, ok := encryptTypeNames[tt]; !ok {
			t.Errorf("未知的加密类型: %d", tt)
		}
	}
}

func TestEncryptHashAlgorithms(t *testing.T) {
	data := "test data"

	// 测试哈希算法
	md5Hash, err := Encrypt(MD5, data, "", nil)
	if err != nil {
		t.Errorf("MD5加密失败: %v", err)
	}

	sha1Hash, err := Encrypt(SHA1, data, "", nil)
	if err != nil {
		t.Errorf("SHA1加密失败: %v", err)
	}

	sha256Hash, err := Encrypt(SHA256, data, "", nil)
	if err != nil {
		t.Errorf("SHA256加密失败: %v", err)
	}

	sha512Hash, err := Encrypt(SHA512, data, "", nil)
	if err != nil {
		t.Errorf("SHA512加密失败: %v", err)
	}

	sha3_256Hash, err := Encrypt(SHA3_256, data, "", nil)
	if err != nil {
		t.Errorf("SHA3-256加密失败: %v", err)
	}

	sha3_384Hash, err := Encrypt(SHA3_384, data, "", nil)
	if err != nil {
		t.Errorf("SHA3-384加密失败: %v", err)
	}

	sha3_512Hash, err := Encrypt(SHA3_512, data, "", nil)
	if err != nil {
		t.Errorf("SHA3-512加密失败: %v", err)
	}

	// 确保所有哈希值都不同
	hashes := []string{md5Hash, sha1Hash, sha256Hash, sha512Hash, sha3_256Hash, sha3_384Hash, sha3_512Hash}
	for i := 0; i < len(hashes); i++ {
		for j := i + 1; j < len(hashes); j++ {
			if hashes[i] == hashes[j] {
				t.Errorf("不同的哈希算法产生了相同的哈希值")
			}
		}
	}
}

func TestEncryptSymmetricAlgorithms(t *testing.T) {
	data := "test data"
	key := "test_key_1234567" // 16字节，适用于AES

	// 测试对称加密算法
	aesECBEncrypted, err := Encrypt(AES_ECB, data, key, nil)
	if err != nil {
		t.Errorf("AES-ECB加密失败: %v", err)
	}

	aesCBCEncrypted, err := Encrypt(AES_CBC, data, key, nil)
	if err != nil {
		t.Errorf("AES-CBC加密失败: %v", err)
	}

	aesCFBEncrypted, err := Encrypt(AES_CFB, data, key, nil)
	if err != nil {
		t.Errorf("AES-CFB加密失败: %v", err)
	}

	// 测试解密
	aesECBDecrypted, err := Decrypt(AES_ECB, aesECBEncrypted, key, nil)
	if err != nil {
		t.Errorf("AES-ECB解密失败: %v", err)
	}
	if aesECBDecrypted != data {
		t.Errorf("AES-ECB解密结果不匹配，期望: %s, 实际: %s", data, aesECBDecrypted)
	}

	aesCBCDecrypted, err := Decrypt(AES_CBC, aesCBCEncrypted, key, nil)
	if err != nil {
		t.Errorf("AES-CBC解密失败: %v", err)
	}
	if aesCBCDecrypted != data {
		t.Errorf("AES-CBC解密结果不匹配，期望: %s, 实际: %s", data, aesCBCDecrypted)
	}

	aesCFBDecrypted, err := Decrypt(AES_CFB, aesCFBEncrypted, key, nil)
	if err != nil {
		t.Errorf("AES-CFB解密失败: %v", err)
	}
	if aesCFBDecrypted != data {
		t.Errorf("AES-CFB解密结果不匹配，期望: %s, 实际: %s", data, aesCFBDecrypted)
	}
}

func TestEncryptAsymmetricAlgorithms(t *testing.T) {
	// RSA需要密钥文件，这里只测试函数调用不会崩溃
	data := "test data"
	options := map[string]interface{}{
		"publicKeyPath": "public.pem",
	}

	// 测试RSA加密（可能会失败，因为没有密钥文件，但不应该崩溃）
	_, err := Encrypt(RSA, data, "", options)
	// 这里不检查错误，因为密钥文件可能不存在
	_ = err
}

func TestEncryptMACAlgorithms(t *testing.T) {
	data := "test data"
	key := "test_key"

	// 测试消息认证码
	hmac256, err := Encrypt(HMAC_SHA256, data, key, nil)
	if err != nil {
		t.Errorf("HMAC-SHA256加密失败: %v", err)
	}

	hmac512, err := Encrypt(HMAC_SHA512, data, key, nil)
	if err != nil {
		t.Errorf("HMAC-SHA512加密失败: %v", err)
	}

	// 确保两种算法产生不同的结果
	if hmac256 == hmac512 {
		t.Errorf("HMAC-SHA256和HMAC-SHA512产生了相同的结果")
	}
}

func TestEncryptPBKDF2(t *testing.T) {
	password := "test_password"
	options := map[string]interface{}{
		"salt":      "test_salt",
		"iterations": 1000,
		"keyLength":  32,
	}

	// 测试PBKDF2
	key, err := Encrypt(PBKDF2, password, "", options)
	if err != nil {
		t.Errorf("PBKDF2失败: %v", err)
	}

	// 确保密钥长度正确
	if len(key) != 64 { // 32字节 = 64个十六进制字符
		t.Errorf("PBKDF2密钥长度错误，期望: 64, 实际: %d", len(key))
	}
}

func TestEncryptBase64(t *testing.T) {
	data := "test data"

	// 测试Base64编码
	encoded, err := Encrypt(BASE64, data, "", nil)
	if err != nil {
		t.Errorf("Base64编码失败: %v", err)
	}

	// 测试Base64解码
	decoded, err := Decrypt(BASE64, encoded, "", nil)
	if err != nil {
		t.Errorf("Base64解码失败: %v", err)
	}

	if decoded != data {
		t.Errorf("Base64解码结果不匹配，期望: %s, 实际: %s", data, decoded)
	}
}

func TestGenerateKey(t *testing.T) {
	// 测试生成AES密钥
	aesKey, err := GenerateKey(AES_CBC, map[string]interface{}{"keyLength": 32})
	if err != nil {
		t.Errorf("生成AES密钥失败: %v", err)
	}

	// AES-256密钥应该是64个字符（32字节转换为十六进制）
	if len(aesKey) != 64 {
		t.Errorf("AES-256密钥长度错误，期望: 64, 实际: %d", len(aesKey))
	}

	// 测试生成HMAC密钥
	hmacKey, err := GenerateKey(HMAC_SHA256, map[string]interface{}{"keyLength": 32})
	if err != nil {
		t.Errorf("生成HMAC密钥失败: %v", err)
	}

	// HMAC密钥应该是64个字符（32字节转换为十六进制）
	if len(hmacKey) != 64 {
		t.Errorf("HMAC密钥长度错误，期望: 64, 实际: %d", len(hmacKey))
	}

	// 测试生成PBKDF2盐值
	salt, err := GenerateKey(PBKDF2, map[string]interface{}{"saltLength": 16})
	if err != nil {
		t.Errorf("生成PBKDF2盐值失败: %v", err)
	}

	// 盐值应该是32个字符（16字节转换为十六进制）
	if len(salt) != 32 {
		t.Errorf("PBKDF2盐值长度错误，期望: 32, 实际: %d", len(salt))
	}
}

func TestDecryptHashAlgorithms(t *testing.T) {
	// 测试哈希算法解密（应该失败）
	_, err := Decrypt(MD5, "test", "", nil)
	if err == nil {
		t.Errorf("MD5解密应该失败")
	}

	_, err = Decrypt(SHA1, "test", "", nil)
	if err == nil {
		t.Errorf("SHA1解密应该失败")
	}

	_, err = Decrypt(SHA256, "test", "", nil)
	if err == nil {
		t.Errorf("SHA256解密应该失败")
	}

	_, err = Decrypt(SHA512, "test", "", nil)
	if err == nil {
		t.Errorf("SHA512解密应该失败")
	}

	_, err = Decrypt(SHA3_256, "test", "", nil)
	if err == nil {
		t.Errorf("SHA3-256解密应该失败")
	}

	_, err = Decrypt(SHA3_384, "test", "", nil)
	if err == nil {
		t.Errorf("SHA3-384解密应该失败")
	}

	_, err = Decrypt(SHA3_512, "test", "", nil)
	if err == nil {
		t.Errorf("SHA3-512解密应该失败")
	}
}

func TestDecryptMACAlgorithms(t *testing.T) {
	// 测试消息认证码解密（应该失败）
	_, err := Decrypt(HMAC_SHA256, "test", "", nil)
	if err == nil {
		t.Errorf("HMAC-SHA256解密应该失败")
	}

	_, err = Decrypt(HMAC_SHA512, "test", "", nil)
	if err == nil {
		t.Errorf("HMAC-SHA512解密应该失败")
	}
}

func TestDecryptPBKDF2(t *testing.T) {
	// 测试PBKDF2解密（应该失败）
	_, err := Decrypt(PBKDF2, "test", "", nil)
	if err == nil {
		t.Errorf("PBKDF2解密应该失败")
	}
}