module Types where

import Control.Concurrent
import Network.Socket
import qualified Data.Map.Strict as Map
import Control.Monad.State
import Parser
import qualified Data.ByteString as BS
import System.Log.Logger
import System.Random
import Data.Time.Clock

-- read dictionary, key = pc, value = mvar bytestring

type Dict = Map.Map Int (MVar BS.ByteString)
-- pid, (socket send to peer (nothing if self), read value from mvar in dict)

data Party = Party {Party -> Integer
pid :: Integer, Party -> String
host :: String, Party -> Integer
port :: Integer, Party -> Chan ByteString
outChan :: Chan BS.ByteString, Party -> Maybe Socket
sock :: Maybe Socket, Party -> MVar Dict
dict :: MVar Dict, Party -> MVar Int
nbytesSent :: MVar Int}

data Barrier = Barrier { Barrier -> MVar Int
count :: MVar Int, Barrier -> MVar ()
signal :: MVar () }

-- state transformer environment

data Env = Env {
    Env -> [Party]
parties :: [Party],
    Env -> Int
pc :: Int,
    Env -> Options
options :: Options,
    Env -> Barrier
forkIOBarrier :: Barrier,
    Env -> StdGen
gen :: StdGen,
    Env -> UTCTime
startTime :: UTCTime
}

type SIO a = StateT Env IO a

runSIO :: SIO a -> Env -> IO a
runSIO :: forall a. SIO a -> Env -> IO a
runSIO = StateT Env IO a -> Env -> IO a
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT

logging :: Priority -> String -> IO ()
logging :: Priority -> String -> IO ()
logging Priority
prio String
str = String -> Priority -> String -> IO ()
logM String
rootLoggerName Priority
prio String
str