{-# LANGUAGE OverloadedStrings, DeriveDataTypeable #-}
module Foreign.JavaScript.Types where

import           Control.Applicative
import qualified Control.Exception       as E
import           Control.Concurrent.STM  as STM
import           Control.Concurrent.Chan as Chan
import           Control.Concurrent.MVar
import           Control.DeepSeq
import           Data.Aeson              as JSON
import           Data.ByteString.Char8           (ByteString)
import qualified Data.ByteString.Char8   as BS   (hPutStrLn)
import           Data.IORef
import           Data.Map                as Map
import           Data.String
import           Data.Text
import           Data.Typeable
import           Snap.Core                       (Cookie(..))
import           System.IO                       (stderr)

import Foreign.RemotePtr

{-----------------------------------------------------------------------------
    Server Configuration -- Static
------------------------------------------------------------------------------}
-- NOTE: Unfortunately, Haddock currently does not create documentation for
-- record fields when the constructor is not exported.
-- That's why we copy & paste it in the documentation for the data type.
{- | Static configuration for a "Foreign.JavaScript" server.

This is a record type which has the following fields:

* @jsPort :: Maybe Int@

    Port number.
    @Nothing@ means that the port number is read from the environment variable @PORT@.
    Alternatively, port @8023@ is used if this variable is not set.

* @jsAddr :: Maybe ByteString@

    Bind address.
    @Nothing@ means that the bind address is read from the environment variable @ADDR@.
    Alternatively, address @127.0.0.1@ is used if this variable is not set.

* @jsCustomHTML :: Maybe FilePath@

    Custom HTML file to replace the default one.

* @jsStatic :: Maybe FilePath@

    Directory that is served under @/static@.

* @jsLog :: ByteString -> IO ()@

    Function to print a single log message.

* @jsWindowReloadOnDisconnect :: Bool@

    Reload the browser window if the connection to the server was dropped accidentally,
    for instance because the computer was put to sleep and awoken again.

* @jsCallBufferMode :: CallBufferMode@

    The initial 'CallBufferMode' to use for 'runFunction'.
    It can be changed at any time with 'setCallBufferMode'.

* @jsUseSSLBind :: Maybe ConfigSSL@

    Whether to serve on a HTTPS connection instead of HTTP for improved security.

    * 'Just' with a 'ConfigSSL' to serve on HTTPS.
        Note that this will fail silently unless the @snap-server@ package
        has been compiled with the @openssl@ flag enabled.

    * 'Nothing' to serve on HTTP.

(For reasons of forward compatibility, the constructor is not exported.)

-}
data Config = Config
    { Config -> Maybe Int
jsPort       :: Maybe Int
    , Config -> Maybe ByteString
jsAddr       :: Maybe ByteString
    , Config -> Maybe [Char]
jsCustomHTML :: Maybe FilePath
    , Config -> Maybe [Char]
jsStatic     :: Maybe FilePath
    , Config -> ByteString -> IO ()
jsLog        :: ByteString -> IO ()
    , Config -> Bool
jsWindowReloadOnDisconnect :: Bool
    , Config -> CallBufferMode
jsCallBufferMode :: CallBufferMode
    , Config -> Maybe ConfigSSL
jsUseSSL      :: Maybe ConfigSSL
    }

{- | Static configuration for the SSL version of the "Foreign.JavaScript" server.

This is a record type which has the following fields:

* @jsSSLBind :: ByteString@

    Bind address.

* @jsSSLCert :: FilePath@

    Path to SSL certificate file. Example: @cert.pem@.

* @jsSSLChainCert :: Bool@

    If it is SSL chain certificate file.

* @jsSSLKey :: FilePath@

    Path to SSL key file. Example: @key.pem@.

* @jsSSLPort :: ByteString@

    Port number. Example: 443.

-}

data ConfigSSL = ConfigSSL
    { ConfigSSL -> ByteString
jsSSLBind      :: ByteString
    , ConfigSSL -> [Char]
jsSSLCert      :: FilePath
    , ConfigSSL -> Bool
jsSSLChainCert :: Bool
    , ConfigSSL -> [Char]
jsSSLKey       :: FilePath
    , ConfigSSL -> Int
jsSSLPort      :: Int
    }

defaultPort :: Int
defaultPort :: Int
defaultPort = Int
8023

defaultAddr :: ByteString
defaultAddr :: ByteString
defaultAddr = ByteString
"127.0.0.1"

-- | Default configuration.
--
-- Port from environment variable or @8023@, listening on @localhost@,
-- no custom HTML, no static directory,
-- logging to stderr,
-- do reload on disconnect,
-- __buffer FFI calls__.
defaultConfig :: Config
defaultConfig :: Config
defaultConfig = Config
    { jsPort :: Maybe Int
jsPort       = forall a. Maybe a
Nothing
    , jsAddr :: Maybe ByteString
jsAddr       = forall a. Maybe a
Nothing
    , jsWindowReloadOnDisconnect :: Bool
jsWindowReloadOnDisconnect = Bool
True
    , jsCustomHTML :: Maybe [Char]
jsCustomHTML = forall a. Maybe a
Nothing
    , jsStatic :: Maybe [Char]
jsStatic     = forall a. Maybe a
Nothing
    , jsLog :: ByteString -> IO ()
jsLog        = Handle -> ByteString -> IO ()
BS.hPutStrLn Handle
stderr
    , jsCallBufferMode :: CallBufferMode
jsCallBufferMode = CallBufferMode
FlushOften
    , jsUseSSL :: Maybe ConfigSSL
jsUseSSL     = forall a. Maybe a
Nothing
    }

{-----------------------------------------------------------------------------
    Server Configuration -- Dynamic
------------------------------------------------------------------------------}
-- | URI type.
--
-- FIXME: Use the correct type from "Network.URI"
type URI = String

-- | MIME type.
type MimeType = String

-- | Representation of a "Foreign.JavaScript" server.
--
-- Can be used for dynamic configuration, e.g. serving additional files.
data Server = Server
    { Server -> MVar Filepaths
sFiles :: MVar Filepaths
    , Server -> MVar Filepaths
sDirs  :: MVar Filepaths
    , Server -> ByteString -> IO ()
sLog   :: ByteString -> IO () -- function for logging
    }
type Filepaths = (Integer, Map ByteString (FilePath, MimeType))
newFilepaths :: (Integer, Map k a)
newFilepaths = (Integer
0, forall k a. Map k a
Map.empty)

{-----------------------------------------------------------------------------
    Communication channel
------------------------------------------------------------------------------}
-- | Bidirectional communication channel.
data Comm = Comm
    { Comm -> TQueue Value
commIn    :: TQueue JSON.Value    -- ^ Read from channel.
    , Comm -> TQueue Value
commOut   :: TQueue JSON.Value    -- ^ Write into channel.
    , Comm -> TVar Bool
commOpen  :: TVar   Bool          -- ^ Indicate whether the channel is still open.
    , Comm -> IO ()
commClose :: IO ()                -- ^ Close the channel.
    }

writeComm :: Comm -> JSON.Value -> STM ()
writeComm :: Comm -> Value -> STM ()
writeComm Comm
c = forall a. TQueue a -> a -> STM ()
STM.writeTQueue (Comm -> TQueue Value
commOut Comm
c)

readComm :: Comm -> STM JSON.Value
readComm :: Comm -> STM Value
readComm Comm
c = forall a. TQueue a -> STM a
STM.readTQueue (Comm -> TQueue Value
commIn Comm
c)

{-----------------------------------------------------------------------------
    Communication protocol
------------------------------------------------------------------------------}
-- | Messages received from the JavaScript client.
data ClientMsg
    = Event Coupon JSON.Value
    | Result JSON.Value
    | Exception String
    | Quit
    deriving (ClientMsg -> ClientMsg -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ClientMsg -> ClientMsg -> Bool
$c/= :: ClientMsg -> ClientMsg -> Bool
== :: ClientMsg -> ClientMsg -> Bool
$c== :: ClientMsg -> ClientMsg -> Bool
Eq, Int -> ClientMsg -> ShowS
[ClientMsg] -> ShowS
ClientMsg -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [ClientMsg] -> ShowS
$cshowList :: [ClientMsg] -> ShowS
show :: ClientMsg -> [Char]
$cshow :: ClientMsg -> [Char]
showsPrec :: Int -> ClientMsg -> ShowS
$cshowsPrec :: Int -> ClientMsg -> ShowS
Show)

instance FromJSON ClientMsg where
    parseJSON :: Value -> Parser ClientMsg
parseJSON (Object Object
msg) = do
        Coupon
tag <- Object
msg forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"tag"
        case (Coupon
tag :: Text) of
            Coupon
"Event"     -> Coupon -> Value -> ClientMsg
Event     forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Object
msg forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name") forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Object
msg forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"arguments")
            Coupon
