{-# LANGUAGE RecordWildCards #-}

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

import qualified Data.ByteString as BS
import Network.Control
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 -> StreamId
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 TxFlow
streamFlowTx :: TVar TxFlow -- counter, maxDax
    , Stream -> IORef RxFlow
streamFlowRx :: IORef RxFlow -- 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 -> StreamId
streamId Stream
s

newStream :: Connection -> Int -> Int -> StreamId -> IO Stream
newStream :: Connection -> StreamId -> StreamId -> StreamId -> IO Stream
newStream Connection
conn StreamId
sid StreamId
txLim StreamId
rxLim =
    StreamId
-> Connection
-> TVar TxFlow
-> IORef RxFlow
-> IORef StreamState
-> IORef StreamState
-> RecvStreamQ
-> IORef (Skew RxStreamData)
-> MVar ()
-> Stream
Stream StreamId
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 (StreamId -> TxFlow
newTxFlow StreamId
txLim)
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. a -> IO (IORef a)
newIORef (StreamId -> RxFlow
newRxFlow StreamId
rxLim)
        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 -> StreamId
rxstrmOff :: Offset
    , RxStreamData -> StreamId
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, StreamId -> RxStreamData -> ShowS
[RxStreamData] -> ShowS
RxStreamData -> String
forall a.
(StreamId -> a -> ShowS)
-> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RxStreamData] -> ShowS
$cshowList :: [RxStreamData] -> ShowS
show :: RxStreamData -> String
$cshow :: RxStreamData -> String
showsPrec :: StreamId -> RxStreamData -> ShowS
$cshowsPrec :: StreamId -> RxStreamData -> ShowS
Show)

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

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

data StreamState = StreamState
    { StreamState -> StreamId
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, StreamId -> StreamState -> ShowS
[StreamState] -> ShowS
StreamState -> String
forall a.
(StreamId -> a -> ShowS)
-> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StreamState] -> ShowS
$cshowList :: [StreamState] -> ShowS
show :: StreamState -> String
$cshow :: StreamState -> String
showsPrec :: StreamId -> StreamState -> ShowS
$cshowsPrec :: StreamId -> StreamState -> ShowS
Show)

emptyStreamState :: StreamState
emptyStreamState :: StreamState
emptyStreamState = StreamId -> Bool -> StreamState
StreamState StreamId
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