package crypto

import (
	"encoding/base64"
	"encoding/hex"
	"fmt"
	"testing"
)

func TestAesEcbMobileEncryption(t *testing.T) {
	// 测试手机号加密
	mobile := "18653052547"
	key := []byte("ff83609b2b24fc73196aac3d3dfb874f") // 16字节AES-128密钥

	keyStr := hex.EncodeToString(key)
	// 测试加密
	encrypted, err := EncryptMobile(mobile, keyStr)
	if err != nil {
		t.Fatalf("手机号加密失败: %v", err)
	}
	fmt.Printf("encrypted: %s\n", encrypted)
	jmStr := "m9EEeW9ZBBJmi1hx1k1uIQ=="
	// 测试解密
	decrypted, err := DecryptMobile(jmStr, keyStr)
	if err != nil {
		t.Fatalf("手机号解密失败: %v", err)
	}
	fmt.Printf("decrypted: %s\n", decrypted)
	// 验证结果
	if decrypted != mobile {
		t.Errorf("解密结果不匹配，期望: %s, 实际: %s", mobile, decrypted)
	}

	// 测试相同输入产生相同输出（确定性）
	encrypted2, _ := EncryptMobile(mobile, keyStr)
	if encrypted != encrypted2 {
		t.Errorf("AES-ECB不是确定性的，两次加密结果不同: %s vs %s", encrypted, encrypted2)
	}
}

func TestAesEcbHexEncryption(t *testing.T) {
	// 测试十六进制编码加密
	idCard := "440101199001011234"
	key := []byte("1234567890abcdef") // 16字节AES-128密钥

	// 测试HEX加密
	encryptedHex, err := EncryptIDCard(idCard, key)
	if err != nil {
		t.Fatalf("身份证加密失败: %v", err)
	}

	// 测试HEX解密
	decrypted, err := DecryptIDCard(encryptedHex, key)
	if err != nil {
		t.Fatalf("身份证解密失败: %v", err)
	}

	// 验证结果
	if decrypted != idCard {
		t.Errorf("解密结果不匹配，期望: %s, 实际: %s", idCard, decrypted)
	}
}

// 需要解密的身份证密文（可替换为其他密文进行测试）
const encryptedIDCardForTest = "z4pIrjlrpfsBtF74kvtRWnjM2UTx8Uq8HVA8dk9hSeI="

// TestDecryptIDCard 身份证解密单元测试（已知密文）
func TestDecryptIDCard(t *testing.T) {
	fmt.Printf("encryptedIDC开始解密")
	key, _ := hex.DecodeString("ff83609b2b24fc73196aac3d3dfb874f")
	fmt.Printf("key: %s\n", key)
	decrypted, err := DecryptIDCard(encryptedIDCardForTest, key)
	if err != nil {
		t.Fatalf("身份证解密失败: %v", err)
	}
	fmt.Printf("decrypted: %s\n", decrypted)
}

// TestEncryptIDCard_DecryptIDCard 身份证加密解密 round-trip 测试
func TestEncryptIDCard_DecryptIDCard(t *testing.T) {
	idCard := "360733199005090032"
	key, _ := hex.DecodeString("ff83609b2b24fc73196aac3d3dfb874f")

	// 加密
	fmt.Printf("idCard: %s\n", idCard)
	encrypted, err := EncryptIDCard(idCard, key)
	if err != nil {
		t.Fatalf("身份证加密失败: %v", err)
	}
	fmt.Printf("encrypted: %s\n", encrypted)
	// 解密
	decrypted, err := DecryptIDCard(encrypted, key)
	if err != nil {
		t.Fatalf("身份证解密失败: %v", err)
	}

	if decrypted != idCard {
		t.Errorf("解密结果不匹配，期望: %s, 实际: %s", idCard, decrypted)
	}
}

