    {-# LANGUAGE BangPatterns, CPP, RecordWildCards #-}
    -- |
    -- Module      : Data.Text.IO.Internal
    -- Copyright   : (c) 2009, 2010 Bryan O'Sullivan,
    --               (c) 2009 Simon Marlow
    -- License     : BSD-style
    -- Maintainer  : bos@serpentine.com
    -- Stability   : experimental
    -- Portability : GHC
    --
    -- Low-level support for text I\/O.

    module Data.Text.IO.Internal
        (
    #if __GLASGOW_HASKELL__ >= 612
          hGetLineWith
        , readChunk
    #endif
        ) where

    #if __GLASGOW_HASKELL__ >= 612
    import qualified Control.Exception as E
    import Data.IORef (readIORef, writeIORef)
    import Data.Text (Text)
    import Data.Text.Fusion (unstream)
    import Data.Text.Fusion.Internal (Step(..), Stream(..))
    import Data.Text.Fusion.Size (exactSize, maxSize)
    import Data.Text.Unsafe (inlinePerformIO)
    import Foreign.Storable (peekElemOff)
    import GHC.IO.Buffer (Buffer(..), CharBuffer, RawCharBuffer, bufferAdjustL,
                          bufferElems, charSize, isEmptyBuffer, readCharBuf,
                          withRawBuffer, writeCharBuf)
    import GHC.IO.Handle.Internals (ioe_EOF, readTextDevice, wantReadableHandle_)
    import GHC.IO.Handle.Types (Handle__(..), Newline(..))
    import System.IO (Handle)
    import System.IO.Error (isEOFError)
    import qualified Data.Text as T

    -- | Read a single line of input from a handle, constructing a list of
    -- decoded chunks as we go.  When we're done, transform them into the
    -- destination type.
    hGetLineWith :: ([Text] -> t) -> Handle -> IO t
    hGetLineWith f h = wantReadableHandle_ "hGetLine" h go
      where
        go hh@Handle__{..} = readIORef haCharBuffer >>= fmap f . hGetLineLoop hh []

    hGetLineLoop :: Handle__ -> [Text] -> CharBuffer -> IO [Text]
    hGetLineLoop hh@Handle__{..} = go where
     go ts buf@Buffer{ bufL=r0, bufR=w, bufRaw=raw0 } = do
      let findEOL raw r | r == w    = return (False, w)
                        | otherwise = do
            (c,r') <- readCharBuf raw r
            if c == '\n'
              then return (True, r)
              else findEOL raw r'
      (eol, off) <- findEOL raw0 r0
      (t,r') <- if haInputNL == CRLF
                then unpack_nl raw0 r0 off
                else do t <- unpack raw0 r0 off
                        return (t,off)
      if eol
        then do writeIORef haCharBuffer (bufferAdjustL (off+1) buf)
                return $ reverse (t:ts)
        else do
          let buf1 = bufferAdjustL r' buf
          maybe_buf <- maybeFillReadBuffer hh buf1
          case maybe_buf of
             -- Nothing indicates we caught an EOF, and we may have a
             -- partial line to return.
             Nothing -> do
                  -- we reached EOF.  There might be a lone \r left
                  -- in the buffer, so check for that and
                  -- append it to the line if necessary.
                  let pre | isEmptyBuffer buf1 = T.empty
                          | otherwise          = T.singleton '\r'
                  writeIORef haCharBuffer buf1{ bufL=0, bufR=0 }
                  let str = reverse . filter (not . T.null) $ pre:t:ts
                  if null str
                    then ioe_EOF
                    else return str
             Just new_buf -> go (t:ts) new_buf

    -- This function is lifted almost verbatim from GHC.IO.Handle.Text.
    maybeFillReadBuffer :: Handle__ -> CharBuffer -> IO (Maybe CharBuffer)
    maybeFillReadBuffer handle_ buf
      = E.catch (Just `fmap` getSomeCharacters handle_ buf) $ \e ->
          if isEOFError e
          then return Nothing
          else ioError e

    unpack :: RawCharBuffer -> Int -> Int -> IO Text
    unpack !buf !r !w
     | charSize /= 4 = sizeError "unpack"
     | r >= w        = return T.empty
     | otherwise     = withRawBuffer buf go
     where
      go pbuf = return $! unstream (Stream next r (exactSize (w-r)))
       where
        next !i | i >= w    = Done
                | otherwise = Yield (ix i) (i+1)
        ix i = inlinePerformIO $ peekElemOff pbuf i

    unpack_nl :: RawCharBuffer -> Int -> Int -> IO (Text, Int)
    unpack_nl !buf !r !w
     | charSize /= 4 = sizeError "unpack_nl"
     | r >= w        = return (T.empty, 0)
     | otherwise     = withRawBuffer buf $ go
     where
      go pbuf = do
        let !t = unstream (Stream next r (maxSize (w-r)))
            w' = w - 1
        return $ if ix w' == '\r'
                 then (t,w')
                 else (t,w)
       where
        next !i | i >= w = Done
                | c == '\r' = let i' = i + 1
                              in if i' < w
                                 then if ix i' == '\n'
                                      then Yield '\n' (i+2)
                                      else Yield '\n' i'
                                 else Done
                | otherwise = Yield c (i+1)
                where c = ix i
        ix i = inlinePerformIO $ peekElemOff pbuf i

    -- This function is completely lifted from GHC.IO.Handle.Text.
    getSomeCharacters :: Handle__ -> CharBuffer -> IO CharBuffer
    getSomeCharacters handle_@Handle__{..} buf@Buffer{..} =
      case bufferElems buf of
        -- buffer empty: read some more
        0 -> {-# SCC "readTextDevice" #-} readTextDevice handle_ buf

        -- if the buffer has a single '\r' in it and we're doing newline
        -- translation: read some more
        1 | haInputNL == CRLF -> do
          (c,_) <- readCharBuf bufRaw bufL
          if c == '\r'
             then do -- shuffle the '\r' to the beginning.  This is only safe
                     -- if we're about to call readTextDevice, otherwise it
                     -- would mess up flushCharBuffer.
                     -- See [note Buffer Flushing], GHC.IO.Handle.Types
                     _ <- writeCharBuf bufRaw 0 '\r'
                     let buf' = buf{ bufL=0, bufR=1 }
                     readTextDevice handle_ buf'
             else do
                     return buf

        -- buffer has some chars in it already: just return it
        _otherwise -> {-# SCC "otherwise" #-} return buf

    -- | Read a single chunk of strict text from a buffer. Used by both
    -- the strict and lazy implementations of hGetContents.
    readChunk :: Handle__ -> CharBuffer -> IO Text
    readChunk hh@Handle__{..} buf = do
      buf'@Buffer{..} <- getSomeCharacters hh buf
      (t,r) <- if haInputNL == CRLF
               then unpack_nl bufRaw bufL bufR
               else do t <- unpack bufRaw bufL bufR
                       return (t,bufR)
      writeIORef haCharBuffer (bufferAdjustL r buf')
      return t

    sizeError :: String -> a
    sizeError loc = error $ "Data.Text.IO." ++ loc ++ ": bad internal buffer size"
    #endif