module Buffet.Facade
  ( AssembleArguments(..)
  , Command(..)
  , DocumentArguments(..)
  , ParseArguments(..)
  , TestArguments(..)
  , get
  ) where

import qualified Buffet.Assemble.Assemble as Assemble
import qualified Buffet.Document.Configuration as Document
import qualified Buffet.Document.Document as Document
import qualified Buffet.Parse.Parse as Parse
import qualified Buffet.Test.Configuration as Test
import qualified Buffet.Test.Test as Test
import qualified Data.Text as T
import qualified Data.Text.IO as T.IO
import Prelude (Bool, Eq, FilePath, IO, Maybe, Ord, Show, (>>=), uncurry)
import qualified System.Exit as Exit

data Command
  = Assemble AssembleArguments
  | Document DocumentArguments
  | Parse ParseArguments
  | Test TestArguments
  deriving (Command -> Command -> Bool
(Command -> Command -> Bool)
-> (Command -> Command -> Bool) -> Eq Command
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Command -> Command -> Bool
$c/= :: Command -> Command -> Bool
== :: Command -> Command -> Bool
$c== :: Command -> Command -> Bool
Eq, Eq Command
Eq Command
-> (Command -> Command -> Ordering)
-> (Command -> Command -> Bool)
-> (Command -> Command -> Bool)
-> (Command -> Command -> Bool)
-> (Command -> Command -> Bool)
-> (Command -> Command -> Command)
-> (Command -> Command -> Command)
-> Ord Command
Command -> Command -> Bool
Command -> Command -> Ordering
Command -> Command -> Command
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Command -> Command -> Command
$cmin :: Command -> Command -> Command
max :: Command -> Command -> Command
$cmax :: Command -> Command -> Command
>= :: Command -> Command -> Bool
$c>= :: Command -> Command -> Bool
> :: Command -> Command -> Bool
$c> :: Command -> Command -> Bool
<= :: Command -> Command -> Bool
$c<= :: Command -> Command -> Bool
< :: Command -> Command -> Bool
$c< :: Command -> Command -> Bool
compare :: Command -> Command -> Ordering
$ccompare :: Command -> Command -> Ordering
$cp1Ord :: Eq Command
Ord, Int -> Command -> ShowS
[Command] -> ShowS
Command -> String
(Int -> Command -> ShowS)
-> (Command -> String) -> ([Command] -> ShowS) -> Show Command
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Command] -> ShowS
$cshowList :: [Command] -> ShowS
show :: Command -> String
$cshow :: Command -> String
showsPrec :: Int -> Command -> ShowS
$cshowsPrec :: Int -> Command -> ShowS
Show)

newtype AssembleArguments =
  AssembleArguments
    { AssembleArguments -> String
assembleMenu :: FilePath
    }
  deriving (AssembleArguments -> AssembleArguments -> Bool
(AssembleArguments -> AssembleArguments -> Bool)
-> (AssembleArguments -> AssembleArguments -> Bool)
-> Eq AssembleArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssembleArguments -> AssembleArguments -> Bool
$c/= :: AssembleArguments -> AssembleArguments -> Bool
== :: AssembleArguments -> AssembleArguments -> Bool
$c== :: AssembleArguments -> AssembleArguments -> Bool
Eq, Eq AssembleArguments
Eq AssembleArguments
-> (AssembleArguments -> AssembleArguments -> Ordering)
-> (AssembleArguments -> AssembleArguments -> Bool)
-> (AssembleArguments -> AssembleArguments -> Bool)
-> (AssembleArguments -> AssembleArguments -> Bool)
-> (AssembleArguments -> AssembleArguments -> Bool)
-> (AssembleArguments -> AssembleArguments -> AssembleArguments)
-> (AssembleArguments -> AssembleArguments -> AssembleArguments)
-> Ord AssembleArguments
AssembleArguments -> AssembleArguments -> Bool
AssembleArguments -> AssembleArguments -> Ordering
AssembleArguments -> AssembleArguments -> AssembleArguments
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: AssembleArguments -> AssembleArguments -> AssembleArguments
$cmin :: AssembleArguments -> AssembleArguments -> AssembleArguments
max :: AssembleArguments -> AssembleArguments -> AssembleArguments
$cmax :: AssembleArguments -> AssembleArguments -> AssembleArguments
>= :: AssembleArguments -> AssembleArguments -> Bool
$c>= :: AssembleArguments -> AssembleArguments -> Bool
> :: AssembleArguments -> AssembleArguments -> Bool
$c> :: AssembleArguments -> AssembleArguments -> Bool
<= :: AssembleArguments -> AssembleArguments -> Bool
$c<= :: AssembleArguments -> AssembleArguments -> Bool
< :: AssembleArguments -> AssembleArguments -> Bool
$c< :: AssembleArguments -> AssembleArguments -> Bool
compare :: AssembleArguments -> AssembleArguments -> Ordering
$ccompare :: AssembleArguments -> AssembleArguments -> Ordering
$cp1Ord :: Eq AssembleArguments
Ord, Int -> AssembleArguments -> ShowS
[AssembleArguments] -> ShowS
AssembleArguments -> String
(Int -> AssembleArguments -> ShowS)
-> (AssembleArguments -> String)
-> ([AssembleArguments] -> ShowS)
-> Show AssembleArguments
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssembleArguments] -> ShowS
$cshowList :: [AssembleArguments] -> ShowS
show :: AssembleArguments -> String
$cshow :: AssembleArguments -> String
showsPrec :: Int -> AssembleArguments -> ShowS
$cshowsPrec :: Int -> AssembleArguments -> ShowS
Show)

