{-# LANGUAGE BangPatterns #-}

module System.IO.Streams.Concurrent.Unagi.Bounded
       ( -- * Channel conversions
         inputToChan
       , chanToInput
       , chanToOutput
       , makeChanPipe
       , dupStream
       , DupHandle
       ) where


------------------------------------------------------------------------------
import           Control.Applicative                   (pure, (<$>), (<*>))
import           Control.Concurrent.Chan.Unagi.Bounded (InChan, OutChan,
                                                        dupChan, newChan,
                                                        readChan, writeChan)
import           Control.Monad                         ((>=>))
import           Prelude                               hiding (read)
import           System.IO.Streams.Internal            (InputStream,
                                                        OutputStream,
                                                        makeInputStream,
                                                        makeOutputStream, read)


newtype DupHandle a = DupHandle { unDupHandle :: InChan (Maybe a) }

------------------------------------------------------------------------------
-- | Writes the contents of an input stream to a channel until the input stream
-- yields end-of-stream.
inputToChan :: InputStream a -> InChan (Maybe a) -> IO ()
inputToChan is ch = go
  where
    go = do
        mb <- read is
        writeChan ch mb
        maybe (return $! ()) (const go) mb


------------------------------------------------------------------------------
-- | Turns an 'OutChan' into an input stream.
--
chanToInput :: OutChan (Maybe a) -> IO (InputStream a)
chanToInput ch = makeInputStream $! readChan ch


------------------------------------------------------------------------------
-- | Turns an 'InChan' into an output stream.
--
chanToOutput :: InChan (Maybe a) -> IO (OutputStream a)
chanToOutput = makeOutputStream . writeChan


--------------------------------------------------------------------------------
-- | Create a new pair of streams using an underlying 'Chan'. Everything written
-- to the 'OutputStream' will appear as-is on the 'InputStream'.
--
-- Since reading from the 'InputStream' and writing to the 'OutputStream' are
-- blocking calls, be sure to do so in different threads.
makeChanPipe :: Int -> IO (InputStream a, OutputStream a, DupHandle a)
makeChanPipe size = do
    (inChan, outChan) <- newChan size
    (,,) <$> chanToInput outChan <*> chanToOutput inChan <*> pure (DupHandle inChan)


------------------------------------------------------------------------------
-- | Use a 'DupHandle' to replicate everything written on the
-- associated 'OutputStream' to the 'InputStream'.
--
dupStream :: DupHandle a -> IO (InputStream a)
dupStream = dupChan . unDupHandle >=> chanToInput