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

-- | JSON string bytes and exact lengths shared by packed values and their writer.
module Ecluse.Core.Registry.Json.StringEncoding (
    encodeString,
    encodedLength,
    writeEncoded,
    writeEncodedSized,
    plain,
    quote,
) where

import Control.Monad.ST (ST)
import Data.Bits (shiftR, (.&.))
import Data.ByteString.Internal qualified as BSI
import Data.ByteString.Short qualified as SBS
import Data.Primitive.ByteArray (MutableByteArray, copyByteArray, copyByteArrayToAddr, createByteArray, writeByteArray)
import Data.Text.Array qualified as TA
import Data.Text.Internal qualified as TI
import Foreign.Ptr (plusPtr)
import Foreign.Storable (pokeByteOff)

-- | The bytes aeson writes for a string, quotes included: 'encodedLength' of them.
encodeString :: Text -> ByteString
encodeString :: Text -> ByteString
encodeString text :: Text
text@(TI.Text Array
array Int
offset Int
len)
    | Text -> Bool
plain Text
text = Int -> (Ptr Word8 -> IO ()) -> ByteString
BSI.unsafeCreate (Int
len Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) ((Ptr Word8 -> IO ()) -> ByteString)
-> (Ptr Word8 -> IO ()) -> ByteString
forall a b. (a -> b) -> a -> b
$ \Ptr Word8
target -> do
        Ptr Word8 -> Int -> Word8 -> IO ()
forall b. Ptr b -> Int -> Word8 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr Word8
target Int
0 Word8
quote
        Ptr Word8 -> Array -> Int -> Int -> IO ()
forall (m :: * -> *).
PrimMonad m =>
Ptr Word8 -> Array -> Int -> Int -> m ()
copyByteArrayToAddr (Ptr Word8
target Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
1) Array
array Int
offset Int
len
        Ptr Word8 -> Int -> Word8 -> IO ()
forall b. Ptr b -> Int -> Word8 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr Word8
target (Int
len Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Word8
quote
    | Bool
otherwise = ShortByteString -> ByteString
SBS.fromShort (Array -> ShortByteString
SBS.ShortByteString (Int -> (forall s. MutableByteArray s -> ST s ()) -> Array
createByteArray (Text -> Int
encodedLength Text
text) (\MutableByteArray s
target -> ST s Int -> ST s ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Text -> MutableByteArray s -> Int -> ST s Int
forall st. Text -> MutableByteArray st -> Int -> ST st Int
writeEncoded Text
text MutableByteArray s
target Int
0))))

-- | The length of 'encodeString', from the escape 'writeEncoded' writes for each byte.
encodedLength :: Text -> Int
encodedLength :: Text -> Int
encodedLength (TI.Text Array
array Int
offset Int
len) = Int -> Int -> Int
go Int
offset Int
2
  where
    end :: Int
end = Int
offset Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
len
    go :: Int -> Int -> Int
go !Int
i !Int
total
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
end = Int
total
        | Bool
otherwise = Int -> Int -> Int
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) (Int
total Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Escape -> Int
escapeWidth (Word8 -> Escape
escapeOf (Array -> Int -> Word8
TA.unsafeIndex Array
array Int
i)))

-- | Whether aeson writes the string's bytes as they are: no backslash, quote or byte below a space.
plain :: Text -> Bool
plain :: Text -> Bool
plain (TI.Text Array
array Int
offset Int
len) = Int -> Bool
go Int
offset
  where
    end :: Int
end = Int
offset Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
len
    go :: Int -> Bool
go !Int
i
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
end = Bool
True
        | Bool
otherwise = case Word8 -> Escape
escapeOf (Array -> Int -> Word8
TA.unsafeIndex Array
array Int
i) of
            Escape
Verbatim -> Int -> Bool
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
            Escape
_ -> Bool
False

-- | Write 'encodeString' at an offset, and return the offset after it.
writeEncoded :: Text -> MutableByteArray st -> Int -> ST st Int
writeEncoded :: forall st. Text -> MutableByteArray st -> Int -> ST st Int
writeEncoded Text
text = Bool -> Text -> MutableByteArray st -> Int -> ST st Int
forall st. Bool -> Text -> MutableByteArray st -> Int -> ST st Int
writeEncodedWith (Text -> Bool
plain Text
text) Text
text

-- | Like 'writeEncoded': the length must equal 'encodedLength' for this same text without 'Int' overflow, and fit from a non-negative target offset.
writeEncodedSized :: Text -> Int -> MutableByteArray st -> Int -> ST st Int
writeEncodedSized :: forall st. Text -> Int -> MutableByteArray st -> Int -> ST st Int
writeEncodedSized text :: Text
text@(TI.Text Array
_ Int
_ Int
len) Int
encoded = Bool -> Text -> MutableByteArray st -> Int -> ST st Int
forall st. Bool -> Text -> MutableByteArray st -> Int -> ST st Int
writeEncodedWith (Int
encoded Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
len Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) Text
text

