-- | Converts a 'SmithEtAlSRS' into a 'CodeSpec'.
module Drasil.Generator.Code.CodeSpec (
  srs2CodeSpec
) where

import Control.Lens ((^.), set)
import Data.List ((\\))
import qualified Data.List.NonEmpty as NE
import qualified Data.Map as Map
import Data.Maybe (mapMaybe)

import Data.List.Extras (subsetOf)
import Drasil.Code.CodeExpr.Development (expr)
import Drasil.Database (ChunkDB, HasUID(..), insertAll)
import qualified Drasil.SRS as S
import Drasil.SRS (HasSmithEtAlSRS(..))
import Drasil.System (HasSystemMeta(..), systemdb)
import Language.Drasil (SimpleQDef, DefiningExpr(defnExpr))
import Language.Drasil.Code (Choices(extLibs, maps, handWiredDefs,
  defaultConfigFiles, extraMods), Maps(conceptMatch), CodeSpec, Input, Const,
  mkCodeSpec, getODE, mapODE, quantvar, qtov, qtoc, constraintMap, codevars,
  odeInfoReqs, odeLibReqs, mkAbstractICOProgram)
import Theory.Drasil (DataDefinition, qdEFromDD, getEqModQdsFromIm)

import Drasil.Generator.Code.ICOSolutionSearch (solveExecOrder)

-- | Creates a 'CodeSpec' from a 'SmithEtAlSRS' and 'Choices'.
srs2CodeSpec :: S.SmithEtAlSRS -> Choices -> CodeSpec
srs2CodeSpec :: SmithEtAlSRS -> Choices -> CodeSpec
srs2CodeSpec si :: SmithEtAlSRS
si@S.ICO{ _inputs :: ()
S._inputs = NonEmpty h
ins
                      , _outputs :: ()
S._outputs = NonEmpty i
outs
                      , _constraints :: ()
S._constraints = [j]
cs
                      , _constants :: SmithEtAlSRS -> [QDefinition Literal]
S._constants = [QDefinition Literal]
cnsts } Choices
chs =
  let els :: [ExtLib]
els = Choices -> [ExtLib]
extLibs Choices
chs
      libReqs :: [DefinedQuantityDict]
libReqs = (ExtLib -> [DefinedQuantityDict])
-> [ExtLib] -> [DefinedQuantityDict]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ExtLib -> [DefinedQuantityDict]
odeLibReqs [ExtLib]
els
      infoReqs :: [DefinedQuantityDict]
infoReqs = (ExtLib -> [DefinedQuantityDict])
-> [ExtLib] -> [DefinedQuantityDict]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ExtLib -> [DefinedQuantityDict]
odeInfoReqs [ExtLib]
els
      db :: ChunkDB
db = [DefinedQuantityDict] -> ChunkDB -> ChunkDB
forall a. TypeableChunk a => [a] -> ChunkDB -> ChunkDB
insertAll ([DefinedQuantityDict]
libReqs [DefinedQuantityDict]
-> [DefinedQuantityDict] -> [DefinedQuantityDict]
forall a. Semigroup a => a -> a -> a
<> [DefinedQuantityDict]
infoReqs) (ChunkDB -> ChunkDB) -> ChunkDB -> ChunkDB
forall a b. (a -> b) -> a -> b
$ SmithEtAlSRS
si SmithEtAlSRS -> Getting ChunkDB SmithEtAlSRS ChunkDB -> ChunkDB
forall s a. s -> Getting a s a -> a
^. Getting ChunkDB SmithEtAlSRS ChunkDB
forall c. HasSystemMeta c => Lens' c ChunkDB
Lens' SmithEtAlSRS ChunkDB
systemdb
      -- FIXME: This _should_ be different in at least one way. The SM from
      -- the SRS _should_ reference "defining an SRS that ...". This SM should
      -- reference said SRS, saying "building a software design satisfying
      -- said SRS."
      sysMeta :: SystemMeta
sysMeta = ASetter SystemMeta SystemMeta ChunkDB ChunkDB
-> ChunkDB -> SystemMeta -> SystemMeta
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter SystemMeta SystemMeta ChunkDB ChunkDB
forall c. HasSystemMeta c => Lens' c ChunkDB
Lens' SystemMeta ChunkDB
systemdb ChunkDB
db (SystemMeta -> SystemMeta) -> SystemMeta -> SystemMeta
forall a b. (a -> b) -> a -> b
$ SmithEtAlSRS
si SmithEtAlSRS
-> Getting SystemMeta SmithEtAlSRS SystemMeta -> SystemMeta
forall s a. s -> Getting a s a -> a
^. Getting SystemMeta SmithEtAlSRS SystemMeta
forall c. HasSystemMeta c => Lens' c SystemMeta
Lens' SmithEtAlSRS SystemMeta
systemMeta
      ddefs :: [DataDefinition]
