{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE TypeApplications #-}

-- | Combinators reexported in Data.TypedEncoding.
-- 
-- Decoding combinators that are backward compatible to v0.2 versions.
--
-- @since 0.3.0.0
module Data.TypedEncoding.Combinators.Decode where

import           Data.TypedEncoding.Common.Types.Enc
import           Data.TypedEncoding.Common.Types.Decoding
import           Data.TypedEncoding.Combinators.Common

import           Data.TypedEncoding.Common.Util.TypeLits
import           Data.TypedEncoding.Common.Class.Decode
import           Data.Functor.Identity
import           GHC.TypeLits


-- * Convenience combinators which mimic v0.2 combinators signatures. These assume that @algs@ are the same as @nms@

decodeF :: forall nm xs f c str . (Decode f nm nm c str) => Enc (nm ': xs) c str -> f (Enc xs c str)
decodeF :: Enc @[Symbol] ((':) @Symbol nm xs) c str
-> f (Enc @[Symbol] xs c str)
decodeF = forall (xs :: [Symbol]) (f :: * -> *) c str.
Decode f nm nm c str =>
Enc @[Symbol] ((':) @Symbol nm xs) c str
-> f (Enc @[Symbol] xs c str)
forall (alg :: Symbol) (nm :: Symbol) (xs :: [Symbol])
       (f :: * -> *) c str.
Decode f nm alg c str =>
Enc @[Symbol] ((':) @Symbol nm xs) c str
-> f (Enc @[Symbol] xs c str)
decodeF' @nm @nm

decodeFAll :: forall nms f c str . (Monad f,  DecodeAll f nms nms c str) => 
               Enc nms c str
               -> f (Enc ('[]::[Symbol]) c str)  
decodeFAll :: Enc @[Symbol] nms c str -> f (Enc @[Symbol] ('[] @Symbol) c str)
decodeFAll = forall (algs :: [Symbol]) (nms :: [Symbol]) (f :: * -> *) c str.
(Monad f, DecodeAll f nms algs c str) =>
Enc @[Symbol] nms c str -> f (Enc @[Symbol] ('[] @Symbol) c str)
forall (f :: * -> *) c str.
(Monad f, DecodeAll f nms nms c str) =>
Enc @[Symbol] nms c str -> f (Enc @[Symbol] ('[] @Symbol) c str)
decodeFAll' @nms @nms 

-- | 
-- 
decodeAll :: forall nms c str . (DecodeAll Identity nms nms c str) =>
               Enc nms c str 
               -> Enc ('[]::[Symbol]) c str 
decodeAll :: Enc @[Symbol] nms c str -> Enc @[Symbol] ('[] @Symbol) c str
decodeAll = forall (algs :: [Symbol]) (nms :: [Symbol]) c str.
DecodeAll Identity nms algs c str =>
Enc @[Symbol] nms c str -> Enc @[Symbol] ('[] @Symbol) c str
forall c str.
DecodeAll Identity nms nms c str =>
Enc @[Symbol] nms c str -> Enc @[Symbol] ('[] @Symbol) c str
decodeAll' @nms @nms  

decodeFPart :: forall xs xsf f c str . (Monad f, DecodeAll f xs xs c str) => Enc (Append xs xsf) c str -> f (Enc xsf c str)
decodeFPart :: Enc @[Symbol] (Append @Symbol xs xsf) c str
-> f (Enc @[Symbol] xsf c str)
decodeFPart = forall (algs :: [Symbol]) (xs :: [Symbol]) (xsf :: [Symbol])
       (f :: * -> *) c str.
(Monad f, DecodeAll f xs algs c str) =>
Enc @[Symbol] (Append @Symbol xs xsf) c str
-> f (Enc @[Symbol] xsf c str)
forall (xsf :: [Symbol]) (f :: * -> *) c str.
(Monad f, DecodeAll f xs xs c str) =>
Enc @[Symbol] (Append @Symbol xs xsf) c str
-> f (Enc @[Symbol] xsf c str)
decodeFPart' @xs @xs 

decodePart :: forall xs xsf c str . (DecodeAll Identity xs xs c str) => Enc (Append xs xsf) c str -> Enc xsf c str   
decodePart :: Enc @[Symbol] (Append @Symbol xs xsf) c str
-> Enc @[Symbol] xsf c str
decodePart = forall (algs :: [Symbol]) (xs :: [Symbol]) (xsf :: [Symbol]) c str.
DecodeAll Identity xs algs c str =>
Enc @[Symbol] (Append @Symbol xs xsf) c str
-> Enc @[Symbol] xsf c str
forall (xsf :: [Symbol]) c str.
DecodeAll Identity xs xs c str =>
Enc @[Symbol] (Append @Symbol xs xsf) c str
-> Enc @[Symbol] xsf c str
decodePart' @xs @xs  



-- * Convenience combinators which mimic v0.2 type signatures. These do not try to figure out @algs@ or assume much about them

decodeF' :: forall alg nm xs f c str . (Decode f nm alg c str) => Enc (nm ': xs) c str -> f (Enc xs c str)
decodeF' :: Enc @[Symbol] ((':) @Symbol nm xs) c str
-> f (Enc @[Symbol] xs c str)
decodeF' = Decoding f nm alg c str
-> Enc @[Symbol] ((':) @Symbol nm xs) c str
-> f (Enc @[Symbol] xs c str)
forall (alg :: Symbol) (nm :: Symbol) (f :: * -> *)
       (xs :: [Symbol]) conf str.
Decoding f nm alg conf str
-> Enc @[Symbol] ((':) @Symbol nm xs) conf str
-> f (Enc @[Symbol] xs conf str)
runDecoding' (forall conf str.
Decode f nm alg conf str =>
Decoding f nm alg conf str
forall (f :: * -> *) (nm :: Symbol) (alg :: Symbol) conf str.
Decode f nm alg conf str =>
Decoding f nm alg conf str
decoding @f @nm @alg)

decodeFAll' :: forall algs nms f c str . (Monad f,  DecodeAll f nms algs c str) => 
               Enc nms c str
               -> f (Enc ('[]::[Symbol]) c str)  
decodeFAll' :: Enc @[Symbol] nms c str -> f (Enc @[Symbol] ('[] @Symbol) c str)
decodeFAll' = Decodings f nms algs c str
-> Enc @[Symbol] nms c str -> f (Enc @[Symbol] ('[] @Symbol) c str)
forall (algs :: [Symbol]) (nms :: [Symbol]) (f :: * -> *) c str.
Monad f =>
Decodings f nms algs c str
-> Enc @[Symbol] nms c str -> f (Enc @[Symbol] ('[] @Symbol) c str)
runDecodings' @algs @nms @f Decodings f nms algs c str
forall (f :: * -> *) (nms :: [Symbol]) (algs :: [Symbol]) conf str.
DecodeAll f nms algs conf str =>
Decodings f nms algs conf str
decodings 

-- | 
-- 
decodeAll' :: forall algs nms c str . (DecodeAll Identity nms algs c str) =>
               Enc nms c str 
               -> Enc ('[]::[Symbol]) c str 
decodeAll' :: Enc @[Symbol] nms c str -> Enc @[Symbol] ('[] @Symbol) c str
decodeAll' = Identity (Enc @[Symbol] ('[] @Symbol) c str)
-> Enc @[Symbol] ('[] @Symbol) c str
forall a. Identity a -> a
runIdentity (Identity (Enc @[Symbol] ('[] @Symbol) c str)
 -> Enc @[Symbol] ('[] @Symbol) c str)
-> (Enc @[Symbol] nms c str
    -> Identity (Enc @[Symbol] ('[] @Symbol) c str))
-> Enc @[Symbol] nms c str
-> Enc @[Symbol] ('[] @Symbol) c str
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (algs :: [Symbol]) (nms :: [Symbol]) (f :: * -> *) c str.
(Monad f, DecodeAll f nms algs c str) =>
Enc @[Symbol] nms c str -> f (Enc @[Symbol] ('[] @Symbol) c str)
forall (nms :: [Symbol]) (f :: * -> *) c str.
(Monad f, DecodeAll f nms algs c str) =>
Enc @[Symbol] nms c str -> f (Enc @[Symbol] ('[] @Symbol) c str)
decodeFAll' @algs 

decodeFPart' :: forall algs xs xsf f c str . (Monad f, DecodeAll f xs algs c str) => Enc (Append xs xsf) c str -> f (Enc xsf c str)
decodeFPart' :: Enc @[Symbol] (Append @Symbol xs xsf) c str
-> f (Enc @[Symbol] xsf c str)
decodeFPart' = (Enc @[Symbol] xs c str -> f (Enc @[Symbol] ('[] @Symbol) c str))
-> Enc @[Symbol] (Append @Symbol xs xsf) c str
-> f (Enc @[Symbol] (Append @Symbol ('[] @Symbol) xsf) c str)
forall (ts :: [Symbol]) (xs :: [Symbol]) (ys :: [Symbol])
       (f :: * -> *) c str.
Functor f =>
(Enc @[Symbol] xs c str -> f (Enc @[Symbol] ys c str))
-> Enc @[Symbol] (Append @Symbol xs ts) c str
-> f (Enc @[Symbol] (Append @Symbol ys ts) c str)
aboveF @xsf @xs @'[] (forall (algs :: [Symbol]) (nms :: [Symbol]) (f :: * -> *) c str.
(Monad f, DecodeAll f nms algs c str) =>
Enc @[Symbol] nms c str -> f (Enc @[Symbol] ('[] @Symbol) c str)
forall (nms :: [Symbol]) (f :: * -> *) c str.
(Monad f, DecodeAll f nms algs c str) =>
Enc @[Symbol] nms c str -> f (Enc @[Symbol] ('[] @Symbol) c str)
decodeFAll' @algs)  
-- decodeFPart' (UnsafeMkEnc _ conf str) =   
--     let re :: f (Enc '[] c str) = decodeFAll' @algs @xs $ UnsafeMkEnc Proxy conf str
--     in  UnsafeMkEnc Proxy conf . getPayload <$> re

decodePart' :: forall algs xs xsf c str . (DecodeAll Identity xs algs c str) => Enc (Append xs xsf) c str -> Enc xsf c str   
decodePart' :: Enc @[Symbol] (Append @Symbol xs xsf) c str
-> Enc @[Symbol] xsf c str
decodePart' = Identity (Enc @[Symbol] xsf c str) -> Enc @[Symbol] xsf c str
forall a. Identity a -> a
runIdentity (Identity (Enc @[Symbol] xsf c str) -> Enc @[Symbol] xsf c str)
-> (Enc @[Symbol] (Append @Symbol xs xsf) c str
    -> Identity (Enc @[Symbol] xsf c str))
-> Enc @[Symbol] (Append @Symbol xs xsf) c str
-> Enc @[Symbol] xsf c str
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (algs :: [Symbol]) (xs :: [Symbol]) (xsf :: [Symbol])
       (f :: * -> *) c str.
(Monad f, DecodeAll f xs algs c str) =>
Enc @[Symbol] (Append @Symbol xs xsf) c str
-> f (Enc @[Symbol] xsf c str)
forall (xsf :: [Symbol]) (f :: * -> *) c str.
(Monad f, DecodeAll f xs algs c str) =>
Enc @[Symbol] (Append @Symbol xs xsf) c str
-> f (Enc @[Symbol] xsf c str)
decodeFPart' @algs @xs