package starcrypto

import (
	"io"

	"b612.me/starcrypto/symm"
)

type CipherOptions = symm.CipherOptions

const (
	PKCS5PADDING    = symm.PKCS5PADDING
	PKCS7PADDING    = symm.PKCS7PADDING
	ZEROPADDING     = symm.ZEROPADDING
	ANSIX923PADDING = symm.ANSIX923PADDING

	MODEECB = symm.MODEECB
	MODECBC = symm.MODECBC
	MODECFB = symm.MODECFB
	MODEOFB = symm.MODEOFB
	MODECTR = symm.MODECTR
	MODEGCM = symm.MODEGCM
	MODECCM = symm.MODECCM
)

func EncryptAes(data, key, iv []byte, mode, paddingType string) ([]byte, error) {
	return symm.EncryptAes(data, key, iv, mode, paddingType)
}

func DecryptAes(src, key, iv []byte, mode, paddingType string) ([]byte, error) {
	return symm.DecryptAes(src, key, iv, mode, paddingType)
}

func EncryptAesStream(dst io.Writer, src io.Reader, key, iv []byte, mode, paddingType string) error {
	return symm.EncryptAesStream(dst, src, key, iv, mode, paddingType)
}

func DecryptAesStream(dst io.Writer, src io.Reader, key, iv []byte, mode, paddingType string) error {
	return symm.DecryptAesStream(dst, src, key, iv, mode, paddingType)
}

func EncryptAesWithOptions(data, key []byte, opts *CipherOptions) ([]byte, error) {
	return symm.EncryptAesWithOptions(data, key, opts)
}

func DecryptAesWithOptions(src, key []byte, opts *CipherOptions) ([]byte, error) {
	return symm.DecryptAesWithOptions(src, key, opts)
}

func EncryptAesStreamWithOptions(dst io.Writer, src io.Reader, key []byte, opts *CipherOptions) error {
	return symm.EncryptAesStreamWithOptions(dst, src, key, opts)
}

func DecryptAesStreamWithOptions(dst io.Writer, src io.Reader, key []byte, opts *CipherOptions) error {
	return symm.DecryptAesStreamWithOptions(dst, src, key, opts)
}

func EncryptAesGCM(plain, key, nonce, aad []byte) ([]byte, error) {
	return symm.EncryptAesGCM(plain, key, nonce, aad)
}

func DecryptAesGCM(ciphertext, key, nonce, aad []byte) ([]byte, error) {
	return symm.DecryptAesGCM(ciphertext, key, nonce, aad)
}

func EncryptAesGCMChunk(plain, key, nonce, aad []byte, chunkIndex uint64) ([]byte, error) {
	return symm.EncryptAesGCMChunk(plain, key, nonce, aad, chunkIndex)
}

func DecryptAesGCMChunk(ciphertext, key, nonce, aad []byte, chunkIndex uint64) ([]byte, error) {
	return symm.DecryptAesGCMChunk(ciphertext, key, nonce, aad, chunkIndex)
}

func EncryptAesGCMStream(dst io.Writer, src io.Reader, key, nonce, aad []byte) error {
	return symm.EncryptAesGCMStream(dst, src, key, nonce, aad)
}

func DecryptAesGCMStream(dst io.Writer, src io.Reader, key, nonce, aad []byte) error {
	return symm.DecryptAesGCMStream(dst, src, key, nonce, aad)
}

func EncryptAesCCM(plain, key, nonce, aad []byte) ([]byte, error) {
	return symm.EncryptAesCCM(plain, key, nonce, aad)
}

func DecryptAesCCM(ciphertext, key, nonce, aad []byte) ([]byte, error) {
	return symm.DecryptAesCCM(ciphertext, key, nonce, aad)
}

func EncryptAesCCMChunk(plain, key, nonce, aad []byte, chunkIndex uint64) ([]byte, error) {
	return symm.EncryptAesCCMChunk(plain, key, nonce, aad, chunkIndex)
}

func DecryptAesCCMChunk(ciphertext, key, nonce, aad []byte, chunkIndex uint64) ([]byte, error) {
	return symm.DecryptAesCCMChunk(ciphertext, key, nonce, aad, chunkIndex)
}

