package sm

import (
	"apigo.cc/go/jsmod"
)

func init() {
	jsmod.Register("sm", map[string]any{
		// SM3 Hash
		"SM3":            jsSM3,
		"SM3ToHex":       jsSM3ToHex,
		"SM3ToBase64":    jsSM3ToBase64,
		"SM3ToURLBase64": jsSM3ToURLBase64,

		// SM4 Symmetric (Stateless)
		"SM4EncryptCBC":  jsSM4EncryptCBC,
		"SM4DecryptCBC":  jsSM4DecryptCBC,
		"SM4EncryptGCM":  jsSM4EncryptGCM,
		"SM4DecryptGCM":  jsSM4DecryptGCM,

		// SM2 Asymmetric (Stateless)
		"SM2Encrypt":     jsSM2Encrypt,
		"SM2Decrypt":     jsSM2Decrypt,
		"SM2Sign":        jsSM2Sign,
		"SM2Verify":      jsSM2Verify,

		// Key Generation
		"GenerateSM2KeyPair": jsGenerateSM2KeyPair,
	})
}

func jsSM3(data ...[]byte) []byte {
	return SM3(data...)
}

func jsSM3ToHex(data []byte) string {
	return SM3ToHex(data)
}

func jsSM3ToBase64(data []byte) string {
	return SM3ToBase64(data)
}

func jsSM3ToURLBase64(data []byte) string {
	return SM3ToURLBase64(data)
}

func jsSM4EncryptCBC(data, key, iv []byte) ([]byte, error) {
	s, err := NewSM4CBCAndEraseKey(key, iv)
	if err != nil {
		return nil, jsmod.MakeError(err)
	}
	res, err := s.EncryptBytes(data)
	if err != nil {
		return nil, jsmod.MakeError(err)
	}
	return res, nil
}

func jsSM4DecryptCBC(data, key, iv []byte) ([]byte, error) {
	s, err := NewSM4CBCAndEraseKey(key, iv)
	if err != nil {
		return nil, jsmod.MakeError(err)
	}
	res, err := s.DecryptBytes(data)
	if err != nil {
		return nil, jsmod.MakeError(err)
	}
	return res, nil
}

func jsSM4EncryptGCM(data, key, iv []byte) ([]byte, error) {
	s, err := NewSM4GCMAndEraseKey(key, iv)
	if err != nil {
		return nil, jsmod.MakeError(err)
	}
	res, err := s.EncryptBytes(data)
	if err != nil {
		return nil, jsmod.MakeError(err)
	}
	return res, nil
}

func jsSM4DecryptGCM(data, key, iv []byte) ([]byte, error) {
	s, err := NewSM4GCMAndEraseKey(key, iv)
	if err != nil {
		return nil, jsmod.MakeError(err)
	}
	res, err := s.DecryptBytes(data)
	if err != nil {
		return nil, jsmod.MakeError(err)
	}
	return res, nil
}

func jsSM2Encrypt(data, pubKey []byte) ([]byte, error) {
	a, err := NewSM2AndEraseKey(nil, pubKey)
	if err != nil {
		return nil, jsmod.MakeError(err)
	}
	res, err := a.EncryptBytes(data)
	if err != nil {
		return nil, jsmod.MakeError(err)
	}
	return res, nil
}

func jsSM2Decrypt(data, privKey []byte) ([]byte, error) {
	a, err := NewSM2AndEraseKey(privKey, nil)
	if err != nil {
		return nil, jsmod.MakeError(err)
	}
	res, err := a.DecryptBytes(data)
	if err != nil {
		return nil, jsmod.MakeError(err)
	}
	return res, nil
}

func jsSM2Sign(data, privKey []byte) ([]byte, error) {
	a, err := NewSM2AndEraseKey(privKey, nil)
	if err != nil {
		return nil, jsmod.MakeError(err)
	}
	res, err := a.Sign(data)
	if err != nil {
		return nil, jsmod.MakeError(err)
	}
	return res, nil
}

func jsSM2Verify(data, sig, pubKey []byte) (bool, error) {
	a, err := NewSM2AndEraseKey(nil, pubKey)
	if err != nil {
		return false, jsmod.MakeError(err)
	}
	res, err := a.Verify(data, sig)
	if err != nil {
		return false, jsmod.MakeError(err)
	}
	return res, nil
}

func jsGenerateSM2KeyPair() ([]byte, []byte, error) {
	priv, pub, err := GenerateSM2KeyPair()
	if err != nil {
		return nil, nil, jsmod.MakeError(err)
	}
	return priv, pub, nil
}