#include "inline.hs"

-- |
-- Module      : Streamly.Internal.FileSystem.Dir
-- Copyright   : (c) 2018 Composewell Technologies
--
-- License     : BSD3
-- Maintainer  : streamly@composewell.com
-- Portability : GHC

module Streamly.Internal.FileSystem.Dir
{-# DEPRECATED "Please use \"Streamly.Internal.FileSystem.DirIO\" instead." #-}
    (
    -- * Streams
      read

    -- read not just the names but also the inode attrs of the children. This
    -- abstraction makes sense because when we read the dir contents we also
    -- get the inodes, and it is cheaper to get the attrs from the inodes
    -- instead of resolving the paths and get those. This abstraction may be
    -- less portable as different platforms may have different attrs. To
    -- optimize, we can also add a filter/pattern/parser on the names of the
    -- children that we want to read. We can call that readAttrsWith? Or just
    -- have the default readAttrs do that? Usually we won't need that, so it
    -- may be better to keep that a separate API.
    -- , readAttrs

    -- recursive read requires us to read the attributes of the children to
    -- determine if something is a dirctory or not. Therefore, it may be a good
    -- idea to have a low level routine that also spits out the attributes of
    -- the files, we get that for free. We can also add a filter/pattern/parser
    -- on the names of the children that we want to read.
    --, readAttrsRecursive -- Options: acyclic, follow symlinks
    , readFiles
    , readDirs
    , readEither
    , readEitherPaths

    -- We can implement this in terms of readAttrsRecursive without losing
    -- perf.
    -- , readEitherRecursive -- Options: acyclic, follow symlinks
    -- , readAncestors -- read the parent chain using the .. entry.
    -- , readAncestorsAttrs

    -- * Unfolds
    -- | Use the more convenient stream APIs instead of unfolds where possible.
    , reader
    , fileReader
    , dirReader
    , eitherReader
    , eitherReaderPaths

      {-
    , toStreamWithBufferOf

    , readChunks
    , readChunksWithBufferOf

    , toChunksWithBufferOf
    , toChunks

    , write
    , writeWithBufferOf

    -- Byte stream write (Streams)
    , fromStream
    , fromStreamWithBufferOf

    -- -- * Array Write
    , writeArray
    , writeChunks
    , writeChunksWithBufferOf

    -- -- * Array stream Write
    , fromChunks
    , fromChunksWithBufferOf
    -}
    -- * Deprecated
    , toStream
    , toEither
    , toFiles
    , toDirs
    )
where

import Control.Monad.Catch (MonadCatch)
import Control.Monad.IO.Class (MonadIO(..))
import Data.Bifunctor (bimap)
import Streamly.Data.Stream (Stream)
import Streamly.Internal.Data.Unfold.Type (Unfold(..))
import System.FilePath ((</>))
import qualified Streamly.Data.Stream as S

import Streamly.Internal.FileSystem.Path (Path)

import qualified Streamly.Internal.FileSystem.Path as Path
import qualified Streamly.Internal.FileSystem.DirIO as DirIO
import qualified Streamly.Internal.Data.Unfold as Unfold

import Prelude hiding (read)

--------------------------------------------------------------------------------
-- Helpers
--------------------------------------------------------------------------------

{-# INLINE ePathMap #-}
ePathMap :: Either Path Path -> Either FilePath FilePath
ePathMap :: Either Path Path -> Either FilePath FilePath
ePathMap (Left Path
a) = FilePath -> Either FilePath FilePath
forall a b. a -> Either a b
Left (Path -> FilePath
Path.toString Path
a)
ePathMap (Right Path
a) = FilePath -> Either FilePath FilePath
forall a b. b -> Either a b
Right (Path -> FilePath
Path.toString Path
a)

{-# INLINE pMapUnfold #-}
pMapUnfold :: MonadCatch m => Unfold m Path Path -> Unfold m FilePath FilePath
pMapUnfold :: forall (m :: * -> *).
MonadCatch m =>
Unfold m Path Path -> Unfold m FilePath FilePath
pMapUnfold = (Path -> FilePath)
-> Unfold m FilePath Path -> Unfold m FilePath FilePath
forall a b. (a -> b) -> Unfold m FilePath a -> Unfold m FilePath b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path -> FilePath
Path.toString (Unfold m FilePath Path -> Unfold m FilePath FilePath)
-> (Unfold m Path Path -> Unfold m FilePath Path)
-> Unfold m Path Path
-> Unfold m FilePath FilePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (FilePath -> m Path)
-> Unfold m Path Path -> Unfold m FilePath Path
forall (m :: * -> *) a c b.
Monad m =>
(a -> m c) -> Unfold m c b -> Unfold m a b
Unfold.lmapM FilePath -> m Path
forall (m :: * -> *). MonadThrow m => FilePath -> m Path
Path.fromString

{-# INLINE pMapUnfoldE #-}
pMapUnfoldE
    :: MonadCatch m
    => Unfold m Path (Either Path Path)
    -> Unfold m FilePath (Either FilePath FilePath)
pMapUnfoldE :: forall (m :: * -> *).
MonadCatch m =>
Unfold m Path (Either Path Path)
-> Unfold m FilePath (Either FilePath FilePath)
pMapUnfoldE = (Either Path Path -> Either FilePath FilePath)
-> Unfold m FilePath (Either Path Path)
-> Unfold m FilePath (Either FilePath FilePath)
forall a b. (a -> b) -> Unfold m FilePath a -> Unfold m FilePath b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Either Path Path -> Either FilePath FilePath
ePathMap (Unfold m FilePath (Either Path Path)
 -> Unfold m FilePath (Either FilePath FilePath))
-> (Unfold m Path (Either Path Path)
    -> Unfold m FilePath (Either Path Path))
-> Unfold m Path (Either Path Path)
-> Unfold m FilePath (Either FilePath FilePath)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (FilePath -> m Path)
-> Unfold m Path (Either Path Path)
-> Unfold m FilePath (Either Path Path)
forall (m :: * -> *) a c b.
Monad m =>
(a -> m c) -> Unfold m c b -> Unfold m a b
Unfold.lmapM FilePath -> m Path
forall (m :: * -> *). MonadThrow m => FilePath -> m Path
Path.fromString

--------------------------------------------------------------------------------
-- Functions
--------------------------------------------------------------------------------

#if defined(mingw32_HOST_OS) || defined(__MINGW32__)
#define CONF id
#else
#define CONF (DirIO.followSymlinks True)
#endif

--  | Read a directory emitting a stream with names of the children. Filter out
--  "." and ".." entries.
--
--  /Internal/
--
{-# INLINE reader #-}
reader :: (MonadIO m, MonadCatch m) => Unfold m FilePath FilePath
reader :: forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
Unfold m FilePath FilePath
reader = (Path -> FilePath)
-> Unfold m FilePath Path -> Unfold m FilePath FilePath
forall a b. (a -> b) -> Unfold m FilePath a -> Unfold m FilePath b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Path -> FilePath
Path.toString (Unfold m FilePath Path -> Unfold m FilePath FilePath)
-> Unfold m FilePath Path -> Unfold m FilePath FilePath
forall a b. (a -> b) -> a -> b
$ (FilePath -> m Path)
-> Unfold m Path Path -> Unfold m FilePath Path
forall (m :: * -> *) a c b.
Monad m =>
(a -> m c) -> Unfold m c b -> Unfold m a b
Unfold.lmapM FilePath -> m Path
forall (m :: * -> *). MonadThrow m => FilePath -> m Path
Path.fromString Unfold m Path Path
forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
Unfold m Path Path
DirIO.reader

-- | Read directories as Left and files as Right. Filter out "." and ".."
-- entries.
--
--  /Internal/
--
{-# INLINE eitherReader #-}
eitherReader :: (MonadIO m, MonadCatch m) => Unfold m FilePath (Either FilePath FilePath)
eitherReader :: forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
Unfold m FilePath (Either FilePath FilePath)
eitherReader = Unfold m Path (Either Path Path)
-> Unfold m FilePath (Either FilePath FilePath)
forall (m :: * -> *).
MonadCatch m =>
Unfold m Path (Either Path Path)
-> Unfold m FilePath (Either FilePath FilePath)
pMapUnfoldE ((ReadOptions -> ReadOptions) -> Unfold m Path (Either Path Path)
forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
(ReadOptions -> ReadOptions) -> Unfold m Path (Either Path Path)
DirIO.eitherReader CONF)


{-# INLINE eitherReaderPaths #-}
eitherReaderPaths ::(MonadIO m, MonadCatch m) => Unfold m FilePath (Either FilePath FilePath)
eitherReaderPaths :: forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
Unfold m FilePath (Either FilePath FilePath)
eitherReaderPaths = Unfold m Path (Either Path Path)
-> Unfold m FilePath (Either FilePath FilePath)
forall (m :: * -> *).
MonadCatch m =>
Unfold m Path (Either Path Path)
-> Unfold m FilePath (Either FilePath FilePath)
pMapUnfoldE ((ReadOptions -> ReadOptions) -> Unfold m Path (Either Path Path)
forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
(ReadOptions -> ReadOptions) -> Unfold m Path (Either Path Path)
DirIO.eitherReaderPaths CONF)

--
-- | Read files only.
--
--  /Internal/
--
{-# INLINE fileReader #-}
fileReader :: (MonadIO m, MonadCatch m) => Unfold m FilePath FilePath
fileReader :: forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
Unfold m FilePath FilePath
fileReader = Unfold m Path Path -> Unfold m FilePath FilePath
forall (m :: * -> *).
MonadCatch m =>
Unfold m Path Path -> Unfold m FilePath FilePath
pMapUnfold ((ReadOptions -> ReadOptions) -> Unfold m Path Path
forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
(ReadOptions -> ReadOptions) -> Unfold m Path Path
DirIO.fileReader CONF)

-- | Read directories only. Filter out "." and ".." entries.
--
--  /Internal/
--
{-# INLINE dirReader #-}
dirReader :: (MonadIO m, MonadCatch m) => Unfold m FilePath FilePath
dirReader :: forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
Unfold m FilePath FilePath
dirReader = Unfold m Path Path -> Unfold m FilePath FilePath
forall (m :: * -> *).
MonadCatch m =>
Unfold m Path Path -> Unfold m FilePath FilePath
pMapUnfold ((ReadOptions -> ReadOptions) -> Unfold m Path Path
forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
(ReadOptions -> ReadOptions) -> Unfold m Path Path
DirIO.dirReader CONF)

-- | Raw read of a directory.
--
-- /Pre-release/
{-# INLINE read #-}
read :: (MonadIO m, MonadCatch m) => FilePath -> Stream m FilePath
read :: forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
FilePath -> Stream m FilePath
read = Unfold m FilePath FilePath -> FilePath -> Stream m FilePath
forall (m :: * -> *) a b.
Applicative m =>
Unfold m a b -> a -> Stream m b
S.unfold Unfold m FilePath FilePath
forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
Unfold m FilePath FilePath
reader

{-# DEPRECATED toStream "Please use 'read' instead" #-}
{-# INLINE toStream #-}
toStream :: (MonadIO m, MonadCatch m) => String -> Stream m String
toStream :: forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
FilePath -> Stream m FilePath
toStream = FilePath -> Stream m FilePath
forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
FilePath -> Stream m FilePath
read

-- | Read directories as Left and files as Right. Filter out "." and ".."
-- entries. The output contains the names of the directories and files.
--
-- /Pre-release/
{-# INLINE readEither #-}
readEither :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Either FilePath FilePath)
readEither :: forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
FilePath -> Stream m (Either FilePath FilePath)
readEither = Unfold m FilePath (Either FilePath FilePath)
-> FilePath -> Stream m (Either FilePath FilePath)
forall (m :: * -> *) a b.
Applicative m =>
Unfold m a b -> a -> Stream m b
S.unfold Unfold m FilePath (Either FilePath FilePath)
forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
Unfold m FilePath (Either FilePath FilePath)
eitherReader

-- | Like 'readEither' but prefix the names of the files and directories with
-- the supplied directory path.
{-# INLINE readEitherPaths #-}
readEitherPaths :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Either FilePath FilePath)
readEitherPaths :: forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
FilePath -> Stream m (Either FilePath FilePath)
readEitherPaths FilePath
dir = (Either FilePath FilePath -> Either FilePath FilePath)
-> Stream m (Either FilePath FilePath)
-> Stream m (Either FilePath FilePath)
forall a b. (a -> b) -> Stream m a -> Stream m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((FilePath -> FilePath)
-> (FilePath -> FilePath)
-> Either FilePath FilePath
-> Either FilePath FilePath
forall a b c d. (a -> b) -> (c -> d) -> Either a c -> Either b d
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap (FilePath
dir FilePath -> FilePath -> FilePath
</>) (FilePath
dir FilePath -> FilePath -> FilePath
</>)) (Stream m (Either FilePath FilePath)
 -> Stream m (Either FilePath FilePath))
-> Stream m (Either FilePath FilePath)
-> Stream m (Either FilePath FilePath)
forall a b. (a -> b) -> a -> b
$ FilePath -> Stream m (Either FilePath FilePath)
forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
FilePath -> Stream m (Either FilePath FilePath)
readEither FilePath
dir

{-# DEPRECATED toEither "Please use 'readEither' instead" #-}
{-# INLINE toEither #-}
toEither :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Either FilePath FilePath)
toEither :: forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
FilePath -> Stream m (Either FilePath FilePath)
toEither = FilePath -> Stream m (Either FilePath FilePath)
forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
FilePath -> Stream m (Either FilePath FilePath)
readEither

-- | Read files only.
--
--  /Internal/
--
{-# INLINE readFiles #-}
readFiles :: (MonadIO m, MonadCatch m) => FilePath -> Stream m FilePath
readFiles :: forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
FilePath -> Stream m FilePath
readFiles = Unfold m FilePath FilePath -> FilePath -> Stream m FilePath
forall (m :: * -> *) a b.
Applicative m =>
Unfold m a b -> a -> Stream m b
S.unfold Unfold m FilePath FilePath
forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
Unfold m FilePath FilePath
fileReader

{-# DEPRECATED toFiles "Please use 'readFiles' instead" #-}
{-# INLINE toFiles #-}
toFiles :: (MonadIO m, MonadCatch m) => FilePath -> Stream m FilePath
toFiles :: forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
FilePath -> Stream m FilePath
toFiles = FilePath -> Stream m FilePath
forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
FilePath -> Stream m FilePath
readFiles

-- | Read directories only.
--
--  /Internal/
--
{-# INLINE readDirs #-}
readDirs :: (MonadIO m, MonadCatch m) => FilePath -> Stream m FilePath
readDirs :: forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
FilePath -> Stream m FilePath
readDirs = Unfold m FilePath FilePath -> FilePath -> Stream m FilePath
forall (m :: * -> *) a b.
Applicative m =>
Unfold m a b -> a -> Stream m b
S.unfold Unfold m FilePath FilePath
forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
Unfold m FilePath FilePath
dirReader

{-# DEPRECATED toDirs "Please use 'readDirs' instead" #-}
{-# INLINE toDirs #-}
toDirs :: (MonadIO m, MonadCatch m) => String -> Stream m String
toDirs :: forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
FilePath -> Stream m FilePath
toDirs = FilePath -> Stream m FilePath
forall (m :: * -> *).
(MonadIO m, MonadCatch m) =>
FilePath -> Stream m FilePath
readDirs