{-# LANGUAGE Haskell2010                #-}
{-# LANGUAGE BangPatterns               #-}
{-# LANGUAGE BinaryLiterals             #-}
{-# LANGUAGE ConstraintKinds            #-}
{-# LANGUAGE CPP                        #-}
{-# LANGUAGE DefaultSignatures          #-}
{-# LANGUAGE DeriveAnyClass             #-}
{-# LANGUAGE DeriveFunctor              #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE DeriveLift                 #-}
{-# LANGUAGE DerivingStrategies         #-}
{-# LANGUAGE DerivingVia                #-}
{-# LANGUAGE ExistentialQuantification  #-}
{-# LANGUAGE FlexibleContexts           #-}
{-# LANGUAGE FunctionalDependencies     #-}
{-# LANGUAGE GADTs                      #-}
{-# LANGUAGE GeneralisedNewtypeDeriving #-}
{-# LANGUAGE InstanceSigs               #-}
{-# LANGUAGE LambdaCase                 #-}
{-# LANGUAGE MultiWayIf                 #-}
{-# LANGUAGE NumericUnderscores         #-}
{-# LANGUAGE OverloadedStrings          #-}
{-# LANGUAGE PackageImports             #-}
{-# LANGUAGE QuasiQuotes                #-}
{-# LANGUAGE RankNTypes                 #-}
{-# LANGUAGE RecordWildCards            #-}
{-# LANGUAGE ScopedTypeVariables        #-}
{-# LANGUAGE StandaloneDeriving         #-}
{-# LANGUAGE StrictData                 #-}
{-# LANGUAGE TemplateHaskell            #-}
{-# LANGUAGE TupleSections              #-}
{-# LANGUAGE TypeApplications           #-}
{-# LANGUAGE TypeFamilies               #-}

module Data.Multibase.Types.MultibaseBytes 
  ( MultibaseBytes(..)
  , module Data.Multibase.Types.MultibaseBytes
  ) where

import           Data.Multibase.Types.Internal.IsMultibase
import           Data.Multibase.Types.Internal.IsCodec


----------------------------------------------------------------------------------------------------
-- decoding
----------------------------------------------------------------------------------------------------

-- | decode the input 'Multibase' to a 'ByteString', or 'MbDecodeFailure' on failure
decodeMultibaseBytes :: MultibaseBytes -> Either MbDecodeFailure ByteString
decodeMultibaseBytes = decodingMultibase

-- | decode the input 'Multibase' to a 'ByteString', or 'MbDecodeFailure' on failure
decodeMultibaseBytesToText :: MultibaseBytes -> Either MbDecodeFailure Text
decodeMultibaseBytesToText = decodingMultibaseToText


----------------------------------------------------------------------------------------------------
-- encode*With
----------------------------------------------------------------------------------------------------

encodeToMultibaseBytesWith :: MbAlgorithm -> ByteString -> MultibaseBytes
encodeToMultibaseBytesWith = encodingToMultibase

encodeTextToMultibaseBytesWith :: MbAlgorithm -> Text -> MultibaseBytes
encodeTextToMultibaseBytesWith = encodingTextToMultibase


----------------------------------------------------------------------------------------------------
-- encoding
----------------------------------------------------------------------------------------------------

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'IdentityBase' codec
encodeIdentityBaseToMultibaseBytes :: ByteString -> MultibaseBytes
encodeIdentityBaseToMultibaseBytes = encodingToMultibase_ $ Proxy @IdentityBase

-- | encode the input 'Text' to 'MultibaseBytes' via the 'IdentityBase' codec
encodeTextInIdentityBaseToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInIdentityBaseToMultibaseBytes = encodingTextToMultibase_ $ Proxy @IdentityBase

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base2' codec
encodeBase2ToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase2ToMultibaseBytes = encodingToMultibase_ $ Proxy @Base2

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base2' codec
encodeTextInBase2ToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase2ToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base2

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base8' codec
encodeBase8ToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase8ToMultibaseBytes = encodingToMultibase_ $ Proxy @Base8

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base8' codec
encodeTextInBase8ToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase8ToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base8

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base10' codec
encodeBase10ToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase10ToMultibaseBytes = encodingToMultibase_ $ Proxy @Base10

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base10' codec
encodeTextInBase10ToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase10ToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base10

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base16Lower' codec
encodeBase16LowerToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase16LowerToMultibaseBytes = encodingToMultibase_ $ Proxy @Base16Lower

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base16Lower' codec
encodeTextInBase16LowerToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase16LowerToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base16Lower

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base16Upper' codec
encodeBase16UpperToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase16UpperToMultibaseBytes = encodingToMultibase_ $ Proxy @Base16Upper

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base16Upper' codec
encodeTextInBase16UpperToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase16UpperToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base16Upper

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base32HexNoPadLower' codec
encodeBase32HexNoPadLowerToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase32HexNoPadLowerToMultibaseBytes = encodingToMultibase_ $ Proxy @Base32HexNoPadLower

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base32HexNoPadLower' codec
encodeTextInBase32HexNoPadLowerToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase32HexNoPadLowerToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base32HexNoPadLower

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base32HexNoPadUpper' codec
encodeBase32HexNoPadUpperToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase32HexNoPadUpperToMultibaseBytes = encodingToMultibase_ $ Proxy @Base32HexNoPadUpper

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base32HexNoPadUpper' codec
encodeTextInBase32HexNoPadUpperToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase32HexNoPadUpperToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base32HexNoPadUpper

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base32HexPadLower' codec
encodeBase32HexPadLowerToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase32HexPadLowerToMultibaseBytes = encodingToMultibase_ $ Proxy @Base32HexPadLower

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base32HexPadLower' codec
encodeTextInBase32HexPadLowerToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase32HexPadLowerToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base32HexPadLower

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base32HexPadUpper' codec
encodeBase32HexPadUpperToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase32HexPadUpperToMultibaseBytes = encodingToMultibase_ $ Proxy @Base32HexPadUpper

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base32HexPadUpper' codec
encodeTextInBase32HexPadUpperToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase32HexPadUpperToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base32HexPadUpper

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base32NoPadLower' codec
encodeBase32NoPadLowerToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase32NoPadLowerToMultibaseBytes = encodingToMultibase_ $ Proxy @Base32NoPadLower

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base32NoPadLower' codec
encodeTextInBase32NoPadLowerToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase32NoPadLowerToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base32NoPadLower

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base32NoPadUpper' codec
encodeBase32NoPadUpperToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase32NoPadUpperToMultibaseBytes = encodingToMultibase_ $ Proxy @Base32NoPadUpper

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base32NoPadUpper' codec
encodeTextInBase32NoPadUpperToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase32NoPadUpperToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base32NoPadUpper

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base32PadLower' codec
encodeBase32PadLowerToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase32PadLowerToMultibaseBytes = encodingToMultibase_ $ Proxy @Base32PadLower

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base32PadLower' codec
encodeTextInBase32PadLowerToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase32PadLowerToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base32PadLower

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base32PadUpper' codec
encodeBase32PadUpperToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase32PadUpperToMultibaseBytes = encodingToMultibase_ $ Proxy @Base32PadUpper

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base32PadUpper' codec
encodeTextInBase32PadUpperToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase32PadUpperToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base32PadUpper

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base32z' codec
encodeBase32zToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase32zToMultibaseBytes = encodingToMultibase_ $ Proxy @Base32z

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base32z' codec
encodeTextInBase32zToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase32zToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base32z

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base36Lower' codec
encodeBase36LowerToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase36LowerToMultibaseBytes = encodingToMultibase_ $ Proxy @Base36Lower

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base36Lower' codec
encodeTextInBase36LowerToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase36LowerToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base36Lower

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base36Upper' codec
encodeBase36UpperToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase36UpperToMultibaseBytes = encodingToMultibase_ $ Proxy @Base36Upper

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base36Upper' codec
encodeTextInBase36UpperToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase36UpperToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base36Upper

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base58Btc' codec
encodeBase58BtcToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase58BtcToMultibaseBytes = encodingToMultibase_ $ Proxy @Base58Btc

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base58Btc' codec
encodeTextInBase58BtcToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase58BtcToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base58Btc

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base58Flickr' codec
encodeBase58FlickrToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase58FlickrToMultibaseBytes = encodingToMultibase_ $ Proxy @Base58Flickr

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base58Flickr' codec
encodeTextInBase58FlickrToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase58FlickrToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base58Flickr

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base64NoPad' codec
encodeBase64NoPadToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase64NoPadToMultibaseBytes = encodingToMultibase_ $ Proxy @Base64NoPad

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base64NoPad' codec
encodeTextInBase64NoPadToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase64NoPadToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base64NoPad

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base64Pad' codec
encodeBase64PadToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase64PadToMultibaseBytes = encodingToMultibase_ $ Proxy @Base64Pad

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base64Pad' codec
encodeTextInBase64PadToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase64PadToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base64Pad

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base64UrlNoPad' codec
encodeBase64UrlNoPadToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase64UrlNoPadToMultibaseBytes = encodingToMultibase_ $ Proxy @Base64UrlNoPad

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base64UrlNoPad' codec
encodeTextInBase64UrlNoPadToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase64UrlNoPadToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base64UrlNoPad

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base64urlPad' codec
encodeBase64urlPadToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase64urlPadToMultibaseBytes = encodingToMultibase_ $ Proxy @Base64urlPad

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base64urlPad' codec
encodeTextInBase64urlPadToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase64urlPadToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base64urlPad

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Proquint' codec
encodeProquintToMultibaseBytes :: ByteString -> MultibaseBytes
encodeProquintToMultibaseBytes = encodingToMultibase_ $ Proxy @Proquint

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Proquint' codec
encodeTextInProquintToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInProquintToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Proquint

-- | encode the input 'ByteString' to 'MultibaseBytes' via the 'Base256Emoji' codec
encodeBase256EmojiToMultibaseBytes :: ByteString -> MultibaseBytes
encodeBase256EmojiToMultibaseBytes = encodingToMultibase_ $ Proxy @Base256Emoji

-- | encode the input 'Text' to 'MultibaseBytes' via the 'Base256Emoji' codec
encodeTextInBase256EmojiToMultibaseBytes :: Text -> MultibaseBytes
encodeTextInBase256EmojiToMultibaseBytes = encodingTextToMultibase_ $ Proxy @Base256Emoji