"Result"    -> Value -> ClientMsg
Result    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Object
msg forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"contents")
            Coupon
"Exception" -> [Char] -> ClientMsg
Exception forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Object
msg forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"contents")
            Coupon
"Quit"      -> forall (m :: * -> *) a. Monad m => a -> m a
return ClientMsg
Quit

readClient :: Comm -> STM ClientMsg
readClient :: Comm -> STM ClientMsg
readClient Comm
c = do
    Value
msg <- Comm -> STM Value
readComm Comm
c
    case forall a. FromJSON a => Value -> Result a
JSON.fromJSON Value
msg of
        Error   [Char]
s -> forall a. HasCallStack => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ [Char]
"Foreign.JavaScript: Error parsing client message " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show [Char]
s
        Success ClientMsg
x -> forall (m :: * -> *) a. Monad m => a -> m a
return ClientMsg
x

-- | Messages sent by the Haskell server.
data ServerMsg
    = RunEval  String
    | CallEval String
    | Debug    String
    | Timestamp
    deriving (ServerMsg -> ServerMsg -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ServerMsg -> ServerMsg -> Bool
$c/= :: ServerMsg -> ServerMsg -> Bool
== :: ServerMsg -> ServerMsg -> Bool
$c== :: ServerMsg -> ServerMsg -> Bool
Eq,Int -> ServerMsg -> ShowS
[ServerMsg] -> ShowS
ServerMsg -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [ServerMsg] -> ShowS
$cshowList :: [ServerMsg] -> ShowS
show :: ServerMsg -> [Char]
$cshow :: ServerMsg -> [Char]
showsPrec :: Int -> ServerMsg -> ShowS
$cshowsPrec :: Int -> ServerMsg -> ShowS
Show)

