ioeither

var (

	// OpenSSLDecryption returns the decryption environment using OpenSSL
	OpenSSLDecryption = IO.MakeIO(func() Decryption {
		return Decryption{
			DecryptBasic: OpenSSLDecryptBasic,
		}
	})

	// CryptoDecryption returns the decryption environment using golang crypto
	CryptoDecryption = IO.MakeIO(func() Decryption {
		return Decryption{
			DecryptBasic: CryptoDecryptBasic,
		}
	})

	// DefaultDecryption detects the decryption environment
	DefaultDecryption = F.Pipe1(
		validOpenSSL,
		IOE.Fold(F.Constant1[error](CryptoDecryption), F.Constant1[string](OpenSSLDecryption)),
	)
)

var (
	// OpenSSLEncryption returns the encryption environment using OpenSSL
	OpenSSLEncryption = IO.MakeIO(func() Encryption {
		return Encryption{
			EncryptBasic:       OpenSSLEncryptBasic,
			CertFingerprint:    OpenSSLCertFingerprint,
			PrivKeyFingerprint: OpenSSLPrivKeyFingerprint,
			PrivKey:            OpenSSLPrivateKey,
			PubKey:             OpenSSLPublicKey,
			SignDigest:         OpenSSLSignDigest,
		}
	})

	// CryptoEncryption returns the encryption environment using golang crypto
	CryptoEncryption = IO.MakeIO(func() Encryption {
		return Encryption{
			EncryptBasic:       CryptoEncryptBasic,
			CertFingerprint:    CryptoCertFingerprint,
			PrivKeyFingerprint: CryptoPrivKeyFingerprint,
			PrivKey:            CryptoPrivateKey,
			PubKey:             CryptoPublicKey,
			SignDigest:         CryptoSignDigest,
		}
	})

	// DefaultEncryption detects the encryption environment
	DefaultEncryption = F.Pipe1(
		validOpenSSL,
		IOE.Fold(F.Constant1[error](CryptoEncryption), F.Constant1[string](OpenSSLEncryption)),
	)
)

var (

	// CryptoCertFingerprint computes the fingerprint of a certificate using the crypto library
	CryptoCertFingerprint = F.Flow5(
		pemDecodeFirstCertificate,
		E.Chain(parseCertificateE),
		E.Map[error](rawFromCertificate),
		E.Map[error](sha256.Sum256),
		E.Map[error](shaToBytes),
	)

	// CryptoPrivKeyFingerprint computes the fingerprint of a private key using the crypto library
	CryptoPrivKeyFingerprint = F.Flow7(
		pemDecodeE,
		E.Chain(parsePrivateKeyE),
		E.Map[error](privToPub),
		E.Map[error](pubToAny),
		E.Chain(marshalPKIXPublicKeyE),
		E.Map[error](sha256.Sum256),
		E.Map[error](shaToBytes),
	)

	// CryptoVerifyDigest verifies the signature of the input data against a signature
	CryptoVerifyDigest = F.Flow2(
		pubToRsaKey,
		E.Fold(errorValidator, verifyPKCS1v15),
	)

	// CryptoPublicKey extracts the public key from a private key
	CryptoPublicKey = F.Flow6(
		pemDecodeE,
		E.Chain(parsePrivateKeyE),
		E.Map[error](privToPub),
		E.Map[error](pubToAny),
		E.Chain(marshalPKIXPublicKeyE),
		E.Map[error](func(data []byte) []byte {
			return pem.EncodeToMemory(
				&pem.Block{
					Type:  EC.TypePublicKey,
					Bytes: data,
				},
			)
		}),
	)

	// IsPublicKey checks if a PEM block is a public key
	IsPublicKey = EC.IsType(EC.TypePublicKey)

	// IsCertificate checks if a PEM block is a certificate
	IsCertificate = EC.IsType(EC.TypeCertificate)

	// CryptoAsymmetricEncryptPubOrCert encrypts a piece of text using a public key or a certificate
	CryptoAsymmetricEncryptPubOrCert = cryptoAsymmetricEncrypt(pubOrCertToRsaKey)

	// CryptoAsymmetricEncryptPub encrypts a piece of text using a public key
	CryptoAsymmetricEncryptPub = cryptoAsymmetricEncrypt(pubToRsaKey)

	// CryptoAsymmetricEncryptCert encrypts a piece of text using a certificate
	CryptoAsymmetricEncryptCert = cryptoAsymmetricEncrypt(certToRsaKey)

	// CryptoAsymmetricDecrypt decrypts a piece of text using a private key
	CryptoAsymmetricDecrypt = cryptoAsymmetricDecrypt(privToRsaKey)
)

var (

	// OpenSSLSignDigest signs the sha256 digest using a private key
	OpenSSLSignDigest = handle(signDigest)

	// OpenSSLAsymmetricEncryptPubOrCert implements asymmetric encryption based on a public key or certificate based on the input
	OpenSSLAsymmetricEncryptPubOrCert = handle(asymmetricEncryptPubOrCert)

	// OpenSSLAsymmetricEncryptPub implements asymmetric encryption based on a public key
	OpenSSLAsymmetricEncryptPub = handle(asymmetricEncryptPub)

	// OpenSSLAsymmetricEncryptCert implements asymmetric encryption based on a certificate
	OpenSSLAsymmetricEncryptCert = handle(asymmetricEncryptCert)

	OpenSSLAsymmetricDecrypt = handle(asymmetricDecrypt)

	OpenSSLSymmetricEncrypt = handle(symmetricEncrypt)

	// CertSerial gets the serial number from a certificate
	CertSerial = F.Flow2(
		OpenSSL("x509", "-serial", "-noout"),
		mapStdout,
	)

	// OpenSSLPrivateKey generates a private key
	OpenSSLPrivateKey = F.Pipe2(
		emptyBytes,
		OpenSSL("genrsa", "4096"),
		mapStdout,
	)
)

var CryptoPrivateKey = F.Pipe1(
	IOE.TryCatchError(func() (*rsa.PrivateKey, error) {
		return rsa.GenerateKey(rand.Reader, 4096)
	}),
	IOE.Map[error](privKeyToPem),
)