ddefs = SmithEtAlSRS
si SmithEtAlSRS
-> Getting [DataDefinition] SmithEtAlSRS [DataDefinition]
-> [DataDefinition]
forall s a. s -> Getting a s a -> a
^. Getting [DataDefinition] SmithEtAlSRS [DataDefinition]
forall c. HasSmithEtAlSRS c => Lens' c [DataDefinition]
Lens' SmithEtAlSRS [DataDefinition]
dataDefns
      inputs' :: [Input]
inputs' = h -> Input
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> Input
quantvar (h -> Input) -> [h] -> [Input]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty h -> [h]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty h
ins
      const' :: [Const]
const' = QDefinition Literal -> Const
forall e. (CanGenCode e, HasChunkRefs e) => QDefinition e -> Const
qtov (QDefinition Literal -> Const) -> [QDefinition Literal] -> [Const]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (QDefinition Literal -> Bool)
-> [QDefinition Literal] -> [QDefinition Literal]
forall a. (a -> Bool) -> [a] -> [a]
filter ((UID -> Map UID [CodeConcept] -> Bool
forall k a. Ord k => k -> Map k a -> Bool
`Map.notMember` Maps -> Map UID [CodeConcept]
conceptMatch (Choices -> Maps
maps Choices
chs)) (UID -> Bool)
-> (QDefinition Literal -> UID) -> QDefinition Literal -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (QDefinition Literal -> Getting UID (QDefinition Literal) UID -> UID
forall s a. s -> Getting a s a -> a
^. Getting UID (QDefinition Literal) UID
forall c. HasUID c => Getter c UID
Getter (QDefinition Literal) UID
uid))
        [QDefinition Literal]
cnsts
      derived :: [Const]
derived = QDefinition Expr -> Const
forall e. (CanGenCode e, HasChunkRefs e) => QDefinition e -> Const
qtov (QDefinition Expr -> Const) -> [QDefinition Expr] -> [Const]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [DataDefinition]
-> [Input] -> [Const] -> ChunkDB -> [QDefinition Expr]
getDerivedInputs [DataDefinition]
ddefs [Input]
inputs' [Const]
const' ChunkDB
db
      rels :: [Const]
rels = ((QDefinition Expr -> Const) -> [QDefinition Expr] -> [Const]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap QDefinition Expr -> Const
forall (q :: * -> *).
(Quantity (q Expr), MayHaveUnit (q Expr), DefiningExpr q,
 Concept (q Expr)) =>
q Expr -> Const
qtoc ([InstanceModel] -> [QDefinition Expr]
getEqModQdsFromIm (SmithEtAlSRS
si SmithEtAlSRS
-> Getting [InstanceModel] SmithEtAlSRS [InstanceModel]
-> [InstanceModel]
forall s a. s -> Getting a s a -> a
^. Getting [InstanceModel] SmithEtAlSRS [InstanceModel]
forall c. HasSmithEtAlSRS c => Lens' c [InstanceModel]
Lens' SmithEtAlSRS [InstanceModel]
instModels) [QDefinition Expr] -> [QDefinition Expr] -> [QDefinition Expr]
forall a. Semigroup a => a -> a -> a
<> (DataDefinition -> Maybe (QDefinition Expr))
-> [DataDefinition] -> [QDefinition Expr]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe DataDefinition -> Maybe (QDefinition Expr)
qdEFromDD [DataDefinition]
ddefs) [Const] -> [Const] -> [Const]
forall a. Eq a => [a] -> [a] -> [a]
\\ [Const]
derived)
        [Const] -> [Const] -> [Const]
forall a. Semigroup a => a -> a -> a
<> Maybe ODE -> [Const]
mapODE ([ExtLib] -> Maybe ODE
getODE ([ExtLib] -> Maybe ODE) -> [ExtLib] -> Maybe ODE
forall a b. (a -> b) -> a -> b
$ Choices -> [ExtLib]
extLibs Choices
chs)
        [Const] -> [Const] -> [Const]
