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

{- | Shared metadata validation for full documents and selective adapter reads.
Ecosystem callbacks own wire projection and package-name parsing.
-}
module Ecluse.Core.Registry.Metadata.Projection (
    validateReportedName,
    validateNameAgreement,
    projectionResult,
    streamError,
    finishSelectedVersion,
) where

import Data.Aeson (Value, parseJSON)
import Data.Aeson.Types (parseMaybe)
import Data.Map.Strict qualified as Map

import Ecluse.Core.Package (PackageInfo (infoVersions), PackageName)
import Ecluse.Core.Registry (ParseError)
import Ecluse.Core.Registry.CachedDocument (CachedDoc)
import Ecluse.Core.Registry.JsonStream (StreamResult (..), isNestingLimit)
import Ecluse.Core.Registry.Metadata (MetadataError (MetadataBoundExceeded, MetadataNameMismatch, MetadataUndecodable), VersionDoc (..), VersionRead (..))
import Ecluse.Core.Registry.WireSupport (Projection (NameMismatch, Projected), checkNameAgreement)
import Ecluse.Core.Security (
    LimitError (TooDeeplyNested),
    Limits,
    maxNestingDepth,
 )
import Ecluse.Core.Version (Version, renderVersion)

-- | An absent, non-string, or rejected name is an undecodable document.
validateReportedName :: (Text -> Either ParseError PackageName) -> Maybe Value -> Either MetadataError PackageName
validateReportedName :: (Text -> Either ParseError PackageName)
-> Maybe Value -> Either MetadataError PackageName
validateReportedName Text -> Either ParseError PackageName
parseName = \case
    Maybe Value
Nothing -> MetadataError -> Either MetadataError PackageName
forall a b. a -> Either a b
Left MetadataError
MetadataUndecodable
    Just Value
nameValue -> case (Value -> Parser Text) -> Value -> Maybe Text
forall a b. (a -> Parser b) -> a -> Maybe b
parseMaybe Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
nameValue of
        Maybe Text
Nothing -> MetadataError -> Either MetadataError PackageName
forall a b. a -> Either a b
Left MetadataError
MetadataUndecodable
        Just Text
raw -> (ParseError -> MetadataError)
-> Either ParseError PackageName
-> Either MetadataError PackageName
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (MetadataError -> ParseError -> MetadataError
forall a b. a -> b -> a
const MetadataError
MetadataUndecodable) (Text -> Either ParseError PackageName
parseName Text
raw)

-- | Validate the native name and preserve it when refusing a mismatched origin.
validateNameAgreement :: (Text -> Either ParseError PackageName) -> PackageName -> Maybe Value -> Either MetadataError PackageName
validateNameAgreement :: (Text -> Either ParseError PackageName)
-> PackageName -> Maybe Value -> Either MetadataError PackageName
validateNameAgreement Text -> Either ParseError PackageName
parseName PackageName
requested Maybe Value
value = do
    reported <- (Text -> Either ParseError PackageName)
-> Maybe Value -> Either MetadataError PackageName
validateReportedName Text -> Either ParseError PackageName
parseName Maybe Value
value
    projectionResult (checkNameAgreement requested reported reported)

-- | Preserve the reported name when refusing a mismatched origin.
projectionResult :: Projection a -> Either MetadataError a
projectionResult :: forall a. Projection a -> Either MetadataError a
projectionResult = \case
    NameMismatch Text
reported -> MetadataError -> Either MetadataError a
forall a b. a -> Either a b
Left (Text -> MetadataError
MetadataNameMismatch Text
reported)
    Projected a
projected -> a -> Either MetadataError a
forall a b. b -> Either a b
Right a
projected

-- | Translate incremental parser bounds without requiring validity of skipped data.
streamError :: Limits -> ParseError -> MetadataError
streamError :: Limits -> ParseError -> MetadataError
streamError Limits
limits ParseError
err =
    if ParseError -> Bool
isNestingLimit ParseError
err
        then LimitError -> MetadataError
MetadataBoundExceeded (Int -> LimitError
TooDeeplyNested (Limits -> Int
maxNestingDepth Limits
limits))
        else MetadataError
MetadataUndecodable

{- | A selected walk's version: its typed details by raw version and the native document @select@
keeps for it. No upstream latest tag is reported.
-}
finishSelectedVersion :: (a -> PackageInfo) -> (Version -> a -> Maybe CachedDoc) -> Limits -> Version -> StreamResult a -> Either MetadataError VersionRead
finishSelectedVersion :: forall a.
(a -> PackageInfo)
-> (Version -> a -> Maybe CachedDoc)
-> Limits
-> Version
-> StreamResult a
-> Either MetadataError VersionRead
finishSelectedVersion a -> PackageInfo
info Version -> a -> Maybe CachedDoc
select Limits
limits Version
version StreamResult a
streamed = do
    result <- (ParseError -> MetadataError)
-> Either ParseError a -> Either MetadataError a
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (Limits -> ParseError -> MetadataError
streamError Limits
limits) (StreamResult a -> Either ParseError a
forall a. StreamResult a -> Either ParseError a
streamValue StreamResult a
streamed)
    let selected = do
            details <- Text -> Map Text PackageDetails -> Maybe PackageDetails
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (Version -> Text
renderVersion Version
version) (PackageInfo -> Map Text PackageDetails
infoVersions (a -> PackageInfo
info a
result))
            raw <- select version result
            pure VersionDoc{vdDetails = details, vdRaw = Just raw}
    pure VersionRead{vrVersion = selected, vrBodyBytes = streamBytes streamed, vrUpstreamLatest = Nothing}