{-# LANGUAGE ImportQualifiedPost #-}
{-# LANGUAGE OverloadedStrings   #-}

module Dovetail.FFI 
  ( 
  -- * Foreign function interface
    FFI(..)
  , ForeignImport(..)
  , toEnv
  , toExterns
  ) where

import Data.Map qualified as Map  
import Dovetail.Types 
import Language.PureScript qualified as P
import Language.PureScript.Externs qualified as Externs
  
-- | Describes a module which is implemented in Haskell, and made available
-- to PureScript code using its foreign function interface. 
--
-- Right now, this consists only of foreign value declarations, even though
-- the FFI supports other forms of interop.
--
-- Values of this type can be constructed directly, but in many cases it is
-- simpler to use the "Dovetail.FFI.Builder" module
-- instead.
--
-- Values of this type can be consumed by the 'toExterns' and 'toEnv' functions,
-- and their results passed to the PureScript APIs or the low-level functions in
-- "Dovetail.Evaluate" and "Dovetail.Build", 
-- directly, but it is more likely that you will use values of this type with the 
-- higher-level 'Dovetail.ffi' function.
data FFI m = FFI
  { FFI m -> ModuleName
ffi_moduleName :: P.ModuleName
  -- ^ The module name for the module being implemented in Haskell.
  , FFI m -> [ForeignImport m]
ffi_values :: [ForeignImport m]
  -- ^ A list of values implemented in Haskell in this module.
  }
  
-- | A single value implemented in a foreign Haskell module.
data ForeignImport m = ForeignImport
  { ForeignImport m -> Ident
fv_name :: P.Ident
  -- ^ The name of this value in PureScript code
  , ForeignImport m -> SourceType
fv_type :: P.SourceType
  -- ^ The PureScript type of this value
  , ForeignImport m -> Value m
fv_value :: Value m
  -- ^ The value itself
  }

-- | Convert a foreign module into a PureScript externs file, for use during
-- separate compilation.
--
-- For advanced use cases, the result may be used with the functions in the 
-- "Dovetail.Build" module.
toExterns :: FFI m -> P.ExternsFile
toExterns :: FFI m -> ExternsFile
toExterns (FFI ModuleName
mn [ForeignImport m]
vals) =
  ExternsFile :: Text
-> ModuleName
-> [DeclarationRef]
-> [ExternsImport]
-> [ExternsFixity]
-> [ExternsTypeFixity]
-> [ExternsDeclaration]
-> SourceSpan
-> ExternsFile
Externs.ExternsFile   
    { efVersion :: Text
Externs.efVersion      = Text
"0.14.2"
    , efModuleName :: ModuleName
Externs.efModuleName   = ModuleName
mn
    , efExports :: [DeclarationRef]
Externs.efExports      = [SourceSpan -> Ident -> DeclarationRef
P.ValueRef SourceSpan
P.nullSourceSpan Ident
name | ForeignImport Ident
name SourceType
_ Value m
_ <- [ForeignImport m]
vals]
    , efImports :: [ExternsImport]
Externs.efImports      = [ ModuleName
-> ImportDeclarationType -> Maybe ModuleName -> ExternsImport
P.ExternsImport (Text -> ModuleName
P.ModuleName Text
"Prim") ImportDeclarationType
P.Implicit (ModuleName -> Maybe ModuleName
forall a. a -> Maybe a
Just (Text -> ModuleName
P.ModuleName Text
"Prim"))
                               , ModuleName
-> ImportDeclarationType -> Maybe ModuleName -> ExternsImport
P.ExternsImport (Text -> ModuleName
P.ModuleName Text
"Prim") ImportDeclarationType
P.Implicit Maybe ModuleName
forall a. Maybe a
Nothing
                               ]
    , efFixities :: [ExternsFixity]
Externs.efFixities     = []
    , efTypeFixities :: [ExternsTypeFixity]
Externs.efTypeFixities = []
    , efDeclarations :: [ExternsDeclaration]
Externs.efDeclarations = [Ident -> SourceType -> ExternsDeclaration
Externs.EDValue Ident
name SourceType
ty | ForeignImport Ident
name SourceType
ty Value m
_ <- [ForeignImport m]
vals]
    , efSourceSpan :: SourceSpan
Externs.efSourceSpan   = SourceSpan
P.nullSourceSpan
    } 

-- | Convert a foreign module into an evaluation environment.
--
-- For advanced use cases, the result may be used with the functions in the 
-- "Dovetail.Evaluate" module.
toEnv :: FFI m -> Env m
toEnv :: FFI m -> Env m
toEnv (FFI ModuleName
mn [ForeignImport m]
vals) = 
  [(Qualified Ident, Value m)] -> Env m
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [ (Ident -> ModuleName -> Qualified Ident
forall a. a -> ModuleName -> Qualified a
P.mkQualified Ident
name ModuleName
mn, Value m
val) | ForeignImport Ident
name SourceType
_ Value m
val <- [ForeignImport m]
vals ]