forall a. Semigroup a => a -> a -> a
<> (QDefinition Expr -> Const) -> [QDefinition Expr] -> [Const]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap QDefinition Expr -> Const
forall (q :: * -> *).
(Quantity (q Expr), MayHaveUnit (q Expr), DefiningExpr q,
 Concept (q Expr)) =>
q Expr -> Const
qtoc (Choices -> [QDefinition Expr]
handWiredDefs Choices
chs)
      -- TODO: When we have better DEModels, we should be deriving our ODE information
      --       directly from the instance models (ims) instead of directly from the choices.
      outs' :: [Input]
outs' = i -> Input
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> Input
quantvar (i -> Input) -> [i] -> [Input]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty i -> [i]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty i
outs
      allInputs :: [Input]
allInputs = [Input]
inputs' [Input] -> [Input] -> [Input]
forall a. Semigroup a => a -> a -> a
<> (Const -> Input) -> [Const] -> [Input]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Const -> Input
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> Input
quantvar [Const]
derived
      exOrder :: [Const]
exOrder = [Const] -> [Input] -> [Input] -> ChunkDB -> [Const]
solveExecOrder [Const]
rels ([Input]
allInputs [Input] -> [Input] -> [Input]
forall a. Semigroup a => a -> a -> a
<> (QDefinition Literal -> Input) -> [QDefinition Literal] -> [Input]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap QDefinition Literal -> Input
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> Input
quantvar [QDefinition Literal]
cnsts) [Input]
outs' ChunkDB
db
      aicop :: AbstractICOProgram
aicop = [Input]
-> [Const]
-> [Input]
-> [Const]
-> ConstraintCEMap
-> [Const]
-> AbstractICOProgram
mkAbstractICOProgram [Input]
inputs' [Const]
derived [Input]
outs' [Const]
exOrder ([j] -> ConstraintCEMap
forall c. (HasUID c, Constrained c) => [c] -> ConstraintCEMap
constraintMap [j]
cs) [Const]
const'
  in SystemMeta
-> AbstractICOProgram -> [RelativeFile] -> [Mod] -> CodeSpec
mkCodeSpec SystemMeta
sysMeta AbstractICOProgram
aicop (Choices -> [RelativeFile]
defaultConfigFiles Choices
chs) (Choices -> [Mod]
extraMods Choices
chs)

-- | Determines the derived inputs: the data definitions that can be calculated
-- immediately from the knowns (inputs and constants). Only data definitions
-- defined by an 'Expr' are considered (see 'qdEFromDD').
getDerivedInputs :: [DataDefinition] -> [Input] -> [Const] ->
  ChunkDB -> [SimpleQDef]
getDerivedInputs :: [DataDefinition]
-> [Input] -> [Const] -> ChunkDB -> [QDefinition Expr]
getDerivedInputs [DataDefinition]
ddefs [Input]
ins [Const]
cnsts ChunkDB
db =
  (QDefinition Expr -> Bool)
-> [QDefinition Expr] -> [QDefinition Expr]
forall a. (a -> Bool) -> [a] -> [a]
filter (([Input] -> [Input] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`subsetOf` [Input]
refSet) ([Input] -> Bool)
-> (QDefinition Expr -> [Input]) -> QDefinition Expr -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CodeExpr -> ChunkDB -> [Input]) -> ChunkDB -> CodeExpr -> [Input]
forall a b c. (a -> b -> c) -> b -> a -> c
flip CodeExpr -> ChunkDB -> [Input]
codevars ChunkDB
db (CodeExpr -> [Input])
-> (QDefinition Expr -> CodeExpr) -> QDefinition Expr -> [Input]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr -> CodeExpr
expr (Expr -> CodeExpr)
-> (QDefinition Expr -> Expr) -> QDefinition Expr -> CodeExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (QDefinition Expr -> Getting Expr (QDefinition Expr) Expr -> Expr
forall s a. s -> Getting a s a -> a
^. Getting Expr (QDefinition Expr) Expr
forall e. Lens' (QDefinition e) e
forall (c :: * -> *) e. DefiningExpr c => Lens' (c e) e
defnExpr)) ((DataDefinition -> Maybe (QDefinition Expr))
-> [DataDefinition] -> [QDefinition Expr]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe DataDefinition -> Maybe (QDefinition Expr)
qdEFromDD [DataDefinition]
ddefs)
  where refSet :: [Input]
refSet = [Input]
ins [Input] -> [Input] -> [Input]
forall a. Semigroup a => a -> a -> a
<> (Const -> Input) -> [Const] -> [Input]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Const -> Input
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> Input
quantvar [Const]
cnsts