-- | This module defines structures and functions for handling README files,
-- which are used as auxiliary documentation files for the system.
module Language.Drasil.Code.Imperative.README (
  ReadMeInfo(..), makeReadMe
) where

import Prelude hiding ((<>))
import Data.List.NonEmpty (nonEmpty, toList)
import Text.PrettyPrint.HughesPJ (Doc)

import Drasil.FileHandling.Legacy (RelativeFile, relFileToStr)
import Language.Drasil.Printers (makeMd, introInfo, verInfo, unsupOS,
    extLibSec, instDoc, endNote, whatInfo)

import Language.Drasil.Choices (ImplementationType(..))
import Language.Drasil.Mod (Name, Version)

-- | Language name.
type LangAbbrev = String
-- | Programming language version.
type LangVers = String
-- | Case name.
type CaseName = String
-- | Purpose of example
type ExamplePurpose = String
-- | Description of example
type ExampleDescr = String
-- | Motivation of example
type ExampleMotivation = String
-- | Scope of example
type ExampleScope = String
-- | File contributors
type Contributor = String
-- | Input File
type InFile = String
-- | Output File
type OutFile = String

-- | Holds all information needed to create a README file.
data ReadMeInfo = ReadMeInfo {
  ReadMeInfo -> LangAbbrev
langName :: LangAbbrev,
  ReadMeInfo -> LangAbbrev
langVersion :: LangVers,
  ReadMeInfo -> Maybe LangAbbrev
invalidOS :: Maybe String,
  ReadMeInfo -> ImplementationType
implementType :: ImplementationType,
  ReadMeInfo -> [(LangAbbrev, LangAbbrev)]
extLibNV :: [(Name, Version)],
  ReadMeInfo -> [LangAbbrev]
extLibFP :: [FilePath],
  ReadMeInfo -> [LangAbbrev]
contributors :: [Contributor],
  ReadMeInfo -> [RelativeFile]
configFP :: [RelativeFile],
  ReadMeInfo -> LangAbbrev
caseName :: CaseName,
  ReadMeInfo -> LangAbbrev
examplePurpose :: ExamplePurpose,
  ReadMeInfo -> LangAbbrev
exampleDescr :: ExampleDescr,
  ReadMeInfo -> LangAbbrev
exampleMotivation :: ExampleMotivation,
  ReadMeInfo -> LangAbbrev
exampleScope :: ExampleScope,
  ReadMeInfo -> Int
folderNum :: Int,
  ReadMeInfo -> (LangAbbrev, LangAbbrev)
inputOutput :: (InFile, OutFile)
}

-- | Generates a README file.
makeReadMe :: ReadMeInfo -> Doc
makeReadMe :: ReadMeInfo -> Doc
makeReadMe ReadMeInfo {
        langName :: ReadMeInfo -> LangAbbrev
langName = LangAbbrev
progLang,
        langVersion :: ReadMeInfo -> LangAbbrev
langVersion = LangAbbrev
progLangVers,
        invalidOS :: ReadMeInfo -> Maybe LangAbbrev
invalidOS = Maybe LangAbbrev
unsupportedOSs,
        implementType :: ReadMeInfo -> ImplementationType
implementType = ImplementationType
imptype,
        extLibNV :: ReadMeInfo -> [(LangAbbrev, LangAbbrev)]
extLibNV = [(LangAbbrev, LangAbbrev)]
extLibns,
        extLibFP :: ReadMeInfo -> [LangAbbrev]
extLibFP = [LangAbbrev]
extLibfp,
        contributors :: ReadMeInfo -> [LangAbbrev]
contributors = [LangAbbrev]
auths,
        configFP :: ReadMeInfo -> [RelativeFile]
configFP = [RelativeFile]
configFPs,
        caseName :: ReadMeInfo -> LangAbbrev
caseName = LangAbbrev
name,
        examplePurpose :: ReadMeInfo -> LangAbbrev
examplePurpose = LangAbbrev
purp,
        exampleDescr :: ReadMeInfo -> LangAbbrev
exampleDescr = LangAbbrev
descr,
        exampleMotivation :: ReadMeInfo -> LangAbbrev
exampleMotivation = LangAbbrev
motiv,
        exampleScope :: ReadMeInfo -> LangAbbrev
exampleScope = LangAbbrev
sc,
        folderNum :: ReadMeInfo -> Int
folderNum = Int
number,
        inputOutput :: ReadMeInfo -> (LangAbbrev, LangAbbrev)
inputOutput = (LangAbbrev, LangAbbrev)
inoutf} =
    [Maybe Doc] -> Doc