// TestDecryptIDCard_EdgeCases 身份证解密边界情况
func TestDecryptIDCard_EdgeCases(t *testing.T) {
	key, _ := hex.DecodeString("ff83609b2b24fc73196aac3d3dfb874f")

	t.Run("空密文", func(t *testing.T) {
		_, err := DecryptIDCard("", key)
		if err == nil {
			t.Error("空密文应返回错误")
		}
	})

	t.Run("无效Base64", func(t *testing.T) {
		_, err := DecryptIDCard("invalid-base64!!!@#$", key)
		if err == nil {
			t.Error("无效Base64应返回错误")
		}
	})

	t.Run("错误密钥", func(t *testing.T) {
		encrypted, err := EncryptIDCard("440101199001011234", key)
		if err != nil {
			t.Fatalf("加密失败: %v", err)
		}
		wrongKey, _ := hex.DecodeString("00000000000000000000000000000000")
		_, err = DecryptIDCard(encrypted, wrongKey)
		if err == nil {
			t.Error("错误密钥应返回错误")
		}
	})

	t.Run("密文长度不是块大小整数倍", func(t *testing.T) {
		shortCipher := base64.StdEncoding.EncodeToString([]byte("short"))
		_, err := DecryptIDCard(shortCipher, key)
		if err == nil {
			t.Error("密文长度异常应返回错误")
		}
	})

	t.Run("加密空身份证应返回错误", func(t *testing.T) {
		_, err := EncryptIDCard("", key)
		if err == nil {
			t.Error("空身份证号应返回错误")
		}
	})
}

func TestAesEcbKeyValidation(t *testing.T) {
	// 测试不同长度的密钥
	validKeys := [][]byte{
		make([]byte, 16), // AES-128
		make([]byte, 24), // AES-192
		make([]byte, 32), // AES-256
	}

	invalidKeys := [][]byte{
		make([]byte, 15),
		make([]byte, 20),
		make([]byte, 33),
	}

	text := []byte("test text")

	// 测试有效密钥
	for _, key := range validKeys {
		_, err := AesEcbEncrypt(text, key)
		if err != nil {
			t.Errorf("有效密钥(%d字节)校验失败: %v", len(key), err)
		}
	}

	// 测试无效密钥
	for _, key := range invalidKeys {
		_, err := AesEcbEncrypt(text, key)
		if err == nil {
			t.Errorf("无效密钥(%d字节)未被检测出", len(key))
		}
	}
}

func TestIsEncrypted(t *testing.T) {
	// 有效的Base64编码字符串
	validBase64 := base64.StdEncoding.EncodeToString([]byte("这是一个足够长的字符串，以通过IsEncrypted检查"))

	// 无效的字符串
	invalidStrings := []string{
		"",
		"abc",
		"not-base64!@#",
		hex.EncodeToString([]byte("hexstring")),
	}

	// 测试有效的加密数据
	if !IsEncrypted(validBase64) {
		t.Errorf("有效的Base64未被识别为加密数据: %s", validBase64)
	}

	// 测试无效的数据
	for _, s := range invalidStrings {
		if IsEncrypted(s) {
			t.Errorf("无效字符串被错误识别为加密数据: %s", s)
		}
	}
}

func TestDeriveKeyFromPassword(t *testing.T) {
	password := "my-secure-password"

	// 测试不同长度的派生密钥
	keySizes := []int{16, 24, 32}

	for _, size := range keySizes {
		key, err := DeriveKeyFromPassword(password, size)
		if err != nil {
			t.Errorf("从密码派生%d字节密钥失败: %v", size, err)
			continue
		}

		if len(key) != size {
			t.Errorf("派生的密钥长度错误，期望: %d, 实际: %d", size, len(key))
		}

		// 测试相同密码总是产生相同密钥
		key2, _ := DeriveKeyFromPassword(password, size)
		if string(key) != string(key2) {
			t.Errorf("从相同密码派生的密钥不一致")
		}

		// 使用派生的密钥加密测试
		_, err = AesEcbEncrypt([]byte("test"), key)
		if err != nil {
			t.Errorf("使用派生的密钥加密失败: %v", err)
		}
	}

	// 测试无效的密钥大小
	_, err := DeriveKeyFromPassword(password, 18)
	if err == nil {
		t.Error("无效的密钥大小未被检测出")
	}
}

func TestGenerateAESKey(t *testing.T) {
	// 测试生成不同长度的密钥
	keySizes := []int{16, 24, 32}

	for _, size := range keySizes {
		key, err := GenerateAESKey(size)
		if err != nil {
			t.Errorf("生成%d字节密钥失败: %v", size, err)
			continue
		}

		if len(key) != size {
			t.Errorf("生成的密钥长度错误，期望: %d, 实际: %d", size, len(key))
		}

		// 使用生成的密钥加密测试
		_, err = AesEcbEncrypt([]byte("test"), key)
		if err != nil {
			t.Errorf("使用生成的密钥加密失败: %v", err)
		}
	}

	// 测试无效的密钥大小
	_, err := GenerateAESKey(18)
	if err == nil {
		t.Error("无效的密钥大小未被检测出")
	}
}