{-# 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.MultibaseBytesLazy 
  ( MultibaseBytesLazy(..)
  , module Data.Multibase.Types.MultibaseBytesLazy
  ) 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
decodeMultibaseBytesLazy :: MultibaseBytesLazy -> Either MbDecodeFailure ByteStringLazy
decodeMultibaseBytesLazy = decodingMultibase

-- | decode the input 'Multibase' to a 'ByteString', or 'MbDecodeFailure' on failure
decodeMultibaseBytesLazyToText :: MultibaseBytesLazy -> Either MbDecodeFailure TextLazy
decodeMultibaseBytesLazyToText = decodingMultibaseToText


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

encodeToMultibaseBytesLazyWith :: MbAlgorithm -> ByteStringLazy -> MultibaseBytesLazy
encodeToMultibaseBytesLazyWith = encodingToMultibase

encodeTextToMultibaseBytesLazyWith :: MbAlgorithm -> TextLazy -> MultibaseBytesLazy
encodeTextToMultibaseBytesLazyWith = encodingTextToMultibase


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

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'IdentityBase' codec
encodeIdentityBaseToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeIdentityBaseToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @IdentityBase

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'IdentityBase' codec
encodeTextInIdentityBaseToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInIdentityBaseToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @IdentityBase

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base2' codec
encodeBase2ToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase2ToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base2

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base2' codec
encodeTextInBase2ToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase2ToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base2

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base8' codec
encodeBase8ToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase8ToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base8

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base8' codec
encodeTextInBase8ToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase8ToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base8

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base10' codec
encodeBase10ToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase10ToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base10

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base10' codec
encodeTextInBase10ToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase10ToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base10

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base16Lower' codec
encodeBase16LowerToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase16LowerToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base16Lower

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base16Lower' codec
encodeTextInBase16LowerToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase16LowerToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base16Lower

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base16Upper' codec
encodeBase16UpperToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase16UpperToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base16Upper

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base16Upper' codec
encodeTextInBase16UpperToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase16UpperToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base16Upper

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base32HexNoPadLower' codec
encodeBase32HexNoPadLowerToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase32HexNoPadLowerToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base32HexNoPadLower

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base32HexNoPadLower' codec
encodeTextInBase32HexNoPadLowerToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase32HexNoPadLowerToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base32HexNoPadLower

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base32HexNoPadUpper' codec
encodeBase32HexNoPadUpperToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase32HexNoPadUpperToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base32HexNoPadUpper

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base32HexNoPadUpper' codec
encodeTextInBase32HexNoPadUpperToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase32HexNoPadUpperToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base32HexNoPadUpper

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base32HexPadLower' codec
encodeBase32HexPadLowerToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase32HexPadLowerToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base32HexPadLower

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base32HexPadLower' codec
encodeTextInBase32HexPadLowerToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase32HexPadLowerToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base32HexPadLower

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base32HexPadUpper' codec
encodeBase32HexPadUpperToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase32HexPadUpperToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base32HexPadUpper

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base32HexPadUpper' codec
encodeTextInBase32HexPadUpperToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase32HexPadUpperToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base32HexPadUpper

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base32NoPadLower' codec
encodeBase32NoPadLowerToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase32NoPadLowerToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base32NoPadLower

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base32NoPadLower' codec
encodeTextInBase32NoPadLowerToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase32NoPadLowerToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base32NoPadLower

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base32NoPadUpper' codec
encodeBase32NoPadUpperToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase32NoPadUpperToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base32NoPadUpper

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base32NoPadUpper' codec
encodeTextInBase32NoPadUpperToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase32NoPadUpperToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base32NoPadUpper

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base32PadLower' codec
encodeBase32PadLowerToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase32PadLowerToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base32PadLower

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base32PadLower' codec
encodeTextInBase32PadLowerToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase32PadLowerToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base32PadLower

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base32PadUpper' codec
encodeBase32PadUpperToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase32PadUpperToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base32PadUpper

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base32PadUpper' codec
encodeTextInBase32PadUpperToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase32PadUpperToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base32PadUpper

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base32z' codec
encodeBase32zToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase32zToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base32z

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base32z' codec
encodeTextInBase32zToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase32zToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base32z

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base36Lower' codec
encodeBase36LowerToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase36LowerToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base36Lower

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base36Lower' codec
encodeTextInBase36LowerToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase36LowerToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base36Lower

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base36Upper' codec
encodeBase36UpperToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase36UpperToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base36Upper

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base36Upper' codec
encodeTextInBase36UpperToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase36UpperToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base36Upper

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base58Btc' codec
encodeBase58BtcToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase58BtcToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base58Btc

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base58Btc' codec
encodeTextInBase58BtcToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase58BtcToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base58Btc

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base58Flickr' codec
encodeBase58FlickrToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase58FlickrToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base58Flickr

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base58Flickr' codec
encodeTextInBase58FlickrToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase58FlickrToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base58Flickr

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base64NoPad' codec
encodeBase64NoPadToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase64NoPadToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base64NoPad

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base64NoPad' codec
encodeTextInBase64NoPadToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase64NoPadToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base64NoPad

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base64Pad' codec
encodeBase64PadToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase64PadToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base64Pad

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base64Pad' codec
encodeTextInBase64PadToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase64PadToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base64Pad

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base64UrlNoPad' codec
encodeBase64UrlNoPadToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase64UrlNoPadToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base64UrlNoPad

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base64UrlNoPad' codec
encodeTextInBase64UrlNoPadToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase64UrlNoPadToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base64UrlNoPad

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base64urlPad' codec
encodeBase64urlPadToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase64urlPadToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base64urlPad

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base64urlPad' codec
encodeTextInBase64urlPadToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase64urlPadToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base64urlPad

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Proquint' codec
encodeProquintToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeProquintToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Proquint

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Proquint' codec
encodeTextInProquintToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInProquintToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Proquint

-- | encode the input 'ByteStringLazy' to 'MultibaseBytesLazy' via the 'Base256Emoji' codec
encodeBase256EmojiToMultibaseBytesLazy :: ByteStringLazy -> MultibaseBytesLazy
encodeBase256EmojiToMultibaseBytesLazy = encodingToMultibase_ $ Proxy @Base256Emoji

-- | encode the input 'TextLazy' to 'MultibaseBytesLazy' via the 'Base256Emoji' codec
encodeTextInBase256EmojiToMultibaseBytesLazy :: TextLazy -> MultibaseBytesLazy
encodeTextInBase256EmojiToMultibaseBytesLazy = encodingTextToMultibase_ $ Proxy @Base256Emoji