{-# LANGUAGE RecordWildCards #-}

module Network.QUIC.Stream.Types (
    Stream(..)
  , newStream
  , TxStreamData(..)
  , Flow(..)
  , defaultFlow
  , flowWindow
  , StreamState(..)
  , RecvStreamQ(..)
  , RxStreamData(..)
  , Length
  , syncFinTx
  , waitFinTx
  ) where

import qualified Data.ByteString as BS
import UnliftIO.Concurrent
import UnliftIO.STM

import {-# Source #-} Network.QUIC.Connection.Types
import Network.QUIC.Imports
import Network.QUIC.Stream.Frag
import Network.QUIC.Stream.Skew
import qualified Network.QUIC.Stream.Skew as Skew
import Network.QUIC.Types

----------------------------------------------------------------

-- | An abstract data type for streams.
data Stream = Stream {
    Stream -> Int
streamId         :: StreamId -- ^ Getting stream identifier.
  , Stream -> Connection
streamConnection :: Connection
  -- "counter" is equivalent to "offset".
  -- It is duplicated but used for API level flow control.
  , Stream -> TVar Flow
streamFlowTx     :: TVar  Flow        -- counter, maxDax
  , Stream -> IORef Flow
streamFlowRx     :: IORef Flow        -- counter, maxDax
  , Stream -> IORef StreamState
streamStateTx    :: IORef StreamState -- offset, fin
  , Stream -> IORef StreamState
streamStateRx    :: IORef StreamState -- offset, fin
  , Stream -> RecvStreamQ
streamRecvQ      :: RecvStreamQ       -- input bytestring
  , Stream -> IORef (Skew RxStreamData)
streamReass      :: IORef (Skew RxStreamData) -- input stream fragments to streamQ
  , Stream -> MVar ()
streamSyncFinTx  :: MVar ()
  }

instance Show Stream where
    show :: Stream -> String
show Stream
s = forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ Stream -> Int
streamId Stream
s

newStream :: Connection -> StreamId -> IO Stream
newStream :: Connection -> Int -> IO Stream
newStream Connection
conn Int
sid = Int
-> Connection
-> TVar Flow
-> IORef Flow
-> IORef StreamState
-> IORef StreamState
-> RecvStreamQ
-> IORef (Skew RxStreamData)
-> MVar ()
-> Stream
Stream Int
sid Connection
conn forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. MonadIO m => a -> m (TVar a)
newTVarIO Flow
defaultFlow
                                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. a -> IO (IORef a)
newIORef  Flow
defaultFlow
                                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. a -> IO (IORef a)
newIORef  StreamState
emptyStreamState
                                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. a -> IO (IORef a)
newIORef  StreamState
emptyStreamState
                                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IO RecvStreamQ
newRecvStreamQ
                                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. a -> IO (IORef a)
newIORef forall a. Skew a
Skew.empty
                                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. MonadIO m => m (MVar a)
newEmptyMVar

syncFinTx :: Stream -> IO ()
syncFinTx :: Stream -> IO ()
syncFinTx Stream
s = forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. MonadIO m => MVar a -> a -> m Bool
tryPutMVar (Stream -> MVar ()
streamSyncFinTx Stream
s) ()

waitFinTx :: Stream -> IO ()
waitFinTx :: Stream -> IO ()
waitFinTx Stream
s = forall (m :: * -> *) a. MonadIO m => MVar a -> m a
takeMVar forall a b. (a -> b) -> a -> b
$ Stream -> MVar ()
streamSyncFinTx Stream
s

----------------------------------------------------------------

type Length = Int

data TxStreamData = TxStreamData Stream [StreamData] Length Fin

data RxStreamData = RxStreamData {
    RxStreamData -> StreamData
rxstrmData :: StreamData
  , RxStreamData -> Int
rxstrmOff  :: Offset
  , RxStreamData -> Int
rxstrmLen  :: Length
  , RxStreamData -> Bool
rxstrmFin  :: Fin
  } deriving (RxStreamData -> RxStreamData -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RxStreamData -> RxStreamData -> Bool
$c/= :: RxStreamData -> RxStreamData -> Bool
== :: RxStreamData -> RxStreamData -> Bool
$c== :: RxStreamData -> RxStreamData -> Bool
Eq, Int -> RxStreamData -> ShowS
[RxStreamData] -> ShowS
RxStreamData -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RxStreamData] -> ShowS
$cshowList :: [RxStreamData] -> ShowS
show :: RxStreamData -> String
$cshow :: RxStreamData -> String
showsPrec :: Int -> RxStreamData -> ShowS
$cshowsPrec :: Int -> RxStreamData -> ShowS
Show)

instance Frag RxStreamData where
    currOff :: RxStreamData -> Int
currOff RxStreamData
r = RxStreamData -> Int
rxstrmOff RxStreamData
r
    nextOff :: RxStreamData -> Int
nextOff RxStreamData
r = RxStreamData -> Int
rxstrmOff RxStreamData
r forall a. Num a => a -> a -> a
+ RxStreamData -> Int
rxstrmLen RxStreamData
r
    shrink :: Int -> RxStreamData -> RxStreamData
shrink Int
off'  (RxStreamData StreamData
bs Int
off Int
len Bool
fin) =
        let n :: Int