instance NFData ServerMsg where
    rnf :: ServerMsg -> ()
rnf (RunEval   [Char]
x) = forall a. NFData a => a -> ()
rnf [Char]
x
    rnf (CallEval  [Char]
x) = forall a. NFData a => a -> ()
rnf [Char]
x
    rnf (Debug     [Char]
x) = forall a. NFData a => a -> ()
rnf [Char]
x
    rnf (ServerMsg
Timestamp  ) = ()

instance ToJSON ServerMsg where
    toJSON :: ServerMsg -> Value
toJSON (Debug    [Char]
x) = [Pair] -> Value
object [ Key
"tag" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Char] -> Coupon
t [Char]
"Debug"   , Key
"contents" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall a. ToJSON a => a -> Value
toJSON [Char]
x]
    toJSON (ServerMsg
Timestamp ) = [Pair] -> Value
object [ Key
"tag" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Char] -> Coupon
t [Char]
"Timestamp" ]
    toJSON (RunEval  [Char]
x) = [Pair] -> Value
object [ Key
"tag" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Char] -> Coupon
t [Char]
"RunEval" , Key
"contents" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall a. ToJSON a => a -> Value
toJSON [Char]
x]
    toJSON (CallEval [Char]
x) = [Pair] -> Value
object [ Key
"tag" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Char] -> Coupon
t [Char]
"CallEval", Key
"contents" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall a. ToJSON a => a -> Value
toJSON [Char]
x]

t :: [Char] -> Coupon
t [Char]
s = forall a. IsString a => [Char] -> a
fromString [Char]
s :: Text

writeServer :: Comm -> ServerMsg -> STM ()
writeServer :: Comm -> ServerMsg -> STM ()
writeServer Comm
c = Comm -> Value -> STM ()
writeComm Comm
c forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ToJSON a => a -> Value
toJSON forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. NFData a => a -> a
force

{- Note [ServerMsg strictness]

The type `ServerMsg` may contain components that evalute to _|_, and
an exception will be thrown when we try to send one of those to the browser.

However, we have to make sure that the exception is thrown
in the thread that constructed the message, not in the thread that
handles the actual communication with the client.

That's why we have to use the function
`Control.DeepSeq.deepseq` to make sure that any exception
is thrown before handing the message over to another thread.

Since exceptions in pure code do not have a precise ordering relative
to exceptions in IO code, evaluating the pure value
also helps with ensuring that the exception is raised before
any subsequent IO exception; this makes it easier to pinpoint
the root cause for library users.

-}


data JavaScriptException = JavaScriptException String deriving Typeable

instance E.Exception JavaScriptException

instance Show JavaScriptException where
    showsPrec :: Int -> JavaScriptException -> ShowS
showsPrec Int
_ (JavaScriptException [Char]
err) = [Char] -> ShowS
showString forall a b. (a -> b) -> a -> b
$ [Char]
"JavaScript error: " forall a. [a] -> [a] -> [a]
++ [Char]
err

{-----------------------------------------------------------------------------
    Window & Event Loop
------------------------------------------------------------------------------}
-- | An event sent from the browser window to the server.
type Event        = (Coupon, JSON.Value)

-- | An event handler that can be passed to the JavaScript client.
type HsEvent      = RemotePtr (JSON.Value -> IO ())

quit :: Event
quit :: Event
quit = (Coupon
"quit", Value
JSON.Null)

