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)
	}
}

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("无效的密钥大小未被检测出")
	}
}