n = Int
off' forall a. Num a => a -> a -> a
- Int
off
            bs' :: StreamData
bs'  = Int -> StreamData -> StreamData
BS.drop Int
n StreamData
bs
            len' :: Int
len' = Int
len forall a. Num a => a -> a -> a
- Int
n
        in StreamData -> Int -> Int -> Bool -> RxStreamData
RxStreamData StreamData
bs' Int
off' Int
len' Bool
fin

----------------------------------------------------------------

data Flow = Flow {
    Flow -> Int
flowData :: Int
  , Flow -> Int
flowMaxData :: Int
  } deriving (Flow -> Flow -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Flow -> Flow -> Bool
$c/= :: Flow -> Flow -> Bool
== :: Flow -> Flow -> Bool
$c== :: Flow -> Flow -> Bool
Eq, Int -> Flow -> ShowS
[Flow] -> ShowS
Flow -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Flow] -> ShowS
$cshowList :: [Flow] -> ShowS
show :: Flow -> String
$cshow :: Flow -> String
showsPrec :: Int -> Flow -> ShowS
$cshowsPrec :: Int -> Flow -> ShowS
Show)

defaultFlow :: Flow
defaultFlow :: Flow
defaultFlow = Int -> Int -> Flow
Flow Int
0 Int
0

flowWindow :: Flow -> Int
flowWindow :: Flow -> Int
flowWindow Flow{Int
flowMaxData :: Int
flowData :: Int
flowMaxData :: Flow -> Int
flowData :: Flow -> Int
..} = Int
flowMaxData forall a. Num a => a -> a -> a
- Int
flowData

----------------------------------------------------------------

data StreamState = StreamState {
    StreamState -> Int
streamOffset :: Offset
  , StreamState -> Bool
streamFin :: Fin
  } deriving (StreamState -> StreamState -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StreamState -> StreamState -> Bool
$c/= :: StreamState -> StreamState -> Bool
== :: StreamState -> StreamState -> Bool
$c== :: StreamState -> StreamState -> Bool
Eq, Int -> StreamState -> ShowS
[StreamState] -> ShowS
StreamState -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StreamState] -> ShowS
$cshowList :: [StreamState] -> ShowS
show :: StreamState -> String
$cshow :: StreamState -> String
showsPrec :: Int -> StreamState -> ShowS
$cshowsPrec :: Int -> StreamState -> ShowS
Show)

emptyStreamState :: StreamState
emptyStreamState :: StreamState
emptyStreamState = Int -> Bool -> StreamState
StreamState Int
0 Bool
False

----------------------------------------------------------------

data RecvStreamQ = RecvStreamQ {
    RecvStreamQ -> TQueue StreamData
recvStreamQ :: TQueue ByteString
  , RecvStreamQ -> IORef (Maybe StreamData)
pendingData :: IORef (Maybe ByteString)
  , RecvStreamQ -> IORef Bool
endOfStream :: IORef Bool
  }

newRecvStreamQ :: IO RecvStreamQ
newRecvStreamQ :: IO RecvStreamQ
newRecvStreamQ = TQueue StreamData
-> IORef (Maybe StreamData) -> IORef Bool -> RecvStreamQ
RecvStreamQ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. MonadIO m => m (TQueue a)
newTQueueIO forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. a -> IO (IORef a)
newIORef forall a. Maybe a
Nothing forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. a -> IO (IORef a)
newIORef Bool
False