data DocumentArguments =
  DocumentArguments
    { DocumentArguments -> Maybe String
documentTemplate :: Maybe FilePath
    , DocumentArguments -> String
documentMenu :: FilePath
    }
  deriving (DocumentArguments -> DocumentArguments -> Bool
(DocumentArguments -> DocumentArguments -> Bool)
-> (DocumentArguments -> DocumentArguments -> Bool)
-> Eq DocumentArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DocumentArguments -> DocumentArguments -> Bool
$c/= :: DocumentArguments -> DocumentArguments -> Bool
== :: DocumentArguments -> DocumentArguments -> Bool
$c== :: DocumentArguments -> DocumentArguments -> Bool
Eq, Eq DocumentArguments
Eq DocumentArguments
-> (DocumentArguments -> DocumentArguments -> Ordering)
-> (DocumentArguments -> DocumentArguments -> Bool)
-> (DocumentArguments -> DocumentArguments -> Bool)
-> (DocumentArguments -> DocumentArguments -> Bool)
-> (DocumentArguments -> DocumentArguments -> Bool)
-> (DocumentArguments -> DocumentArguments -> DocumentArguments)
-> (DocumentArguments -> DocumentArguments -> DocumentArguments)
-> Ord DocumentArguments
DocumentArguments -> DocumentArguments -> Bool
DocumentArguments -> DocumentArguments -> Ordering
DocumentArguments -> DocumentArguments -> DocumentArguments
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DocumentArguments -> DocumentArguments -> DocumentArguments
$cmin :: DocumentArguments -> DocumentArguments -> DocumentArguments
max :: DocumentArguments -> DocumentArguments -> DocumentArguments
$cmax :: DocumentArguments -> DocumentArguments -> DocumentArguments
>= :: DocumentArguments -> DocumentArguments -> Bool
$c>= :: DocumentArguments -> DocumentArguments -> Bool
> :: DocumentArguments -> DocumentArguments -> Bool
$c> :: DocumentArguments -> DocumentArguments -> Bool
<= :: DocumentArguments -> DocumentArguments -> Bool
$c<= :: DocumentArguments -> DocumentArguments -> Bool
< :: DocumentArguments -> DocumentArguments -> Bool
$c< :: DocumentArguments -> DocumentArguments -> Bool
compare :: DocumentArguments -> DocumentArguments -> Ordering
$ccompare :: DocumentArguments -> DocumentArguments -> Ordering
$cp1Ord :: Eq DocumentArguments
Ord, Int -> DocumentArguments -> ShowS
[DocumentArguments] -> ShowS
DocumentArguments -> String
(Int -> DocumentArguments -> ShowS)
-> (DocumentArguments -> String)
-> ([DocumentArguments] -> ShowS)
-> Show DocumentArguments
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DocumentArguments] -> ShowS
$cshowList :: [DocumentArguments] -> ShowS
show :: DocumentArguments -> String
$cshow :: DocumentArguments -> String
showsPrec :: Int -> DocumentArguments -> ShowS
$cshowsPrec :: Int -> DocumentArguments -> ShowS
Show)

