-- SPDX-FileCopyrightText: 2026 Alexandra de Wit
--
-- SPDX-License-Identifier: MIT

{- | Byte limits and whole-stream digests for advisory streams. Callers own the breach effect, so
ingestion and runtime downloads can share the traversal without sharing error types.
-}
module Ecluse.Core.Stream (boundBytes, boundLines, digestWhole) where

import Conduit (ConduitT, await, yield)
import Crypto.Hash (hashInit, hashUpdate)
import Data.ByteString qualified as BS

import Ecluse.Core.Snapshot (ContentDigest, digestFromContext)

-- | Pass chunks up to the byte cap. A breach hands the action the bytes seen and stops before the excess chunk, even if the action returns.
boundBytes :: (Monad m) => Int -> (Int -> m ()) -> ConduitT ByteString ByteString m ()
boundBytes :: forall (m :: * -> *).
Monad m =>
Int -> (Int -> m ()) -> ConduitT ByteString ByteString m ()
boundBytes Int
cap Int -> m ()
onBreach = Int -> ConduitT ByteString ByteString m ()
go Int
0
  where
    go :: Int -> ConduitT ByteString ByteString m ()
go !Int
seen =
        ConduitT ByteString ByteString m (Maybe ByteString)
forall (m :: * -> *) i o. Monad m => ConduitT i o m (Maybe i)
await ConduitT ByteString ByteString m (Maybe ByteString)
-> (Maybe ByteString -> ConduitT ByteString ByteString m ())
-> ConduitT ByteString ByteString m ()
forall a b.
ConduitT ByteString ByteString m a
-> (a -> ConduitT ByteString ByteString m b)
-> ConduitT ByteString ByteString m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
            Maybe ByteString
Nothing -> ConduitT ByteString ByteString m ()
forall (f :: * -> *). Applicative f => f ()
pass
            Just ByteString
chunk ->
                let seen' :: Int
seen' = Int
seen Int -> Int -> Int
forall a. Num a => a -> a -> a
+ ByteString -> Int
BS.length ByteString
chunk
                 in if Int
seen' Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
cap
                        then m () -> ConduitT ByteString ByteString m ()
forall (m :: * -> *) a.
Monad m =>
m a -> ConduitT ByteString ByteString m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Int -> m ()
onBreach Int
seen')
                        else ByteString -> ConduitT ByteString ByteString m ()
forall (m :: * -> *) o i. Monad m => o -> ConduitT i o m ()
yield ByteString
chunk ConduitT ByteString ByteString m ()
-> ConduitT ByteString ByteString m ()
-> ConduitT ByteString ByteString m ()
forall a b.
ConduitT ByteString ByteString m a
-> ConduitT ByteString ByteString m b
-> ConduitT ByteString ByteString m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> ConduitT ByteString ByteString m ()
go Int
seen'

-- | Split a stream into lines, holding at most @cap@ bytes of one. A longer line hands the action its length and stops, even if the action returns.
boundLines :: (Monad m) => Int -> (Int -> m ()) -> ConduitT ByteString ByteString m ()
boundLines :: forall (m :: * -> *).
Monad m =>
Int -> (Int -> m ()) -> ConduitT ByteString ByteString m ()
boundLines Int
cap Int -> m ()
onBreach = ByteString -> ConduitT ByteString ByteString m ()
go ByteString
BS.empty
  where
    go :: ByteString -> ConduitT ByteString ByteString m ()
go ByteString
pending =
        ConduitT ByteString ByteString m (Maybe ByteString)
forall (m :: * -> *) i o. Monad m => ConduitT i o m (Maybe i)
await ConduitT ByteString ByteString m (Maybe ByteString)
-> (Maybe ByteString -> ConduitT ByteString ByteString m ())
-> ConduitT ByteString ByteString m ()
forall a b.
ConduitT ByteString ByteString m a
-> (a -> ConduitT ByteString ByteString m b)
-> ConduitT ByteString ByteString m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
            Maybe ByteString