-- | Specification of how JavaScript functions should be called.
data CallBufferMode
    = NoBuffering
    -- ^ When 'runFunction' is used to call a JavaScript function,
    -- immediately send a message to the browser window to execute
    -- said function.
    | BufferRun
    -- ^ When 'runFunction' is used to call a JavaScript function,
    -- hold back any message to the server.
    -- All JavaScript functions that are held back in this way
    -- are combined into a single message,
    -- which is finally sent whenever 'callFunction' or
    -- 'flushCallBuffer' are used, or an exported Haskell function is called.
    | FlushOften
    -- ^ The same as 'BufferRun', but this mode indicates
    -- client libraries and programs are encouraged to flush the buffer more often
    -- to simplify usage. Users may choose 'BufferRun' instead if they want more control
    -- over flushing the buffer.
    | FlushPeriodically
    -- ^ The same as 'BufferRun', except that the buffer will also be flushed
    -- every 300ms.

flushPeriod :: Int
flushPeriod = Int
300 :: Int

-- | Action that the server will run when a browser window connects.
type EventLoop   = Server -> RequestInfo -> Comm -> IO ()
type RequestInfo = [Cookie]

-- | Representation of a browser window.
data Window = Window
    { Window -> Server
getServer      :: Server
    -- ^ Server that the browser window communicates with.
    , Window -> [Cookie]
getCookies     :: [Cookie]
    -- ^ Cookies that the browser window has sent to the server when connecting.

    , Window -> [Char] -> IO ()
runEval        :: String -> IO ()
    , Window -> [Char] -> IO Value
callEval       :: String -> IO JSON.Value

    , Window -> TMVar ShowS
wCallBuffer     :: TMVar (String -> String)
    , Window -> TVar CallBufferMode
wCallBufferMode :: TVar CallBufferMode

    , Window -> IO ()
timestamp      :: IO ()
    -- ^ Print a timestamp and the time difference to the previous one
    -- in the JavaScript console.
    , Window -> [Char] -> IO ()
debug          :: String -> IO ()
    -- ^ Send a debug message to the JavaScript console.
    , Window -> IO () -> IO ()
onDisconnect   :: IO () -> IO ()
    -- ^ Register an action to be performed when the client disconnects.
    , Window -> RemotePtr ()
wRoot          :: RemotePtr ()
    , Window -> Vendor (Value -> IO ())
wEventHandlers :: Vendor (JSON.Value -> IO ())
    , Window -> Vendor JSPtr
wJSObjects     :: Vendor JSPtr
    }

newPartialWindow :: IO Window
newPartialWindow :: IO Window
newPartialWindow = do
    RemotePtr ()
ptr <- forall a. Coupon -> a -> Vendor a -> IO (RemotePtr a)
newRemotePtr Coupon
"" () forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a. IO (Vendor a)
newVendor
    TMVar ShowS
b1  <- forall a. a -> IO (TMVar a)
newTMVarIO forall a. a -> a
id
    TVar CallBufferMode
b2  <- forall a. a -> IO (TVar a)
newTVarIO CallBufferMode
NoBuffering
    let nop :: b -> IO ()
nop = forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return ()
    Server
-> [Cookie]
-> ([Char] -> IO ())
-> ([Char] -> IO Value)
-> TMVar ShowS
-> TVar CallBufferMode
-> IO ()
-> ([Char] -> IO ())
-> (IO () -> IO ())
-> RemotePtr ()
-> Vendor (Value -> IO ())
-> Vendor JSPtr
-> Window
Window forall a. HasCallStack => a
undefined [] forall {b}. b -> IO ()
nop forall a. HasCallStack => a
undefined TMVar ShowS
b1 TVar CallBufferMode
b2 (forall (m :: * -> *) a. Monad m => a -> m a
return ()) forall {b}. b -> IO ()
nop forall {b}. b -> IO ()
nop RemotePtr ()
ptr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. IO (Vendor a)
newVendor forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. IO (Vendor a)
newVendor

-- | For the purpose of controlling garbage collection,
-- every 'Window' as an associated 'RemotePtr' that is alive
-- as long as the external JavaScript connection is alive.
root :: Window -> RemotePtr ()
root :: Window -> RemotePtr ()
root = Window -> RemotePtr ()
wRoot

{-----------------------------------------------------------------------------
    Marshalling
------------------------------------------------------------------------------}
newtype JSPtr = JSPtr { JSPtr -> Coupon
unsJSPtr :: Coupon }

-- | A mutable JavaScript object.
type JSObject = RemotePtr JSPtr

-- | A mutable JavaScript object that has just been created.
-- This a dummy type used for additional type safety.
data NewJSObject = NewJSObject