newtype ParseArguments =
  ParseArguments
    { ParseArguments -> String
parseMenu :: FilePath
    }
  deriving (ParseArguments -> ParseArguments -> Bool
(ParseArguments -> ParseArguments -> Bool)
-> (ParseArguments -> ParseArguments -> Bool) -> Eq ParseArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ParseArguments -> ParseArguments -> Bool
$c/= :: ParseArguments -> ParseArguments -> Bool
== :: ParseArguments -> ParseArguments -> Bool
$c== :: ParseArguments -> ParseArguments -> Bool
Eq, Eq ParseArguments
Eq ParseArguments
-> (ParseArguments -> ParseArguments -> Ordering)
-> (ParseArguments -> ParseArguments -> Bool)
-> (ParseArguments -> ParseArguments -> Bool)
-> (ParseArguments -> ParseArguments -> Bool)
-> (ParseArguments -> ParseArguments -> Bool)
-> (ParseArguments -> ParseArguments -> ParseArguments)
-> (ParseArguments -> ParseArguments -> ParseArguments)
-> Ord ParseArguments
ParseArguments -> ParseArguments -> Bool
ParseArguments -> ParseArguments -> Ordering
ParseArguments -> ParseArguments -> ParseArguments
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ParseArguments -> ParseArguments -> ParseArguments
$cmin :: ParseArguments -> ParseArguments -> ParseArguments
max :: ParseArguments -> ParseArguments -> ParseArguments
$cmax :: ParseArguments -> ParseArguments -> ParseArguments
>= :: ParseArguments -> ParseArguments -> Bool
$c>= :: ParseArguments -> ParseArguments -> Bool
> :: ParseArguments -> ParseArguments -> Bool
$c> :: ParseArguments -> ParseArguments -> Bool
<= :: ParseArguments -> ParseArguments -> Bool
$c<= :: ParseArguments -> ParseArguments -> Bool
< :: ParseArguments -> ParseArguments -> Bool
$c< :: ParseArguments -> ParseArguments -> Bool
compare :: ParseArguments -> ParseArguments -> Ordering
$ccompare :: ParseArguments -> ParseArguments -> Ordering
$cp1Ord :: Eq ParseArguments
Ord, Int -> ParseArguments -> ShowS
[ParseArguments] -> ShowS
ParseArguments -> String
(Int -> ParseArguments -> ShowS)
-> (ParseArguments -> String)
-> ([ParseArguments] -> ShowS)
-> Show ParseArguments
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ParseArguments] -> ShowS
$cshowList :: [ParseArguments] -> ShowS
show :: ParseArguments -> String
$cshow :: ParseArguments -> String
showsPrec :: Int -> ParseArguments -> ShowS
$cshowsPrec :: Int -> ParseArguments -> ShowS
Show)