Nothing -> Bool
-> ConduitT ByteString ByteString m ()
-> ConduitT ByteString ByteString m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (ByteString -> Bool
BS.null ByteString
pending) (ByteString -> ConduitT ByteString ByteString m ()
forall (m :: * -> *) o i. Monad m => o -> ConduitT i o m ()
yield ByteString
pending)
            Just ByteString
chunk -> ByteString -> ConduitT ByteString ByteString m ()
split (ByteString
pending ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> ByteString
chunk)
    split :: ByteString -> ConduitT ByteString ByteString m ()
split ByteString
buffer = case Word8 -> ByteString -> Maybe Int
BS.elemIndex Word8
newline ByteString
buffer of
        Just Int
end
            | Int
end Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
cap -> m () -> ConduitT ByteString ByteString m ()
forall (m :: * -> *) a.
Monad m =>
m a -> ConduitT ByteString ByteString m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Int -> m ()
onBreach Int
end)
            | Bool
otherwise -> ByteString -> ConduitT ByteString ByteString m ()
forall (m :: * -> *) o i. Monad m => o -> ConduitT i o m ()
yield (Int -> ByteString -> ByteString
BS.take Int
end ByteString
buffer) ConduitT ByteString ByteString m ()
-> ConduitT ByteString ByteString m ()
-> ConduitT ByteString ByteString m ()
forall a b.
ConduitT ByteString ByteString m a
-> ConduitT ByteString ByteString m b
-> ConduitT ByteString ByteString m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ByteString -> ConduitT ByteString ByteString m ()
split (Int -> ByteString -> ByteString
BS.drop (Int
end Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) ByteString
buffer)
        Maybe Int
Nothing
            | ByteString -> Int
BS.length ByteString
buffer Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
cap -> m () -> ConduitT ByteString ByteString m ()
forall (m :: * -> *) a.
Monad m =>
m a -> ConduitT ByteString ByteString m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Int -> m ()
onBreach (ByteString -> Int
BS.length ByteString
buffer))
            | Bool
otherwise -> ByteString -> ConduitT ByteString ByteString m ()
go ByteString
buffer
    newline :: Word8
newline = Word8
10

-- | Pass every chunk on and return their SHA-256 at the end. Fuse it with 'Data.Conduit.fuseBoth', which drains the source into the digest.
digestWhole :: (Monad m) => ConduitT ByteString ByteString m ContentDigest
digestWhole :: forall (m :: * -> *).
Monad m =>
ConduitT ByteString ByteString m ContentDigest
digestWhole = Context SHA256 -> ConduitT ByteString ByteString m ContentDigest
forall {m :: * -> *} {o}.
(Monad m, ByteArrayAccess o) =>
Context SHA256 -> ConduitT o o m ContentDigest
go Context SHA256
forall a. HashAlgorithm a => Context a
hashInit
  where
    go :: Context SHA256 -> ConduitT o o m ContentDigest
go Context SHA256
context =
        ConduitT o o m (Maybe o)
forall (m :: * -> *) i o. Monad m => ConduitT i o m (Maybe i)
await ConduitT o o m (Maybe o)
-> (Maybe o -> ConduitT o o m ContentDigest)
-> ConduitT o o m ContentDigest
forall a b.
ConduitT o o m a -> (a -> ConduitT o o m b) -> ConduitT o o m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
            Maybe o
Nothing -> ContentDigest -> ConduitT o o m ContentDigest
forall a. a -> ConduitT o o m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Context SHA256 -> ContentDigest
digestFromContext Context SHA256
context)
            Just o
chunk -> do
                let !next :: Context SHA256
next = Context SHA256 -> o -> Context SHA256
forall ba a.
(ByteArrayAccess ba, HashAlgorithm a) =>
Context a -> ba -> Context a
hashUpdate Context SHA256
context o
chunk
                o -> ConduitT o o m ()
forall (m :: * -> *) o i. Monad m => o -> ConduitT i o m ()
yield o
chunk
                Context SHA256 -> ConduitT o o m ContentDigest
go Context SHA256
next