writeEncodedWith :: Bool -> Text -> MutableByteArray st -> Int -> ST st Int
writeEncodedWith :: forall st. Bool -> Text -> MutableByteArray st -> Int -> ST st Int
writeEncodedWith Bool
isPlain (TI.Text Array
array Int
offset Int
len) MutableByteArray st
target Int
at
    | Bool
isPlain = do
        MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target Int
at Word8
quote
        MutableByteArray (PrimState (ST st))
-> Int -> Array -> Int -> Int -> ST st ()
forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m)
-> Int -> Array -> Int -> Int -> m ()
copyByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target (Int
at Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Array
array Int
offset Int
len
        MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target (Int
at Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
len Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Word8
quote
        Int -> ST st Int
forall a. a -> ST st a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int
at Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
len Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)
    | Bool
otherwise = do
        MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target Int
at Word8
quote
        end <- Array -> Int -> Int -> MutableByteArray st -> Int -> ST st Int
forall st.
Array -> Int -> Int -> MutableByteArray st -> Int -> ST st Int
escapeFrom Array
array Int
offset (Int
offset Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
len) MutableByteArray st
target (Int
at Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
        writeByteArray target end quote
        pure (end + 1)
{-# INLINE writeEncodedWith #-}

data Escape = Verbatim | Named !Word8 | Coded

escapeOf :: Word8 -> Escape
escapeOf :: Word8 -> Escape
escapeOf Word8
byte
    | Word8
byte Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x5c = Word8 -> Escape
Named Word8
0x5c
    | Word8
byte Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x22 = Word8 -> Escape
Named Word8
0x22
    | Word8
byte Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
>= Word8
0x20 = Escape
Verbatim
    | Word8
byte Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x0a = Word8 -> Escape
Named Word8
0x6e
    | Word8
byte Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x0d = Word8 -> Escape
Named Word8
0x72
    | Word8
byte Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x09 = Word8 -> Escape
Named Word8
0x74
    | Bool
otherwise = Escape
Coded
{-# INLINE escapeOf #-}

escapeWidth :: Escape -> Int
escapeWidth :: Escape -> Int
escapeWidth = \case
    Escape
Verbatim -> Int
1
    Named Word8
_ -> Int
2
    Escape
Coded -> Int
6
{-# INLINE escapeWidth #-}

escapeFrom :: TA.Array -> Int -> Int -> MutableByteArray st -> Int -> ST st Int
escapeFrom :: forall st.
Array -> Int -> Int -> MutableByteArray st -> Int -> ST st Int
escapeFrom Array
array !Int
from !Int
to MutableByteArray st
target !Int
at
    | Int
from Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
to = Int -> ST st Int
forall a. a -> ST st a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
at
    | Bool
otherwise = case Word8 -> Escape
escapeOf Word8
byte of
        Escape
Verbatim -> MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target Int
at Word8
byte ST st () -> ST st Int -> ST st Int
forall a b. ST st a -> ST st b -> ST st b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> ST st Int
next Int
1
        Named Word8
letter -> do
            MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target Int
at (Word8
0x5c :: Word8)
            MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target (Int
at Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Word8
letter
            Int -> ST st Int
next Int
2
        Escape
Coded -> do
            MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target Int
at (Word8
0x5c :: Word8)
            MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target (Int
at Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) (Word8
0x75 :: Word8)
            MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target (Int
at Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) (Word8
0x30 :: Word8)
            MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target (Int
at Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3) (Word8
0x30 :: Word8)
            MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target (Int
at Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4) (Word8 -> Word8
hexDigit (Word8
byte Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`shiftR` Int
4))
            MutableByteArray (PrimState (ST st)) -> Int -> Word8 -> ST st ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray st
MutableByteArray (PrimState (ST st))
target (Int
at Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
5) (Word8 -> Word8
hexDigit (Word8
byte Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f))
            Int -> ST st Int
next Int
6
  where
    byte :: Word8
byte = Array -> Int -> Word8
TA.unsafeIndex Array
array Int
from
    next :: Int -> ST st Int
next Int
width = Array -> Int -> Int -> MutableByteArray st -> Int -> ST st Int
forall st.
Array -> Int -> Int -> MutableByteArray st -> Int -> ST st Int
escapeFrom Array
array (Int
from Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int
to MutableByteArray st
target (Int
at Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
width)

hexDigit :: Word8 -> Word8
hexDigit :: Word8 -> Word8
hexDigit Word8
digit
    | Word8
digit Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
< Word8
10 = Word8
0x30 Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
+ Word8
digit
    | Bool
otherwise = Word8
0x57 Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
+ Word8
digit

-- | The quote byte that opens and closes a string's encoding.
quote :: Word8
quote :: Word8
quote = Word8
0x22