module Data.Git.Phoenix.Io where

import Data.ByteString.Lazy qualified as L
import Data.Git.Phoenix.Prelude
import System.IO qualified as IO
import Lazy.Scope as S
import UnliftIO.IO qualified as U

class HasInHandlesSem m where
  getInHandlesSem :: m QSem

instance (Monad m, HasInHandlesSem m) => HasInHandlesSem (ResourceT m) where
  getInHandlesSem :: ResourceT m QSem
getInHandlesSem = m QSem -> ResourceT m QSem
forall (m :: * -> *) a. Monad m => m a -> ResourceT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m QSem
forall (m :: * -> *). HasInHandlesSem m => m QSem
getInHandlesSem

data Compressed

withHandleX :: (NFData a, MonadUnliftIO m, HasInHandlesSem m) =>
  IOMode -> FilePath -> (forall s. Handle s -> LazyT s m a) -> m a
withHandleX :: forall {k} a (m :: * -> *).
(NFData a, MonadUnliftIO m, HasInHandlesSem m) =>
IOMode
-> FilePath -> (forall (s :: k). Handle s -> LazyT s m a) -> m a
withHandleX IOMode
mode FilePath
fp forall (s :: k). Handle s -> LazyT s m a
a = do
  s <- m QSem
forall (m :: * -> *). HasInHandlesSem m => m QSem
getInHandlesSem
  bracket_ (waitQSem s) (signalQSem s) $
    withBinaryFile fp mode a


withHandle :: (NFData a, MonadUnliftIO m, HasInHandlesSem m) =>
  FilePath -> (forall s. Handle s -> LazyT s m a) -> m a
withHandle :: forall {k} a (m :: * -> *).
(NFData a, MonadUnliftIO m, HasInHandlesSem m) =>
FilePath -> (forall (s :: k). Handle s -> LazyT s m a) -> m a
withHandle = IOMode
-> FilePath -> (forall (s :: k). Handle s -> LazyT s m a) -> m a
forall {k} a (m :: * -> *).
(NFData a, MonadUnliftIO m, HasInHandlesSem m) =>
IOMode
-> FilePath -> (forall (s :: k). Handle s -> LazyT s m a) -> m a
withHandleX IOMode
ReadMode

withCompressedH :: (NFData a, MonadUnliftIO m, HasInHandlesSem m) =>
  FilePath ->
  (forall s. Tagged Compressed (Bs s) -> Bs s -> LazyT s m a) ->
  m a
withCompressedH :: forall {k} a (m :: * -> *).
(NFData a, MonadUnliftIO m, HasInHandlesSem m) =>
FilePath
-> (forall (s :: k).
    Tagged Compressed (Bs s) -> Bs s -> LazyT s m a)
-> m a
withCompressedH FilePath
fp forall (s :: k). Tagged Compressed (Bs s) -> Bs s -> LazyT s m a
a =
  FilePath -> (forall (s :: k). Handle s -> LazyT s m a) -> m a
forall {k} a (m :: * -> *).
(NFData a, MonadUnliftIO m, HasInHandlesSem m) =>
FilePath -> (forall (s :: k). Handle s -> LazyT s m a) -> m a
withHandle ($(tr "/fp") FilePath
fp) ((forall (s :: k). Handle s -> LazyT s m a) -> m a)
-> (forall (s :: k). Handle s -> LazyT s m a) -> m a
forall a b. (a -> b) -> a -> b
$ \Handle s
inH -> Handle s -> LazyT s m (Bs s)
forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m (Bs s)
hGetContents Handle s
inH LazyT s m (Bs s) -> (Bs s -> LazyT s m a) -> LazyT s m a
forall a b. LazyT s m a -> (a -> LazyT s m b) -> LazyT s m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\Bs s
cbs -> Tagged Compressed (Bs s) -> Bs s -> LazyT s m a
forall (s :: k). Tagged Compressed (Bs s) -> Bs s -> LazyT s m a
a (Bs s -> Tagged Compressed (Bs s)
forall {k} (s :: k) b. b -> Tagged s b
Tagged Bs s
cbs) (Bs s -> LazyT s m a) -> Bs s -> LazyT s m a
forall a b. (a -> b) -> a -> b
$ (LByteString -> LByteString) -> Bs s -> Bs s
forall {k} (s :: k). (LByteString -> LByteString) -> Bs s -> Bs s
mapLbs LByteString -> LByteString
decompress Bs s
cbs)

withCompressed :: (NFData a, MonadUnliftIO m, HasInHandlesSem m) =>
  FilePath -> (forall s. Bs s -> LazyT s m a) -> m a