data TestArguments =
  TestArguments
    { TestArguments -> Maybe String
testArguments :: Maybe FilePath
    , TestArguments -> String
testMenu :: FilePath
    }
  deriving (TestArguments -> TestArguments -> Bool
(TestArguments -> TestArguments -> Bool)
-> (TestArguments -> TestArguments -> Bool) -> Eq TestArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TestArguments -> TestArguments -> Bool
$c/= :: TestArguments -> TestArguments -> Bool
== :: TestArguments -> TestArguments -> Bool
$c== :: TestArguments -> TestArguments -> Bool
Eq, Eq TestArguments
Eq TestArguments
-> (TestArguments -> TestArguments -> Ordering)
-> (TestArguments -> TestArguments -> Bool)
-> (TestArguments -> TestArguments -> Bool)
-> (TestArguments -> TestArguments -> Bool)
-> (TestArguments -> TestArguments -> Bool)
-> (TestArguments -> TestArguments -> TestArguments)
-> (TestArguments -> TestArguments -> TestArguments)
-> Ord TestArguments
TestArguments -> TestArguments -> Bool
TestArguments -> TestArguments -> Ordering
TestArguments -> TestArguments -> TestArguments
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TestArguments -> TestArguments -> TestArguments
$cmin :: TestArguments -> TestArguments -> TestArguments
max :: TestArguments -> TestArguments -> TestArguments
$cmax :: TestArguments -> TestArguments -> TestArguments
>= :: TestArguments -> TestArguments -> Bool
$c>= :: TestArguments -> TestArguments -> Bool
> :: TestArguments -> TestArguments -> Bool
$c> :: TestArguments -> TestArguments -> Bool
<= :: TestArguments -> TestArguments -> Bool
$c<= :: TestArguments -> TestArguments -> Bool
< :: TestArguments -> TestArguments -> Bool
$c< :: TestArguments -> TestArguments -> Bool
compare :: TestArguments -> TestArguments -> Ordering
$ccompare :: TestArguments -> TestArguments -> Ordering
$cp1Ord :: Eq TestArguments
Ord, Int -> TestArguments -> ShowS
[TestArguments] -> ShowS
TestArguments -> String
(Int -> TestArguments -> ShowS)
-> (TestArguments -> String)
-> ([TestArguments] -> ShowS)
-> Show TestArguments
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TestArguments] -> ShowS
$cshowList :: [TestArguments] -> ShowS
show :: TestArguments -> String
$cshow :: TestArguments -> String
showsPrec :: Int -> TestArguments -> ShowS
$cshowsPrec :: Int -> TestArguments -> ShowS
Show)

get :: Command -> IO ()
get :: Command -> IO ()
get Command
command =
  case Command
command of
    Assemble AssembleArguments
arguments -> AssembleArguments -> IO ()
assemble AssembleArguments
arguments
    Document DocumentArguments
arguments -> DocumentArguments -> IO ()
document DocumentArguments
arguments
    Parse ParseArguments
arguments -> ParseArguments -> IO ()
parse ParseArguments
arguments
    Test TestArguments
arguments -> TestArguments -> IO ()
test TestArguments
arguments

assemble :: AssembleArguments -> IO ()
assemble :: AssembleArguments -> IO ()
assemble AssembleArguments
arguments = String -> IO Text
Assemble.get (AssembleArguments -> String
assembleMenu AssembleArguments
arguments) IO Text -> (Text -> IO ()) -> IO ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Text -> IO ()
T.IO.putStr

document :: DocumentArguments -> IO ()
document :: DocumentArguments -> IO ()
document DocumentArguments
arguments =
  Configuration -> String -> IO Text
Document.get Configuration
configuration (DocumentArguments -> String
documentMenu DocumentArguments
arguments) IO Text -> (Text -> IO ()) -> IO ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Text -> IO ()
T.IO.putStr
  where
    configuration :: Configuration
configuration =
      Configuration :: Maybe String -> Configuration
Document.Configuration {template :: Maybe String
Document.template = DocumentArguments -> Maybe String
documentTemplate DocumentArguments
arguments}

parse :: ParseArguments -> IO ()
parse :: ParseArguments -> IO ()
parse ParseArguments
arguments = String -> IO Text
Parse.get (ParseArguments -> String
parseMenu ParseArguments
arguments) IO Text -> (Text -> IO ()) -> IO ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Text -> IO ()
T.IO.putStr

test :: TestArguments -> IO ()
test :: TestArguments -> IO ()
test TestArguments
arguments =
  Configuration -> String -> IO (Bool, Text)
Test.get Configuration
configuration (TestArguments -> String
testMenu TestArguments
arguments) IO (Bool, Text) -> ((Bool, Text) -> IO ()) -> IO ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Bool -> Text -> IO ()) -> (Bool, Text) -> IO ()
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Bool -> Text -> IO ()
forall a. Bool -> Text -> IO a
exitPrintingStdout
  where
    configuration :: Configuration
configuration =
      Configuration :: Maybe String -> Configuration
Test.Configuration {arguments :: Maybe String
Test.arguments = TestArguments -> Maybe String
testArguments TestArguments
arguments}

exitPrintingStdout :: Bool -> T.Text -> IO a
exitPrintingStdout :: Bool -> Text -> IO a
exitPrintingStdout Bool
isSuccess Text
result = do
  Text -> IO ()
T.IO.putStr Text
result
  if Bool
isSuccess
    then IO a
forall a. IO a
Exit.exitSuccess
    else IO a
forall a. IO a
Exit.exitFailure