-- | Streams using `T.Text` by encoding in Utf 8.
module Network.Text.Lazy.Stream
    (
    Result(..),
    Stream,

    invalidate,
    withStream,
    write,

    receive,
    receiveE
    )
where

import Control.Monad.IO.Class
import qualified Data.Enumerator as E
import qualified Data.Enumerator.List as EL
import qualified Data.Text.Lazy as T
import qualified Data.Text.Lazy.Encoding as T
import qualified Network.ByteString.Lazy.Stream as S
import Network.ByteString.Lazy.Stream (Result(..), Stream, invalidate, withStream)
import System.IO

-- | Writes partial or full data over a `Stream`, placing it in the queue of
-- data to be sent. Encodes the `T.Text` with Utf8
-- into a strict `Data.ByteString.Lazy.ByteString`.
write :: Stream -> T.Text -> IO ()
write s t = S.write s (T.encodeUtf8 t)

-- | Receives the entire data should the transfer over the stream be successful.
-- Returns `Nothing` on failure.
receive h = do bytesM <- S.receive h
               case bytesM of
                Nothing -> return Nothing
                Just bytes -> return . Just $ T.decodeUtf8 bytes

-- | Run an iteratee through an enumerator which supplies each block of Text.
receiveE :: MonadIO m => Handle -> E.Iteratee T.Text m b -> m (Maybe b)
receiveE h iter = let iter' = EL.map T.decodeUtf8 E.=$ iter
                  in S.receiveE h iter'