withCompressed :: forall {k} a (m :: * -> *).
(NFData a, MonadUnliftIO m, HasInHandlesSem m) =>
FilePath -> (forall (s :: k). Bs s -> LazyT s m a) -> m a
withCompressed FilePath
fp forall (s :: k). Bs s -> LazyT s m a
a = FilePath
-> (forall (s :: k).
    Tagged Compressed (Bs s) -> Bs s -> LazyT s m a)
-> m a
forall {k} a (m :: * -> *).
(NFData a, MonadUnliftIO m, HasInHandlesSem m) =>
FilePath
-> (forall (s :: k).
    Tagged Compressed (Bs s) -> Bs s -> LazyT s m a)
-> m a
withCompressedH FilePath
fp (\Tagged Compressed (Bs s)
_cbs Bs s
bs -> Bs s -> LazyT s m a
forall (s :: k). Bs s -> LazyT s m a
a Bs s
bs)

writeBinaryFile :: MonadUnliftIO m => FilePath -> IOMode -> (IO.Handle -> m ()) -> m ()
writeBinaryFile :: forall (m :: * -> *).
MonadUnliftIO m =>
FilePath -> IOMode -> (Handle -> m ()) -> m ()
writeBinaryFile FilePath
fp IOMode
mode Handle -> m ()
cb = FilePath -> IOMode -> (Handle -> m ()) -> m ()
forall (m :: * -> *) a.
MonadUnliftIO m =>
FilePath -> IOMode -> (Handle -> m a) -> m a
U.withBinaryFile FilePath
fp IOMode
mode Handle -> m ()
cb

hPutLbs :: MonadIO m => IO.Handle -> LByteString -> m ()
hPutLbs :: forall (m :: * -> *). MonadIO m => Handle -> LByteString -> m ()
hPutLbs Handle
h LByteString
bs = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Handle -> LByteString -> IO ()
L.hPut Handle
h LByteString
bs

-- | just 'copyFile' is not possible due to trash after archive
saveCompressedBs :: MonadUnliftIO m => FilePath -> LByteString -> m ()
saveCompressedBs :: forall (m :: * -> *).
MonadUnliftIO m =>
FilePath -> LByteString -> m ()
saveCompressedBs FilePath
fp LByteString
bs = do
  Bool -> FilePath -> m ()
forall (m :: * -> *). MonadIO m => Bool -> FilePath -> m ()
createDirectoryIfMissing Bool
False (FilePath -> m ()) -> FilePath -> m ()
forall a b. (a -> b) -> a -> b
$ FilePath -> FilePath
dropFileName FilePath
fp
  FilePath
-> IOMode
-> (forall (s :: ZonkAny 0). Handle s -> LazyT s m ())
-> m ()
forall a {k} r (m :: * -> *).
(WithFile a, NFData r, MonadUnliftIO m) =>
a -> IOMode -> (forall (s :: k). Handle s -> LazyT s m r) -> m r
forall {k} r (m :: * -> *).
(NFData r, MonadUnliftIO m) =>
FilePath
-> IOMode -> (forall (s :: k). Handle s -> LazyT s m r) -> m r
withBinaryFile ($(tr "/fp") FilePath
fp) IOMode
WriteMode ((forall (s :: ZonkAny 0). Handle s -> LazyT s m ()) -> m ())
-> (forall (s :: ZonkAny 0). Handle s -> LazyT s m ()) -> m ()
forall a b. (a -> b) -> a -> b
$ \Handle s
h -> Handle s -> LByteString -> LazyT s m ()
forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LByteString -> LazyT s m ()
S.hPut Handle s
h (LByteString -> LazyT s m ()) -> LByteString -> LazyT s m ()
forall a b. (a -> b) -> a -> b
$ LByteString -> LByteString
compress LByteString
bs

readNumber :: MonadIO m => Int -> Int -> m Int
readNumber :: forall (m :: * -> *). MonadIO m => Int -> Int -> m Int
readNumber Int
minVal Int
maxVal = m Int
go
  where
    go :: m Int
go = do
      s <- IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ IO Text
forall (m :: * -> *). MonadIO m => m Text
getLine
      case readMaybe $ toString s of
        Just Int
n
          | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
minVal Bool -> Bool -> Bool
&& Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
maxVal ->
            Int -> m Int
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
n
          | Bool
otherwise -> do
            FilePath -> m ()
forall (m :: * -> *). MonadIO m => FilePath -> m ()
putStrLn FilePath
"Value is out of range. Try again"
            m Int
go
        Maybe Int
Nothing -> do
            FilePath -> m ()
forall (m :: * -> *). MonadIO m => FilePath -> m ()
putStrLn FilePath
"Value is number. Try again"
            m Int
go