func EncryptAesCCMStream(dst io.Writer, src io.Reader, key, nonce, aad []byte) error {
	return symm.EncryptAesCCMStream(dst, src, key, nonce, aad)
}

func DecryptAesCCMStream(dst io.Writer, src io.Reader, key, nonce, aad []byte) error {
	return symm.DecryptAesCCMStream(dst, src, key, nonce, aad)
}

func EncryptAesECB(data, key []byte, paddingType string) ([]byte, error) {
	return symm.EncryptAesECB(data, key, paddingType)
}

func DecryptAesECB(src, key []byte, paddingType string) ([]byte, error) {
	return symm.DecryptAesECB(src, key, paddingType)
}

func EncryptAesCBC(data, key []byte, iv []byte, paddingType string) ([]byte, error) {
	return symm.EncryptAesCBC(data, key, iv, paddingType)
}

func DecryptAesCBC(src, key []byte, iv []byte, paddingType string) (data []byte, err error) {
	return symm.DecryptAesCBC(src, key, iv, paddingType)
}

func EncryptAesCFB(data, key, iv []byte) ([]byte, error) {
	return symm.EncryptAesCFB(data, key, iv)
}

func DecryptAesCFB(src, key, iv []byte) ([]byte, error) {
	return symm.DecryptAesCFB(src, key, iv)
}

func EncryptAesOFB(data, key, iv []byte) ([]byte, error) {
	return symm.EncryptAesOFB(data, key, iv)
}

func DecryptAesOFB(src, key, iv []byte) ([]byte, error) {
	return symm.DecryptAesOFB(src, key, iv)
}

func EncryptAesCTR(data, key, iv []byte) ([]byte, error) {
	return symm.EncryptAesCTR(data, key, iv)
}

func DecryptAesCTR(src, key, iv []byte) ([]byte, error) {
	return symm.DecryptAesCTR(src, key, iv)
}

func EncryptAesCTRAt(data, key, iv []byte, offset int64) ([]byte, error) {
	return symm.EncryptAesCTRAt(data, key, iv, offset)
}

func DecryptAesCTRAt(src, key, iv []byte, offset int64) ([]byte, error) {
	return symm.DecryptAesCTRAt(src, key, iv, offset)
}

func EncryptAesECBStream(dst io.Writer, src io.Reader, key []byte, paddingType string) error {
	return symm.EncryptAesECBStream(dst, src, key, paddingType)
}

func DecryptAesECBStream(dst io.Writer, src io.Reader, key []byte, paddingType string) error {
	return symm.DecryptAesECBStream(dst, src, key, paddingType)
}

func EncryptAesCBCStream(dst io.Writer, src io.Reader, key, iv []byte, paddingType string) error {
	return symm.EncryptAesCBCStream(dst, src, key, iv, paddingType)
}

func DecryptAesCBCStream(dst io.Writer, src io.Reader, key, iv []byte, paddingType string) error {
	return symm.DecryptAesCBCStream(dst, src, key, iv, paddingType)
}

func EncryptAesCFBStream(dst io.Writer, src io.Reader, key, iv []byte) error {
	return symm.EncryptAesCFBStream(dst, src, key, iv)
}

func DecryptAesCFBStream(dst io.Writer, src io.Reader, key, iv []byte) error {
	return symm.DecryptAesCFBStream(dst, src, key, iv)
}

func EncryptAesOFBStream(dst io.Writer, src io.Reader, key, iv []byte) error {
	return symm.EncryptAesOFBStream(dst, src, key, iv)
}

func DecryptAesOFBStream(dst io.Writer, src io.Reader, key, iv []byte) error {
	return symm.DecryptAesOFBStream(dst, src, key, iv)
}

func EncryptAesCTRStream(dst io.Writer, src io.Reader, key, iv []byte) error {
	return symm.EncryptAesCTRStream(dst, src, key, iv)
}

func DecryptAesCTRStream(dst io.Writer, src io.Reader, key, iv []byte) error {
	return symm.DecryptAesCTRStream(dst, src, key, iv)
}

func CustomEncryptAesCFB(origData []byte, key []byte) ([]byte, error) {
	return symm.CustomEncryptAesCFB(origData, key)
}

func CustomDecryptAesCFB(encrypted []byte, key []byte) ([]byte, error) {
	return symm.CustomDecryptAesCFB(encrypted, key)
}

