{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
module Language.Symantic.HTTP.Command where

import Control.Applicative (Applicative(..), Alternative(..))
import Control.Monad (Monad(..), MonadPlus(..), void)
import Data.Bool
import Data.Either (Either(..))
import Data.Eq (Eq(..))
import Data.Foldable (toList)
import Data.Function (($), (.), id)
import Data.Functor (Functor)
import Data.Maybe (Maybe(..))
import Data.Ord (Ord(..))
import Data.Semigroup (Semigroup(..))
import Data.String (IsString(..))
import Data.Tuple (fst, snd)
import Prelude (Num(..), max, undefined)
import System.IO (IO)
import Text.Show (Show(..))
import qualified Control.Monad.Trans.Reader as R
import qualified Data.ByteString as BS
import qualified Data.List as List
import qualified Data.Set as Set
import qualified Data.Text as Text
import qualified Network.HTTP.Media as Media
import qualified Network.HTTP.Types as HTTP
import qualified Network.Wai as Wai
import qualified Text.Megaparsec as P

import Language.Symantic.HTTP.Media
import Language.Symantic.HTTP.API
import Language.Symantic.HTTP.Client

-- Client a = R.ReaderT ClientRequest Client a

{-
newtype FPr a end b = FPr ({-k-}(Client a -> end) -> {-cont-}b)
newtype FPr a b = FPr ((String -> a) -> b)
sprintf :: FPr String b -> b
sprintf (FPr fmt) = fmt id

instance FormattingSpec FPr where
	lit str = FPr $ \k -> k str
	int     = FPr $ \k -> \x -> k (show x)
	char    = FPr $ \k -> \x -> k [x]
	fpp (PrinterParser pr _) = FPr $ \k -> \x -> k (pr x)
	(FPr a) ^ (FPr b)  = FPr $ \k -> a (\sa -> b (\sb -> k (sa ++ sb)))
-}


{-
runRouter :: Command a -> Wai.Request -> RoutingResult a
runRouter (Command rt) rq =
	let p = R.runReaderT rt rq in
	P.runParser (p <* P.eof) "<Request>" $
		RouteToken_Segment <$> Wai.pathInfo rq
-}

instance Altern Command where
	x <+> y = x :<|> y
instance HTTP_Path Command where
instance HTTP_Method Command where
instance HTTP_Header Command where
instance HTTP_Accept Command where
instance HTTP_Query Command where
instance HTTP_Version Command where

-- ** Type 'RouterEndpoint'
newtype CommandEndpoint a
 =      CommandEndpoint (Client a) -- (HTTP.Status -> HTTP.ResponseHeaders -> a -> Wai.Response)
instance HTTP_Endpoint Command where
	type Endpoint Command = CommandEndpoint
-- instance HTTP_API Command