{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE PackageImports #-}

{-# OPTIONS_GHC -Wno-deprecations #-}

module Streamly.Compat.OsPath
    ( unsafeToPath
    , toPath
    , fromPath
    )
where

import Control.Monad.Catch (MonadThrow)
#if MIN_VERSION_filepath(1,5,0)
import System.OsString.Internal.Types (OsString(..))
#if defined(mingw32_HOST_OS)
import System.OsString.Internal.Types (WindowsString(..))
#else
import System.OsString.Internal.Types (PosixString(..))
#endif
import "os-string" System.OsString.Data.ByteString.Short (ShortByteString(..))
#else
import "filepath" System.OsString.Internal.Types (OsString(..))
#if defined(mingw32_HOST_OS)
import "filepath" System.OsString.Internal.Types (WindowsString(..))
#else
import "filepath" System.OsString.Internal.Types (PosixString(..))
#endif
import "filepath" System.OsPath.Data.ByteString.Short (ShortByteString(..))
#endif
import Streamly.Internal.Data.MutByteArray (MutByteArray(..))
import Streamly.Internal.Data.Array (Array(..))
import Streamly.FileSystem.Path (Path, OsWord)
import System.OsPath (OsPath)
import GHC.Exts (sizeofByteArray#, Int(..), unsafeCoerce#)
import System.IO.Unsafe (unsafePerformIO)

import qualified Streamly.Internal.Data.MutByteArray as MBA
import qualified Streamly.Internal.FileSystem.Path as Path

#if defined(mingw32_HOST_OS)
getString :: WindowsString -> ShortByteString
getString = getWindowsString
#else
getString :: PosixString -> ShortByteString
getString :: PosixString -> ShortByteString
getString = PosixString -> ShortByteString
getPosixString
#endif

#if defined(mingw32_HOST_OS)
mkString :: ShortByteString -> WindowsString
mkString = WindowsString
#else
mkString :: ShortByteString -> PosixString
mkString :: ShortByteString -> PosixString
mkString = ShortByteString -> PosixString
PosixString
#endif

{-# INLINE toOsWordArray #-}
toOsWordArray :: OsPath -> Array OsWord
toOsWordArray :: OsPath -> Array OsWord
toOsWordArray OsPath
p =
    let !(SBS ByteArray#
barr#) = PosixString -> ShortByteString
getString (PosixString -> ShortByteString) -> PosixString -> ShortByteString
forall a b. (a -> b) -> a -> b
$ OsPath -> PosixString
getOsString OsPath
p
        mbarr :: MutByteArray
mbarr = MutableByteArray# RealWorld -> MutByteArray
MutByteArray (ByteArray# -> MutableByteArray# RealWorld
forall a b. a -> b
unsafeCoerce# ByteArray#
barr#)
      in MutByteArray -> Int -> Int -> Array OsWord
forall a. MutByteArray -> Int -> Int -> Array a
Array MutByteArray
mbarr Int
0 (Int# -> Int
I# (ByteArray# -> Int#
sizeofByteArray# ByteArray#
barr#)) :: Array OsWord

{-# INLINE fromOsWordArray #-}
fromOsWordArray :: Array OsWord -> OsPath
fromOsWordArray :: Array OsWord -> OsPath
fromOsWordArray (Array mba :: MutByteArray
mba@(MutByteArray MutableByteArray# RealWorld
mbarr#) Int
start Int
end) =
    let sz :: Int
sz = Int# -> Int
I# (ByteArray# -> Int#
sizeofByteArray# (MutableByteArray# RealWorld -> ByteArray#
forall a b. a -> b
unsafeCoerce# MutableByteArray# RealWorld
mbarr#))
     in if Int
start Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 Bool -> Bool -> Bool
&& Int
end Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
sz
        -- freeze it instead of coercing? What if mba has been coerced from a
        -- frozen byetarray e.g. in toOsWordArray above?
        then PosixString -> OsPath
OsString (PosixString -> OsPath) -> PosixString -> OsPath
forall a b. (a -> b) -> a -> b
$ ShortByteString -> PosixString
mkString (ByteArray# -> ShortByteString
SBS (MutableByteArray# RealWorld -> ByteArray#
forall a b. a -> b
unsafeCoerce# MutableByteArray# RealWorld
mbarr#))
        else let !(MutByteArray MutableByteArray# RealWorld
arr#) =
                    IO MutByteArray -> MutByteArray
forall a. IO a -> a
unsafePerformIO
                        (IO MutByteArray -> MutByteArray)
-> IO MutByteArray -> MutByteArray
forall a b. (a -> b) -> a -> b
$ Int -> Int -> MutByteArray -> IO MutByteArray
forall (m :: * -> *).
MonadIO m =>
Int -> Int -> MutByteArray -> m MutByteArray
MBA.unsafeCloneSlice Int
start (Int
end Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
start) MutByteArray
mba
             in PosixString -> OsPath
OsString (PosixString -> OsPath) -> PosixString -> OsPath
forall a b. (a -> b) -> a -> b
$ ShortByteString -> PosixString
mkString (ByteArray# -> ShortByteString
SBS (MutableByteArray# RealWorld -> ByteArray#
forall a b. a -> b
unsafeCoerce# MutableByteArray# RealWorld
arr#))

-- | Adapt an 'OsPath' type to the streamly 'Path' type at zero cost.
--
-- Unsafe: The user is responsible to make sure that the 'OsPath' is valid as
-- per 'Path.validatePath'.
--
unsafeToPath :: OsPath -> Path
unsafeToPath :: OsPath -> Path
unsafeToPath = Array OsWord -> Path
Path.unsafeFromArray (Array OsWord -> Path)
-> (OsPath -> Array OsWord) -> OsPath -> Path
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OsPath -> Array OsWord
toOsWordArray

-- | Adapt an 'OsPath' type to the streamly 'Path' type at zero cost.
--
toPath :: MonadThrow m => OsPath -> m Path
toPath :: forall (m :: * -> *). MonadThrow m => OsPath -> m Path
toPath = Array OsWord -> m Path
forall (m :: * -> *). MonadThrow m => Array OsWord -> m Path
Path.fromArray (Array OsWord -> m Path)
-> (OsPath -> Array OsWord) -> OsPath -> m Path
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OsPath -> Array OsWord
toOsWordArray

-- | Adapt a Streamly 'Path' type to 'OsPath' type at zero cost.
fromPath :: Path -> OsPath
fromPath :: Path -> OsPath
fromPath = Array OsWord -> OsPath
fromOsWordArray (Array OsWord -> OsPath)
-> (Path -> Array OsWord) -> Path -> OsPath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Path -> Array OsWord
Path.toArray