module Argo.Internal.Encode where

import qualified Argo.Internal.Class.HasCodec as HasCodec
import qualified Argo.Internal.Codec.Value as Codec
import qualified Argo.Internal.Json.Value as Value
import qualified Argo.Internal.Literal as Literal
import qualified Argo.Internal.Pointer.Pointer as Pointer
import qualified Argo.Internal.Type.Config as Config
import qualified Argo.Internal.Type.Encoder as Encoder
import qualified Argo.Internal.Type.Indent as Indent
import qualified Argo.Vendor.Builder as Builder
import qualified Argo.Vendor.Transformers as Trans
import qualified Control.Monad as Monad

encode :: HasCodec.HasCodec a => a -> Builder.Builder
encode :: forall a. HasCodec a => a -> Builder
encode = forall a. HasCodec a => Indent -> a -> Builder
encodeWith forall a b. (a -> b) -> a -> b
$ Int -> Indent
Indent.Spaces Int
0

encodeWith :: HasCodec.HasCodec a => Indent.Indent -> a -> Builder.Builder
encodeWith :: forall a. HasCodec a => Indent -> a -> Builder
encodeWith Indent
i a
x =
    let c :: Config
c = Config
Config.initial { indent :: Indent
Config.indent = Indent
i }
    in
        forall a. Config -> Encoder a -> Builder
Encoder.run Config
c forall a b. (a -> b) -> a -> b
$ do
            Value -> Encoder ()
Value.encode forall a b. (a -> b) -> a -> b
$ forall a. HasCodec a => a -> Value
toValue a
x
            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
Monad.when (Config -> Bool
Config.hasIndent Config
c)
                forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
Trans.lift
                forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) w. Monad m => w -> WriterT w m ()
Trans.tell
                forall a b. (a -> b) -> a -> b
$ Word8 -> Builder
Builder.word8 Word8
Literal.newLine

encodePointer :: Pointer.Pointer -> Builder.Builder
encodePointer :: Pointer -> Builder
encodePointer = forall a. Config -> Encoder a -> Builder
Encoder.run Config
Config.initial forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pointer -> Encoder ()
Pointer.encode

toValue :: HasCodec.HasCodec a => a -> Value.Value
toValue :: forall a. HasCodec a => a -> Value
toValue = forall a. Value a -> a -> Value
Codec.encodeWith forall a. HasCodec a => Value a
HasCodec.codec