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

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


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

encodeToMultibaseLazyWith :: MbAlgorithm -> ByteStringLazy -> MultibaseLazy
encodeToMultibaseLazyWith = encodingToMultibase

encodeTextToMultibaseLazyWith :: MbAlgorithm -> TextLazy -> MultibaseLazy
encodeTextToMultibaseLazyWith = encodingTextToMultibase


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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