func CustomEncryptAesCFBNoBlock(origData []byte, key []byte, iv []byte) ([]byte, error) {
	return symm.CustomEncryptAesCFBNoBlock(origData, key, iv)
}

func CustomDecryptAesCFBNoBlock(encrypted []byte, key []byte, iv []byte) ([]byte, error) {
	return symm.CustomDecryptAesCFBNoBlock(encrypted, key, iv)
}

func PKCS5Padding(cipherText []byte, blockSize int) []byte {
	return symm.PKCS5Padding(cipherText, blockSize)
}

func PKCS5Trimming(encrypt []byte) []byte {
	return symm.PKCS5Trimming(encrypt)
}

func PKCS7Padding(cipherText []byte, blockSize int) []byte {
	return symm.PKCS7Padding(cipherText, blockSize)
}

func PKCS7Trimming(encrypt []byte, blockSize int) []byte {
	return symm.PKCS7Trimming(encrypt, blockSize)
}

func EncryptAesCFB8(data, key, iv []byte) ([]byte, error) {
	return symm.EncryptAesCFB8(data, key, iv)
}

func DecryptAesCFB8(src, key, iv []byte) ([]byte, error) {
	return symm.DecryptAesCFB8(src, key, iv)
}

func EncryptAesCFB8Stream(dst io.Writer, src io.Reader, key, iv []byte) error {
	return symm.EncryptAesCFB8Stream(dst, src, key, iv)
}

func DecryptAesCFB8Stream(dst io.Writer, src io.Reader, key, iv []byte) error {
	return symm.DecryptAesCFB8Stream(dst, src, key, iv)
}

func DecryptAesECBBlocks(src, key []byte) ([]byte, error) {
	return symm.DecryptAesECBBlocks(src, key)
}

func DecryptAesCBCFromSecondBlock(src, key, prevCipherBlock []byte) ([]byte, error) {
	return symm.DecryptAesCBCFromSecondBlock(src, key, prevCipherBlock)
}

func DecryptAesCFBFromSecondBlock(src, key, prevCipherBlock []byte) ([]byte, error) {
	return symm.DecryptAesCFBFromSecondBlock(src, key, prevCipherBlock)
}
func EncryptAesXTS(plain, key1, key2 []byte, dataUnitSize int) ([]byte, error) {
	return symm.EncryptAesXTS(plain, key1, key2, dataUnitSize)
}

func DecryptAesXTS(ciphertext, key1, key2 []byte, dataUnitSize int) ([]byte, error) {
	return symm.DecryptAesXTS(ciphertext, key1, key2, dataUnitSize)
}

func EncryptAesXTSAt(plain, key1, key2 []byte, dataUnitSize int, dataUnitIndex uint64) ([]byte, error) {
	return symm.EncryptAesXTSAt(plain, key1, key2, dataUnitSize, dataUnitIndex)
}

func DecryptAesXTSAt(ciphertext, key1, key2 []byte, dataUnitSize int, dataUnitIndex uint64) ([]byte, error) {
	return symm.DecryptAesXTSAt(ciphertext, key1, key2, dataUnitSize, dataUnitIndex)
}

func EncryptAesXTSStream(dst io.Writer, src io.Reader, key1, key2 []byte, dataUnitSize int) error {
	return symm.EncryptAesXTSStream(dst, src, key1, key2, dataUnitSize)
}

func DecryptAesXTSStream(dst io.Writer, src io.Reader, key1, key2 []byte, dataUnitSize int) error {
	return symm.DecryptAesXTSStream(dst, src, key1, key2, dataUnitSize)
}

func EncryptAesXTSStreamAt(dst io.Writer, src io.Reader, key1, key2 []byte, dataUnitSize int, dataUnitIndex uint64) error {
	return symm.EncryptAesXTSStreamAt(dst, src, key1, key2, dataUnitSize, dataUnitIndex)
}

func DecryptAesXTSStreamAt(dst io.Writer, src io.Reader, key1, key2 []byte, dataUnitSize int, dataUnitIndex uint64) error {
	return symm.DecryptAesXTSStreamAt(dst, src, key1, key2, dataUnitSize, dataUnitIndex)
}