-- SPDX-FileCopyrightText: 2026 Alexandra de Wit
--
-- SPDX-License-Identifier: MIT
{-# LANGUAGE TypeFamilies #-}

-- | Delay companion values until a selected filename survives, while checking duplicate keys as read.
module Ecluse.Core.Registry.PyPI.PendingSidecar (readPendingSidecar) where

import Data.Aeson (Value (..))
import Data.Aeson.Key qualified as Key
import Data.Aeson.KeyMap qualified as KeyMap
import Data.JsonStream.Lexer (Cursor, Element (ObjectBegin, ObjectEnd, StringPlain), plainText)
import Data.JsonStream.Lexer qualified as Lexer
import Data.Vector qualified as Vector

import Ecluse.Core.Registry.Json.Intern (InternTable, entryString, nameText, plainName)
import Ecluse.Core.Registry.Json.Shape (Build (..), Members, Mode (Keep), Shape (ObjectWith, Scalar), listedMember, memberText, readShape)
import Ecluse.Core.Registry.Json.Walk (Walk)

{- | Read one plain singleton digest directly, or resume the general reader from the untouched cursor.
The members must retain every digest as a scalar with one less level of structural budget.
-}
readPendingSidecar :: (Walk r) => Int -> Members -> InternTable -> Element -> Cursor -> (Value -> InternTable -> Cursor -> r) -> r
readPendingSidecar :: forall r.
Walk r =>
Int
-> Members
-> InternTable
-> Element
-> Cursor
-> (Value -> InternTable -> Cursor -> r)
-> r
readPendingSidecar Int
budget Members
members InternTable
table Element
element Cursor
rest Value -> InternTable -> Cursor -> r
next
    | Int
budget Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1
    , Element
ObjectBegin <- Element
element
    , Lexer.Token (StringPlain PlainString
key) Cursor
afterKey <- Cursor -> Scanned
Lexer.next Cursor
rest
    , Lexer.Token (StringPlain PlainString
digest) Cursor
afterDigest <- Cursor -> Scanned
Lexer.next Cursor
afterKey
    , Lexer.Token Element
ObjectEnd Cursor
afterObject <- Cursor -> Scanned
Lexer.next Cursor
afterDigest =
        let name :: Name
name = PlainString -> Name
plainName PlainString
key
            algorithm :: Key
algorithm = Key -> ((Key, Shape) -> Key) -> Maybe (Key, Shape) -> Key
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Text -> Key
Key.fromText (Name -> Text
nameText Name
name)) (Key, Shape) -> Key
forall a b. (a, b) -> a
fst (Members -> Name -> Maybe (Key, Shape)
listedMember Members
members Name
name)
         in Value -> InternTable -> Cursor -> r
next (KeyMap Value -> Value
Object (Key -> Value -> KeyMap Value
forall v. Key -> v -> KeyMap v
KeyMap.singleton Key
algorithm (Text -> Value
String (PlainString -> Text
plainText PlainString
digest)))) InternTable
table Cursor
afterObject
    | Bool
otherwise = PendingSidecar
-> Shape
-> Mode
-> InternTable
-> Element
-> Cursor
-> (Built PendingSidecar -> InternTable -> Cursor -> r)
-> r
forall b r.
Build b r =>
b
-> Shape
-> Mode
-> InternTable
-> Element
-> Cursor
-> (Built b -> InternTable -> Cursor -> r)
-> r
readShape PendingSidecar
PendingSidecar (Int -> Members -> Shape -> Shape
ObjectWith Int
budget Members
members (Int -> Shape
Scalar Int
budget)) Mode
Keep InternTable
table Element
element Cursor
rest Value -> InternTable -> Cursor -> r
Built PendingSidecar -> InternTable -> Cursor -> r
next
{-# INLINEABLE readPendingSidecar #-}

-- | A tree builder for a scalar or digest object read in Keep mode.
data PendingSidecar = PendingSidecar

data PendingFields
    = NoFields
    | OneField Key.Key ~Value
    | ManyFields (KeyMap.KeyMap (() -> Value))

instance (Walk r) => Build PendingSidecar r where
    type Built PendingSidecar = Value
    type Fields PendingSidecar = PendingFields
    type Items PendingSidecar = [Value]
    sharedString :: PendingSidecar -> Entry -> (Built PendingSidecar -> r) -> r
sharedString PendingSidecar
_ Entry
entry Built PendingSidecar -> r
next = Built PendingSidecar -> r
next (Entry -> Value
entryString Entry
entry)
    ownString :: PendingSidecar -> Name -> (Built PendingSidecar -> r) -> r
ownString PendingSidecar
_ Name
name Built PendingSidecar -> r
next = Built PendingSidecar -> r
next (Text -> Value
String (Name -> Text
nameText Name
name))
    integer :: PendingSidecar -> Int -> (Built PendingSidecar -> r) -> r
integer PendingSidecar
_ Int
number Built PendingSidecar -> r
next = Built PendingSidecar -> r
next (Scientific -> Value
Number (Int -> Scientific
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
number))
    whole :: PendingSidecar -> Value -> (Built PendingSidecar -> r) -> r
whole PendingSidecar
_ Value
value Built PendingSidecar -> r
next = Built PendingSidecar -> r
next Value
Built PendingSidecar
value
    emptyContainer :: PendingSidecar -> (Built PendingSidecar -> r) -> r
emptyContainer PendingSidecar
_ Built PendingSidecar -> r
next = Built PendingSidecar -> r
next (Array -> Value
Array Array
forall a. Monoid a => a
mempty)
    openObject :: PendingSidecar -> (Fields PendingSidecar -> r) -> r
openObject PendingSidecar
_ Fields PendingSidecar -> r
next = Fields PendingSidecar -> r
next Fields PendingSidecar
PendingFields
NoFields
    beginMember :: PendingSidecar
-> MemberKey -> Fields PendingSidecar -> (Bool -> r) -> r
beginMember PendingSidecar
_ MemberKey
key Fields PendingSidecar
fields Bool -> r
next = Bool -> r
next (Key -> PendingFields -> Bool
contains (Text -> Key
Key.fromText (MemberKey -> Text
memberText MemberKey
key)) Fields PendingSidecar
PendingFields
fields)
    addMember :: PendingSidecar
-> MemberKey
-> Built PendingSidecar
-> Fields PendingSidecar
-> (Fields PendingSidecar -> r)
-> r
addMember PendingSidecar
_ MemberKey
key Built PendingSidecar
value Fields PendingSidecar
fields Fields PendingSidecar -> r
next = Fields PendingSidecar -> r
next (Key -> Value -> PendingFields -> PendingFields
insertField (Text -> Key
Key.fromText (MemberKey -> Text
memberText MemberKey
key)) Value
Built PendingSidecar
value Fields PendingSidecar
PendingFields
fields)
    dropValue :: PendingSidecar -> Built PendingSidecar -> r -> r
dropValue PendingSidecar
_ Built PendingSidecar
_ r
next = r
next
    closeObject :: PendingSidecar
-> Fields PendingSidecar -> (Built PendingSidecar -> r) -> r
closeObject PendingSidecar
_ Fields PendingSidecar
fields Built PendingSidecar -> r
next = Built PendingSidecar -> r
next (KeyMap Value -> Value
Object (PendingFields -> KeyMap Value
finishFields Fields PendingSidecar
PendingFields
fields))
    openArray :: PendingSidecar -> (Items PendingSidecar -> r) -> r
openArray PendingSidecar
_ Items PendingSidecar -> r
next = Items PendingSidecar -> r
next []
    addItem :: PendingSidecar
-> Built PendingSidecar
-> Items PendingSidecar
-> (Items PendingSidecar -> r)
-> r
addItem PendingSidecar
_ Built PendingSidecar
value Items PendingSidecar
values Items PendingSidecar -> r
next = Items PendingSidecar -> r
next (Value
Built PendingSidecar
value Value -> [Value] -> [Value]
forall a. a -> [a] -> [a]
: [Value]
Items PendingSidecar
values)
    closeArray :: PendingSidecar
-> Int -> Items PendingSidecar -> (Built PendingSidecar -> r) -> r
closeArray PendingSidecar
_ Int
count Items PendingSidecar
values Built PendingSidecar -> r
next = Built PendingSidecar -> r
next (Array -> Value
Array (Int -> [Value] -> Array
forall a. Int -> [a] -> Vector a
Vector.fromListN Int
count ([Value] -> [Value]
forall a. [a] -> [a]
reverse [Value]
Items PendingSidecar
values)))
    {-# INLINE sharedString #-}
    {-# INLINE ownString #-}
    {-# INLINE integer #-}
    {-# INLINE whole #-}
    {-# INLINE emptyContainer #-}
    {-# INLINE openObject #-}
    {-# INLINE beginMember #-}
    {-# INLINE addMember #-}
    {-# INLINE dropValue #-}
    {-# INLINE closeObject #-}
    {-# INLINE openArray #-}
    {-# INLINE addItem #-}
    {-# INLINE closeArray #-}

contains :: Key.Key -> PendingFields -> Bool
contains :: Key -> PendingFields -> Bool
contains Key
_ PendingFields
NoFields = Bool
False
contains Key
key (OneField Key
held Value
_) = Key
key Key -> Key -> Bool
forall a. Eq a => a -> a -> Bool
== Key
held
contains Key
key (ManyFields KeyMap (() -> Value)
fields) = Key -> KeyMap (() -> Value) -> Bool
forall a. Key -> KeyMap a -> Bool
KeyMap.member Key
key KeyMap (() -> Value)
fields

insertField :: Key.Key -> Value -> PendingFields -> PendingFields
insertField :: Key -> Value -> PendingFields -> PendingFields
insertField Key
key Value
value = \case
    PendingFields
NoFields -> Key -> Value -> PendingFields
OneField Key
key Value
value
    OneField Key
held Value
previous -> KeyMap (() -> Value) -> PendingFields
ManyFields ([(Key, () -> Value)] -> KeyMap (() -> Value)
forall v. [(Key, v)] -> KeyMap v
KeyMap.fromList [(Key
held, Value -> () -> Value
forall a b. a -> b -> a
const Value
previous), (Key
key, Value -> () -> Value
forall a b. a -> b -> a
const Value
value)])
    ManyFields KeyMap (() -> Value)
fields -> KeyMap (() -> Value) -> PendingFields
ManyFields (Key
-> (() -> Value) -> KeyMap (() -> Value) -> KeyMap (() -> Value)
forall v. Key -> v -> KeyMap v -> KeyMap v
KeyMap.insert Key
key (Value -> () -> Value
forall a b. a -> b -> a
const Value
value) KeyMap (() -> Value)
fields)

finishFields :: PendingFields -> KeyMap.KeyMap Value
finishFields :: PendingFields -> KeyMap Value
finishFields = \case
    PendingFields
NoFields -> KeyMap Value
forall a. Monoid a => a
mempty
    OneField Key
key Value
value -> Key -> Value -> KeyMap Value
forall v. Key -> v -> KeyMap v
KeyMap.singleton Key
key Value
value
    ManyFields KeyMap (() -> Value)
fields -> ((() -> Value) -> Value) -> KeyMap (() -> Value) -> KeyMap Value
forall a b. (a -> b) -> KeyMap a -> KeyMap b
KeyMap.map ((() -> Value) -> () -> Value
forall a b. (a -> b) -> a -> b
$ ()) KeyMap (() -> Value)
fields