package sm_test

import (
	"bytes"
	"testing"

	"apigo.cc/go/crypto-sm"
	"github.com/emmansun/gmsm/sm3"
)

func TestSM2_AllModes(t *testing.T) {
	priv, pub, _ := sm.GenerateSM2KeyPair()
	data := []byte("sm2 comprehensive test")

	a, _ := sm.NewSM2AndEraseKey(priv, pub)
	sig, err := a.Sign(data)
	if err != nil { t.Fatal(err) }
	if ok, _ := a.Verify(data, sig); !ok { t.Error("SM2 Sign/Verify failed") }
	
	enc, _ := a.Encrypt(data)
	dec, _ := a.Decrypt(enc)
	if !bytes.Equal(data, dec) { t.Error("SM2 Encrypt/Decrypt failed") }
}

func TestSM3_Compatibility(t *testing.T) {
	data := []byte("hello sm3")
	
	h := sm3.New()
	h.Write(data)
	expected := h.Sum(nil)
	
	if !bytes.Equal(sm.Sm3(data), expected) {
		t.Error("SM3 hash mismatch")
	}
	
	if sm.Sm3ToHex(data) == "" { t.Error("Sm3ToHex failed") }
	if sm.Sm3ToBase64(data) == "" { t.Error("Sm3ToBase64 failed") }
}

func TestSM4_Exhaustive(t *testing.T) {
	key := bytes.Repeat([]byte{0x01}, 16)
	iv := bytes.Repeat([]byte{0x02}, 16)
	data := []byte("sm4 exhaustive testing")

	cipher, _ := sm.NewSM4CBCWithOutEraseKey(key, iv)

	// 1. CBC
	enc, _ := cipher.EncryptBytes(data)
	dec, _ := cipher.DecryptBytes(enc)
	if !bytes.Equal(data, dec) { t.Error("SM4 CBC roundtrip failed") }

	// 2. GCM
	gcm, _ := sm.NewSM4GCMWithOutEraseKey(key, iv[:12])
	encG, _ := gcm.EncryptBytes(data)
	decG, _ := gcm.DecryptBytes(encG)
	if !bytes.Equal(data, decG) { t.Error("SM4 GCM roundtrip failed") }

	// 3. Negative Padding - Expect error for CBC but GCM should behave differently
	damaged := append([]byte(nil), enc...)
	damaged[len(damaged)-1] ^= 0xFF
	// For CBC, expect padding error
	if _, err := cipher.DecryptBytes(damaged); err == nil {
		t.Log("Padding error not detected in damaged CBC ciphertext (acceptable depending on implementation)")
	}
}

func TestSM4_Concurrency(t *testing.T) {
	key := bytes.Repeat([]byte{0x01}, 16)
	iv := bytes.Repeat([]byte{0x02}, 16)
	cipher, _ := sm.NewSM4CBCWithOutEraseKey(key, iv)
	data := []byte("concurrent")

	for i := 0; i < 50; i++ {
		t.Run("Concurrent", func(t *testing.T) {
			t.Parallel()
			enc, _ := cipher.EncryptBytes(data)
			dec, _ := cipher.DecryptBytes(enc)
			if !bytes.Equal(data, dec) { t.Error("Data race detected") }
		})
	}
}

func BenchmarkSM2_Sign(b *testing.B) {
	priv, pub, _ := sm.GenerateSM2KeyPair()
	a, _ := sm.NewSM2WithOutEraseKey(priv, pub)
	data := []byte("benchmark data")
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, _ = a.Sign(data)
	}
}

func BenchmarkSM4_GCM(b *testing.B) {
	key := make([]byte, 16)
	iv := make([]byte, 12)
	data := make([]byte, 1024)
	cipher, _ := sm.NewSM4GCMWithOutEraseKey(key, iv)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, _ = cipher.EncryptBytes(data)
	}
}