makeMd [LangAbbrev
-> [LangAbbrev]
-> Maybe LangAbbrev
-> Maybe LangAbbrev
-> Maybe Doc
introInfo LangAbbrev
name [LangAbbrev]
auths (LangAbbrev -> Maybe LangAbbrev
fieldEmptySTR LangAbbrev
motiv)
      (LangAbbrev -> Maybe LangAbbrev
fieldEmptySTR LangAbbrev
purp),
    Maybe LangAbbrev -> Maybe LangAbbrev -> Maybe Doc
whatInfo (LangAbbrev -> Maybe LangAbbrev
fieldEmptySTR LangAbbrev
descr) (LangAbbrev -> Maybe LangAbbrev
fieldEmptySTR LangAbbrev
sc),
    ImplementationType
-> [LangAbbrev]
-> LangAbbrev
-> (LangAbbrev, LangAbbrev)
-> Maybe Doc
makeInstr ImplementationType
imptype ((RelativeFile -> LangAbbrev) -> [RelativeFile] -> [LangAbbrev]
forall a b. (a -> b) -> [a] -> [b]
map RelativeFile -> LangAbbrev
relFileToStr [RelativeFile]
configFPs) LangAbbrev
name (LangAbbrev, LangAbbrev)
inoutf,
    LangAbbrev -> LangAbbrev -> Maybe Doc
verInfo LangAbbrev
progLang LangAbbrev
progLangVers,
    Maybe LangAbbrev -> Maybe Doc
unsupOS Maybe LangAbbrev
unsupportedOSs,
    [(LangAbbrev, LangAbbrev)] -> [LangAbbrev] -> Maybe Doc
extLibSec [(LangAbbrev, LangAbbrev)]
extLibns [LangAbbrev]
extLibfp,
    Int -> [LangAbbrev] -> Maybe Doc
endNote Int
number [LangAbbrev]
auths] -- add date information to end note for license

-- | Helper for encoding the type of program (either library or controller-based) in a README file.
makeInstr :: ImplementationType -> [FilePath] -> String -> (String, String) -> Maybe Doc
makeInstr :: ImplementationType
-> [LangAbbrev]
-> LangAbbrev
-> (LangAbbrev, LangAbbrev)
-> Maybe Doc
makeInstr ImplementationType
Library [LangAbbrev]
_ LangAbbrev
_ (LangAbbrev, LangAbbrev)
_ = Maybe Doc
forall a. Maybe a
Nothing
makeInstr ImplementationType
Program [LangAbbrev]
cfp LangAbbrev
n (LangAbbrev, LangAbbrev)
inOutf = [LangAbbrev] -> LangAbbrev -> (LangAbbrev, LangAbbrev) -> Maybe Doc
instDoc [LangAbbrev]
cfp LangAbbrev
n (LangAbbrev, LangAbbrev)
inOutf

-- |Helper that checks if the field is empty; allowing optional content
-- rendering in a README file
fieldEmptySTR :: String -> Maybe String
fieldEmptySTR :: LangAbbrev -> Maybe LangAbbrev
fieldEmptySTR = (NonEmpty Char -> LangAbbrev)
-> Maybe (NonEmpty Char) -> Maybe LangAbbrev
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NonEmpty Char -> LangAbbrev
forall a. NonEmpty a -> [a]
toList (Maybe (NonEmpty Char) -> Maybe LangAbbrev)
-> (LangAbbrev -> Maybe (NonEmpty Char))
-> LangAbbrev
-> Maybe LangAbbrev
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LangAbbrev -> Maybe (NonEmpty Char)
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty